Java ConnectionStateListener类代码示例

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
@Inject
public SingularityCuratorProvider(final SingularityConfiguration configuration, final Set<ConnectionStateListener> connectionStateListeners) {

  checkNotNull(configuration, "configuration is null");
  checkNotNull(connectionStateListeners, "connectionStateListeners is null");

  ZooKeeperConfiguration zookeeperConfig = configuration.getZooKeeperConfiguration();

  this.curatorFramework = CuratorFrameworkFactory.builder()
      .defaultData(null)
      .sessionTimeoutMs(zookeeperConfig.getSessionTimeoutMillis())
      .connectionTimeoutMs(zookeeperConfig.getConnectTimeoutMillis())
      .connectString(zookeeperConfig.getQuorum())
      .retryPolicy(new ExponentialBackoffRetry(zookeeperConfig.getRetryBaseSleepTimeMilliseconds(), zookeeperConfig.getRetryMaxTries()))
      .namespace(zookeeperConfig.getZkNamespace()).build();

  for (ConnectionStateListener connectionStateListener : connectionStateListeners) {
    curatorFramework.getConnectionStateListenable().addListener(connectionStateListener);
  }
}
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
@Override
public ListenableFuture<Boolean> setMetricsCacheLocation(
    TopologyMaster.MetricsCacheLocation location,
    String topologyName) {
  client.getConnectionStateListenable().addListener(new ConnectionStateListener() {
    @Override
    public void stateChanged(CuratorFramework arg0, ConnectionState arg1) {
      if (arg1 != ConnectionState.CONNECTED) {
        // if not the first time successful connection, fail fast
        throw new RuntimeException("Unexpected state change to: " + arg1.name());
      }
    }
  });
  return createNode(
      StateLocation.METRICSCACHE_LOCATION, topologyName, location.toByteArray(), true);
}
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
@Override
public void stateChanged(CuratorFramework client, ConnectionState newState) {
    if (newState == ConnectionState.CONNECTED) {
        isConnected.set(true);
        if (!isFirstConnection.get()) {
            for (ConnectionStateListener listener : listenerStateProxy.getListeners()) {
                listener.stateChanged(client, ConnectionState.RECONNECTED);
            }
        }
        return;
    }

    if (newState == ConnectionState.LOST) {
        isConnected.set(false);
        isFirstConnection.set(false);
        retryConnection();
    }
}
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
@Override
protected void before() throws Throwable
{
    ts = new TestingServer();
    curator = CuratorFrameworkFactory.builder()
                                     .namespace("ezkr")
                                     .connectString(ts.getConnectString())
                                     .retryPolicy(new BoundedExponentialBackoffRetry(10, 100, 7))
                                     .build();
    curator.getConnectionStateListenable().addListener(new ConnectionStateListener()
    {
        @Override
        public void stateChanged(final CuratorFramework client, final ConnectionState newState)
        {

        }
    });
    curator.start();
}
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
@Test
public void     testBasic() throws Exception
{
    Timing                          timing = new Timing();
    DistributedDelayQueue<Long>     queue = null;
    CuratorFramework                client = CuratorFrameworkFactory.newClient(server.getConnectString(), timing.session(), timing.connection(), new RetryOneTime(1));
    client.start();
    try
    {
        BlockingQueueConsumer<Long> consumer = new BlockingQueueConsumer<Long>(Mockito.mock(ConnectionStateListener.class));
        queue = QueueBuilder.builder(client, consumer, new LongSerializer(), "/test").buildDelayQueue();
        queue.start();

        queue.put(1L, System.currentTimeMillis() + 1000);
        Thread.sleep(100);
        Assert.assertEquals(consumer.size(), 0);    // delay hasn't been reached

        Long        value = consumer.take(timing.forWaiting().seconds(), TimeUnit.SECONDS);
        Assert.assertEquals(value, Long.valueOf(1));
    }
    finally
    {
        CloseableUtils.closeQuietly(queue);
        CloseableUtils.closeQuietly(client);
    }
}
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
private BlockingQueueConsumer<String> makeConsumer(final CountDownLatch latch)
{
    ConnectionStateListener connectionStateListener = new ConnectionStateListener()
    {
        @Override
        public void stateChanged(CuratorFramework client, ConnectionState newState)
        {
        }
    };

    return new BlockingQueueConsumer<String>(connectionStateListener)
    {
        @Override
        public void consumeMessage(String message) throws Exception
        {
            if ( latch != null )
            {
                latch.await();
            }
            super.consumeMessage(message);
        }
    };
}
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
private CuratorFramework buildCuratorWithZookeeperDirectly(Configuration configuration) {
      LOGGER.debug("configuring direct zookeeper connection.");
      
      CuratorFramework curator = CuratorFrameworkFactory.newClient(
              this.zookeeperConnectionString,
              configuration.getInt(ZOOKEEPER_SESSION_TIMEOUT_MILLIS.getPropertyName()),
              configuration.getInt(ZOOKEEPER_CONNECTION_TIMEOUT_MILLIS.getPropertyName()),
              buildZookeeperRetryPolicy(configuration));
      curator.getConnectionStateListenable().addListener(new ConnectionStateListener() {
	public void stateChanged(CuratorFramework client, ConnectionState newState) {
		LOGGER.debug("Connection state to ZooKeeper changed: " + newState);
	}
});
      
      return curator;
  }
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
private ZookeeperClient(){
	//1000 是重试间隔时间基数，3 是重试次数
    RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
    zkClient = createWithOptions(zkConnectionString, retryPolicy, 2000, 10000);
    zkClient.getConnectionStateListenable().addListener(new ConnectionStateListener() {
        @Override
        public void stateChanged(CuratorFramework client, ConnectionState newState) {
            logger.info("CuratorFramework state changed: {}", newState);
            if(newState == ConnectionState.CONNECTED || newState == ConnectionState.RECONNECTED){
            	for (String key : listeners.keySet()) {
            		System.out.println(key);
		IZoopkeeperListener listener = listeners.get(key);
		listener.execute(client);
	}
            }
        }
    });
    zkClient.getUnhandledErrorListenable().addListener(new UnhandledErrorListener() {
        @Override
        public void unhandledError(String message, Throwable e) {
            logger.info("CuratorFramework unhandledError: {}", message);
        }
    });
    zkClient.start();
}
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
/**
 * Builds a {@link org.apache.curator.framework.CuratorFramework} from the specified {@link java.util.Map<String, ?>}.
 */
