Refine search
public void process(WatchedEvent event) { // lets either become the leader or watch the new/updated node LOG.debug("Watcher fired on path: " + event.getPath() + " state: " + event.getState() + " type " + event.getType()); try { lock(); } catch (Exception e) { LOG.warn("Failed to acquire lock: " + e, e); } } }
public void process(WatchedEvent event) { // lets either become the leader or watch the new/updated node LOG.debug("Watcher fired on path: " + event.getPath() + " state: " + event.getState() + " type " + event.getType()); try { lock(); } catch (Exception e) { LOG.warn("Failed to acquire lock: " + e, e); } } }
private void processWatchedEvent(WatchedEvent event) { if (event.getType() != EventType.NodeDeleted) return; String localPath = nodePath.get(); if (localPath == null) return; if (!localPath.equals(event.getPath())) { LOG.info("Ignoring the NodeDeleted event for " + event.getPath()); return; } LOG.info("Trying to reacquire because of the NodeDeleted event"); startCreateCurrentNode(); }
private void queueEvent(WatchedEvent event, Set<Watcher> materializedWatchers) { if (event.getType() == EventType.None && sessionState == event.getState()) { return; } sessionState = event.getState(); final Set<Watcher> watchers; if (materializedWatchers == null) { // materialize the watchers based on the event watchers = watcher.materialize(event.getState(), event.getType(), event.getPath()); } else { watchers = new HashSet<Watcher>(); watchers.addAll(materializedWatchers); } WatcherSetEventPair pair = new WatcherSetEventPair(watchers, event); // queue the pair (watch set & event) for later processing waitingEvents.add(pair); }
private void childEventWatch(WatchedEvent event) { if (event.getPath() == null) { return; } try { // child Changed if (event.getType() == Event.EventType.NodeChildrenChanged || event.getType() == Event.EventType.NodeCreated || event.getType() == Event.EventType.NodeDeleted) { final String path = event.getPath(); fireChangeEvent(path, childListeners.get(path)); } } finally { if (event.getState() == Event.KeeperState.Expired) { for (Map.Entry<String, Set<ChildListener>> entry : childListeners.entrySet()) { fireChangeEvent(entry.getKey(), entry.getValue()); } } } }
private void childEventWatch(WatchedEvent event) { if (event.getPath() == null) { return; } try { // child Changed if (event.getType() == Event.EventType.NodeChildrenChanged || event.getType() == Event.EventType.NodeCreated || event.getType() == Event.EventType.NodeDeleted) { final String path = event.getPath(); fireChangeEvent(path, childListeners.get(path)); } } finally { if (event.getState() == Event.KeeperState.Expired) { for (Map.Entry<String, Set<ChildListener>> entry : childListeners.entrySet()) { fireChangeEvent(entry.getKey(), entry.getValue()); } } } }
public void queueEvent(WatchedEvent event) { if (event.getType() == EventType.None && sessionState == event.getState()) { return; } sessionState = event.getState(); // materialize the watchers based on the event WatcherSetEventPair pair = new WatcherSetEventPair( watcher.materialize(event.getState(), event.getType(), event.getPath()), event); // queue the pair (watch set & event) for later processing waitingEvents.add(pair); }
@Override public void process(WatchedEvent event) { LOG.debug("Received event {} from lock {} at {} : watcher epoch {}, lock epoch {}.", new Object[] { event, lockPath, System.currentTimeMillis(), epoch, ZKSessionLock.this.epoch.get() }); if (event.getType() == Watcher.Event.EventType.None) { switch (event.getState()) { case SyncConnected: break; case Expired: LOG.info("Session {} is expired for lock {} at {} : watcher epoch {}, lock epoch {}.", new Object[] { lockId.getRight(), lockPath, System.currentTimeMillis(), epoch, ZKSessionLock.this.epoch.get() }); handleSessionExpired(epoch); break; default: break; } } else if (event.getType() == Event.EventType.NodeDeleted) { // this handles the case where we have aborted a lock and deleted ourselves but still have a // watch on the nextLowestNode. This is a workaround since ZK doesn't support unsub. if (!event.getPath().equals(watchedNode)) { LOG.warn("{} (watching {}) ignored watched event from {} ", new Object[] { lockId, watchedNode, event.getPath() }); return; } handleNodeDelete(epoch, event); } else { LOG.warn("Unexpected ZK event: {}", event.getType().name()); } }
public void process(WatchedEvent event) { LOG.debug("Event path : {}, eventPath : {}" + new Object[] { path, event.getPath() }); this.eventPath = event.getPath(); // notifies watcher removal if (latch.getCount() == 0) { if (event.getType() != EventType.None) { eventsAfterWatchRemoval.add(event.getType()); } } if (event.getType() == EventType.ChildWatchRemoved || event.getType() == EventType.DataWatchRemoved) { latch.countDown(); } }
private void addWatchNotifications( final Map<String, List<EventType>> pathVsEvent, WatchedEvent event) { List<EventType> events = pathVsEvent.get(event.getPath()); if (null == events) { events = new ArrayList<Watcher.Event.EventType>(); pathVsEvent.put(event.getPath(), events); } events.add(event.getType()); } };
/** {@inheritDoc} */ @Override public void process0(WatchedEvent evt) { if (evt.getType() == Event.EventType.NodeDataChanged) { if (evt.getPath().equals(zkPaths.evtsPath)) { if (!rtState.crd) rtState.zkClient.getDataAsync(evt.getPath(), this, this); } else U.warn(log, "Received NodeDataChanged for unexpected path: " + evt.getPath()); } else if (evt.getType() == Event.EventType.NodeChildrenChanged) { if (evt.getPath().equals(zkPaths.aliveNodesDir)) rtState.zkClient.getChildrenAsync(evt.getPath(), this, this); else if (evt.getPath().equals(zkPaths.customEvtsDir)) rtState.zkClient.getChildrenAsync(evt.getPath(), this, this); else U.warn(log, "Received NodeChildrenChanged for unexpected path: " + evt.getPath()); } }
public void process(WatchedEvent event) throws Exception { if (EventType.NodeChildrenChanged.equals(event.getType())) { this.processNodeChildrenChanged(event); } else if (EventType.NodeDeleted.equals(event.getType())) { String application = CommonUtils.getApplication(this.endpoint); String parent = String.format("%s/%s/instances", CONSTANTS_ROOT_PATH, application); String current = event.getPath(); String path = String.format("%s/%s", parent, this.endpoint); if (StringUtils.equalsIgnoreCase(path, current)) { this.initializeCurrentClusterInstanceConfigIfNecessary(false); } // end-if (StringUtils.equalsIgnoreCase(path, current)) } }