View Javadoc

1   /*
2    * Copyright 2007-2008 the original author or authors.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package org.gwe.app.daemon.domain;
18  
19  import java.sql.Timestamp;
20  import java.util.ArrayList;
21  import java.util.Collection;
22  import java.util.HashMap;
23  import java.util.List;
24  import java.util.Map;
25  
26  import org.gwe.api.event.Event;
27  import org.gwe.api.event.EventFilter;
28  import org.gwe.persistence.model.BaseModelInfo;
29  import org.gwe.persistence.model.EventType;
30  import org.gwe.persistence.model.IEventLogger;
31  import org.gwe.utils.concurrent.BlockingList;
32  
33  /**
34   * 
35   * @author Marco Ruiz
36   * @since Oct 4, 2007
37   */
38  public class MonitorDomain extends BaseDomain implements Runnable, IEventLogger {
39  	
40  	private static final long MAXIMUM_BLOCKING_PERIOD = 10000;
41  
42  	private Map<Long, UserEventNotifier> notifiers = new HashMap<Long, UserEventNotifier>();
43  	private BlockingList<Event> events = new BlockingList<Event>();
44  	
45  	public <KEY_TYPE> Timestamp logEvent(BaseModelInfo<KEY_TYPE> source, EventType evType, Timestamp when, BaseModelInfo... relatedModels) {
46  		events.add(new Event(evType, source, relatedModels));
47  		return when;
48  	}
49  	
50  	public long createHandle() {
51  		// TODO: Create a stronger unique handle for monitoring 
52  		return System.currentTimeMillis();
53  	}
54  
55  	public List<Event> getNextEvents(long handle, EventFilter filter) {
56  		return getUserEventNotifier(handle).getNextEvents();
57  	}
58  
59  	private UserEventNotifier getUserEventNotifier(long handle) {
60  		synchronized (notifiers) {
61  			UserEventNotifier notif = notifiers.get(handle);
62  			if (notif == null) {
63  				notif = new UserEventNotifier(handle);
64  				notifiers.put(handle, notif);
65  			}
66  			return notif;
67  		}
68  	}
69  	
70  	public void disposeNotifier(long handle) {
71  		synchronized (notifiers) { notifiers.remove(handle); }
72  	}
73  
74  	public void run() {
75  		List<Event> eventsCopy;
76  		while (true) {
77  			eventsCopy = events.takeAll();
78  			if (!eventsCopy.isEmpty()) {
79  				Collection<UserEventNotifier> notifiersCopy;
80  				synchronized (notifiers) { notifiersCopy = notifiers.values(); }
81  				for (UserEventNotifier notif : notifiersCopy) notif.postEvents(eventsCopy);
82  			}
83  		}
84  	}
85  
86  	class UserEventNotifier {
87  		
88  		private Long monitoringHandle;
89  		private List<Event> userEvents = new ArrayList<Event>();
90  		
91  		private UserEventNotifier(long monitoringHandle) {
92  			this.monitoringHandle = monitoringHandle;
93  		}
94  		
95  		private List<Event> getNextEvents() {
96  			List<Event> result = new ArrayList<Event>();
97  			synchronized (monitoringHandle) {
98  				while (userEvents.isEmpty())
99  					try { monitoringHandle.wait(MAXIMUM_BLOCKING_PERIOD); } catch (InterruptedException e) {}
100 				result.addAll(userEvents);
101 				userEvents.clear();
102 			}
103 			return result;
104 		}
105 		
106 		private void postEvents(List<Event> events) {
107 			synchronized (monitoringHandle) { 
108 				userEvents.addAll(events);
109 				monitoringHandle.notify();
110 			}
111 		}
112 	}
113 }