private synchronized CuratorFramework buildCuratorFramework(ZookeeperConfig curatorConfig) {
    CuratorFrameworkFactory.Builder builder = CuratorFrameworkFactory.builder()
            .ensembleProvider(new FixedEnsembleProvider(curatorConfig.getZookeeperUrl()))
            .connectionTimeoutMs(curatorConfig.getZookeeperConnectionTimeOut())
            .sessionTimeoutMs(curatorConfig.getZookeeperSessionTimeout())
            .retryPolicy(new RetryNTimes(curatorConfig.getZookeeperRetryMax(), curatorConfig.getZookeeperRetryInterval()));

    if (!StringUtils.isNullOrBlank(curatorConfig.getZookeeperPassword())) {
        String scheme = "digest";
        byte[] auth = ("fabric:" + PasswordEncoder.decode(curatorConfig.getZookeeperPassword())).getBytes();
        builder = builder.authorization(scheme, auth).aclProvider(aclProvider.get());
    }

    CuratorFramework framework = builder.build();

    for (ConnectionStateListener listener : connectionStateListeners) {
        framework.getConnectionStateListenable().addListener(listener);
    }
    return framework;
}
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
public RestablishingKeeper(String hostList)  {
  RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 5);
  client = CuratorFrameworkFactory.newClient(hostList, retryPolicy);
  client.getConnectionStateListenable().addListener(new ConnectionStateListener(){
    @Override
    public void stateChanged(CuratorFramework framework, ConnectionState state) {
      LOGGER.debug("State change "+ state);
      if (state.equals(ConnectionState.CONNECTED) || state.equals(ConnectionState.RECONNECTED)){
        reEstablished.incrementAndGet();
        try {
          onReconnect(framework.getZookeeperClient().getZooKeeper(), framework);
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
      }
    }});
}
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
@Override
public void addListener(Object listener) {
    ConnectionStateListener stateListener = (ConnectionStateListener) listener;
    if (curator != null) {
        curator.getConnectionStateListenable().addListener(stateListener);
    }
    listeners.add(stateListener);
}
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
@Override
public void removeListener(Object listener) {
    ConnectionStateListener stateListener = (ConnectionStateListener) listener;
    if (curator != null) {
        curator.getConnectionStateListenable().removeListener(stateListener);
    }
    listeners.remove(stateListener);
}
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
public void clearCurator() {
    for (ConnectionStateListener stateListener : listeners) {
        if (curator != null) {
            curator.getConnectionStateListenable().removeListener(stateListener);
        }
    }
}
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
public void updateCurator(CuratorFramework curator) {
    this.curator = curator;
    for (ConnectionStateListener stateListener : listeners) {
        if (this.curator != null) {
            this.curator.getConnectionStateListenable().addListener(stateListener);
        }
    }
}
 

import org.apache.curator.framework.state.ConnectionStateListener; //导入依赖的package包/类
/**
 * Creates a KafkaConsumerCache object. Before it is used, you must call
 * startCache()
 * 
 * @param apiId
 * @param s
 * @param metrics
 */
public KafkaConsumerCache(String apiId,  MetricsSet metrics) {

	if (apiId == null) {
		throw new IllegalArgumentException("API Node ID must be specified.");
	}

	fApiId = apiId;
//	fSettings = s;
	fMetrics = metrics;
	String strkSetting_ZkBasePath= AJSCPropertiesMap.getProperty(CambriaConstants.msgRtr_prop,kSetting_ZkBasePath);
	if(null==strkSetting_ZkBasePath)strkSetting_ZkBasePath = kDefault_ZkBasePath;
	fBaseZkPath = strkSetting_ZkBasePath;

	fConsumers = new ConcurrentHashMap<String, KafkaConsumer>();
	fSweepScheduler = Executors.newScheduledThreadPool(1);

	curatorConsumerCache = null;

	status = Status.NOT_STARTED;

	listener = new ConnectionStateListener() {
		public void stateChanged(CuratorFramework client, ConnectionState newState) {
			if (newState == ConnectionState.LOST) {
				log.info("ZooKeeper connection expired");
				handleConnectionLoss();
			} else if (newState == ConnectionState.READ_ONLY) {
				log.warn("ZooKeeper connection set to read only mode.");
			} else if (newState == ConnectionState.RECONNECTED) {
				log.info("ZooKeeper connection re-established");
				handleReconnection();
			} else if (newState == ConnectionState.SUSPENDED) {
				log.warn("ZooKeeper connection has been suspended.");
				handleConnectionSuspended();
			}
		}
	};
}