Added compute_instance_not_consume_reservation sample and test.

TetyanaYahodska · TetyanaYahodska · commit 3ce6598c4304 · 2024-10-09T17:40:34.000+02:00
diff --git a/compute/cloud-client/src/main/java/compute/reservation/CreateInstanceNotConsumeReservation.java b/compute/cloud-client/src/main/java/compute/reservation/CreateInstanceNotConsumeReservation.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package compute.reservation;
+
+// [START compute_instance_not_consume_reservation]
+
+import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.NO_RESERVATION;
+
+import com.google.cloud.compute.v1.AttachedDisk;
+import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
+import com.google.cloud.compute.v1.Instance;
+import com.google.cloud.compute.v1.InstancesClient;
+import com.google.cloud.compute.v1.NetworkInterface;
+import com.google.cloud.compute.v1.Operation;
+import com.google.cloud.compute.v1.ReservationAffinity;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public class CreateInstanceNotConsumeReservation {
+  public static void main(String[] args)
+      throws IOException, ExecutionException, InterruptedException, TimeoutException {
+    // TODO(developer): Replace these variables before running the sample.
+    // Project ID or project number of the Cloud project you want to use.
+    String projectId = "YOUR_PROJECT_ID";
+    // Name of the zone in which you want to create the reservation.
+    String zone = "us-central1-a";
+    // Name of the VM instance you want to query.
+    String instanceName = "YOUR_INSTANCE_NAME";
+    // Machine type of the instances in the reservation.
+    String machineType = "n2-standard-32";
+
+    createInstanceNotConsumeReservation(projectId, zone, instanceName, machineType);
+  }
+
+  // Create a virtual machine that explicitly doesn't consume reservations
+  public static void createInstanceNotConsumeReservation(
+      String projectId, String zone, String instanceName, String machineType)
+      throws IOException, InterruptedException, ExecutionException, TimeoutException {
+    // Below are sample values that can be replaced.
+    // sourceImage: path to the operating system image to mount.
+    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
+    // Network interface to associate with the instance.
+    String sourceImage = String
+        .format("projects/debian-cloud/global/images/family/%s", "debian-11");
+    String network = "global/networks/default"; // Example network
+
+    // Initialize client that will be used to send requests. This client only needs to be created
+    // once, and can be reused for multiple requests.
+    try (InstancesClient instancesClient = InstancesClient.create()) {
+
+      // Create the attached disk object
+      AttachedDisk attachedDisk =
+          AttachedDisk.newBuilder()
+              .setBoot(true)
+              .setAutoDelete(true)
+              .setInitializeParams(
+                  AttachedDiskInitializeParams.newBuilder()
+                      .setSourceImage(sourceImage)
+                      .build())
+              .build();
+
+      // Create the network interface object
+      NetworkInterface networkInterface =
+          NetworkInterface.newBuilder().setName(network).build();
+
+      // Set reservation affinity to "none"
+      ReservationAffinity reservationAffinity =
+          ReservationAffinity.newBuilder()
+              .setConsumeReservationType(NO_RESERVATION.toString())
+              .build();
+
+      // Create the instance object
+      Instance instance =
+          Instance.newBuilder()
+              .setName(instanceName)
+              .setMachineType("zones/" + zone + "/machineTypes/" + machineType)
+              .addDisks(attachedDisk)
+              .addNetworkInterfaces(networkInterface)
+              .setReservationAffinity(reservationAffinity)
+              .build();
+
+      // Wait for the operation to complete.
+      Operation response = instancesClient.insertAsync(
+          projectId, zone, instance).get(3, TimeUnit.MINUTES);
+
+      if (response.hasError()) {
+        System.out.println("Instance creation failed ! ! " + response);
+        return;
+      }
+      System.out.println("Operation Status: " + response.getStatus());
+    }
+  }
+}
+// [END compute_instance_not_consume_reservation]
diff --git a/compute/cloud-client/src/main/java/compute/reservation/CreateReservation.java b/compute/cloud-client/src/main/java/compute/reservation/CreateReservation.java
@@ -16,6 +16,8 @@
 
 package compute.reservation;
 
+// [START compute_reservation_create]
+
 import com.google.cloud.compute.v1.AcceleratorConfig;
 import com.google.cloud.compute.v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk;
 import com.google.cloud.compute.v1.AllocationSpecificSKUAllocationReservedInstanceProperties;
