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 DeprecationUtil.isDeprecated("use info.magnolia.observation.WorkspaceEventListenerRegistration.Registrar instead");
173
174 log.debug("Registering event listener for path [{}] in workspace [{}]", observationPath, workspace);
175
176 try {
177 ObservationManager observationManager = getObservationManager(workspace);
178 if (observationManager == null) {
179 log.error("Unable to add event listeners for {}", observationPath);
180 throw new IllegalStateException("Observation manager can't be obtained due to invalid session.");
181 }
182
183 observationManager.addEventListener(listener, eventTypesMask, observationPath, includeSubnodes, null, nodeTypes, false);
184 } catch (RepositoryException e) {
185 log.error("Unable to add event listeners for {}", observationPath, e);
186 }
187 }
188
189
190
191
192
193
194
195 @Deprecated
196 public static void registerDeferredChangeListener(String workspace, String observationPath, EventListener listener, long delay, long maxDelay) {
197 registerDeferredChangeListener(workspace, observationPath, true, (String[]) null, listener, delay, maxDelay);
198 }
199
200
201
202
203
204
205
206 @Deprecated
207 public static void registerDeferredChangeListener(String workspace, String observationPath, boolean includeSubnodes, EventListener listener, long delay, long maxDelay) {
208 registerDeferredChangeListener(workspace, observationPath, includeSubnodes, (String[]) null, listener, delay, maxDelay);
209 }
210
211
212
213
214
215
216
217 @Deprecated
218 public static void registerDeferredChangeListener(String workspace, String observationPath, boolean includeSubnodes, String nodeType, EventListener listener, long delay, long maxDelay) {
219 registerDeferredChangeListener(workspace, observationPath, includeSubnodes, new String[] { nodeType }, listener, delay, maxDelay);
220 }
221
222
223
224
225
226
227
228 @Deprecated
229 public static void registerDeferredChangeListener(String workspace, String observationPath, boolean includeSubnodes, String[] nodeTypes, EventListener listener, long delay, long maxDelay) {
230 final EventListener deferredListener = instanciateDeferredEventListener(listener, delay, maxDelay);
231 registerChangeListener(workspace, observationPath, includeSubnodes, nodeTypes, deferredListener);
232 }
233
234
235
236
237
238
239
240
241 @Deprecated
242 public static EventListener instanciateDeferredEventListener(EventListener listener, long delay, long maxDelay) {
243 return new DeferringEventListener(listener, delay, maxDelay);
244 }
245
246
247
248
249 @Deprecated
250 public static void unregisterChangeListener(String workspace, EventListener listener) {
251 try {
252 ObservationManager om = getObservationManager(workspace);
253 if (om == null) {
254
255 return;
256 }
257 om.removeEventListener(listener);
258 } catch (RepositoryException e) {
259 log.error("Unable to remove event listener [{}] from workspace {}", listener, workspace, e);
260 }
261 }
262
263 private static ObservationManager getObservationManager(String workspace) throws RepositoryException {
264 Workspace wks = getSession(workspace).getWorkspace();
265 return wks.getSession().isLive() ? wks.getObservationManager() : null;
266 }
267
268 private static Session getSession(String workspace) throws RepositoryException {
269 return LifeTimeJCRSessionUtil.getSession(workspace);
270 }
271
272
273
274
275
276
277 @Deprecated
278 public static class DeferringEventListener implements EventListener {
279
280 private ObservationBasedDelayedExecutor executor;
281
282 private EventListener listener;
283
284 public DeferringEventListener(EventListener listener, long delay, long maxDelay) {
285 this.listener = listener;
286 executor = new ObservationBasedDelayedExecutor(listener, delay, maxDelay);
287 }
288
289 @Override
290 public void onEvent(EventIterator events) {
291 this.executor.consume(events);
292 }
293
294 @Override
295 public String toString() {
296 return super.toString() + ":" + this.listener;
297 }
298 }
299
300
301
302
303
304
305 @Deprecated
306 public static class ObservationBasedDelayedExecutor {
307
308 private final DelayedExecutor delayedExecutor;
309 private final List eventsBuffer = new ArrayList();
310
311 public ObservationBasedDelayedExecutor(final EventListener listener, long delay, long maxDelay) {
312 delayedExecutor = new DelayedExecutor(new Runnable() {
313 @Override
314 public void run() {
315
316 synchronized (eventsBuffer) {
317 listener.onEvent(new ListBasedEventIterator(eventsBuffer));
318 eventsBuffer.clear();
319 }
320 }
321 }, delay, maxDelay);
322 }
323
324 protected void consume(EventIterator events) {
325 synchronized (this.eventsBuffer) {
326 while (events.hasNext()) {
327 this.eventsBuffer.add(events.next());
328 }
329 delayedExecutor.trigger();
330 }
331 }
332 }
333
334
335
336
337
338
339
340 @Deprecated
341 public static class ListBasedEventIterator implements EventIterator {
342
343 private Iterator iterator;
344 private List events;
345 private int pos = 0;
346
347 public ListBasedEventIterator(List events) {
348 this.events = events;
349 this.iterator = events.iterator();
350 }
351
352 @Override
353 public boolean hasNext() {
354 return this.iterator.hasNext();
355 }
356
357 @Override
358 public Object next() {
359 pos++;
360 return this.iterator.next();
361 }
362
363 @Override
364 public void remove() {
365 this.iterator.remove();
366 }
367
368 @Override
369 public Event nextEvent() {
370 return (Event) next();
371 }
372
373 @Override
374 public long getPosition() {
375 return pos;
376 }
377
378 @Override
379 public long getSize() {
380 return events.size();
381 }
382
383 @Override
384 public void skip(long skipNum) {
385 for (int i = 0; i < skipNum; i++) {
386 next();
387 }
388 }
389 }
390
391 }