Added compute_template_not_consume_reservation sample, fixed tests

Author: TetyanaYahodska

compute/cloud-client/src/main/java/compute/reservation/CreateTemplateNotConsumeReservation.java

@@ -0,0 +1,116 @@
+/*
+ * 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_template_not_consume_reservation]
+
+import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.NO_RESERVATION;
+
+import com.google.cloud.compute.v1.AccessConfig;
+import com.google.cloud.compute.v1.AttachedDisk;
+import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
+import com.google.cloud.compute.v1.InsertInstanceTemplateRequest;
+import com.google.cloud.compute.v1.InstanceProperties;
+import com.google.cloud.compute.v1.InstanceTemplate;
+import com.google.cloud.compute.v1.InstanceTemplatesClient;
+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 CreateTemplateNotConsumeReservation {
+  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 template you want to query.
+    String templateName = "YOUR_INSTANCE_TEMPLATE_NAME";
+    // Machine type of the template.
+    String machineType = "n2-standard-32";
+
+    createTemplateNotConsumeReservation(projectId, templateName, machineType);
+  }
+
+  // Create a template that explicitly doesn't consume any reservations.
+  public static void createTemplateNotConsumeReservation(
+      String projectId, String templateName, String machineType)
+      throws IOException, InterruptedException, ExecutionException, TimeoutException {
+    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {
+      // 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");
+
+      // The template describes the size and source image of the boot disk
+      // to attach to the instance.
+      AttachedDisk attachedDisk = AttachedDisk.newBuilder()
+          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
+              .setSourceImage(sourceImage)
+              .setDiskType("pd-balanced")
+              .setDiskSizeGb(250).build())
+          .setAutoDelete(true)
+          .setBoot(true).build();
+
+      // The template connects the instance to the `default` network,
+      // without specifying a subnetwork.
+      NetworkInterface networkInterface = NetworkInterface.newBuilder()
+          .setName("global/networks/default")
+          // The template lets the instance use an external IP address.
+          .addAccessConfigs(AccessConfig.newBuilder()
+              .setName("External NAT")
+              .setType(AccessConfig.Type.ONE_TO_ONE_NAT.toString())
+              .setNetworkTier(AccessConfig.NetworkTier.PREMIUM.toString()).build()).build();
+
+      // Set reservation affinity to "none"
+      ReservationAffinity reservationAffinity =
+          ReservationAffinity.newBuilder()
+              .setConsumeReservationType(NO_RESERVATION.toString())
+              .build();
+
+      InstanceProperties instanceProperties = InstanceProperties.newBuilder()
+          .addDisks(attachedDisk)
+          .setMachineType(machineType)
+          .setReservationAffinity(reservationAffinity)
+          .addNetworkInterfaces(networkInterface).build();
+
+      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
+          .newBuilder()
+          .setProject(projectId)
+          .setInstanceTemplateResource(InstanceTemplate.newBuilder()
+              .setName(templateName)
+              .setProperties(instanceProperties).build()).build();
+
+      // Create the Instance Template.
+      Operation response = instanceTemplatesClient.insertAsync(insertInstanceTemplateRequest)
+          .get(3, TimeUnit.MINUTES);
+
+      if (response.hasError()) {
+        System.out.println("Instance Template creation failed ! ! " + response);
+        return;
+      }
+      System.out
+          .printf("Instance Template Operation Status %s: %s", templateName, response.getStatus());
+    }
+  }
+}
+// [END compute_template_not_consume_reservation]

compute/cloud-client/src/test/java/compute/reservation/ConsumeReservationIT.java

@@ -20,27 +20,40 @@
 import static com.google.common.truth.Truth.assertWithMessage;
 
 import com.google.cloud.compute.v1.Instance;
+import com.google.cloud.compute.v1.InstanceTemplate;
+import com.google.cloud.compute.v1.InstanceTemplatesClient;
 import com.google.cloud.compute.v1.InstancesClient;
 import compute.DeleteInstance;
+import compute.DeleteInstanceTemplate;
 import compute.Util;
 import java.io.IOException;
 import java.util.UUID;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
 
+@RunWith(JUnit4.class)
+@Timeout(value = 25, unit = TimeUnit.MINUTES)
 public class ConsumeReservationIT {
 
   private static final String PROJECT_ID = System.getenv("GOOGLE_CLOUD_PROJECT");
   private static final String ZONE = "europe-southwest1-a";
   private static InstancesClient instancesClient;
+  private static InstanceTemplatesClient instanceTemplatesClient;
   static String javaVersion = System.getProperty("java.version").substring(0, 2);
   private static final String INSTANCE_NOT_CONSUME_RESERVATION_NAME =
       "test-instance-not-consume-"  + javaVersion  + "-"
           + UUID.randomUUID().toString().substring(0, 8);
+  private static final String TEMPLATE_NOT_CONSUME_RESERVATION_NAME =
+      "test-template-not-consume-"  + javaVersion  + "-"
+      + UUID.randomUUID().toString().substring(0, 8);
   private static final String MACHINE_TYPE = "n2-standard-32";
 
   // Check if the required environment variables are set.
@@ -55,35 +68,51 @@ public static void setUp()
     requireEnvVar("GOOGLE_APPLICATION_CREDENTIALS");
     requireEnvVar("GOOGLE_CLOUD_PROJECT");
 
-    // Initialize the clients once for all tests
+    // Initialize clients once for all tests
     instancesClient = InstancesClient.create();
+    instanceTemplatesClient = InstanceTemplatesClient.create();
 
     // Cleanup existing stale resources.
     Util.cleanUpExistingInstances("test-instance-not-consume-"  + javaVersion, PROJECT_ID, ZONE);
+    Util.cleanUpExistingInstanceTemplates("test-template-not-consume-"  + javaVersion, PROJECT_ID);
+
+    // Create resources for testing.
+    CreateInstanceNotConsumeReservation.createInstanceNotConsumeReservation(
+        PROJECT_ID, ZONE, INSTANCE_NOT_CONSUME_RESERVATION_NAME, MACHINE_TYPE);
+    CreateTemplateNotConsumeReservation.createTemplateNotConsumeReservation(
+        PROJECT_ID, TEMPLATE_NOT_CONSUME_RESERVATION_NAME, MACHINE_TYPE);
   }
 
   @AfterAll
   public static void cleanup()
       throws IOException, ExecutionException, InterruptedException, TimeoutException {
     // Delete the instance created for testing.
     DeleteInstance.deleteInstance(PROJECT_ID, ZONE, INSTANCE_NOT_CONSUME_RESERVATION_NAME);
+    DeleteInstanceTemplate.deleteInstanceTemplate(
+        PROJECT_ID, TEMPLATE_NOT_CONSUME_RESERVATION_NAME);
 
-    // Close the client after all tests
+    // Close clients after all tests
     instancesClient.close();
+    instanceTemplatesClient.close();
   }
 
   @Test
-  public void testCreateInstanceNotConsumeReservation()
-      throws IOException, ExecutionException, InterruptedException, TimeoutException {
-
-    CreateInstanceNotConsumeReservation.createInstanceNotConsumeReservation(
-        PROJECT_ID, ZONE, INSTANCE_NOT_CONSUME_RESERVATION_NAME, MACHINE_TYPE);
-
-    // Verify that the instance was created with the correct consumeReservationType
+  public void testCreateInstanceNotConsumeReservation() {
     Instance instance = instancesClient.get(
         PROJECT_ID, ZONE, INSTANCE_NOT_CONSUME_RESERVATION_NAME);
 
+    // Verify that the instance was created with the correct consumeReservationType
     Assertions.assertEquals(NO_RESERVATION.toString(),
         instance.getReservationAffinity().getConsumeReservationType());
   }
+
+  @Test
+  public void testCreateTemplateNotConsumeReservation() {
+    InstanceTemplate template = instanceTemplatesClient.get(
+        PROJECT_ID, TEMPLATE_NOT_CONSUME_RESERVATION_NAME);
+
+    // Verify that the instance was created with the correct reservation and consumeReservationType
+    Assertions.assertEquals(NO_RESERVATION.toString(),
+        template.getPropertiesOrBuilder().getReservationAffinity().getConsumeReservationType());
+  }
 }