org.apache.curator.ensemble.EnsembleProvider Java Examples

/**
 * @param zookeeperFactory factory for creating {@link ZooKeeper} instances
 * @param ensembleProvider the ensemble provider
 * @param sessionTimeoutMs session timeout
 * @param connectionTimeoutMs connection timeout
 * @param waitForShutdownTimeoutMs default timeout fo close operation
 * @param watcher default watcher or null
 * @param retryPolicy the retry policy to use
 * @param canBeReadOnly if true, allow ZooKeeper client to enter
 *                      read only mode in case of a network partition. See
 *                      {@link ZooKeeper#ZooKeeper(String, int, Watcher, long, byte[], boolean)}
 *                      for details
 * @since 4.0.2
 */
public CuratorZookeeperClient(ZookeeperFactory zookeeperFactory, EnsembleProvider ensembleProvider,
        int sessionTimeoutMs, int connectionTimeoutMs, int waitForShutdownTimeoutMs, Watcher watcher,
        RetryPolicy retryPolicy, boolean canBeReadOnly)
{
    if ( sessionTimeoutMs < connectionTimeoutMs )
    {
        log.warn(String.format("session timeout [%d] is less than connection timeout [%d]", sessionTimeoutMs, connectionTimeoutMs));
    }

    retryPolicy = Preconditions.checkNotNull(retryPolicy, "retryPolicy cannot be null");
    ensembleProvider = Preconditions.checkNotNull(ensembleProvider, "ensembleProvider cannot be null");

    this.connectionTimeoutMs = connectionTimeoutMs;
    this.waitForShutdownTimeoutMs = waitForShutdownTimeoutMs;
    state = new ConnectionState(zookeeperFactory, ensembleProvider, sessionTimeoutMs, watcher, tracer, canBeReadOnly);
    setRetryPolicy(retryPolicy);
}
 

/**
 * @param zookeeperFactory factory for creating {@link ZooKeeper} instances
 * @param ensembleProvider the ensemble provider
 * @param sessionTimeoutMs session timeout
 * @param connectionTimeoutMs connection timeout
 * @param watcher default watcher or null
 * @param retryPolicy the retry policy to use
 * @param canBeReadOnly if true, allow ZooKeeper client to enter
 *                      read only mode in case of a network partition. See
 *                      {@link ZooKeeper#ZooKeeper(String, int, Watcher, long, byte[], boolean)}
 *                      for details
 */
public CuratorZookeeperClient(ZookeeperFactory zookeeperFactory, EnsembleProvider ensembleProvider, int sessionTimeoutMs, int connectionTimeoutMs, Watcher watcher, RetryPolicy retryPolicy, boolean canBeReadOnly)
{
    if ( sessionTimeoutMs < connectionTimeoutMs )
    {
        log.warn(String.format("session timeout [%d] is less than connection timeout [%d]", sessionTimeoutMs, connectionTimeoutMs));
    }

    retryPolicy = Preconditions.checkNotNull(retryPolicy, "retryPolicy cannot be null");
    ensembleProvider = Preconditions.checkNotNull(ensembleProvider, "ensembleProvider cannot be null");

    this.connectionTimeoutMs = connectionTimeoutMs;
    state = new ConnectionState(zookeeperFactory, ensembleProvider, sessionTimeoutMs, connectionTimeoutMs, watcher, tracer, canBeReadOnly);
    setRetryPolicy(retryPolicy);
}
 

private static EnsembleProvider defaultDelegate(String connectString) {
    // ZooKeeper 3.4.13 and 3.5.5 are have the fixed HostProvider
    if (Info.MAJOR < 3
            || (Info.MAJOR == 3
                && (Info.MINOR < 4
                    || (Info.MINOR == 4 && Info.MICRO < 13)
                    || (Info.MINOR == 5 && Info.MICRO < 5)
                )
            )
    ) {
        return new FixedEnsembleProvider(connectString);
    } else {
        return new ResolvingEnsembleProviderDelegate(connectString);
    }
}
 

HandleHolder(ZookeeperFactory zookeeperFactory, Watcher watcher, EnsembleProvider ensembleProvider, int sessionTimeout, boolean canBeReadOnly)
{
    this.zookeeperFactory = zookeeperFactory;
    this.watcher = watcher;
    this.ensembleProvider = ensembleProvider;
    this.sessionTimeout = sessionTimeout;
    this.canBeReadOnly = canBeReadOnly;
}
 

