1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 package info.magnolia.cms.util;
35
36 import info.magnolia.context.LifeTimeJCRSessionUtil;
37
38 import java.util.ArrayList;
39 import java.util.Iterator;
40 import java.util.List;
41
42 import javax.jcr.RepositoryException;
43 import javax.jcr.Session;
44 import javax.jcr.Workspace;
45 import javax.jcr.observation.Event;
46 import javax.jcr.observation.EventIterator;
47 import javax.jcr.observation.EventListener;
48 import javax.jcr.observation.ObservationManager;
49
50 import org.apache.jackrabbit.core.observation.ObservationManagerImpl;
51 import org.slf4j.Logger;
52 import org.slf4j.LoggerFactory;
53
54
55
56
57
58
59
60 @Deprecated
61 public class ObservationUtil {
62
63 private final static Logger log = LoggerFactory.getLogger(ObservationUtil.class);
64
65 private static final int ALL_EVENT_TYPES_MASK = Event.NODE_ADDED | Event.NODE_REMOVED | Event.NODE_MOVED | Event.PROPERTY_ADDED | Event.PROPERTY_CHANGED | Event.PROPERTY_REMOVED;
66
67
68
69
70
71
72
73 @Deprecated
74 public static void dispose(String workspace) {
75 try {
76 ObservationManager om = getObservationManager(workspace);
77
78 if (om instanceof ObservationManagerImpl) {
79 ((ObservationManagerImpl) om).dispose();
80 } else {
81 log.warn("Observation can not be disposed ");
82 }
83 } catch (RepositoryException e) {
84 log.error("Unable to Unregisters all EventListeners for the following workspace {}", workspace, e);
85 }
86 }
87
88
89
90
91
92
93
94 @Deprecated
95 public static void registerChangeListener(String workspace, String observationPath, EventListener listener) {
96 registerChangeListener(workspace, observationPath, true, listener);
97 }
98
99
100
101
102
103
104
105 @Deprecated
106 public static void registerChangeListener(String workspace, String observationPath, boolean includeSubnodes, EventListener listener) {
107 registerChangeListener(workspace, observationPath, includeSubnodes, (String[]) null, listener);
108 }
109
110
111
112
113
114
115
116 @Deprecated
117 public static void registerChangeListener(String workspace, String observationPath, boolean includeSubnodes, String nodeType, EventListener listener) {
118 registerChangeListener(workspace, observationPath, includeSubnodes, new String[]{nodeType}, listener);
119 }
120
121
122
123
124
125
126
127 @Deprecated
128 public static void registerChangeListener(String workspace, String observationPath, boolean includeSubnodes, String nodeType, int eventTypesMask, EventListener listener) {
129 if (nodeType == null) {
130 registerChangeListener(workspace, observationPath, includeSubnodes, (String[]) null, eventTypesMask, listener);
131 } else {
132 registerChangeListener(workspace, observationPath, includeSubnodes, new String[]{nodeType}, eventTypesMask, listener);
133 }
134 }
135
136
137
138
139
140
141
142 @Deprecated
143 public static void registerChangeListener(String workspace, String observationPath, boolean includeSubnodes, String[] nodeTypes, EventListener listener) {
144 registerChangeListener(workspace, observationPath, includeSubnodes, nodeTypes, ALL_EVENT_TYPES_MASK, listener);
145 }
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170 @Deprecated
171 public static void registerChangeListener(String workspace, String observationPath, boolean includeSubnodes, String[] nodeTypes, int eventTypesMask, EventListener listener) {
172 log.debug("Registering event listener for path [{}]", observationPath);
173
174 try {
175 ObservationManager observationManager = getObservationManager(workspace);
176 if (observationManager == null) {
177 log.error("Unable to add event listeners for {}", observationPath);
178 throw new IllegalStateException("Observation manager can't be obtained due to invalid session.");
179 }
180
181 observationManager.addEventListener(listener, eventTypesMask, observationPath, includeSubnodes, null, nodeTypes, false);
182 } catch (RepositoryException e) {
183 log.error("Unable to add event listeners for {}", observationPath, e);
184 }
185 }
186
187
188
189
190
191
192
193 @Deprecated
194 public static void registerDeferredChangeListener(String workspace, String observationPath, EventListener listener, long delay, long maxDelay) {
195 registerDeferredChangeListener(workspace, observationPath, true, (String[]) null, listener, delay, maxDelay);
196 }
197
198
199
200
201
202
203
204 @Deprecated
205 public static void registerDeferredChangeListener(String workspace, String observationPath, boolean includeSubnodes, EventListener listener, long delay, long maxDelay) {
206 registerDeferredChangeListener(workspace, observationPath, includeSubnodes, (String[]) null, listener, delay, maxDelay);
207 }
208
209
210
211
212
213
214
215 @Deprecated
216 public static void registerDeferredChangeListener(String workspace, String observationPath, boolean includeSubnodes, String nodeType, EventListener listener, long delay, long maxDelay) {
217 registerDeferredChangeListener(workspace, observationPath, includeSubnodes, new String[] { nodeType }, listener, delay, maxDelay);
218 }
219
220
221
222
223
224
225
226 @Deprecated
227 public static void registerDeferredChangeListener(String workspace, String observationPath, boolean includeSubnodes, String[] nodeTypes, EventListener listener, long delay, long maxDelay) {
228 final EventListener deferredListener = instanciateDeferredEventListener(listener, delay, maxDelay);
229 registerChangeListener(workspace, observationPath, includeSubnodes, nodeTypes, deferredListener);
230 }
231
232
233
234
235
236
237
238
239 @Deprecated
240 public static EventListener instanciateDeferredEventListener(EventListener listener, long delay, long maxDelay) {
241 return new DeferringEventListener(listener, delay, maxDelay);
242 }
243
244
245
246
247 @Deprecated
248 public static void unregisterChangeListener(String workspace, EventListener listener) {
249 try {
250 ObservationManager om = getObservationManager(workspace);
251 if (om == null) {
252
253 return;
254 }
255 om.removeEventListener(listener);
256 } catch (RepositoryException e) {
257 log.error("Unable to remove event listener [{}] from workspace {}", listener, workspace, e);
258 }
259 }
260
261 private static ObservationManager getObservationManager(String workspace) throws RepositoryException {
262 Workspace wks = getSession(workspace).getWorkspace();
263 return wks.getSession().isLive() ? wks.getObservationManager() : null;
264 }
265
266 private static Session getSession(String workspace) throws RepositoryException {
267 return LifeTimeJCRSessionUtil.getSession(workspace);
268 }
269
270
271
272
273
274
275 @Deprecated
276 public static class DeferringEventListener implements EventListener {
277
278 private ObservationBasedDelayedExecutor executor;
279
280 private EventListener listener;
281
282 public DeferringEventListener(EventListener listener, long delay, long maxDelay) {
283 this.listener = listener;
284 executor = new ObservationBasedDelayedExecutor(listener, delay, maxDelay);
285 }
286
287 @Override
288 public void onEvent(EventIterator events) {
289 this.executor.consume(events);
290 }
291
292 @Override
293 public String toString() {
294 return super.toString() + ":" + this.listener;
295 }
296 }
297
298
299
300
301
302
303 @Deprecated
304 public static class ObservationBasedDelayedExecutor {
305
306 private final DelayedExecutor delayedExecutor;
307 private final List eventsBuffer = new ArrayList();
308
309 public ObservationBasedDelayedExecutor(final EventListener listener, long delay, long maxDelay) {
310 delayedExecutor = new DelayedExecutor(new Runnable() {
311 @Override
312 public void run() {
313
314 synchronized (eventsBuffer) {
315 listener.onEvent(new ListBasedEventIterator(eventsBuffer));
316 eventsBuffer.clear();
317 }
318 }
319 }, delay, maxDelay);
320 }
321
322 protected void consume(EventIterator events) {
323 synchronized (this.eventsBuffer) {
324 while (events.hasNext()) {
325 this.eventsBuffer.add(events.next());
326 }
327 delayedExecutor.trigger();
328 }
329 }
330 }
331
332
333
334
335
336
337
338 @Deprecated
339 public static class ListBasedEventIterator implements EventIterator {
340
341 private Iterator iterator;
342 private List events;
343 private int pos = 0;
344
345 public ListBasedEventIterator(List events) {
346 this.events = events;
347 this.iterator = events.iterator();
348 }
349
350 @Override
351 public boolean hasNext() {
352 return this.iterator.hasNext();
353 }
354
355 @Override
356 public Object next() {
357 pos++;
358 return this.iterator.next();
359 }
360
361 @Override
362 public void remove() {
363 this.iterator.remove();
364 }
365
366 @Override
367 public Event nextEvent() {
368 return (Event) next();
369 }
370
371 @Override
372 public long getPosition() {
373 return pos;
374 }
375
376 @Override
377 public long getSize() {
378 return events.size();
379 }
380
381 @Override
382 public void skip(long skipNum) {
383 for (int i = 0; i < skipNum; i++) {
384 next();
385 }
386 }
387 }
388
389 }