How to use

StorageClientSettings

in

org.apache.bookkeeper.clients.config

/** Sets all property values using the given {@code StorageClientSettings} as a template. */
public StorageClientSettings.Builder mergeFrom(StorageClientSettings value) {
 StorageClientSettings_Builder _defaults = StorageClientSettings.newBuilder();
 if (!Objects.equals(value.numWorkerThreads(), _defaults.numWorkerThreads())) {
  numWorkerThreads(value.numWorkerThreads());
 }
 if (_defaults._unsetProperties.contains(StorageClientSettings_Builder.Property.SERVICE_URI)
   || !Objects.equals(value.serviceUri(), _defaults.serviceUri())) {
  serviceUri(value.serviceUri());
 }
 if (!Objects.equals(value.endpointResolver(), _defaults.endpointResolver())) {
  endpointResolver(value.endpointResolver());
 }
 if (!Objects.equals(value.usePlaintext(), _defaults.usePlaintext())) {
  usePlaintext(value.usePlaintext());
 }
 value.clientName().ifPresent(this::clientName);
 value.statsLogger().ifPresent(this::statsLogger);
 if (!Objects.equals(value.backoffPolicy(), _defaults.backoffPolicy())) {
  backoffPolicy(value.backoffPolicy());
 }
 if (!Objects.equals(value.enableServerSideRouting(), _defaults.enableServerSideRouting())) {
  enableServerSideRouting(value.enableServerSideRouting());
 }
 return (StorageClientSettings.Builder) this;
}

  @Override
  public StorageServerChannel apply(Endpoint endpoint) {
    StorageServerChannel channel = new StorageServerChannel(
      endpoint,
      Optional.empty(),
      settings.usePlaintext(),
      settings.endpointResolver());
    return interceptor
      .map(interceptor -> channel.intercept(interceptor))
      .orElse(channel);
  }
};

/** Creates a new builder using {@code value} as a template. */
public static StorageClientSettings.Builder from(StorageClientSettings value) {
 return StorageClientSettings.newBuilder().mergeFrom(value);
}

protected SimpleClientBase(StorageClientSettings settings,
              Resource<OrderedScheduler> schedulerResource,
              ManagedChannel managedChannel,
              boolean ownChannel) {
  this.settings = settings;
  this.managedChannel = managedChannel;
  this.ownChannel = ownChannel;
  this.channel = ClientInterceptors.intercept(
    managedChannel,
    new StorageContainerClientInterceptor(0L));
  this.schedulerResource = schedulerResource;
  this.scheduler = SharedResourceManager.shared().get(schedulerResource);
  this.retryUtils = RetryUtils.create(settings.backoffPolicy(), scheduler);
}

protected SimpleClientBase(StorageClientSettings settings,
              Resource<OrderedScheduler> schedulerResource) {
  this(
    settings,
    schedulerResource,
    GrpcChannels.createChannelBuilder(settings.serviceUri(), settings).build(),
    true);
}

/**
 * Build a {@link StorageAdminClient} client.
 *
 * @return a {@link StorageAdminClient} client.
 */
public StorageAdminClient buildAdmin() {
  checkNotNull(settings, "Storage client settings is null");
  if (settings.enableServerSideRouting()) {
    return new SimpleStorageAdminClientImpl(settings);
  } else {
    return new StorageAdminClientImpl(settings, ClientResources.create());
  }
}

/** Resets the state of this builder. */
public StorageClientSettings.Builder clear() {
 StorageClientSettings_Builder _defaults = StorageClientSettings.newBuilder();
 numWorkerThreads = _defaults.numWorkerThreads;
 serviceUri = _defaults.serviceUri;
 endpointResolver = _defaults.endpointResolver;
 usePlaintext = _defaults.usePlaintext;
 clientName = _defaults.clientName;
 statsLogger = _defaults.statsLogger;
 backoffPolicy = _defaults.backoffPolicy;
 enableServerSideRouting = _defaults.enableServerSideRouting;
 _unsetProperties.clear();
 _unsetProperties.addAll(_defaults._unsetProperties);
 return (StorageClientSettings.Builder) this;
}

public StorageServerClientManagerImpl(StorageClientSettings settings,
                   Resource<OrderedScheduler> schedulerResource,
                   Function<Endpoint, StorageServerChannel> channelFactory) {
  this.schedulerResource = schedulerResource;
  this.scheduler = SharedResourceManager.shared().get(schedulerResource);
  this.locationClient = new LocationClientImpl(settings, scheduler);
  this.channelManager = new StorageServerChannelManager(channelFactory);
  this.scChannelManager = new StorageContainerChannelManager(
    this.channelManager,
    this.locationClient,
    scheduler);
  this.rootRangeClient = new RootRangeClientImplWithRetries(
    new RootRangeClientImpl(
      scheduler,
      scChannelManager),
    settings.backoffPolicy(),
    scheduler
  );
  this.streamMetadataCache = new StreamMetadataCache(rootRangeClient);
  this.metaRangeClients = Maps.newConcurrentMap();
}

@SuppressWarnings("deprecation")
public LocationClientImpl(StorageClientSettings settings,
             OrderedScheduler scheduler) {
  this.settings = settings;
  this.scheduler = scheduler;
  this.channel = GrpcChannels.createChannelBuilder(
    settings.serviceUri(), settings
  ).build();
  this.locationService = GrpcUtils.configureGrpcStub(
    StorageContainerServiceGrpc.newFutureStub(channel),
    Optional.empty());
}

/**
 * Build a {@link StorageClient} client.
 *
 * @return a {@link StorageClient} client.
 */
public StorageClient build() {
  checkNotNull(settings, "Stream settings is null");
  checkArgument(validateNamespaceName(namespaceName), "Namespace name '" + namespaceName + "'is invalid");
  if (settings.enableServerSideRouting()) {
    return new SimpleStorageClientImpl(namespaceName, settings);
  } else {
    return new StorageClientImpl(
      namespaceName,
      settings,
      ClientResources.create());
  }
}

.withSettings(StorageClientSettings.newBuilder()
  .serviceUri(stateStorageServiceUrl)
  .clientName("functions-admin")

private void openTableImpl(String namespaceName,
              String tableName,
              CompletableFuture<PTable<ByteBuf, ByteBuf>> future) {
  FutureUtils.proxyTo(
    getStreamProperties(namespaceName, tableName).thenComposeAsync(props -> {
      if (log.isInfoEnabled()) {
        log.info("Retrieved table properties for table {}/{} : {}", namespaceName, tableName, props);
      }
      if (StorageType.TABLE != props.getStreamConf().getStorageType()) {
        return FutureUtils.exception(new ApiException(
          "Can't open a non-table storage entity : " + props.getStreamConf().getStorageType())
        );
      }
      return new PByteBufTableImpl(
        tableName,
        props,
        serverManager,
        scheduler.chooseThread(props.getStreamId()),
        settings.backoffPolicy()
      ).initialize();
    }),
    future
  );
}

StorageClientSettings_Builder _defaults = StorageClientSettings.newBuilder();

.withSettings(StorageClientSettings.newBuilder()
  .serviceUri("bk://localhost:4181")
  .backoffPolicy(Backoff.Jitter.of(

String tableName = instanceConfig.getFunctionDetails().getName();
StorageClientSettings settings = StorageClientSettings.newBuilder()
    .serviceUri(stateStorageServiceUrl)
    .clientName("function-" + tableNs + "/" + tableName)