Class BigtableInstanceAdminClient (2.77.0)

 // One instance per application.
 BigtableInstanceAdminClient client =  BigtableInstanceAdminClient.create("my-project");
 CreateInstanceRequest request = CreateInstanceRequest.of("my-instance")
   .addCluster("my-cluster", "us-east1-c", 3, StorageType.SSD);

 Instance instance = client.createInstance(request);

 // Cleanup during application shutdown.
 client.close();
 

 BigtableInstanceAdminSettings settings = BigtableInstanceAdminSettings.newBuilder()
   .setProjectId("my-project")
   .setCredentialsProvider(FixedCredentialsProvider.create(myCredentials))
   .build();

 BigtableInstanceAdminClient client = BigtableInstanceAdminClient.create(settings);
 

 BigtableInstanceAdminSettings.Builder settingsBuilder = BigtableInstanceAdminSettings.newBuilder()
   .setProjectId("my-project");

 settingsBuilder.stubSettings()
   .setEndpoint(myEndpoint);

 BigtableInstanceAdminClient client = BigtableInstanceAdminClient.create(settingsBuilder.build());
 

 AppProfile appProfile = client.createAppProfile(
   CreateAppProfileRequest.of("my-instance", "my-new-app-profile")
     .setRoutingPolicy(SingleClusterRoutingPolicy.of("my-cluster"))
 );
 

 ApiFuture<AppProfile> appProfileFuture = client.createAppProfileAsync(
   CreateAppProfileRequest.of("my-instance", "my-new-app-profile")
     .setRoutingPolicy(SingleClusterRoutingPolicy.of("my-cluster"))
 );

 AppProfile appProfile = appProfileFuture.get();
 

 Cluster cluster = client.createCluster(
   CreateClusterRequest.of("my-instance", "my-new-cluster")
     .setZone("us-east1-c")
     .setServeNodes(3)
     .setStorageType(StorageType.SSD)
 );
 

 ApiFuture<Cluster> clusterFuture = client.createClusterAsync(
   CreateClusterRequest.of("my-instance", "my-new-cluster")
     .setZone("us-east1-c")
     .setServeNodes(3)
     .setStorageType(StorageType.SSD)
 );

 Cluster cluster = clusterFuture.get();
 

 Instance instance = client.createInstance(
   CreateInstanceRequest.of("my-instance")
     .addCluster("my-cluster", "us-east1-c", 3, StorageType.SSD)
 );
 

 ApiFuture<Instance> instanceFuture = client.createInstanceAsync(
   CreateInstanceRequest.of("my-instance")
     .addCluster("my-cluster", "us-east1-c", 3, StorageType.SSD)
 );

 Instance instance = instanceFuture.get();
 

 LogicalView logicalView = client.createLogicalView(
   CreateLogicalViewRequest.of("my-instance", "my-new-logical-view")
     .setQuery(query)
 );
 

 ApiFuture<LogicalView> logicalViewFuture = client.createLogicalViewAsync(
   CreateLogicalViewRequest.of("my-instance", "my-new-logical-view")
     .setQuery(query)
 );

 LogicalView logicalView = logicalViewFuture.get();
 

 MaterializedView materializedView = client.createMaterializedView(
   CreateMaterializedViewRequest.of("my-instance", "my-new-materialized-view")
     .setQuery(query)
 );
 

 ApiFuture<MaterializedView> materializedViewFuture = client.createMaterializedViewAsync(
   CreateMaterializedViewRequest.of("my-instance", "my-new-materialized-view")
     .setQuery(query)
 );

 MaterializedView materializedView = materializedViewFuture.get();
 

 client.deleteAppProfile("my-instance", "my-app-profile");
 

 client.deleteAppProfile("my-instance", "my-app-profile", true);
 

 ApiFuture<Void> deleteFuture = client.deleteAppProfileAsync("my-instance", "my-app-profile");

 deleteFuture.get();
 

 ApiFuture<Void> deleteFuture = client.deleteAppProfileAsync("my-instance", "my-app-profile", true);

 deleteFuture.get();
 

 client.deleteCluster("my-instance", "my-cluster");
 

 ApiFuture<Void> future = client.deleteClusterAsync("my-instance", "my-cluster");
 future.get();
 

 client.deleteInstance("my-instance");
 

 ApiFuture<Void> deleteFuture = client.deleteInstanceAsync("my-instance");
 deleteFuture.get();
 

 client.deleteLogicalView("my-instance", "my-logical-view");
 

 ApiFuture<Void> deleteFuture = client.deleteLogicalViewAsync("my-instance", "my-logical-view");

 deleteFuture.get();
 

 client.deleteMaterializedView("my-instance", "my-materialized-view");
 

 ApiFuture<Void> deleteFuture = client.deleteMaterializedViewAsync("my-instance", "my-materialized-view");

 deleteFuture.get();
 

 Cluster cluster = client.disableClusterAutoscaling("my-instance", "my-cluster", 3);
 

 ApiFuture<Cluster> clusterApiFuture = client.disableClusterAutoscalingAsync("my-instance", "my-cluster", 3);
 Cluster cluster = clusterApiFuture.get();
 

 if(client.exists("my-instance")) {
   System.out.println("Instance exists");
 }
 

 ApiFuture<Boolean> found = client.existsAsync("my-instance");

 ApiFutures.addCallback(
  found,
  new ApiFutureCallback<Boolean>() {
    public void onSuccess(Boolean found) {
      if (found) {
        System.out.println("Instance exists");
      } else {
        System.out.println("Instance not found");
      }
    }

    public void onFailure(Throwable t) {
      t.printStackTrace();
    }
  },
  MoreExecutors.directExecutor()
 );
 

 AppProfile appProfile = client.getAppProfile("my-instance", "my-app-profile");
 

 ApiFuture<AppProfile> appProfileFuture = client.getAppProfileAsync("my-instance", "my-app-profile");

 AppProfile appProfile = appProfileFuture.get();
 

 Cluster cluster = client.getCluster("my-instance", "my-cluster");
 

 ApiFuture<Cluster> clusterFuture = client.getClusterAsync("my-instance", "my-cluster");
 Cluster cluster = clusterFuture.get();
 

 Policy policy = client.getIamPolicy("my-instance");
 for(Map.Entry<Role, Set<Identity>> entry : policy.getBindings().entrySet()) {
   System.out.printf("Role: %s Identities: %s
", entry.getKey(), entry.getValue());
 }
 

 ApiFuture<Policy> policyFuture = client.getIamPolicyAsync("my-instance");

 ApiFutures.addCallback(policyFuture,
   new ApiFutureCallback<Policy>() {
     public void onSuccess(Policy policy) {
       for (Entry<Role, Set<Identity>> entry : policy.getBindings().entrySet()) {
         System.out.printf("Role: %s Identities: %s
", entry.getKey(), entry.getValue());
       }
     }

     public void onFailure(Throwable t) {
       t.printStackTrace();
     }
   },
   MoreExecutors.directExecutor());
 

 Instance instance = client.getInstance("my-instance");
 

 ApiFuture<Instance> instanceFuture = client.getInstanceAsync("my-instance");
 Instance instance = instanceFuture.get();
 

 LogicalView logicalView = client.getLogicalView("my-instance", "my-logical-view");
 

 ApiFuture<LogicalView> logicalViewFuture = client.getLogicalViewAsync("my-instance", "my-logical-view");

 LogicalView logicalView = logicalViewFuture.get();
 

 MaterializedView materializedView = client.getMaterializedView("my-instance", "my-materialized-view");
 

 ApiFuture<MaterializedView> materializedViewFuture = client.getMaterializedViewAsync("my-instance", "my-materialized-view");

 MaterializedView materializedView = materializedViewFuture.get();
 

 List<AppProfile> appProfiles = client.listAppProfiles("my-instance");
 

 ApiFuture<List<AppProfile>> appProfilesFuture = client.listAppProfilesAsync("my-instance");

 List<AppProfile> appProfiles = appProfileFuture.get();
 

 try {
   List<Cluster> clusters = client.listClusters("my-instance");
 } catch (PartialListClustersException e) {
   System.out.println("The following zones are unavailable: " + e.getUnavailableZones());
   System.out.println("But the following clusters are reachable: " + e.getClusters())
 }
 

 ApiFuture<Cluster> clustersFuture = client.listClustersAsync("my-instance");

 ApiFutures.addCallback(clustersFuture, new ApiFutureCallback<List<Cluster>>() {
   public void onFailure(Throwable t) {
     if (t instanceof PartialListClustersException) {
       PartialListClustersException partialError = (PartialListClustersException)t;
       System.out.println("The following zones are unavailable: " + partialError.getUnavailableZones());
       System.out.println("But the following clusters are reachable: " + partialError.getClusters());
     } else {
       t.printStackTrace();
     }
   }

   public void onSuccess(List<Cluster> result) {
     System.out.println("Found a complete set of instances: " + result);
   }
 }, MoreExecutors.directExecutor());
 

 try {
   List<Instance> instances = client.listInstances();
 } catch (PartialListInstancesException e) {
   System.out.println("The following zones are unavailable: " + e.getUnavailableZones());
   System.out.println("But the following instances are reachable: " + e.getInstances());
 }
 

 ApiFuture<Instance> instancesFuture = client.listInstancesAsync();

 ApiFutures.addCallback(instancesFuture, new ApiFutureCallback<List<Instance>>() {
   public void onFailure(Throwable t) {
     if (t instanceof PartialListInstancesException) {
       PartialListInstancesException partialError = (PartialListInstancesException)t;
       System.out.println("The following zones are unavailable: " + partialError.getUnavailableZones());
       System.out.println("But the following instances are reachable: " + partialError.getInstances());
     } else {
       t.printStackTrace();
     }
   }

   public void onSuccess(List<Instance> result) {
     System.out.println("Found a complete set of instances: " + result);
   }
 }, MoreExecutors.directExecutor());
 

 List<LogicalView> logicalViews = client.listLogicalViews("my-instance");
 

 ApiFuture<List<LogicalView>> logicalViewsFuture = client.listLogicalViewsAsync("my-instance");

 List<LogicalView> logicalViews = logicalViewFuture.get();
 

 List<MaterializedView> materializedViews = client.listMaterializedViews("my-instance");
 

 ApiFuture<List<MaterializedView>> materializedViewsFuture = client.listMaterializedViewsAsync("my-instance");

 List<MaterializedView> materializedViews = materializedViewFuture.get();
 

 Cluster cluster = client.resizeCluster("my-instance", "my-cluster", 30);
 

 ApiFuture<Cluster> clusterFuture = client.resizeCluster("my-instance", "my-cluster", 30);
 Cluster cluster = clusterFuture.get();
 

 Policy newPolicy = client.setIamPolicy("my-instance",
   Policy.newBuilder()
     .addIdentity(Role.of("bigtable.user"), Identity.user("someone@example.com"))
     .addIdentity(Role.of("bigtable.admin"), Identity.group("admins@example.com"))
     .build());
 

 ApiFuture<Policy> newPolicyFuture = client.setIamPolicyAsync("my-instance",
   Policy.newBuilder()
     .addIdentity(Role.of("bigtable.user"), Identity.user("someone@example.com"))
     .addIdentity(Role.of("bigtable.admin"), Identity.group("admins@example.com"))
     .build());

 ApiFutures.addCallback(policyFuture,
   new ApiFutureCallback<Policy>() {
     public void onSuccess(Policy policy) {
       for (Entry<Role, Set<Identity>> entry : policy.getBindings().entrySet()) {
         System.out.printf("Role: %s Identities: %s
", entry.getKey(), entry.getValue());
       }
     }

     public void onFailure(Throwable t) {
       t.printStackTrace();
     }
   },
   MoreExecutors.directExecutor());
 

 List<String> grantedPermissions = client.testIamPermission("my-instance",
   "bigtable.tables.readRows", "bigtable.tables.mutateRows");
 

 ApiFuture<List<String>> grantedPermissionsFuture = client.testIamPermissionAsync("my-instance",
   "bigtable.tables.readRows", "bigtable.tables.mutateRows");

 ApiFutures.addCallback(grantedPermissionsFuture,
   new ApiFutureCallback<List<String>>() {
     public void onSuccess(List<String> grantedPermissions) {
       System.out.println("Has read access: " + grantedPermissions.contains("bigtable.tables.readRows"));
       System.out.println("Has write access: " + grantedPermissions.contains("bigtable.tables.mutateRows"));
     }

     public void onFailure(Throwable t) {
       t.printStackTrace();
     }
   },
   MoreExecutors.directExecutor());
 

 AppProfile existingAppProfile = client.getAppProfile("my-instance", "my-app-profile");

 AppProfile updatedAppProfile = client.updateAppProfile(
   UpdateAppProfileRequest.of(existingAppProfile)
     .setRoutingPolicy(SingleClusterRoutingPolicy.of("my-cluster"))
 );
 

 ApiFuture<AppProfile> existingAppProfileFuture = client.getAppProfileAsync("my-instance", "my-app-profile");

 ApiFuture<AppProfile> updatedAppProfileFuture = ApiFutures.transformAsync(
   existingAppProfileFuture,
   new ApiAsyncFunction<AppProfile, AppProfile>() {
     public ApiFuture<AppProfile> apply(AppProfile existingAppProfile) {
       return client.updateAppProfileAsync(
         UpdateAppProfileRequest.of(existingAppProfile)
           .setRoutingPolicy(SingleClusterRoutingPolicy.of("my-other-cluster"))
       );
     }
   },
   MoreExecutors.directExecutor()
 );

 ApiFuture<AppProfile> appProfile = updatedAppProfileFuture.get();
 

 ClusterAutoscalingConfig clusterAutoscalingConfig =
      ClusterAutoscalingConfig.of("my-instance", "my-cluster")
          .setMinNodes(1)
          .setMaxNodes(4)
          .setCpuUtilizationTargetPercent(40);
 Cluster cluster = client.updateClusterAutoscalingConfig(clusterAutoscalingConfig);
 

 ClusterAutoscalingConfig clusterAutoscalingConfig =
      ClusterAutoscalingConfig.of(targetInstanceId, targetClusterId)
          .setMinNodes(1)
          .setMaxNodes(4)
          .setCpuUtilizationTargetPercent(40);

  ApiFuture<Cluster> clusterApiFuture = client.updateClusterAutoscalingConfigAsync(clusterAutoscalingConfig);
  Cluster cluster = clusterApiFuture.get();
 

 Instance instance = client.updateInstance(
   UpdateInstanceRequest.of("my-instance")
     .setProductionType()
 );
 

 ApiFuture<Instance> instanceFuture = client.updateInstanceAsync(
   UpdateInstanceRequest.of("my-instance")
     .setProductionType()
 );

 Instance instance = instanceFuture.get();
 

 LogicalView existingLogicalView = client.getLogicalView("my-instance", "my-logical-view");

 LogicalView updatedLogicalView = client.updateLogicalView(
   UpdateLogicalViewRequest.of(existingLogicalView)
     .setQuery(query)
 );
 

 ApiFuture<LogicalView> existingLogicalViewFuture = client.getLogicalViewAsync("my-instance", "my-logical-view");

 ApiFuture<LogicalView> updatedLogicalViewFuture = ApiFutures.transformAsync(
   existingLogicalViewFuture,
   new ApiAsyncFunction<LogicalView, LogicalView>() {
     public ApiFuture<LogicalView> apply(LogicalView existingLogicalView) {
       return client.updateLogicalViewAsync(
         UpdateLogicalViewRequest.of(existingLogicalView)
           .setQuery(query)
       );
     }
   },
   MoreExecutors.directExecutor()
 );

 ApiFuture<LogicalView> logicalView = updatedLogicalViewFuture.get();
 

 MaterializedView existingMaterializedView = client.getMaterializedView("my-instance", "my-materialized-view");

 MaterializedView updatedMaterializedView = client.updateMaterializedView(
   UpdateMaterializedViewRequest.of(existingMaterializedView)
     .setDeletionProtection(false)
 );
 

 ApiFuture<MaterializedView> existingMaterializedViewFuture = client.getMaterializedViewAsync("my-instance", "my-materialized-view");

 ApiFuture<MaterializedView> updatedMaterializedViewFuture = ApiFutures.transformAsync(
   existingMaterializedViewFuture,
   new ApiAsyncFunction<MaterializedView, MaterializedView>() {
     public ApiFuture<MaterializedView> apply(MaterializedView existingMaterializedView) {
       return client.updateMaterializedViewAsync(
         UpdateMaterializedViewRequest.of(existingMaterializedView)
           .setDeletionProtection(false)
       );
     }
   },
   MoreExecutors.directExecutor()
 );

 ApiFuture<MaterializedView> materializedView = updatedMaterializedViewFuture.get();