ConnectionState(ZookeeperFactory zookeeperFactory, EnsembleProvider ensembleProvider, int sessionTimeoutMs, Watcher parentWatcher, AtomicReference<TracerDriver> tracer, boolean canBeReadOnly)
{
    this.ensembleProvider = ensembleProvider;
    this.tracer = tracer;
    if ( parentWatcher != null )
    {
        parentWatchers.offer(parentWatcher);
    }

    handleHolder = new HandleHolder(zookeeperFactory, this, ensembleProvider, sessionTimeoutMs, canBeReadOnly);
}
 

public AwsDeployment(AwsDeploymentConfig config, int port) throws Exception {
  this.config = config;
  objectMapper = new ObjectMapper();
  EnsembleProvider ensembleProvider = buildEnsembleProvider(config.getExhibitorConfig());
  this.curatorClient = buildCuratorClient(ensembleProvider, config.getZookeeperConfig());
  AwsIdentity identity = AwsIdentity.getIdentity(config);
  DeploymentPayload payload =
      new DeploymentPayload(identity.privateIp, port, identity.availabilityZone);
  this.groupMember =
      buildGroupMember(curatorClient, config.getZookeeperConfig(), identity.instanceId, payload);
}
 

private CuratorFramework buildCuratorClient(
    EnsembleProvider ensembleProvider, ZookeeperConfig config) throws Exception {
  RetryPolicy retryPolicy = buildRetryPolicy(config.getRetryConfig());
  CuratorFramework curatorClient =
      CuratorFrameworkFactory.builder()
          .ensembleProvider(ensembleProvider)
          .retryPolicy(retryPolicy)
          .build();
  return curatorClient;
}
 

private EnsembleProvider buildEnsembleProvider(ExhibitorConfig config) throws Exception {
  Exhibitors exhibitors = new Exhibitors(config.getHostnames(), config.getRestPort(), () -> "");
  RetryPolicy retryPolicy = buildRetryPolicy(config.getRetryConfig());
  ExhibitorEnsembleProvider ensembleProvider =
      new ExhibitorEnsembleProvider(
          exhibitors,
          new DefaultExhibitorRestClient(),
          config.getRestUriPath(),
          config.getPollingMs(),
          retryPolicy);
  ensembleProvider.pollForInitialEnsemble();
  return ensembleProvider;
}
 

@Bean(destroyMethod = "close")
@ConditionalOnMissingBean
public CuratorFramework curatorFramework(RetryPolicy retryPolicy,
		ZookeeperProperties properties,
		ObjectProvider<CuratorFrameworkCustomizer> optionalCuratorFrameworkCustomizerProvider,
		ObjectProvider<EnsembleProvider> optionalEnsembleProvider,
		ObjectProvider<TracerDriver> optionalTracerDriverProvider) throws Exception {
	CuratorFrameworkFactory.Builder builder = CuratorFrameworkFactory.builder();

	EnsembleProvider ensembleProvider = optionalEnsembleProvider.getIfAvailable();
	if (ensembleProvider != null) {
		builder.ensembleProvider(ensembleProvider);
	}
	else {
		builder.connectString(properties.getConnectString());
	}
	builder.sessionTimeoutMs((int) properties.getSessionTimeout().toMillis())
			.connectionTimeoutMs((int) properties.getConnectionTimeout().toMillis())
			.retryPolicy(retryPolicy);

	optionalCuratorFrameworkCustomizerProvider.orderedStream()
			.forEach(curatorFrameworkCustomizer -> curatorFrameworkCustomizer
					.customize(builder));

	CuratorFramework curator = builder.build();
	optionalTracerDriverProvider.ifAvailable(tracerDriver -> {
		if (curator.getZookeeperClient() != null) {
			curator.getZookeeperClient().setTracerDriver(tracerDriver);
		}
	});

	curator.start();
	log.trace("blocking until connected to zookeeper for "
			+ properties.getBlockUntilConnectedWait()
			+ properties.getBlockUntilConnectedUnit());
	curator.blockUntilConnected(properties.getBlockUntilConnectedWait(),
			properties.getBlockUntilConnectedUnit());
	log.trace("connected to zookeeper");
	return curator;
}
 

