Implemented compute_reservation_create_from_vm sample. created test

TetyanaYahodska · TetyanaYahodska · commit c2e84ffd4f2b · 2024-10-13T14:28:53.000+02:00
diff --git a/compute/cloud-client/src/main/java/compute/reservation/CreateReservation.java b/compute/cloud-client/src/main/java/compute/reservation/CreateReservation.java
@@ -107,7 +107,7 @@ public static void createReservation(
 
       // Wait for the create reservation operation to complete.
       Operation response =
-          reservationsClient.insertAsync(projectId, zone, reservation).get(5, TimeUnit.MINUTES);
+          reservationsClient.insertAsync(projectId, zone, reservation).get(7, TimeUnit.MINUTES);
 
       if (response.hasError()) {
         System.out.println("Reservation creation failed!" + response);
diff --git a/compute/cloud-client/src/main/java/compute/reservation/CreateReservationFromVm.java b/compute/cloud-client/src/main/java/compute/reservation/CreateReservationFromVm.java
@@ -0,0 +1,132 @@
+/*
+ * 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_reservation_create_from_vm]
+
+import com.google.cloud.compute.v1.AcceleratorConfig;
+import com.google.cloud.compute.v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk;
+import com.google.cloud.compute.v1.AllocationSpecificSKUAllocationReservedInstanceProperties;
+import com.google.cloud.compute.v1.AllocationSpecificSKUReservation;
+import com.google.cloud.compute.v1.AttachedDisk;
+import com.google.cloud.compute.v1.InsertReservationRequest;
+import com.google.cloud.compute.v1.Instance;
+import com.google.cloud.compute.v1.InstancesClient;
+import com.google.cloud.compute.v1.Operation;
+import com.google.cloud.compute.v1.Reservation;
+import com.google.cloud.compute.v1.ReservationsClient;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public class CreateReservationFromVm {
+
+  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 project = "YOUR_PROJECT_ID";
+    // The zone of the VM. In this zone the reservation will be created.
+    String zone = "us-central1-a";
+    // The name of the reservation to create.
+    String reservationName = "YOUR_RESERVATION_NAME";
+    // The name of the VM to create the reservation from.
+    String vmName = "YOUR_VM_NAME";
+
+    createComputeReservationFromVm(project, zone, reservationName, vmName);
+  }
+
+  // Creates a compute reservation from an existing VM.
+  public static void createComputeReservationFromVm(
+      String project, String zone, String reservationName, String vmName)
+      throws IOException, ExecutionException, InterruptedException, TimeoutException {
+    // 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();
+         ReservationsClient reservationsClient = ReservationsClient.create()) {
+      Instance existingVm = instancesClient.get(project, zone, vmName);
+
+      // Extract properties from the existing VM
+      List<AcceleratorConfig> guestAccelerators = new ArrayList<>();
+      if (!existingVm.getGuestAcceleratorsList().isEmpty()) {
+        for (AcceleratorConfig a : existingVm.getGuestAcceleratorsList()) {
+          guestAccelerators.add(
+              AcceleratorConfig.newBuilder()
+                  .setAcceleratorCount(a.getAcceleratorCount())
+                  .setAcceleratorType(a.getAcceleratorType()
+                      .substring(a.getAcceleratorType().lastIndexOf('/') + 1))
+                  .build());
+        }
+      }
+
+      List<AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk> localSsds =
+          new ArrayList<>();
+      if (!existingVm.getDisksList().isEmpty()) {
+        for (AttachedDisk disk : existingVm.getDisksList()) {
+          if (disk.getDiskSizeGb() >= 375) {
+            localSsds.add(
+                AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk.newBuilder()
+                    .setDiskSizeGb(disk.getDiskSizeGb())
+                    .setInterface(disk.getInterface())
+                    .build());
+          }
+        }
+      }
+
+      AllocationSpecificSKUAllocationReservedInstanceProperties instanceProperties =
+          AllocationSpecificSKUAllocationReservedInstanceProperties.newBuilder()
+              .setMachineType(
+                  existingVm.getMachineType()
+                      .substring(existingVm.getMachineType().lastIndexOf('/') + 1))
+              .setMinCpuPlatform(existingVm.getMinCpuPlatform())
+              .addAllLocalSsds(localSsds)
+              .addAllGuestAccelerators(guestAccelerators)
+              .build();
+
+      Reservation reservation =
+          Reservation.newBuilder()
+              .setName(reservationName)
+              .setSpecificReservation(
+                  AllocationSpecificSKUReservation.newBuilder()
+                      .setCount(3)
+                      .setInstanceProperties(instanceProperties)
+                      .build())
+              .setSpecificReservationRequired(true)
+              .build();
+
+      InsertReservationRequest insertReservationRequest =
+          InsertReservationRequest.newBuilder()
+              .setProject(project)
+              .setZone(zone)
+              .setReservationResource(reservation)
+              .build();
+
+      Operation response = reservationsClient
+          .insertAsync(insertReservationRequest).get(3, TimeUnit.MINUTES);
+
+      if (response.hasError()) {
+        System.out.println("Reservation creation failed ! ! " + response);
+        return;
+      }
+      System.out.println("Operation completed successfully.");
+    }
+  }
+}
+// [END compute_reservation_create_from_vm]
diff --git a/compute/cloud-client/src/test/java/compute/reservation/CrudOperationsReservationIT.java b/compute/cloud-client/src/test/java/compute/reservation/CrudOperationsReservationIT.java
@@ -21,7 +21,12 @@
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 import com.google.api.gax.rpc.NotFoundException;
+import com.google.cloud.compute.v1.Instance;
+import com.google.cloud.compute.v1.InstancesClient;
 import com.google.cloud.compute.v1.Reservation;
+import com.google.cloud.compute.v1.ReservationsClient;
+import compute.CreateInstance;
+import compute.DeleteInstance;
 import compute.Util;
 import java.io.IOException;
 import java.util.List;
@@ -44,7 +49,11 @@ public class CrudOperationsReservationIT {
 
   private static final String PROJECT_ID = System.getenv("GOOGLE_CLOUD_PROJECT");
   private static final String ZONE = "us-central1-a";
+  private static ReservationsClient reservationsClient;
+  private static InstancesClient instancesClient;
   private static String RESERVATION_NAME;
+  private static String RESERVATION_NAME_FROM_VM;
+  private static String INSTANCE_FOR_RESERVATION;
   private static final int NUMBER_OF_VMS = 3;
   static String javaVersion = System.getProperty("java.version").substring(0, 2);
 
@@ -59,26 +68,44 @@ public static void setUp()
       throws IOException, ExecutionException, InterruptedException, TimeoutException {
     requireEnvVar("GOOGLE_APPLICATION_CREDENTIALS");
     requireEnvVar("GOOGLE_CLOUD_PROJECT");
+    reservationsClient = ReservationsClient.create();
+    instancesClient = InstancesClient.create();
+
     RESERVATION_NAME = "test-reservation-" + javaVersion + "-"
         + UUID.randomUUID().toString().substring(0, 8);
+    RESERVATION_NAME_FROM_VM = "test-reservation-from-vm-" + javaVersion + "-"
+        + UUID.randomUUID().toString().substring(0, 8);
+    INSTANCE_FOR_RESERVATION = "test-instance-for-reserv-" + javaVersion + "-"
+        + UUID.randomUUID().toString().substring(0, 8);
 
     // Cleanup existing stale resources.
+    Util.cleanUpExistingInstances("test-instance-for-reserv-"  + javaVersion, PROJECT_ID, ZONE);
     Util.cleanUpExistingReservations("test-reservation-"  + javaVersion, PROJECT_ID, ZONE);
+    Util.cleanUpExistingReservations("test-reservation-from-vm-"  + javaVersion, PROJECT_ID, ZONE);
 
+    CreateInstance.createInstance(PROJECT_ID, ZONE, INSTANCE_FOR_RESERVATION);
     CreateReservation.createReservation(
         PROJECT_ID, RESERVATION_NAME, NUMBER_OF_VMS, ZONE);
   }
 
   @AfterAll
   public static void cleanup()
       throws IOException, ExecutionException, InterruptedException, TimeoutException {
-    // Delete all reservations created for testing.
+    // Delete resources created for testing.
+    DeleteInstance.deleteInstance(PROJECT_ID, ZONE, INSTANCE_FOR_RESERVATION);
     DeleteReservation.deleteReservation(PROJECT_ID, ZONE, RESERVATION_NAME);
+    DeleteReservation.deleteReservation(PROJECT_ID, ZONE, RESERVATION_NAME_FROM_VM);
 
     // Test that reservations are deleted
     Assertions.assertThrows(
         NotFoundException.class,
         () -> GetReservation.getReservation(PROJECT_ID, RESERVATION_NAME, ZONE));
+    Assertions.assertThrows(
+        NotFoundException.class,
+        () -> GetReservation.getReservation(PROJECT_ID, RESERVATION_NAME_FROM_VM, ZONE));
+
+    reservationsClient.close();
+    instancesClient.close();
   }
 
   @Test
@@ -97,6 +124,25 @@ public void testListReservation() throws IOException {
         ListReservations.listReservations(PROJECT_ID, ZONE);
 
     assertThat(reservations).isNotNull();
-    Assert.assertTrue(reservations.get(0).getName().contains("test-"));
+    Assert.assertTrue(reservations.get(0).getName().contains("test-reservation-"));
+    Assert.assertTrue(reservations.get(1).getName().contains("test-reservation-"));
+  }
+
+  @Test
+  public void testCreateComputeReservationFromVm()
+      throws IOException, ExecutionException, InterruptedException, TimeoutException {
+    CreateReservationFromVm.createComputeReservationFromVm(
+        PROJECT_ID, ZONE, RESERVATION_NAME_FROM_VM, INSTANCE_FOR_RESERVATION);
+
+    Instance instance = instancesClient.get(PROJECT_ID, ZONE, INSTANCE_FOR_RESERVATION);
+    Reservation reservation =
+        reservationsClient.get(PROJECT_ID, ZONE, RESERVATION_NAME_FROM_VM);
+
+    Assert.assertNotNull(reservation);
+    assertThat(reservation.getName()).isEqualTo(RESERVATION_NAME_FROM_VM);
+    Assert.assertEquals(instance.getMinCpuPlatform(),
+        reservation.getSpecificReservation().getInstanceProperties().getMinCpuPlatform());
+    Assert.assertEquals(instance.getGuestAcceleratorsList(),
+        reservation.getSpecificReservation().getInstanceProperties().getGuestAcceleratorsList());
   }
 }