@@ -28,7 +30,6 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
-// [START compute_reservation_create]
 public class CreateReservation {
 
   public static void main(String[] args)
diff --git a/compute/cloud-client/src/test/java/compute/SnippetsIT.java b/compute/cloud-client/src/test/java/compute/SnippetsIT.java
@@ -102,7 +102,7 @@ public static void setUp()
     Util.cleanUpExistingInstances("my-new-test-instance", PROJECT_ID, ZONE);
     Util.cleanUpExistingInstances("encrypted-test-instance", PROJECT_ID, ZONE);
     Util.cleanUpExistingInstances("test-instance-with-ssd", PROJECT_ID, ZONE);
-    Util.cleanUpExistingInstanceTemplates("test-inst-temp-regional", PROJECT_ID);
+    Util.cleanUpExistingRegionalInstanceTemplates("test-inst-temp-regional", PROJECT_ID, ZONE);
 
     compute.CreateInstance.createInstance(PROJECT_ID, ZONE, MACHINE_NAME);
     compute.CreateInstance.createInstance(PROJECT_ID, ZONE, MACHINE_NAME_LIST_INSTANCE);
diff --git a/compute/cloud-client/src/test/java/compute/Util.java b/compute/cloud-client/src/test/java/compute/Util.java
@@ -16,22 +16,21 @@
 
 package compute;
 
-import com.google.api.gax.rpc.NotFoundException;
-import com.google.cloud.compute.v1.AggregatedListInstancesRequest;
 import com.google.cloud.compute.v1.Disk;
 import com.google.cloud.compute.v1.DisksClient;
 import com.google.cloud.compute.v1.Instance;
-import com.google.cloud.compute.v1.Instance.Status;
 import com.google.cloud.compute.v1.InstanceTemplate;
 import com.google.cloud.compute.v1.InstanceTemplatesClient;
 import com.google.cloud.compute.v1.InstanceTemplatesClient.ListPagedResponse;
 import com.google.cloud.compute.v1.InstancesClient;
-import com.google.cloud.compute.v1.InstancesClient.AggregatedListPagedResponse;
-import com.google.cloud.compute.v1.InstancesScopedList;
-import com.google.cloud.compute.v1.ListInstanceTemplatesRequest;
+import com.google.cloud.compute.v1.ListRegionInstanceTemplatesRequest;
 import com.google.cloud.compute.v1.RegionDisksClient;
+import com.google.cloud.compute.v1.RegionInstanceTemplatesClient;
 import com.google.cloud.compute.v1.Reservation;
 import com.google.cloud.compute.v1.ReservationsClient;
+import com.google.cloud.compute.v1.Snapshot;
+import com.google.cloud.compute.v1.StoragePool;
+import compute.deleteprotection.SetDeleteProtection;
 import compute.reservation.DeleteReservation;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
@@ -40,7 +39,6 @@
 import java.time.OffsetDateTime;
 import java.time.temporal.ChronoUnit;
 import java.util.Base64;
-import java.util.Map;
 import java.util.Random;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeoutException;
@@ -52,7 +50,7 @@ public abstract class Util {
   // resources
   // and delete the listed resources based on the timestamp.
 
-  private static final int DELETION_THRESHOLD_TIME_HOURS = 24;
+  private static final int DELETION_THRESHOLD_TIME_HOURS = 30;
   // comma separate list of zone names
   private static final String TEST_ZONES_NAME = "JAVA_DOCS_COMPUTE_TEST_ZONES";
   private static final String DEFAULT_ZONES = "us-central1-a,us-west1-a,asia-south1-a";
@@ -61,70 +59,67 @@ public abstract class Util {
   // has creation timestamp >24 hours.
   public static void cleanUpExistingInstanceTemplates(String prefixToDelete, String projectId)
       throws IOException, ExecutionException, InterruptedException, TimeoutException {
-    for (InstanceTemplate template : listFilteredInstanceTemplates(projectId, prefixToDelete)
-        .iterateAll()) {
-      if (!template.hasCreationTimestamp()) {
-        continue;
+    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {
+      ListPagedResponse templates = instanceTemplatesClient.list(projectId);
+      for (InstanceTemplate instanceTemplate : templates.iterateAll()) {
+        if (containPrefixToDelete(instanceTemplate, prefixToDelete)
+            && isCreatedBeforeThresholdTime(instanceTemplate.getCreationTimestamp())
+            && instanceTemplate.isInitialized()) {
+          DeleteInstanceTemplate.deleteInstanceTemplate(projectId, instanceTemplate.getName());
+        }
       }
-      if (template.getName().contains(prefixToDelete)
-          && isCreatedBeforeThresholdTime(template.getCreationTimestamp())
-          && template.isInitialized()) {
-        DeleteInstanceTemplate.deleteInstanceTemplate(projectId, template.getName());
+    }
+  }
+
+  // Delete regional instance templates which starts with the given prefixToDelete and
+  // has creation timestamp >24 hours.
+  public static void cleanUpExistingRegionalInstanceTemplates(
+      String prefixToDelete, String projectId, String zone)
+      throws IOException, ExecutionException, InterruptedException, TimeoutException {
+    try (RegionInstanceTemplatesClient instanceTemplatesClient =
+             RegionInstanceTemplatesClient.create()) {
+      String region = zone.substring(0, zone.lastIndexOf('-'));
+      ListRegionInstanceTemplatesRequest request =
+          ListRegionInstanceTemplatesRequest.newBuilder()
+              .setProject(projectId)
+              .setRegion(region)
+              .build();
+
+      for (InstanceTemplate instanceTemplate :
+          instanceTemplatesClient.list(request).iterateAll()) {
+        if (containPrefixToDeleteAndZone(instanceTemplate, prefixToDelete, zone)
+            && isCreatedBeforeThresholdTime(instanceTemplate.getCreationTimestamp())
+            && instanceTemplate.isInitialized()) {
+          DeleteRegionalInstanceTemplate.deleteRegionalInstanceTemplate(
+              projectId, region, instanceTemplate.getName());
+        }
       }
     }
   }
 
   // Delete instances which starts with the given prefixToDelete and
   // has creation timestamp >24 hours.
   public static void cleanUpExistingInstances(String prefixToDelete, String projectId,
-      String instanceZone)
+                                              String instanceZone)
       throws IOException, ExecutionException, InterruptedException, TimeoutException {
-    for (Map.Entry<String, InstancesScopedList> instanceGroup : listFilteredInstances(
-        projectId, prefixToDelete).iterateAll()) {
-      for (Instance instance : instanceGroup.getValue().getInstancesList()) {
-        if (!instance.hasCreationTimestamp()) {
-          continue;
+    try (InstancesClient instancesClient = InstancesClient.create()) {
+      for (Instance instance : instancesClient.list(projectId, instanceZone).iterateAll()) {
+        if (instance.getDeletionProtection()
+            && isCreatedBeforeThresholdTime(instance.getCreationTimestamp())) {
+          SetDeleteProtection.setDeleteProtection(
+              projectId, instanceZone, instance.getName(), false);
         }
-        if (instance.getName().contains(prefixToDelete)
-            && isCreatedBeforeThresholdTime(instance.getCreationTimestamp())
-            && instance.getStatus().equalsIgnoreCase(Status.RUNNING.toString())) {
+        if (containPrefixToDeleteAndZone(instance, prefixToDelete, instanceZone)
+            && isCreatedBeforeThresholdTime(instance.getCreationTimestamp())) {
           DeleteInstance.deleteInstance(projectId, instanceZone, instance.getName());
         }
       }
     }
   }
 
-  public static AggregatedListPagedResponse listFilteredInstances(
-      String project, String instanceNamePrefix) throws IOException {
-    try (InstancesClient instancesClient = InstancesClient.create()) {
-
-      AggregatedListInstancesRequest aggregatedListInstancesRequest = AggregatedListInstancesRequest
-          .newBuilder()
-          .setProject(project)
-          .setFilter(String.format("name:%s", instanceNamePrefix))
-          .build();
-
-      return instancesClient
-          .aggregatedList(aggregatedListInstancesRequest);
-    }
-  }
-
-  public static ListPagedResponse listFilteredInstanceTemplates(
-      String projectId, String instanceTemplatePrefix) throws IOException {
-    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {
-      ListInstanceTemplatesRequest listInstanceTemplatesRequest =
-          ListInstanceTemplatesRequest.newBuilder()
-              .setProject(projectId)
-              .setFilter(String.format("name:%s", instanceTemplatePrefix))
-              .build();
-
-      return instanceTemplatesClient.list(listInstanceTemplatesRequest);
-    }
-  }
-
   public static boolean isCreatedBeforeThresholdTime(String timestamp) {
     return OffsetDateTime.parse(timestamp).toInstant()
-        .isBefore(Instant.now().minus(DELETION_THRESHOLD_TIME_HOURS, ChronoUnit.HOURS));
+        .isBefore(Instant.now().minus(DELETION_THRESHOLD_TIME_HOURS, ChronoUnit.MINUTES));
   }
 
   public static String getBase64EncodedKey() {
@@ -185,25 +180,65 @@ public static String getEnvVar(String envVarName, String defaultValue) {
     return val;
   }
 
-  // Delete reservations which starts with the given prefixToDelete and
+  // Delete reservation which starts with the given prefixToDelete and
   // has creation timestamp >24 hours.
   public static void cleanUpExistingReservations(
       String prefixToDelete, String projectId, String zone)
       throws IOException, ExecutionException, InterruptedException, TimeoutException {
     try (ReservationsClient reservationsClient = ReservationsClient.create()) {
       for (Reservation reservation : reservationsClient.list(projectId, zone).iterateAll()) {
-        if (!reservationsClient.list(projectId, zone).iterateAll().iterator().hasNext()) {
-          break;
-        }
-        if (reservation.getName().contains(prefixToDelete)
+        if (containPrefixToDeleteAndZone(reservation, prefixToDelete, zone)
             && isCreatedBeforeThresholdTime(reservation.getCreationTimestamp())) {
-          try {
-            DeleteReservation.deleteReservation(projectId, zone, reservation.getName());
-          } catch (NotFoundException e) {
-            System.err.println("Reservation not found, skipping deletion:" + reservation.getName());
-          }
+          DeleteReservation.deleteReservation(projectId, zone, reservation.getName());
         }
       }
     }
   }
+
+  public static boolean containPrefixToDeleteAndZone(
+      Object resource, String prefixToDelete, String zone) {
+    boolean containPrefixAndZone = false;
+    try {
+      if (resource instanceof Instance) {
+        containPrefixAndZone = ((Instance) resource).getName().contains(prefixToDelete)
+            && ((Instance) resource).getZone().contains(zone);
+      }
+      if (resource instanceof InstanceTemplate) {
+        containPrefixAndZone = ((InstanceTemplate) resource).getName().contains(prefixToDelete)
+            && ((InstanceTemplate) resource).getRegion()
+            .contains(zone.substring(0, zone.lastIndexOf('-')));
+      }
+      if (resource instanceof Reservation) {
+        containPrefixAndZone = ((Reservation) resource).getName().contains(prefixToDelete)
+            && ((Reservation) resource).getZone().contains(zone);
+      }
+      if (resource instanceof Disk) {
+        containPrefixAndZone = ((Disk) resource).getName().contains(prefixToDelete)
+            && ((Disk) resource).getZone().contains(zone);
+      }
+      if (resource instanceof StoragePool) {
+        containPrefixAndZone = ((StoragePool) resource).getName().contains(prefixToDelete)
+            && ((StoragePool) resource).getZone().contains(zone);
+      }
+    } catch (NullPointerException e) {
+      System.err.println("Resource not found, skipping deletion:");
+    }
+    return containPrefixAndZone;
+  }
+
+  public static boolean containPrefixToDelete(
+      Object resource, String prefixToDelete) {
+    boolean containPrefixToDelete = false;
+    try {
+      if (resource instanceof InstanceTemplate) {
+        containPrefixToDelete = ((InstanceTemplate) resource).getName().contains(prefixToDelete);
+      }
+      if (resource instanceof Snapshot) {
+        containPrefixToDelete = ((Snapshot) resource).getName().contains(prefixToDelete);
+      }
+    } catch (NullPointerException e) {
+      System.err.println("Resource not found, skipping deletion:");
+    }
+    return containPrefixToDelete;
+  }
 }
diff --git a/compute/cloud-client/src/test/java/compute/reservation/CrudOperationReservationIT.java b/compute/cloud-client/src/test/java/compute/reservation/CrudOperationReservationIT.java
diff --git a/compute/cloud-client/src/test/java/compute/reservation/ReservationIT.java b/compute/cloud-client/src/test/java/compute/reservation/ReservationIT.java