private EnsembleProvider createEnsembleProvider() throws Exception {
    switch (conn.getType()) {
        case EXHIBITOR:
            final Exhibitors exhibitors = new Exhibitors(
                    conn.getAddresses().stream().map(AddressPort::getAddress).collect(Collectors.toList()),
                    conn.getAddresses().get(0).getPort(),
                    () -> {
                        throw new RuntimeException("There is no backup connection string (or it is wrong)");
                    });
            final ExhibitorRestClient exhibitorRestClient = new DefaultExhibitorRestClient();
            final ExhibitorEnsembleProvider result = new ExhibitorEnsembleProvider(
                    exhibitors,
                    exhibitorRestClient,
                    "/exhibitor/v1/cluster/list",
                    EXHIBITOR_POLLING_MS,
                    new ExponentialBackoffRetry(EXHIBITOR_RETRY_TIME, EXHIBITOR_RETRY_MAX)) {
                @Override
                public String getConnectionString() {
                    return super.getConnectionString() + conn.getPathPrepared();
                }
            };
            result.pollForInitialEnsemble();
            return result;
        case ZOOKEEPER:
            final String addressesJoined = conn.getAddresses().stream()
                    .map(AddressPort::asAddressPort)
                    .collect(Collectors.joining(","));
            return new ChrootedFixedEnsembleProvider(addressesJoined, conn.getPathPrepared());
        default:
            throw new RuntimeException("Connection type " + conn.getType() + " is not supported");
    }
}
 

private void startCuratorFramework(ZookeeperEnsemble primaryEnsemble) throws InitializationException {
	Builder builder = CuratorFrameworkFactory.builder();

	builder.connectionTimeoutMs(m_config.getZkConnectionTimeoutMillis());
	builder.maxCloseWaitMs(m_config.getZkCloseWaitMillis());
	builder.namespace(m_config.getZkNamespace());
	builder.retryPolicy(new RetryNTimes(m_config.getZkRetries(), m_config.getSleepMsBetweenRetries()));
	builder.sessionTimeoutMs(m_config.getZkSessionTimeoutMillis());
	builder.threadFactory(HermesThreadFactory.create("Broker-Zk", true));
	builder.ensembleProvider(new EnsembleProvider() {

		@Override
		public void start() throws Exception {
		}

		@Override
		public String getConnectionString() {
			return m_primaryZookeeperEnsemble.get().getConnectionString();
		}

		@Override
		public void close() throws IOException {
		}
	});

	m_client = builder.build();
	m_client.start();
	try {
		m_client.blockUntilConnected();
		log.info("Conneted to zookeeper({}).", JSON.toJSONString(primaryEnsemble));
	} catch (InterruptedException e) {
		throw new InitializationException(e.getMessage(), e);
	}
}
 

private void startCuratorFramework(ZookeeperEnsemble primaryEnsemble) throws InitializationException {
	Builder builder = CuratorFrameworkFactory.builder();

	builder.connectionTimeoutMs(m_config.getZkConnectionTimeoutMillis());
	builder.maxCloseWaitMs(m_config.getZkCloseWaitMillis());
	builder.namespace(m_config.getZkNamespace());
	builder.retryPolicy(new RetryNTimes(m_config.getZkRetries(), m_config.getSleepMsBetweenRetries()));
	builder.sessionTimeoutMs(m_config.getZkSessionTimeoutMillis());
	builder.threadFactory(HermesThreadFactory.create("MetaService-Zk", true));
	builder.ensembleProvider(new EnsembleProvider() {

		@Override
		public void start() throws Exception {
		}

		@Override
		public String getConnectionString() {
			return m_primaryZookeeperEnsemble.get().getConnectionString();
		}

		@Override
		public void close() throws IOException {
		}
	});

	m_client = builder.build();
	m_client.start();
	try {
		m_client.blockUntilConnected();
		log.info("Conneted to zookeeper({}).", JSON.toJSONString(primaryEnsemble));
	} catch (InterruptedException e) {
		throw new InitializationException(e.getMessage(), e);
	}
}
 

