org.apache.curator.framework.listen.ListenerContainer Java Examples

public boolean mockSync(TaskDO taskDO) throws Exception {
    List<ChildData> childDataList = spy(ArrayList.class);
    ListenerContainer<PathChildrenCacheListener> listeners = mock(ListenerContainer.class);
    childDataList.add(new ChildData(TEST_PATH, null, null));
    when(taskDO.getTaskId()).thenReturn(TEST_TASK_ID);
    when(taskDO.getSourceClusterId()).thenReturn(TEST_SOURCE_CLUSTER_ID);
    when(taskDO.getDestClusterId()).thenReturn(TEST_DEST_CLUSTER_ID);
    CuratorFramework curatorFramework = mock(CuratorFramework.class);
    doReturn(curatorFramework).when(zookeeperServerHolder).get(any(), any());
    doReturn(destNamingService).when(nacosServerHolder).get(any(), any());
    doReturn(pathChildrenCache).when(zookeeperSyncToNacosService).getPathCache(any());
    when(pathChildrenCache.getCurrentData()).thenReturn(childDataList);
    doReturn(ClusterTypeEnum.ZK).when(skyWalkerCacheServices).getClusterType(any());
    when(pathChildrenCache.getListenable()).thenReturn(listeners);
    return zookeeperSyncToNacosService.sync(taskDO);
}
 

@Inject
public BaragonStateWatcher(final BaragonStateFetcher stateFetcher,
                           Set<BaragonStateListener> listeners,
                           @Baragon PersistentWatcher watcher) {
  this.stateFetcher = stateFetcher;
  this.listenerContainer = new ListenerContainer<>();
  this.executor = newExecutor();
  this.versionQueue = new LinkedTransferQueue<>();
  for (BaragonStateListener listener : listeners) {
    listenerContainer.addListener(listener);
  }

  watcher.getEventListenable().addListener(new EventListener() {

    @Override
    public void newEvent(Event event) {
      switch (event.getType()) {
        case NODE_UPDATED:
          int version = event.getStat().getVersion();
          versionQueue.add(version);
          executor.submit(new Runnable() {

            @Override
            public void run() {
              updateToLatestVersion();
            }
          });
          break;
        case NODE_DELETED:
          LOG.warn("Baragon state node was deleted");
          break;
        default:
          LOG.warn("Unrecognized event type {}", event.getType());
          break;
      }
    }
  }, executor);

  watcher.start();
}
 

/**
 * Return the cache listenable
 *
 * @return listenable
 */
public ListenerContainer<NodeCacheListener> getListenable()
{
    Preconditions.checkState(state.get() != State.CLOSED, "Closed");

    return listeners;
}
 

public CuratorFrameworkImpl(CuratorFrameworkFactory.Builder builder)
{
    ZookeeperFactory localZookeeperFactory = makeZookeeperFactory(builder.getZookeeperFactory());
    this.client = new CuratorZookeeperClient(localZookeeperFactory, builder.getEnsembleProvider(), builder.getSessionTimeoutMs(), builder.getConnectionTimeoutMs(), new Watcher()
    {
        @Override
        public void process(WatchedEvent watchedEvent)
        {
            CuratorEvent event = new CuratorEventImpl(CuratorFrameworkImpl.this, CuratorEventType.WATCHED, watchedEvent.getState().getIntValue(), unfixForNamespace(watchedEvent.getPath()), null, null, null, null, null, watchedEvent, null);
            processEvent(event);
        }
    }, builder.getRetryPolicy(), builder.canBeReadOnly());

    listeners = new ListenerContainer<CuratorListener>();
    unhandledErrorListeners = new ListenerContainer<UnhandledErrorListener>();
    backgroundOperations = new DelayQueue<OperationAndData<?>>();
    namespace = new NamespaceImpl(this, builder.getNamespace());
    threadFactory = getThreadFactory(builder);
    maxCloseWaitMs = builder.getMaxCloseWaitMs();
    connectionStateManager = new ConnectionStateManager(this, builder.getThreadFactory());
    compressionProvider = builder.getCompressionProvider();
    aclProvider = builder.getAclProvider();
    state = new AtomicReference<CuratorFrameworkState>(CuratorFrameworkState.LATENT);
    useContainerParentsIfAvailable = builder.useContainerParentsIfAvailable();

    byte[] builderDefaultData = builder.getDefaultData();
    defaultData = (builderDefaultData != null) ? Arrays.copyOf(builderDefaultData, builderDefaultData.length) : new byte[0];
    authInfos = buildAuths(builder);

    failedDeleteManager = new FailedDeleteManager(this);
    namespaceFacadeCache = new NamespaceFacadeCache(this);
}
 

protected BasePathChildrenCacheListener(long version, ListenerContainer<PathChildrenCacheListener> listenerContainer) {
	m_version = version;
	m_eventBus = PlexusComponentLocator.lookup(EventBus.class);
	m_clusterStateHolder = PlexusComponentLocator.lookup(ClusterStateHolder.class);
	m_listenerContainer = listenerContainer;
}
 

/**
 * Re-attach the {@link TreeCacheListener TreeCacheListeners}.
 */
