/** {@inheritDoc} */
public void onEvent(EventIterator eventIterator) {
// waiting for Event.PROPERTY_ADDED, Event.PROPERTY_REMOVED,
// Event.PROPERTY_CHANGED
Session session = null;
try {
while (eventIterator.hasNext()) {
Event event = eventIterator.nextEvent();
String path = event.getPath();
if (path.endsWith("/jcr:data")) {
// jcr:data removed 'exo:groovyResourceContainer' then unbind resource
if (event.getType() == Event.PROPERTY_REMOVED) {
unloadScript(path.substring(0, path.lastIndexOf('/')));
} else if (event.getType() == Event.PROPERTY_ADDED
|| event.getType() == Event.PROPERTY_CHANGED) {
if (session == null) {
session = repository.getSystemSession(workspaceName);
}
Node node = session.getItem(path).getParent();
if (node.getProperty("exo:autoload").getBoolean()) loadScript(node);
}
}
}
} catch (Exception e) {
LOG.error("Process event failed. ", e);
} finally {
if (session != null) {
session.logout();
}
}
}
@SuppressWarnings("synthetic-access")
@Override
public void onEvent(EventIterator events) {
while (events.hasNext()) {
try {
Event event = (Event) events.nextEvent();
smokeCheckSequencingEvent(
event,
NODE_SEQUENCING_FAILURE,
SEQUENCED_NODE_ID,
SEQUENCED_NODE_PATH,
Event.Sequencing.SEQUENCING_FAILURE_CAUSE,
OUTPUT_PATH,
SELECTED_PATH,
SEQUENCER_NAME,
USER_ID);
String nodePath = event.getPath();
sequencingEvents.putIfAbsent(nodePath, event);
createWaitingLatchIfNecessary(nodePath, sequencingFailureLatches);
sequencingFailureLatches.get(nodePath).countDown();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
@SuppressWarnings("synthetic-access")
@Override
public void onEvent(EventIterator events) {
while (events.hasNext()) {
try {
Event event = (Event) events.nextEvent();
smokeCheckSequencingEvent(
event,
NODE_SEQUENCED,
SEQUENCED_NODE_ID,
SEQUENCED_NODE_PATH,
OUTPUT_PATH,
SELECTED_PATH,
SEQUENCER_NAME,
USER_ID);
sequencingEvents.putIfAbsent((String) event.getInfo().get(SEQUENCED_NODE_PATH), event);
String nodePath = event.getPath();
logger.debug("New sequenced node at: " + nodePath);
sequencedNodes.put(nodePath, session.getNode(nodePath));
// signal the node is available
createWaitingLatchIfNecessary(nodePath, nodeSequencedLatches);
nodeSequencedLatches.get(nodePath).countDown();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
@Override
public void onEvent(EventIterator eventIterator) {
while (eventIterator.hasNext()) {
try {
Event currentEvent = eventIterator.nextEvent();
if (currentEvent.getType() == Event.PROPERTY_ADDED
|| currentEvent.getType() == Event.PROPERTY_CHANGED
|| currentEvent.getType() == Event.PROPERTY_REMOVED) {
clientLibraryCacheManager.invalidateCache(
currentEvent.getPath().substring(0, currentEvent.getPath().lastIndexOf("/")));
} else if (currentEvent.getType() == Event.NODE_REMOVED) {
clientLibraryCacheManager.invalidateCache(currentEvent.getPath());
} else if (currentEvent.getType() == Event.NODE_MOVED) {
if (currentEvent.getInfo().containsKey("srcAbsPath")) {
clientLibraryCacheManager.invalidateCache(
(String) currentEvent.getInfo().get("srcAbsPath"));
}
clientLibraryCacheManager.invalidateCache(currentEvent.getPath());
}
} catch (RepositoryException e) {
LOG.error("Repository Exception", e);
} catch (ClientLibraryCachingException e) {
LOG.error(
"Client Library Caching Exception encountered while processing page content events", e);
}
}
}
/** @see javax.jcr.observation.EventListener#onEvent(javax.jcr.observation.EventIterator) */
public void onEvent(EventIterator iterator) {
System.out.println("received events: ");
for (; iterator.hasNext(); ) {
try {
System.out.println(toStringEvent(iterator.nextEvent()));
} catch (RepositoryException e) {
System.err.println(
"exception while listnening " + SessionFactoryUtils.translateException(e));
}
}
}
/**
* This method is called when a bundle of events is dispatched.
*
* @param events The event set received.
*/
public void onEvent(EventIterator events) {
final Cache depCache = cacheProvider.getDependenciesCache();
final Cache regexpDepCache = cacheProvider.getRegexpDependenciesCache();
final Set<String> flushed = new HashSet<String>();
while (events.hasNext()) {
Event event = (Event) events.next();
boolean propageToOtherClusterNodes = !isExternal(event);
try {
String path = event.getPath();
if (!path.startsWith("/jcr:system")) {
boolean flushParent = false;
boolean flushRoles = false;
if (path.contains("j:view")) {
flushParent = true;
}
final int type = event.getType();
if (type == Event.PROPERTY_ADDED
|| type == Event.PROPERTY_CHANGED
|| type == Event.PROPERTY_REMOVED) {
if (path.endsWith("/j:published")) {
flushParent = true;
}
if (path.endsWith("j:roles")) {
flushRoles = true;
}
path = path.substring(0, path.lastIndexOf("/"));
} else if (type == Event.NODE_ADDED
|| type == Event.NODE_MOVED
|| type == Event.NODE_REMOVED) {
flushParent = true;
}
if (path.contains("vanityUrlMapping")) {
flushParent = true;
}
if (path.contains("j:acl")
|| path.contains("jnt:group")
|| flushRoles
|| type == Event.NODE_MOVED) {
// Flushing cache of acl key for users as a group or an acl has been updated
CacheKeyGenerator cacheKeyGenerator = cacheProvider.getKeyGenerator();
if (cacheKeyGenerator instanceof DefaultCacheKeyGenerator) {
DefaultCacheKeyGenerator generator = (DefaultCacheKeyGenerator) cacheKeyGenerator;
generator.flushUsersGroupsKey(propageToOtherClusterNodes);
}
flushParent = true;
}
path =
StringUtils.substringBeforeLast(
StringUtils.substringBeforeLast(path, "/j:translation"), "/j:acl");
flushDependenciesOfPath(depCache, flushed, path, propageToOtherClusterNodes);
try {
flushDependenciesOfPath(
depCache,
flushed,
((JCREventIterator) events).getSession().getNode(path).getIdentifier(),
propageToOtherClusterNodes);
} catch (PathNotFoundException e) {
if (event instanceof EventImpl && (((EventImpl) event).getChildId() != null)) {
flushDependenciesOfPath(
depCache,
flushed,
((EventImpl) event).getChildId().toString(),
propageToOtherClusterNodes);
}
}
flushRegexpDependenciesOfPath(regexpDepCache, path, propageToOtherClusterNodes);
if (flushParent) {
path = StringUtils.substringBeforeLast(path, "/");
flushDependenciesOfPath(depCache, flushed, path, propageToOtherClusterNodes);
try {
flushDependenciesOfPath(
depCache,
flushed,
((JCREventIterator) events).getSession().getNode(path).getIdentifier(),
propageToOtherClusterNodes);
} catch (PathNotFoundException e) {
if (event instanceof EventImpl && (((EventImpl) event).getParentId() != null)) {
flushDependenciesOfPath(
depCache,
flushed,
((EventImpl) event).getParentId().toString(),
propageToOtherClusterNodes);
}
}
flushRegexpDependenciesOfPath(regexpDepCache, path, propageToOtherClusterNodes);
}
}
} catch (RepositoryException e) {
logger.error(e.getMessage(), e);
}
}
}