momento.sdk.StorageControlClient Maven / Gradle / Ivy

Go to download
package momento.sdk;

import static momento.sdk.ValidationUtils.checkStoreNameValid;

import com.google.common.util.concurrent.ListenableFuture;
import grpc.control_client._CreateStoreRequest;
import grpc.control_client._CreateStoreResponse;
import grpc.control_client._DeleteStoreRequest;
import grpc.control_client._DeleteStoreResponse;
import grpc.control_client._ListStoresRequest;
import grpc.control_client._ListStoresResponse;
import java.util.concurrent.CompletableFuture;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import momento.sdk.auth.CredentialProvider;
import momento.sdk.config.StorageConfiguration;
import momento.sdk.exceptions.CacheServiceExceptionMapper;
import momento.sdk.exceptions.SdkException;
import momento.sdk.exceptions.StoreAlreadyExistsException;
import momento.sdk.responses.storage.CreateStoreResponse;
import momento.sdk.responses.storage.DeleteStoreResponse;
import momento.sdk.responses.storage.ListStoresResponse;
import momento.sdk.responses.storage.StoreInfo;

/** Client for interacting with Scs Control Plane. */
final class StorageControlClient extends ScsClientBase {

  private final CredentialProvider credentialProvider;
  private final StorageControlGrpcStubsManager controlGrpcStubsManager;

  StorageControlClient(
      @Nonnull CredentialProvider credentialProvider, StorageConfiguration configuration) {
    super(null);
    this.credentialProvider = credentialProvider;
    this.controlGrpcStubsManager =
        new StorageControlGrpcStubsManager(credentialProvider, configuration);
  }

  CompletableFuture createStore(String storeName) {
    try {
      checkStoreNameValid(storeName);

      return sendCreateStore(storeName);
    } catch (Exception e) {
      return CompletableFuture.completedFuture(
          new CreateStoreResponse.Error(CacheServiceExceptionMapper.convert(e)));
    }
  }

  CompletableFuture deleteStore(String cacheName) {
    try {
      checkStoreNameValid(cacheName);

      return sendDeleteStore(cacheName);
    } catch (Exception e) {
      return CompletableFuture.completedFuture(
          new DeleteStoreResponse.Error(CacheServiceExceptionMapper.convert(e)));
    }
  }

  CompletableFuture listStores() {
    try {
      return sendListStores();
    } catch (Exception e) {
      return CompletableFuture.completedFuture(
          new ListStoresResponse.Error(CacheServiceExceptionMapper.convert(e)));
    }
  }

  private CompletableFuture sendCreateStore(String storeName) {
    final Supplier> stubSupplier =
        () ->
            controlGrpcStubsManager
                .getStub()
                .createStore(_CreateStoreRequest.newBuilder().setStoreName(storeName).build());

    final Function<_CreateStoreResponse, CreateStoreResponse> success =
        rsp -> new CreateStoreResponse.Success();

    final Function failure =
        e -> {
          final SdkException sdkException = CacheServiceExceptionMapper.convert(e);
          if (sdkException instanceof StoreAlreadyExistsException) {
            return new CreateStoreResponse.AlreadyExists();
          }
          return new CreateStoreResponse.Error(CacheServiceExceptionMapper.convert(e));
        };

    return executeGrpcFunction(stubSupplier, success, failure);
  }

  private CompletableFuture sendDeleteStore(String storeName) {
    final Supplier> stubSupplier =
        () ->
            controlGrpcStubsManager
                .getStub()
                .deleteStore(_DeleteStoreRequest.newBuilder().setStoreName(storeName).build());

    final Function<_DeleteStoreResponse, DeleteStoreResponse> success =
        rsp -> new DeleteStoreResponse.Success();

    final Function failure =
        e -> new DeleteStoreResponse.Error(CacheServiceExceptionMapper.convert(e));

    return executeGrpcFunction(stubSupplier, success, failure);
  }

  private CompletableFuture sendListStores() {

    final Supplier> stubSupplier =
        () ->
            controlGrpcStubsManager
                .getStub()
                .listStores(_ListStoresRequest.newBuilder().setNextToken("").build());

    final Function<_ListStoresResponse, ListStoresResponse> success =
        rsp ->
            new ListStoresResponse.Success(
                rsp.getStoreList().stream()
                    .map(s -> new StoreInfo(s.getStoreName()))
                    .collect(Collectors.toList()));

    final Function failure =
        e -> new ListStoresResponse.Error(CacheServiceExceptionMapper.convert(e));

    return executeGrpcFunction(stubSupplier, success, failure);
  }

  @Override
  public void doClose() {
    controlGrpcStubsManager.close();
  }
}