private void reattachTreeCacheListeners() {

	TreeCache treeCache = zookeeperServiceWatch.getCache();

	Listenable<TreeCacheListener> listenable = treeCache.getListenable();

	/**
	 * All registered TreeCacheListeners except {@link ZookeeperServiceWatch}.
	 * Usually, "otherListeners" will be empty because Spring Cloud Zookeeper only
	 * adds "zookeeperServiceWatch" bean as {@link TreeCacheListener}.
	 */
	List<TreeCacheListener> otherListeners = new LinkedList<>();

	if (listenable instanceof ListenerContainer) {
		ListenerContainer<TreeCacheListener> listenerContainer = (ListenerContainer) listenable;
		listenerContainer.forEach(listener -> {
			/**
			 * Even though "listener" is an instance of
			 * {@link ZookeeperServiceWatch}, "zookeeperServiceWatch" bean that
			 * was enhanced by AOP is different from the former, thus it's
			 * required to exclude "listener".
			 */
			if (!(listener instanceof ZookeeperServiceWatch)) {
				otherListeners.add(listener);
			}
			return null;
		});

		// remove all TreeCacheListeners temporarily
		listenerContainer.clear();
		// re-store zookeeperServiceWatch, and make sure it's first one
		// now "beforeChildEvent" is available for Spring AOP
		listenerContainer.addListener(zookeeperServiceWatch);
		// re-store others
		otherListeners.forEach(listenerContainer::addListener);
	}
	else {
		if (logger.isWarnEnabled()) {
			logger.warn(
					"Tell me which version Curator framework current application used? I will do better :D");
		}
	}
}
 

protected LeaderMetaVersionListener(long version, ListenerContainer<NodeCacheListener> listenerContainer) {
	super(version, listenerContainer);
}
 

protected BaseMetaVersionListener(long version, ListenerContainer<NodeCacheListener> listenerContainer) {
	super(version, listenerContainer);
}
 

protected void loadAndAddLeaderMetaVersionListener(long version) {
	ListenerContainer<NodeCacheListener> listenerContainer = m_leaderMetaVersionCache.getListenable();
	listenerContainer
	      .addListener(new LeaderMetaVersionListener(version, listenerContainer), m_eventBus.getExecutor());
	loadLeaderMeta(version);
}
 

protected void addBaseMetaVersionListener(long version) throws DalException {
	ListenerContainer<NodeCacheListener> listenerContainer = m_baseMetaVersionCache.getListenable();
	listenerContainer.addListener(new BaseMetaVersionListener(version, listenerContainer), m_eventBus.getExecutor());
}
 

protected MetaServerListListener(long version, ListenerContainer<PathChildrenCacheListener> listenerContainer) {
	super(version, listenerContainer);
}
 

protected BaseMetaVersionListener(long version, ListenerContainer<NodeCacheListener> listenerContainer) {
	super(version, listenerContainer);
}
 

protected void addMetaServerListListener(long version) throws Exception {
	ListenerContainer<PathChildrenCacheListener> listenerContainer = m_metaServerListCache.getListenable();
	listenerContainer.addListener(new MetaServerListListener(version, listenerContainer), m_eventBus.getExecutor());
}
 

protected void addBaseMetaVersionListener(long version) throws DalException {
	ListenerContainer<NodeCacheListener> listenerContainer = m_baseMetaVersionCache.getListenable();
	listenerContainer.addListener(new BaseMetaVersionListener(version, listenerContainer), m_eventBus.getExecutor());
}
 

protected BaseNodeCacheListener(long version, ListenerContainer<NodeCacheListener> listenerContainer) {
	m_version = version;
	m_eventBus = PlexusComponentLocator.lookup(EventBus.class);
	m_clusterStateHolder = PlexusComponentLocator.lookup(ClusterStateHolder.class);
	m_listenerContainer = listenerContainer;
}
 

/**
 * Return the manager for put listeners
 *
 * @return put listener container
 */
@Override
public ListenerContainer<QueuePutListener<T>> getPutListenerContainer()
{
    return queue.getPutListenerContainer();
}
 

/**
 * Return the manager for put listeners
 *
 * @return put listener container
 */
@Override
public ListenerContainer<QueuePutListener<T>> getPutListenerContainer()
{
    return putListenerContainer;
}
 

/**
 * Return the manager for put listeners
 *
 * @return put listener container
 */
@Override
public ListenerContainer<QueuePutListener<T>> getPutListenerContainer()
{
    return queue.getPutListenerContainer();
}
 

@Override
public ListenerContainer<QueuePutListener<T>> getPutListenerContainer()
{
    return queue.getPutListenerContainer();
}
 

/**
 * Return the listenable
 *
 * @return listenable
 */
public ListenerContainer<ConnectionStateListener> getListenable()
{
    return listeners;
}
 

/**
 * Return the manager for put listeners
 *
 * @return put listener container
 */
ListenerContainer<QueuePutListener<T>> getPutListenerContainer();
 

/**
 * Return the cache listenable
 *
 * @return listenable
 */
public ListenerContainer<PathChildrenCacheListener> getListenable()
{
    return listeners;
}
 

/**
 * Returns the listenable
 *
 * @return listenable
 */
public ListenerContainer<SharedValueListener> getListenable();
 

/**
 * Returns the listenable
 *
 * @return listenable
 */
public ListenerContainer<SharedValueListener> getListenable()
{
    return listeners;
}