HandleHolder(ZookeeperFactory zookeeperFactory, Watcher watcher, EnsembleProvider ensembleProvider, int sessionTimeout, boolean canBeReadOnly)
{
    this.zookeeperFactory = zookeeperFactory;
    this.watcher = watcher;
    this.ensembleProvider = ensembleProvider;
    this.sessionTimeout = sessionTimeout;
    this.canBeReadOnly = canBeReadOnly;
}
 

ConnectionState(ZookeeperFactory zookeeperFactory, EnsembleProvider ensembleProvider, int sessionTimeoutMs, int connectionTimeoutMs, Watcher parentWatcher, AtomicReference<TracerDriver> tracer, boolean canBeReadOnly)
{
    this.ensembleProvider = ensembleProvider;
    this.sessionTimeoutMs = sessionTimeoutMs;
    this.connectionTimeoutMs = connectionTimeoutMs;
    this.tracer = tracer;
    if ( parentWatcher != null )
    {
        parentWatchers.offer(parentWatcher);
    }

    zooKeeper = new HandleHolder(zookeeperFactory, this, ensembleProvider, sessionTimeoutMs, canBeReadOnly);
}
 

@Bean
EnsembleProvider ensembleProvider(TestingServer testingServer) {
	return new FixedEnsembleProvider(testingServer.getConnectString());
}
 

public EnsembleProvider getEnsembleProvider()
{
    return ensembleProvider;
}
 

public EnsembleProvider getEnsembleProvider()
{
    return ensembleProvider;
}
 

EnsembleTracker(CuratorFramework client, EnsembleProvider ensembleProvider)
{
    this.client = client.newWatcherRemoveCuratorFramework();
    this.ensembleProvider = ensembleProvider;
}
 

EnsembleProvider getEnsembleProvider()
{
    return ensembleProvider;
}
 

EnsembleProvider getEnsembleProvider()
{
    return ensembleProvider;
}
 

@VisibleForTesting
ResolvingEnsembleProvider(EnsembleProvider delegate) {
    _delegate = delegate;
}
 

/**
 * @param ensembleProvider the ensemble provider
 * @param sessionTimeoutMs session timeout
 * @param connectionTimeoutMs connection timeout
 * @param watcher default watcher or null
 * @param retryPolicy the retry policy to use
 */
public CuratorZookeeperClient(EnsembleProvider ensembleProvider, int sessionTimeoutMs, int connectionTimeoutMs, Watcher watcher, RetryPolicy retryPolicy)
{
    this(new DefaultZookeeperFactory(), ensembleProvider, sessionTimeoutMs, connectionTimeoutMs, watcher, retryPolicy, false);
}
 

/**
 * @param zookeeperFactory factory for creating {@link ZooKeeper} instances
 * @param ensembleProvider the ensemble provider
 * @param sessionTimeoutMs session timeout
 * @param connectionTimeoutMs connection timeout
 * @param watcher default watcher or null
 * @param retryPolicy the retry policy to use
 * @param canBeReadOnly if true, allow ZooKeeper client to enter
 *                      read only mode in case of a network partition. See
 *                      {@link ZooKeeper#ZooKeeper(String, int, Watcher, long, byte[], boolean)}
 *                      for details
 */
public CuratorZookeeperClient(ZookeeperFactory zookeeperFactory, EnsembleProvider ensembleProvider, int sessionTimeoutMs, int connectionTimeoutMs, Watcher watcher, RetryPolicy retryPolicy, boolean canBeReadOnly)
{
    this(zookeeperFactory, ensembleProvider, sessionTimeoutMs, connectionTimeoutMs, 0, watcher, retryPolicy, canBeReadOnly);
}
 

/**
 * @param ensembleProvider the ensemble provider
 * @param sessionTimeoutMs session timeout
 * @param connectionTimeoutMs connection timeout
 * @param watcher default watcher or null
 * @param retryPolicy the retry policy to use
 */
public CuratorZookeeperClient(EnsembleProvider ensembleProvider, int sessionTimeoutMs, int connectionTimeoutMs, Watcher watcher, RetryPolicy retryPolicy)
{
    this(new DefaultZookeeperFactory(), ensembleProvider, sessionTimeoutMs, connectionTimeoutMs, watcher, retryPolicy, false);
}