From 594de00027cbd37313bf01cbc9804d4129b03986 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Tue, 5 Nov 2024 15:42:16 +0100 Subject: [PATCH 01/23] Implemented compute_consistency_group_create and compute_consistency_group_delete samples, created test --- .../CreateDiskConsistencyGroup.java | 67 +++++++++++++++++ .../DeleteDiskConsistencyGroup.java | 59 +++++++++++++++ .../compute/disks/ConsistencyGroupIT.java | 73 +++++++++++++++++++ 3 files changed, 199 insertions(+) create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java create mode 100644 compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java new file mode 100644 index 00000000000..a2d0d1e3d23 --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java @@ -0,0 +1,67 @@ +/* + * 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.disks.consistencygroup; + +// [START compute_consistency_group_create] +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.ResourcePoliciesClient; +import com.google.cloud.compute.v1.ResourcePolicy; +import java.io.IOException; +import java.util.concurrent.ExecutionException; + +public class CreateDiskConsistencyGroup { + + public static void main(String[] args) + throws IOException, ExecutionException, InterruptedException { + // 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"; + // Name of the region in which you want to create the consistency group. + String region = "us-central1"; + // Name of the consistency group you want to create. + String consistencyGroupName = "YOUR_CONSISTENCY_GROUP_NAME"; + + createDiskConsistencyGroup(project, region, consistencyGroupName); + } + + // Creates a new disk consistency group resource policy in the specified project and region. + // Return a link to the consistency group. + public static String createDiskConsistencyGroup( + String project, String region, String consistencyGroupName) + throws IOException, ExecutionException, InterruptedException { + // 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 (ResourcePoliciesClient regionResourcePoliciesClient = ResourcePoliciesClient.create()) { + ResourcePolicy resourcePolicy = + ResourcePolicy.newBuilder() + .setName(consistencyGroupName) + .setRegion(region) + .setDiskConsistencyGroupPolicy( + ResourcePolicy.newBuilder().getDiskConsistencyGroupPolicy()) + .build(); + + Operation response = + regionResourcePoliciesClient.insertAsync(project, region, resourcePolicy).get(); + + if (response.hasError()) { + return null; + } + return regionResourcePoliciesClient.get(project, region, consistencyGroupName).getSelfLink(); + } + } +} +// [END compute_consistency_group_create] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java new file mode 100644 index 00000000000..d80ef0c67dd --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java @@ -0,0 +1,59 @@ +/* + * 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.disks.consistencygroup; + +// [START compute_consistency_group_delete] +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.ResourcePoliciesClient; +import java.io.IOException; +import java.util.concurrent.ExecutionException; + +public class DeleteDiskConsistencyGroup { + + public static void main(String[] args) + throws IOException, ExecutionException, InterruptedException { + // 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"; + // Name of the region in which your consistency group is located. + String region = "us-central1"; + // Name of the consistency group you want to delete. + String consistencyGroupName = "YOUR_CONSISTENCY_GROUP_NAME"; + + deleteDiskConsistencyGroup(project, region, consistencyGroupName); + } + + // Deletes a disk consistency group resource policy in the specified project and region. + public static void deleteDiskConsistencyGroup( + String project, String region, String consistencyGroupName) + throws IOException, ExecutionException, InterruptedException { + // 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 (ResourcePoliciesClient regionResourcePoliciesClient = ResourcePoliciesClient.create()) { + Operation response = regionResourcePoliciesClient + .deleteAsync(project, region, consistencyGroupName).get(); + + if (response.hasError()) { + return; + } + System.out.println( + "Disk consistency group resource policy deleted successfully: " + + consistencyGroupName); + } + } +} +// [END compute_consistency_group_delete] diff --git a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java new file mode 100644 index 00000000000..ea720937306 --- /dev/null +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -0,0 +1,73 @@ +/* + * 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.disks; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth.assertWithMessage; +import static org.junit.Assert.assertNotNull; + +import compute.disks.consistencygroup.CreateDiskConsistencyGroup; +import compute.disks.consistencygroup.DeleteDiskConsistencyGroup; +import java.io.IOException; +import java.util.UUID; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import org.junit.jupiter.api.AfterAll; +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 = 3, unit = TimeUnit.MINUTES) +public class ConsistencyGroupIT { + private static final String PROJECT_ID = System.getenv("GOOGLE_CLOUD_PROJECT"); + private static final String REGION = "us-central1"; + private static final String CONSISTENCY_GROUP_NAME = + "test-consistency-group-" + UUID.randomUUID(); + + // Check if the required environment variables are set. + public static void requireEnvVar(String envVarName) { + assertWithMessage(String.format("Missing environment variable '%s' ", envVarName)) + .that(System.getenv(envVarName)).isNotEmpty(); + } + + @BeforeAll + public static void setUp() throws Exception { + requireEnvVar("GOOGLE_CLOUD_PROJECT"); + } + + @AfterAll + public static void cleanUp() + throws IOException, ExecutionException, InterruptedException { + // Delete created consistency group + DeleteDiskConsistencyGroup.deleteDiskConsistencyGroup( + PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); + } + + @Test + public void testCreateDiskConsistencyGroupResourcePolicy() + throws IOException, ExecutionException, InterruptedException { + String consistencyGroupLink = CreateDiskConsistencyGroup.createDiskConsistencyGroup( + PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); + + // Verify that the consistency group was created + assertNotNull(consistencyGroupLink); + assertThat(consistencyGroupLink.contains(CONSISTENCY_GROUP_NAME)); + } +} From 411cc01879be7da6f032bd02ebf926439b2d8601 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Fri, 15 Nov 2024 09:38:01 +0100 Subject: [PATCH 02/23] Implemented compute_consistency_group_clone sample --- .../consistencygroup/BulkCreateDisks.java | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/BulkCreateDisks.java diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/BulkCreateDisks.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/BulkCreateDisks.java new file mode 100644 index 00000000000..55e8ba739f8 --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/BulkCreateDisks.java @@ -0,0 +1,66 @@ +package compute.disks.consistencygroup; + +import com.google.cloud.compute.v1.BulkInsertDiskRequest; +import com.google.cloud.compute.v1.BulkInsertDiskResource; +import com.google.cloud.compute.v1.BulkInsertRegionDiskRequest; +import com.google.cloud.compute.v1.Disk; +import com.google.cloud.compute.v1.DisksClient; +import com.google.cloud.compute.v1.ListDisksRequest; +import com.google.cloud.compute.v1.ListRegionDisksRequest; +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.RegionDisksClient; + +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 BulkCreateDisks { + + public static void main(String[] args) throws IOException, ExecutionException, InterruptedException, TimeoutException { + // TODO(developer): Replace these variables before running the sample. + String project = "tyaho-softserve-project"; + String region = "us-central1"; // Or region + String consistencyGroupPolicy = "my-group"; // Replace with your consistency group self-link + + + bulkCreateDisks(project, region, consistencyGroupPolicy); + } + + // Creates multiple disks from a consistency group policy. + public static List bulkCreateDisks(String project, String region, String consistencyGroupPolicy) throws IOException, ExecutionException, InterruptedException, TimeoutException { + String sourceConsistencyGroupPolicy = String.format("projects/%s/regions/%s/resourcePolicies/%s", project,region, consistencyGroupPolicy); + try (RegionDisksClient disksClient = RegionDisksClient.create()) { + BulkInsertDiskResource.Builder bulkInsertDiskResource = BulkInsertDiskResource.newBuilder() + .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy); + + BulkInsertRegionDiskRequest bulkCreateDisksRequest = BulkInsertRegionDiskRequest.newBuilder() + .setProject(project) + .setRegion(region) + .setBulkInsertDiskResourceResource(bulkInsertDiskResource.build()) + .build(); + + Operation operation = disksClient.bulkInsertAsync(bulkCreateDisksRequest).get(3, TimeUnit.MINUTES); + ListRegionDisksRequest listRequest = + + ListRegionDisksRequest.newBuilder() + .setProject(project) + .setRegion(region) +// .setFilter(filter) + .build(); + List createdDisks = new ArrayList<>(); + for (Disk disk : disksClient.list(listRequest).iterateAll()) { + createdDisks.add(disk); + System.out.println("Created Disk: " + disk.getName()); // Or other relevant info + } + if (operation.hasError()) { + return null; + } + System.out.println(createdDisks); + return createdDisks; + + } + } +} \ No newline at end of file From 35b9bf496a791e01018e454278e926297ede04f8 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Thu, 21 Nov 2024 11:41:45 +0100 Subject: [PATCH 03/23] Fixed code --- .../consistencygroup/BulkCreateDisks.java | 64 ++++++++----------- 1 file changed, 25 insertions(+), 39 deletions(-) diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/BulkCreateDisks.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/BulkCreateDisks.java index 55e8ba739f8..65c7a647fc4 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/BulkCreateDisks.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/BulkCreateDisks.java @@ -1,18 +1,8 @@ package compute.disks.consistencygroup; -import com.google.cloud.compute.v1.BulkInsertDiskRequest; -import com.google.cloud.compute.v1.BulkInsertDiskResource; -import com.google.cloud.compute.v1.BulkInsertRegionDiskRequest; -import com.google.cloud.compute.v1.Disk; -import com.google.cloud.compute.v1.DisksClient; -import com.google.cloud.compute.v1.ListDisksRequest; -import com.google.cloud.compute.v1.ListRegionDisksRequest; -import com.google.cloud.compute.v1.Operation; -import com.google.cloud.compute.v1.RegionDisksClient; +import com.google.cloud.compute.v1.*; 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; @@ -22,44 +12,40 @@ public class BulkCreateDisks { public static void main(String[] args) throws IOException, ExecutionException, InterruptedException, TimeoutException { // TODO(developer): Replace these variables before running the sample. String project = "tyaho-softserve-project"; - String region = "us-central1"; // Or region - String consistencyGroupPolicy = "my-group"; // Replace with your consistency group self-link - - - bulkCreateDisks(project, region, consistencyGroupPolicy); + String disksLocation = "northamerica-northeast1-a"; + String consistencyGroupLocation = "northamerica-northeast1"; // Or region + String consistencyGroupName = "consistency-group-2"; // Replace with your consistency group self-link + cloneDisksFromConsistencyGroup(project, disksLocation, consistencyGroupName, + consistencyGroupLocation); } // Creates multiple disks from a consistency group policy. - public static List bulkCreateDisks(String project, String region, String consistencyGroupPolicy) throws IOException, ExecutionException, InterruptedException, TimeoutException { - String sourceConsistencyGroupPolicy = String.format("projects/%s/regions/%s/resourcePolicies/%s", project,region, consistencyGroupPolicy); - try (RegionDisksClient disksClient = RegionDisksClient.create()) { - BulkInsertDiskResource.Builder bulkInsertDiskResource = BulkInsertDiskResource.newBuilder() - .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy); + public static void cloneDisksFromConsistencyGroup(String project, String disksLocation, String consistencyGroupLocation, String consistencyGroupName) throws IOException, ExecutionException, InterruptedException, TimeoutException { + String sourceConsistencyGroupPolicy = String.format("projects/%s/regions/%s/resourcePolicies/%s", project,consistencyGroupLocation, consistencyGroupName); + String region = disksLocation.substring(0, disksLocation.lastIndexOf('-')); - BulkInsertRegionDiskRequest bulkCreateDisksRequest = BulkInsertRegionDiskRequest.newBuilder() - .setProject(project) - .setRegion(region) - .setBulkInsertDiskResourceResource(bulkInsertDiskResource.build()) - .build(); + try (RegionDisksClient regionDisksClient = RegionDisksClient.create()) { - Operation operation = disksClient.bulkInsertAsync(bulkCreateDisksRequest).get(3, TimeUnit.MINUTES); - ListRegionDisksRequest listRequest = + BulkInsertDiskResource bulkInsertDiskResource = BulkInsertDiskResource.newBuilder() + .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) + .build(); - ListRegionDisksRequest.newBuilder() + BulkInsertRegionDiskRequest bulkInsertRegionDiskRequest = BulkInsertRegionDiskRequest + .newBuilder() .setProject(project) .setRegion(region) -// .setFilter(filter) + .setBulkInsertDiskResourceResource(bulkInsertDiskResource) .build(); - List createdDisks = new ArrayList<>(); - for (Disk disk : disksClient.list(listRequest).iterateAll()) { - createdDisks.add(disk); - System.out.println("Created Disk: " + disk.getName()); // Or other relevant info - } - if (operation.hasError()) { - return null; + Operation operation = regionDisksClient.bulkInsertAsync(bulkInsertRegionDiskRequest).get(3, + TimeUnit.MINUTES); + + + if(operation.hasError() ) { + System.out.println("Clone disks from consistency group failed! " + operation.getError().toString()); + return; } - System.out.println(createdDisks); - return createdDisks; + System.out.println(String.format("Disks cloned from consistency group: %s.", + consistencyGroupName)); } } From 57f57d01a87b18799c100c1712b24c8af3068cb8 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Thu, 21 Nov 2024 18:27:47 +0100 Subject: [PATCH 04/23] Created test --- .../consistencygroup/BulkCreateDisks.java | 52 ----------- .../CloneDisksFromConsistencyGroup.java | 90 +++++++++++++++++++ .../compute/disks/ConsistencyGroupIT.java | 38 ++++++++ 3 files changed, 128 insertions(+), 52 deletions(-) delete mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/BulkCreateDisks.java create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/BulkCreateDisks.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/BulkCreateDisks.java deleted file mode 100644 index 65c7a647fc4..00000000000 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/BulkCreateDisks.java +++ /dev/null @@ -1,52 +0,0 @@ -package compute.disks.consistencygroup; - -import com.google.cloud.compute.v1.*; - -import java.io.IOException; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; - -public class BulkCreateDisks { - - public static void main(String[] args) throws IOException, ExecutionException, InterruptedException, TimeoutException { - // TODO(developer): Replace these variables before running the sample. - String project = "tyaho-softserve-project"; - String disksLocation = "northamerica-northeast1-a"; - String consistencyGroupLocation = "northamerica-northeast1"; // Or region - String consistencyGroupName = "consistency-group-2"; // Replace with your consistency group self-link - cloneDisksFromConsistencyGroup(project, disksLocation, consistencyGroupName, - consistencyGroupLocation); - } - - // Creates multiple disks from a consistency group policy. - public static void cloneDisksFromConsistencyGroup(String project, String disksLocation, String consistencyGroupLocation, String consistencyGroupName) throws IOException, ExecutionException, InterruptedException, TimeoutException { - String sourceConsistencyGroupPolicy = String.format("projects/%s/regions/%s/resourcePolicies/%s", project,consistencyGroupLocation, consistencyGroupName); - String region = disksLocation.substring(0, disksLocation.lastIndexOf('-')); - - try (RegionDisksClient regionDisksClient = RegionDisksClient.create()) { - - BulkInsertDiskResource bulkInsertDiskResource = BulkInsertDiskResource.newBuilder() - .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) - .build(); - - BulkInsertRegionDiskRequest bulkInsertRegionDiskRequest = BulkInsertRegionDiskRequest - .newBuilder() - .setProject(project) - .setRegion(region) - .setBulkInsertDiskResourceResource(bulkInsertDiskResource) - .build(); - Operation operation = regionDisksClient.bulkInsertAsync(bulkInsertRegionDiskRequest).get(3, - TimeUnit.MINUTES); - - - if(operation.hasError() ) { - System.out.println("Clone disks from consistency group failed! " + operation.getError().toString()); - return; - } - System.out.println(String.format("Disks cloned from consistency group: %s.", - consistencyGroupName)); - - } - } -} \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java new file mode 100644 index 00000000000..6de7cb2e213 --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java @@ -0,0 +1,90 @@ +/* + * 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.disks.consistencygroup; + +// [START compute_consistency_group_clone] +// If your disk has zonal location uncomment these lines +//import com.google.cloud.compute.v1.DisksClient; +//import com.google.cloud.compute.v1.BulkInsertDiskRequest; +import com.google.cloud.compute.v1.BulkInsertDiskResource; +import com.google.cloud.compute.v1.BulkInsertRegionDiskRequest; +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.RegionDisksClient; +import java.io.IOException; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +public class CloneDisksFromConsistencyGroup { + + 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"; + // Name of the region or zone in which your disk is located. + String disksLocation = "us-central1"; + // Name of the consistency group you want to clone disks from. + String consistencyGroupName = "YOUR_CONSISTENCY_GROUP_NAME"; + // Name of the region in which your consistency group is located. + String consistencyGroupLocation = "us-central1"; + + cloneDisksFromConsistencyGroup( + project, disksLocation, consistencyGroupName, consistencyGroupLocation); + } + + // Clones disks from a consistency group. + public static void cloneDisksFromConsistencyGroup(String project, String disksLocation, + String consistencyGroupName, String consistencyGroupLocation) + throws IOException, InterruptedException, ExecutionException, TimeoutException { + String sourceConsistencyGroupPolicy = String.format( + "projects/%s/regions/%s/resourcePolicies/%s", project, consistencyGroupLocation, + consistencyGroupName); + + //try (DisksClient disksClient = DisksClient.create()){ + // BulkInsertDiskRequest request = BulkInsertDiskRequest.newBuilder() + // .setProject(project) + // .setZone(disksLocation) + // .setBulkInsertDiskResourceResource( + // BulkInsertDiskResource.newBuilder() + // .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) + // .build()) + // .build(); + //Operation response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); + + + try (RegionDisksClient regionDisksClient = RegionDisksClient.create()) { + BulkInsertRegionDiskRequest request = BulkInsertRegionDiskRequest.newBuilder() + .setProject(project) + .setRegion(disksLocation) + .setBulkInsertDiskResourceResource( + BulkInsertDiskResource.newBuilder() + .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) + .build()) + .build(); + + Operation response = regionDisksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); + + if (response.hasError()) { + System.out.println(String.format("Error cloning disks: %s", response.getError())); + return; + } + System.out.printf("Disks cloned from consistency group: %s\n", consistencyGroupName); + } + } +} +// [END compute_consistency_group_clone] \ No newline at end of file diff --git a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java index ea720937306..3d94b18da38 100644 --- a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -19,19 +19,31 @@ import static com.google.common.truth.Truth.assertThat; import static com.google.common.truth.Truth.assertWithMessage; import static org.junit.Assert.assertNotNull; +import static org.mockito.Mockito.*; +import com.google.api.gax.longrunning.OperationFuture; +import com.google.cloud.compute.v1.BulkInsertRegionDiskRequest; +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.RegionDisksClient; +import compute.disks.consistencygroup.CloneDisksFromConsistencyGroup; import compute.disks.consistencygroup.CreateDiskConsistencyGroup; import compute.disks.consistencygroup.DeleteDiskConsistencyGroup; + +import java.io.ByteArrayOutputStream; import java.io.IOException; +import java.io.PrintStream; 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.BeforeAll; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Timeout; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; +import org.mockito.MockedStatic; @RunWith(JUnit4.class) @Timeout(value = 3, unit = TimeUnit.MINUTES) @@ -41,6 +53,7 @@ public class ConsistencyGroupIT { private static final String CONSISTENCY_GROUP_NAME = "test-consistency-group-" + UUID.randomUUID(); + // Check if the required environment variables are set. public static void requireEnvVar(String envVarName) { assertWithMessage(String.format("Missing environment variable '%s' ", envVarName)) @@ -70,4 +83,29 @@ public void testCreateDiskConsistencyGroupResourcePolicy() assertNotNull(consistencyGroupLink); assertThat(consistencyGroupLink.contains(CONSISTENCY_GROUP_NAME)); } + + @Test + public void testCloneDisksFromConsistencyGroup() + throws IOException, InterruptedException, ExecutionException, TimeoutException { + ByteArrayOutputStream bout = new ByteArrayOutputStream(); + System.setOut(new PrintStream(bout)); + try (MockedStatic mockedRegionDisksClient = mockStatic(RegionDisksClient.class)) { + Operation mockOperation = mock(Operation.class); + RegionDisksClient mockClient = mock(RegionDisksClient.class); + OperationFuture mockFuture = mock(OperationFuture.class); + + mockedRegionDisksClient.when(RegionDisksClient::create).thenReturn(mockClient); + when(mockClient.bulkInsertAsync(any(BulkInsertRegionDiskRequest.class))) + .thenReturn(mockFuture); + when(mockFuture.get()).thenReturn(mockOperation); + + CloneDisksFromConsistencyGroup.cloneDisksFromConsistencyGroup(PROJECT_ID, REGION, + CONSISTENCY_GROUP_NAME, REGION); + + + assertThat(bout).isEqualTo(String.format("Disks cloned from consistency group: %s", CONSISTENCY_GROUP_NAME)); + verify(mockClient, times(1)) + .bulkInsertAsync(any(BulkInsertRegionDiskRequest.class)); + } + } } From ba07c6f54ba5bff694d9724838dec55161b2358f Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Fri, 22 Nov 2024 11:43:23 +0100 Subject: [PATCH 05/23] Created test and added needed classes --- .../disks/CreateDiskSecondaryRegional.java | 106 ++++++++++++++++++ .../compute/disks/StartDiskReplication.java | 83 ++++++++++++++ .../compute/disks/StopDiskReplication.java | 63 +++++++++++ .../AddDiskToConsistencyGroup.java | 92 +++++++++++++++ .../RemoveDiskFromConsistencyGroup.java | 93 +++++++++++++++ .../compute/disks/ConsistencyGroupIT.java | 106 ++++++++++++------ 6 files changed, 509 insertions(+), 34 deletions(-) create mode 100644 compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java create mode 100644 compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java create mode 100644 compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java diff --git a/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java b/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java new file mode 100644 index 00000000000..f4fa9f1dc67 --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java @@ -0,0 +1,106 @@ +/* + * 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.disks; + +// [START compute_disk_create_secondary_regional] +import com.google.cloud.compute.v1.Disk; +import com.google.cloud.compute.v1.DiskAsyncReplication; +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.RegionDisksClient; +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +public class CreateDiskSecondaryRegional { + public static void main(String[] args) + throws IOException, ExecutionException, InterruptedException, TimeoutException { + // TODO(developer): Replace these variables before running the sample. + // The project that contains the primary disk. + String primaryProjectId = "PRIMARY_PROJECT_ID"; + // The project that contains the secondary disk. + String secondaryProjectId = "SECONDARY_PROJECT_ID"; + // Name of the primary disk you want to use. + String primaryDiskName = "PRIMARY_DISK_NAME"; + // Name of the disk you want to create. + String secondaryDiskName = "SECONDARY_DISK_NAME"; + // Name of the region in which your primary disk is located. + // Learn more about zones and regions: + // https://cloud.google.com/compute/docs/disks/async-pd/about#supported_region_pairs + String primaryDiskRegion = "us-central1"; + // Name of the region in which you want to create the secondary disk. + String secondaryDiskRegion = "us-east1"; + // Size of the new disk in gigabytes. + // Learn more about disk requirements: + // https://cloud.google.com/compute/docs/disks/async-pd/configure?authuser=0#disk_requirements + long diskSizeGb = 30L; + // The type of the disk you want to create. This value uses the following format: + // "projects/{projectId}/zones/{zone}/diskTypes/ + // (pd-standard|pd-ssd|pd-balanced|pd-extreme)". + String diskType = String.format( + "projects/%s/regions/%s/diskTypes/pd-balanced", secondaryProjectId, secondaryDiskRegion); + + createDiskSecondaryRegional(primaryProjectId, secondaryProjectId, primaryDiskName, + secondaryDiskName, primaryDiskRegion, secondaryDiskRegion, diskSizeGb, diskType); + } + + // Creates a secondary disk in a specified region. + public static Disk createDiskSecondaryRegional(String projectId, String secondaryProjectId, + String primaryDiskName, String secondaryDiskName, String primaryDiskRegion, + String secondaryDiskRegion, long diskSizeGb, String diskType) + throws IOException, ExecutionException, InterruptedException, TimeoutException { + // An iterable collection of zone names in which you want to keep + // the new disks' replicas. One of the replica zones of the clone must match + // the zone of the source disk. + List replicaZones = Arrays.asList( + String.format("projects/%s/zones/%s-c", secondaryProjectId, secondaryDiskRegion), + String.format("projects/%s/zones/%s-b", secondaryProjectId, secondaryDiskRegion)); + + String primaryDiskSource = String.format("projects/%s/regions/%s/disks/%s", + projectId, primaryDiskRegion, primaryDiskName); + + DiskAsyncReplication asyncReplication = DiskAsyncReplication.newBuilder() + .setDisk(primaryDiskSource) + .build(); + + // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { + + Disk disk = Disk.newBuilder() + .addAllReplicaZones(replicaZones) + .setName(secondaryDiskName) + .setSizeGb(diskSizeGb) + .setType(diskType) + .setRegion(secondaryDiskRegion) + .setAsyncPrimaryDisk(asyncReplication) + .build(); + + // Wait for the create disk operation to complete. + Operation response = disksClient.insertAsync(secondaryProjectId, secondaryDiskRegion, disk) + .get(3, TimeUnit.MINUTES); + + if (response.hasError()) { + return null; + } + return disksClient.get(secondaryProjectId, secondaryDiskRegion, secondaryDiskName); + } + } +} +// [END compute_disk_create_secondary_regional] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java b/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java new file mode 100644 index 00000000000..a5d850e61e6 --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java @@ -0,0 +1,83 @@ +/* + * 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.disks; + +// [START compute_disk_start_replication] +// Uncomment this line if your disk has zonal location. +// import com.google.cloud.compute.v1.DisksClient; +// import com.google.cloud.compute.v1.DisksStartAsyncReplicationRequest; +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.RegionDisksClient; +import com.google.cloud.compute.v1.RegionDisksStartAsyncReplicationRequest; +import java.io.IOException; +import java.util.concurrent.ExecutionException; + +public class StartDiskReplication { + + public static void main(String[] args) + throws IOException, ExecutionException, InterruptedException { + // TODO(developer): Replace these variables before running the sample. + // The project that contains the primary disk. + String primaryProjectId = "PRIMARY_PROJECT_ID"; + // Name of the primary disk. + String primaryDiskName = "PRIMARY_DISK_NAME"; + // Name of the region in which your primary disk is located. + // Learn more about zones and regions: + // https://cloud.google.com/compute/docs/disks/async-pd/about#supported_region_pairs + String primaryDiskLocation = "YOUR_PRIMARY_DISK_LOCATION"; + // Path to your secondary disk. + // This value uses the following format for zonal location: + // "projects/%sYOUR_PROJECT_ID/zones/YOUR_PRIMARY_DISK_LOCATION/disks/PRIMARY_DISK_NAME" + String secondaryDiskPath = + "projects/%s/regions/YOUR_SECONDARY_DISK_LOCATION/disks/SECONDARY_DISK_NAME"; + + startDiskAsyncReplication( + primaryProjectId, primaryDiskName, primaryDiskLocation, secondaryDiskPath); + } + + // Starts asynchronous replication for the specified disk. + public static void startDiskAsyncReplication(String primaryProjectId, String primaryDiskName, + String primaryDiskLocation, String secondaryDiskPath) + throws IOException, ExecutionException, InterruptedException { + // Initialize client that will be used to send requests. This client only needs to be created + // once, and can be reused for multiple requests. + + // Uncomment these lines if your disk has zonal location. + // try (DisksClient disksClient = DisksClient.create()) { + // DisksStartAsyncReplicationRequest startAsyncReplicationRequest = + // DisksStartAsyncReplicationRequest.newBuilder() + // .setAsyncSecondaryDisk(secondaryDiskPath) + // .build(); + + try (RegionDisksClient disksClient = RegionDisksClient.create()) { + + RegionDisksStartAsyncReplicationRequest replicationRequest = + RegionDisksStartAsyncReplicationRequest.newBuilder() + .setAsyncSecondaryDisk(secondaryDiskPath) + .build(); + + Operation response = disksClient.startAsyncReplicationAsync( + primaryProjectId, primaryDiskLocation, primaryDiskName, replicationRequest).get(); + + if (response.hasError()) { + return; + } + System.out.println("Async replication started successfully."); + } + } +} +// [END compute_disk_start_replication] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java b/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java new file mode 100644 index 00000000000..f6e49de8804 --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java @@ -0,0 +1,63 @@ +/* + * 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.disks; + +// [START compute_disk_stop_replication] +// Uncomment this line if your disk has zonal location. +// import com.google.cloud.compute.v1.DisksClient; +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.RegionDisksClient; +import java.io.IOException; +import java.util.concurrent.ExecutionException; + +public class StopDiskReplication { + + public static void main(String[] args) + throws IOException, ExecutionException, InterruptedException { + // 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"; + // Location of your disk. + String diskLocation = "us-central1-a"; + // Name of your disk. + String diskName = "YOUR_DISK_NAME"; + + stopDiskAsyncReplication(projectId, diskLocation, diskName); + } + + // Stops asynchronous replication for the specified disk. + public static void stopDiskAsyncReplication( + String project, String diskLocation, String diskName) + throws IOException, ExecutionException, InterruptedException { + // Initialize client that will be used to send requests. This client only needs to be created + // once, and can be reused for multiple requests. + + // Uncomment this line if your disk has zonal location. + //try (DisksClient disksClient = DisksClient.create()) { + + try (RegionDisksClient disksClient = RegionDisksClient.create()) { + Operation response = disksClient.stopAsyncReplicationAsync( + project, diskLocation, diskName).get(); + + if (response.hasError()) { + return; + } + System.out.println("Async replication stopped successfully."); + } + } +} +// [END compute_disk_stop_replication] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java new file mode 100644 index 00000000000..e04c697082f --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java @@ -0,0 +1,92 @@ +/* + * 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.disks.consistencygroup; + +// [START compute_consistency_group_add_disk] +import com.google.cloud.compute.v1.AddResourcePoliciesRegionDiskRequest; +import com.google.cloud.compute.v1.Disk; +// If your disk has zonal location uncomment these lines +//import com.google.cloud.compute.v1.AddResourcePoliciesDiskRequest; +//import com.google.cloud.compute.v1.DisksAddResourcePoliciesRequest; +//import com.google.cloud.compute.v1.DisksClient; +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.RegionDisksAddResourcePoliciesRequest; +import com.google.cloud.compute.v1.RegionDisksClient; +import java.io.IOException; +import java.util.Arrays; +import java.util.concurrent.ExecutionException; + +public class AddDiskToConsistencyGroup { + public static void main(String[] args) + throws IOException, ExecutionException, InterruptedException { + // TODO(developer): Replace these variables before running the sample. + // The project that contains the disk. + String project = "YOUR_PROJECT_ID"; + // The zone or region of the disk. + String location = "us-central1"; + // The name of the disk. + String diskName = "DISK_NAME"; + // The name of the consistency group. + String consistencyGroupName = "CONSISTENCY_GROUP"; + // The region of the consistency group. + String consistencyGroupLocation = "us-central1"; + addDiskToConsistencyGroup( + project, location, diskName, consistencyGroupName, consistencyGroupLocation); + } + + // Adds a disk to a Consistency Group. + public static Disk addDiskToConsistencyGroup( + String project, String location, String diskName, + String consistencyGroupName, String consistencyGroupLocation) + throws IOException, ExecutionException, InterruptedException { + String consistencyGroupUrl = String.format( + "https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s", + project, consistencyGroupLocation, consistencyGroupName); + // If your disk has zonal location uncomment these lines + // try (DisksClient disksClient = DisksClient.create()) { + // AddResourcePoliciesDiskRequest request = + // AddResourcePoliciesDiskRequest.newBuilder() + // .setDisk(diskName) + // .setDisksAddResourcePoliciesRequestResource( + // DisksAddResourcePoliciesRequest.newBuilder() + // .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) + // .build()) + // .setProject(project) + // .setZone(location) + // .build(); + + try (RegionDisksClient disksClient = RegionDisksClient.create()) { + AddResourcePoliciesRegionDiskRequest disksRequest = + AddResourcePoliciesRegionDiskRequest.newBuilder() + .setDisk(diskName) + .setRegion(location) + .setProject(project) + .setRegionDisksAddResourcePoliciesRequestResource( + RegionDisksAddResourcePoliciesRequest.newBuilder() + .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) + .build()) + .build(); + + Operation response = disksClient.addResourcePoliciesAsync(disksRequest).get(); + if (response.hasError()) { + return null; + } + return disksClient.get(project, location, diskName); + } + } +} +// [END compute_consistency_group_add_disk] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java new file mode 100644 index 00000000000..dc1cb80db36 --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java @@ -0,0 +1,93 @@ +/* + * 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.disks.consistencygroup; + +// [START compute_consistency_group_remove_disk] +import com.google.cloud.compute.v1.Disk; +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.RegionDisksClient; +import com.google.cloud.compute.v1.RegionDisksRemoveResourcePoliciesRequest; +import com.google.cloud.compute.v1.RemoveResourcePoliciesRegionDiskRequest; +// If your disk has zonal location uncomment these lines +//import com.google.cloud.compute.v1.DisksClient; +//import com.google.cloud.compute.v1.DisksRemoveResourcePoliciesRequest; +//import com.google.cloud.compute.v1.RemoveResourcePoliciesDiskRequest; +import java.io.IOException; +import java.util.Arrays; +import java.util.concurrent.ExecutionException; + +public class RemoveDiskFromConsistencyGroup { + + public static void main(String[] args) + throws IOException, ExecutionException, InterruptedException { + // TODO(developer): Replace these variables before running the sample. + // The project that contains the disk. + String project = "YOUR_PROJECT_ID"; + // The zone or region of the disk. + String location = "us-central1"; + // The name of the disk. + String diskName = "DISK_NAME"; + // The name of the consistency group. + String consistencyGroupName = "CONSISTENCY_GROUP"; + // The region of the consistency group. + String consistencyGroupLocation = "us-central1"; + removeDiskFromConsistencyGroup( + project, location, diskName, consistencyGroupName, consistencyGroupLocation); + } + + // Removes a disk from a Consistency Group. + public static Disk removeDiskFromConsistencyGroup( + String project, String location, String diskName, + String consistencyGroupName, String consistencyGroupLocation) + throws IOException, ExecutionException, InterruptedException { + String consistencyGroupUrl = String.format( + "https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s", + project, consistencyGroupLocation, consistencyGroupName); + // If your disk has zonal location uncomment these lines + // try (DisksClient disksClient = DisksClient.create()) { + // RemoveResourcePoliciesDiskRequest request = + // RemoveResourcePoliciesDiskRequest.newBuilder() + // .setDisk(diskName) + // .setDisksRemoveResourcePoliciesRequestResource( + // DisksRemoveResourcePoliciesRequest.newBuilder() + // .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) + // .build()) + // .setProject(project) + // .setZone(location) + // .build(); + + try (RegionDisksClient disksClient = RegionDisksClient.create()) { + RemoveResourcePoliciesRegionDiskRequest disksRequest = + RemoveResourcePoliciesRegionDiskRequest.newBuilder() + .setDisk(diskName) + .setRegion(location) + .setProject(project) + .setRegionDisksRemoveResourcePoliciesRequestResource( + RegionDisksRemoveResourcePoliciesRequest.newBuilder() + .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) + .build()) + .build(); + + Operation response = disksClient.removeResourcePoliciesAsync(disksRequest).get(); + if (response.hasError()) { + return null; + } + return disksClient.get(project, location, diskName); + } + } +} +// [END compute_consistency_group_remove_disk] diff --git a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java index 3d94b18da38..205b238084a 100644 --- a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -19,40 +19,48 @@ import static com.google.common.truth.Truth.assertThat; import static com.google.common.truth.Truth.assertWithMessage; import static org.junit.Assert.assertNotNull; -import static org.mockito.Mockito.*; -import com.google.api.gax.longrunning.OperationFuture; -import com.google.cloud.compute.v1.BulkInsertRegionDiskRequest; -import com.google.cloud.compute.v1.Operation; -import com.google.cloud.compute.v1.RegionDisksClient; +import com.google.cloud.compute.v1.Disk; +import compute.disks.consistencygroup.AddDiskToConsistencyGroup; import compute.disks.consistencygroup.CloneDisksFromConsistencyGroup; import compute.disks.consistencygroup.CreateDiskConsistencyGroup; import compute.disks.consistencygroup.DeleteDiskConsistencyGroup; - import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.PrintStream; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; 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.BeforeAll; +import org.junit.jupiter.api.MethodOrderer; +import org.junit.jupiter.api.Order; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestMethodOrder; import org.junit.jupiter.api.Timeout; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; -import org.mockito.MockedStatic; @RunWith(JUnit4.class) -@Timeout(value = 3, unit = TimeUnit.MINUTES) +@Timeout(value = 5, unit = TimeUnit.MINUTES) +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) public class ConsistencyGroupIT { private static final String PROJECT_ID = System.getenv("GOOGLE_CLOUD_PROJECT"); private static final String REGION = "us-central1"; - private static final String CONSISTENCY_GROUP_NAME = - "test-consistency-group-" + UUID.randomUUID(); - + private static final String REGION_SECONDARY = "northamerica-northeast1"; + static String randomUUID = UUID.randomUUID().toString().split("-")[0]; + private static final String CONSISTENCY_GROUP_NAME = "test-consistency-group-" + randomUUID; + private static final String CONSISTENCY_GROUP_SECONDARY = + "test-consistency-group-secondary-" + randomUUID; + private static final String DISK_NAME = "test-disk-for-consistency-" + randomUUID; + private static final String DISK_TYPE = String.format("regions/%s/diskTypes/pd-balanced", REGION); + private static final String SECONDARY_REGIONAL_DISK = + "gcloud-test-disk-secondary-regional-" + randomUUID; + private static final long DISK_SIZE = 10L; // Check if the required environment variables are set. public static void requireEnvVar(String envVarName) { @@ -63,17 +71,33 @@ public static void requireEnvVar(String envVarName) { @BeforeAll public static void setUp() throws Exception { requireEnvVar("GOOGLE_CLOUD_PROJECT"); + List replicaZones = Arrays.asList( + String.format("projects/%s/zones/%s-a", PROJECT_ID, REGION), + String.format("projects/%s/zones/%s-b", PROJECT_ID, REGION)); + + RegionalCreateFromSource.createRegionalDisk(PROJECT_ID, REGION, replicaZones, + DISK_NAME, DISK_TYPE, 10, Optional.empty(), Optional.empty()); } @AfterAll public static void cleanUp() - throws IOException, ExecutionException, InterruptedException { + throws IOException, ExecutionException, InterruptedException, TimeoutException { + StopDiskReplication.stopDiskAsyncReplication(PROJECT_ID, REGION, DISK_NAME); + StopDiskReplication.stopDiskAsyncReplication( + PROJECT_ID, REGION_SECONDARY, SECONDARY_REGIONAL_DISK); + + RegionalDelete.deleteRegionalDisk(PROJECT_ID, REGION, DISK_NAME); + RegionalDelete.deleteRegionalDisk(PROJECT_ID, REGION_SECONDARY, SECONDARY_REGIONAL_DISK); // Delete created consistency group DeleteDiskConsistencyGroup.deleteDiskConsistencyGroup( PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); + DeleteDiskConsistencyGroup.deleteDiskConsistencyGroup( + PROJECT_ID, REGION_SECONDARY, CONSISTENCY_GROUP_SECONDARY); + } @Test + @Order(1) public void testCreateDiskConsistencyGroupResourcePolicy() throws IOException, ExecutionException, InterruptedException { String consistencyGroupLink = CreateDiskConsistencyGroup.createDiskConsistencyGroup( @@ -85,27 +109,41 @@ public void testCreateDiskConsistencyGroupResourcePolicy() } @Test + @Order(2) + public void testAddRegionalDiskToConsistencyGroup() + throws IOException, ExecutionException, InterruptedException { + Disk disk = AddDiskToConsistencyGroup.addDiskToConsistencyGroup( + PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME, REGION); + + // Verify that the disk was added to the consistency group + assertNotNull(disk); + assertThat(disk.getResourcePoliciesList().get(0).contains(CONSISTENCY_GROUP_NAME)); + } + + @Test + @Order(3) public void testCloneDisksFromConsistencyGroup() - throws IOException, InterruptedException, ExecutionException, TimeoutException { - ByteArrayOutputStream bout = new ByteArrayOutputStream(); - System.setOut(new PrintStream(bout)); - try (MockedStatic mockedRegionDisksClient = mockStatic(RegionDisksClient.class)) { - Operation mockOperation = mock(Operation.class); - RegionDisksClient mockClient = mock(RegionDisksClient.class); - OperationFuture mockFuture = mock(OperationFuture.class); - - mockedRegionDisksClient.when(RegionDisksClient::create).thenReturn(mockClient); - when(mockClient.bulkInsertAsync(any(BulkInsertRegionDiskRequest.class))) - .thenReturn(mockFuture); - when(mockFuture.get()).thenReturn(mockOperation); - - CloneDisksFromConsistencyGroup.cloneDisksFromConsistencyGroup(PROJECT_ID, REGION, - CONSISTENCY_GROUP_NAME, REGION); - - - assertThat(bout).isEqualTo(String.format("Disks cloned from consistency group: %s", CONSISTENCY_GROUP_NAME)); - verify(mockClient, times(1)) - .bulkInsertAsync(any(BulkInsertRegionDiskRequest.class)); - } + throws IOException, ExecutionException, InterruptedException, TimeoutException { + ByteArrayOutputStream stdOut = new ByteArrayOutputStream(); + System.setOut(new PrintStream(stdOut)); + Disk disk = CreateDiskSecondaryRegional.createDiskSecondaryRegional( + PROJECT_ID, PROJECT_ID, DISK_NAME, SECONDARY_REGIONAL_DISK, + REGION, REGION_SECONDARY, DISK_SIZE, DISK_TYPE); + CreateDiskConsistencyGroup.createDiskConsistencyGroup( + PROJECT_ID, REGION_SECONDARY, CONSISTENCY_GROUP_SECONDARY); + assert disk != null; + StartDiskReplication.startDiskAsyncReplication( + PROJECT_ID, DISK_NAME, REGION, disk.getSelfLink()); + AddDiskToConsistencyGroup.addDiskToConsistencyGroup(PROJECT_ID, REGION_SECONDARY, + SECONDARY_REGIONAL_DISK, CONSISTENCY_GROUP_SECONDARY, REGION_SECONDARY); + TimeUnit.MINUTES.sleep(1); + + CloneDisksFromConsistencyGroup.cloneDisksFromConsistencyGroup( + PROJECT_ID, REGION_SECONDARY, CONSISTENCY_GROUP_SECONDARY, REGION_SECONDARY); + + assertThat(stdOut.toString()).contains("Disks cloned from consistency group: "); + + stdOut.close(); } + } From 5ec04118ad37a3c53aecf38f509f348f42a29c24 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Fri, 22 Nov 2024 12:29:29 +0100 Subject: [PATCH 06/23] Added clean up method for regional disks, added comments --- .../CloneDisksFromConsistencyGroup.java | 32 +++++++++---------- .../src/test/java/compute/Util.java | 17 ++++++++++ .../compute/disks/ConsistencyGroupIT.java | 14 ++++---- 3 files changed, 41 insertions(+), 22 deletions(-) diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java index 6de7cb2e213..5670575aafb 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java @@ -55,32 +55,32 @@ public static void cloneDisksFromConsistencyGroup(String project, String disksLo "projects/%s/regions/%s/resourcePolicies/%s", project, consistencyGroupLocation, consistencyGroupName); + // If your disk has zonal location uncomment this code //try (DisksClient disksClient = DisksClient.create()){ // BulkInsertDiskRequest request = BulkInsertDiskRequest.newBuilder() - // .setProject(project) - // .setZone(disksLocation) - // .setBulkInsertDiskResourceResource( - // BulkInsertDiskResource.newBuilder() - // .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) - // .build()) - // .build(); + // .setProject(project) + // .setZone(disksLocation) + // .setBulkInsertDiskResourceResource( + // BulkInsertDiskResource.newBuilder() + // .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) + // .build()) + // .build(); //Operation response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); - try (RegionDisksClient regionDisksClient = RegionDisksClient.create()) { BulkInsertRegionDiskRequest request = BulkInsertRegionDiskRequest.newBuilder() - .setProject(project) - .setRegion(disksLocation) - .setBulkInsertDiskResourceResource( - BulkInsertDiskResource.newBuilder() - .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) - .build()) - .build(); + .setProject(project) + .setRegion(disksLocation) + .setBulkInsertDiskResourceResource( + BulkInsertDiskResource.newBuilder() + .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) + .build()) + .build(); Operation response = regionDisksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); if (response.hasError()) { - System.out.println(String.format("Error cloning disks: %s", response.getError())); + System.out.printf("Error cloning disks: %s%n", response.getError()); return; } System.out.printf("Disks cloned from consistency group: %s\n", consistencyGroupName); diff --git a/compute/cloud-client/src/test/java/compute/Util.java b/compute/cloud-client/src/test/java/compute/Util.java index 5c89de8faa8..510effed769 100644 --- a/compute/cloud-client/src/test/java/compute/Util.java +++ b/compute/cloud-client/src/test/java/compute/Util.java @@ -37,6 +37,7 @@ import compute.deleteprotection.SetDeleteProtection; import compute.disks.DeleteDisk; import compute.disks.DeleteSnapshot; +import compute.disks.RegionalDelete; import compute.reservation.DeleteReservation; import java.io.IOException; import java.nio.charset.StandardCharsets; @@ -266,6 +267,22 @@ public static void deleteStoragePool(String project, String zone, String storage } } + // Delete disks which starts with the given prefixToDelete and + // has creation timestamp >24 hours. + public static void cleanUpExistingRegionalDisks( + String prefixToDelete, String projectId, String region) + throws IOException, ExecutionException, InterruptedException, TimeoutException { + try (RegionDisksClient disksClient = RegionDisksClient.create()) { + for (Disk disk : disksClient.list(projectId, region).iterateAll()) { + if (disk.getName().contains(prefixToDelete) + && disk.getRegion().equals(region) + && isCreatedBeforeThresholdTime(disk.getCreationTimestamp())) { + RegionalDelete.deleteRegionalDisk(projectId, region, disk.getName()); + } + } + } + } + public static boolean containPrefixToDeleteAndZone( Object resource, String prefixToDelete, String zone) { boolean containPrefixAndZone = false; diff --git a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java index 205b238084a..1d5580e2b50 100644 --- a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -21,6 +21,7 @@ import static org.junit.Assert.assertNotNull; import com.google.cloud.compute.v1.Disk; +import compute.Util; import compute.disks.consistencygroup.AddDiskToConsistencyGroup; import compute.disks.consistencygroup.CloneDisksFromConsistencyGroup; import compute.disks.consistencygroup.CreateDiskConsistencyGroup; @@ -61,6 +62,9 @@ public class ConsistencyGroupIT { private static final String SECONDARY_REGIONAL_DISK = "gcloud-test-disk-secondary-regional-" + randomUUID; private static final long DISK_SIZE = 10L; + private static final List replicaZones = Arrays.asList( + String.format("projects/%s/zones/%s-a", PROJECT_ID, REGION), + String.format("projects/%s/zones/%s-b", PROJECT_ID, REGION)); // Check if the required environment variables are set. public static void requireEnvVar(String envVarName) { @@ -71,9 +75,6 @@ public static void requireEnvVar(String envVarName) { @BeforeAll public static void setUp() throws Exception { requireEnvVar("GOOGLE_CLOUD_PROJECT"); - List replicaZones = Arrays.asList( - String.format("projects/%s/zones/%s-a", PROJECT_ID, REGION), - String.format("projects/%s/zones/%s-b", PROJECT_ID, REGION)); RegionalCreateFromSource.createRegionalDisk(PROJECT_ID, REGION, replicaZones, DISK_NAME, DISK_TYPE, 10, Optional.empty(), Optional.empty()); @@ -88,12 +89,15 @@ public static void cleanUp() RegionalDelete.deleteRegionalDisk(PROJECT_ID, REGION, DISK_NAME); RegionalDelete.deleteRegionalDisk(PROJECT_ID, REGION_SECONDARY, SECONDARY_REGIONAL_DISK); - // Delete created consistency group DeleteDiskConsistencyGroup.deleteDiskConsistencyGroup( PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); DeleteDiskConsistencyGroup.deleteDiskConsistencyGroup( PROJECT_ID, REGION_SECONDARY, CONSISTENCY_GROUP_SECONDARY); + // Clean up existing stale resources. + Util.cleanUpExistingRegionalDisks("test-disk-for-consistency-", PROJECT_ID, REGION); + Util.cleanUpExistingRegionalDisks( + "gcloud-test-disk-secondary-regional-", PROJECT_ID, REGION_SECONDARY); } @Test @@ -103,7 +107,6 @@ public void testCreateDiskConsistencyGroupResourcePolicy() String consistencyGroupLink = CreateDiskConsistencyGroup.createDiskConsistencyGroup( PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); - // Verify that the consistency group was created assertNotNull(consistencyGroupLink); assertThat(consistencyGroupLink.contains(CONSISTENCY_GROUP_NAME)); } @@ -115,7 +118,6 @@ public void testAddRegionalDiskToConsistencyGroup() Disk disk = AddDiskToConsistencyGroup.addDiskToConsistencyGroup( PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME, REGION); - // Verify that the disk was added to the consistency group assertNotNull(disk); assertThat(disk.getResourcePoliciesList().get(0).contains(CONSISTENCY_GROUP_NAME)); } From 71ec736794a57a81c95637ce2b79fd83c9b8d51a Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Fri, 22 Nov 2024 13:35:24 +0100 Subject: [PATCH 07/23] Added clean up method for HyperdisksIT --- .../src/test/java/compute/disks/HyperdisksIT.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java b/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java index 4b61e5bf16d..47342bd5596 100644 --- a/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java @@ -72,6 +72,10 @@ public static void cleanup() DeleteDisk.deleteDisk(PROJECT_ID, ZONE, HYPERDISK_IN_POOL_NAME); Util.deleteStoragePool(PROJECT_ID, ZONE, STORAGE_POOL_NAME); + + // Clean up stale resources + Util.cleanUpExistingDisks("test-hyperdisk-enc-", PROJECT_ID, ZONE); + Util.cleanUpExistingStoragePool("test-storage-pool-enc-", PROJECT_ID, ZONE); } @Test From 825b042439b5bb43c1ff05783a8734652070f181 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Tue, 26 Nov 2024 11:14:42 +0100 Subject: [PATCH 08/23] Fixed code following the comments --- .../disks/CreateDiskSecondaryRegional.java | 15 +++++------ .../compute/disks/StartDiskReplication.java | 27 +++++++++++-------- .../compute/disks/StopDiskReplication.java | 7 ++--- .../compute/disks/ConsistencyGroupIT.java | 10 +++---- 4 files changed, 31 insertions(+), 28 deletions(-) diff --git a/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java b/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java index f4fa9f1dc67..22d1999753c 100644 --- a/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java +++ b/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java @@ -49,21 +49,16 @@ public static void main(String[] args) // Size of the new disk in gigabytes. // Learn more about disk requirements: // https://cloud.google.com/compute/docs/disks/async-pd/configure?authuser=0#disk_requirements - long diskSizeGb = 30L; - // The type of the disk you want to create. This value uses the following format: - // "projects/{projectId}/zones/{zone}/diskTypes/ - // (pd-standard|pd-ssd|pd-balanced|pd-extreme)". - String diskType = String.format( - "projects/%s/regions/%s/diskTypes/pd-balanced", secondaryProjectId, secondaryDiskRegion); + int diskSizeGb = 10; createDiskSecondaryRegional(primaryProjectId, secondaryProjectId, primaryDiskName, - secondaryDiskName, primaryDiskRegion, secondaryDiskRegion, diskSizeGb, diskType); + secondaryDiskName, primaryDiskRegion, secondaryDiskRegion, diskSizeGb); } // Creates a secondary disk in a specified region. public static Disk createDiskSecondaryRegional(String projectId, String secondaryProjectId, String primaryDiskName, String secondaryDiskName, String primaryDiskRegion, - String secondaryDiskRegion, long diskSizeGb, String diskType) + String secondaryDiskRegion, int diskSizeGb) throws IOException, ExecutionException, InterruptedException, TimeoutException { // An iterable collection of zone names in which you want to keep // the new disks' replicas. One of the replica zones of the clone must match @@ -72,6 +67,9 @@ public static Disk createDiskSecondaryRegional(String projectId, String secondar String.format("projects/%s/zones/%s-c", secondaryProjectId, secondaryDiskRegion), String.format("projects/%s/zones/%s-b", secondaryProjectId, secondaryDiskRegion)); + String diskType = String.format("projects/%s/regions/%s/diskTypes/pd-balanced", + secondaryProjectId, secondaryDiskRegion); + String primaryDiskSource = String.format("projects/%s/regions/%s/disks/%s", projectId, primaryDiskRegion, primaryDiskName); @@ -97,6 +95,7 @@ public static Disk createDiskSecondaryRegional(String projectId, String secondar .get(3, TimeUnit.MINUTES); if (response.hasError()) { + System.out.println(response.getError()); return null; } return disksClient.get(secondaryProjectId, secondaryDiskRegion, secondaryDiskName); diff --git a/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java b/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java index a5d850e61e6..82cb8dc59b1 100644 --- a/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java +++ b/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java @@ -39,20 +39,24 @@ public static void main(String[] args) // Learn more about zones and regions: // https://cloud.google.com/compute/docs/disks/async-pd/about#supported_region_pairs String primaryDiskLocation = "YOUR_PRIMARY_DISK_LOCATION"; - // Path to your secondary disk. - // This value uses the following format for zonal location: - // "projects/%sYOUR_PROJECT_ID/zones/YOUR_PRIMARY_DISK_LOCATION/disks/PRIMARY_DISK_NAME" - String secondaryDiskPath = - "projects/%s/regions/YOUR_SECONDARY_DISK_LOCATION/disks/SECONDARY_DISK_NAME"; + // The project that contains the secondary disk. + String secondaryProjectId = "SECONDARY_PROJECT_ID"; + // Name of the region in which your secondary disk is located. + String secondaryDiskLocation = "YOUR_SECONDARY_DISK_LOCATION"; + // Name of the secondary disk. + String secondaryDiskName = "SECONDARY_DISK_NAME"; - startDiskAsyncReplication( - primaryProjectId, primaryDiskName, primaryDiskLocation, secondaryDiskPath); + startDiskAsyncReplication(primaryProjectId, primaryDiskName, + primaryDiskLocation, secondaryProjectId, secondaryDiskLocation, secondaryDiskName); } // Starts asynchronous replication for the specified disk. - public static void startDiskAsyncReplication(String primaryProjectId, String primaryDiskName, - String primaryDiskLocation, String secondaryDiskPath) + public static Operation.Status startDiskAsyncReplication(String primaryProjectId, + String primaryDiskName, String primaryDiskLocation, String secondaryProjectId, + String secondaryDiskLocation, String secondaryDiskName) throws IOException, ExecutionException, InterruptedException { + String secondaryDiskPath = String.format("projects/%s/regions/%s/disks/%s", + secondaryProjectId, secondaryDiskLocation, secondaryDiskName); // Initialize client that will be used to send requests. This client only needs to be created // once, and can be reused for multiple requests. @@ -74,9 +78,10 @@ public static void startDiskAsyncReplication(String primaryProjectId, String pri primaryProjectId, primaryDiskLocation, primaryDiskName, replicationRequest).get(); if (response.hasError()) { - return; + System.out.println(response.getError()); + return null; } - System.out.println("Async replication started successfully."); + return response.getStatus(); } } } diff --git a/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java b/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java index f6e49de8804..c587bd1ca5a 100644 --- a/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java +++ b/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java @@ -40,7 +40,7 @@ public static void main(String[] args) } // Stops asynchronous replication for the specified disk. - public static void stopDiskAsyncReplication( + public static Operation.Status stopDiskAsyncReplication( String project, String diskLocation, String diskName) throws IOException, ExecutionException, InterruptedException { // Initialize client that will be used to send requests. This client only needs to be created @@ -54,9 +54,10 @@ public static void stopDiskAsyncReplication( project, diskLocation, diskName).get(); if (response.hasError()) { - return; + System.out.println(response.getError()); + return null; } - System.out.println("Async replication stopped successfully."); + return response.getStatus(); } } } diff --git a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java index 1d5580e2b50..895be496cbc 100644 --- a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -61,7 +61,7 @@ public class ConsistencyGroupIT { private static final String DISK_TYPE = String.format("regions/%s/diskTypes/pd-balanced", REGION); private static final String SECONDARY_REGIONAL_DISK = "gcloud-test-disk-secondary-regional-" + randomUUID; - private static final long DISK_SIZE = 10L; + private static final int DISK_SIZE = 10; private static final List replicaZones = Arrays.asList( String.format("projects/%s/zones/%s-a", PROJECT_ID, REGION), String.format("projects/%s/zones/%s-b", PROJECT_ID, REGION)); @@ -86,7 +86,6 @@ public static void cleanUp() StopDiskReplication.stopDiskAsyncReplication(PROJECT_ID, REGION, DISK_NAME); StopDiskReplication.stopDiskAsyncReplication( PROJECT_ID, REGION_SECONDARY, SECONDARY_REGIONAL_DISK); - RegionalDelete.deleteRegionalDisk(PROJECT_ID, REGION, DISK_NAME); RegionalDelete.deleteRegionalDisk(PROJECT_ID, REGION_SECONDARY, SECONDARY_REGIONAL_DISK); DeleteDiskConsistencyGroup.deleteDiskConsistencyGroup( @@ -128,14 +127,13 @@ public void testCloneDisksFromConsistencyGroup() throws IOException, ExecutionException, InterruptedException, TimeoutException { ByteArrayOutputStream stdOut = new ByteArrayOutputStream(); System.setOut(new PrintStream(stdOut)); - Disk disk = CreateDiskSecondaryRegional.createDiskSecondaryRegional( + CreateDiskSecondaryRegional.createDiskSecondaryRegional( PROJECT_ID, PROJECT_ID, DISK_NAME, SECONDARY_REGIONAL_DISK, - REGION, REGION_SECONDARY, DISK_SIZE, DISK_TYPE); + REGION, REGION_SECONDARY, DISK_SIZE); CreateDiskConsistencyGroup.createDiskConsistencyGroup( PROJECT_ID, REGION_SECONDARY, CONSISTENCY_GROUP_SECONDARY); - assert disk != null; StartDiskReplication.startDiskAsyncReplication( - PROJECT_ID, DISK_NAME, REGION, disk.getSelfLink()); + PROJECT_ID, DISK_NAME, REGION, PROJECT_ID, REGION_SECONDARY, SECONDARY_REGIONAL_DISK); AddDiskToConsistencyGroup.addDiskToConsistencyGroup(PROJECT_ID, REGION_SECONDARY, SECONDARY_REGIONAL_DISK, CONSISTENCY_GROUP_SECONDARY, REGION_SECONDARY); TimeUnit.MINUTES.sleep(1); From 5463364e9a21c4a4ef91157a0c4a42585071cbf3 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Tue, 26 Nov 2024 11:38:13 +0100 Subject: [PATCH 09/23] Fixed code following the comments --- .../disks/CreateDiskSecondaryRegional.java | 2 +- .../AddDiskToConsistencyGroup.java | 6 ++--- .../CloneDisksFromConsistencyGroup.java | 8 +++---- .../CreateDiskConsistencyGroup.java | 5 ++-- .../DeleteDiskConsistencyGroup.java | 9 ++++--- .../RemoveDiskFromConsistencyGroup.java | 6 ++--- .../compute/disks/ConsistencyGroupIT.java | 24 ++++++------------- 7 files changed, 25 insertions(+), 35 deletions(-) diff --git a/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java b/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java index 22d1999753c..f55c8f2fd05 100644 --- a/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java +++ b/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java @@ -95,7 +95,7 @@ public static Disk createDiskSecondaryRegional(String projectId, String secondar .get(3, TimeUnit.MINUTES); if (response.hasError()) { - System.out.println(response.getError()); + System.out.printf("Error creating disk: %s%n", response.getError()); return null; } return disksClient.get(secondaryProjectId, secondaryDiskRegion, secondaryDiskName); diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java index e04c697082f..9d8fbb971fc 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java @@ -18,7 +18,6 @@ // [START compute_consistency_group_add_disk] import com.google.cloud.compute.v1.AddResourcePoliciesRegionDiskRequest; -import com.google.cloud.compute.v1.Disk; // If your disk has zonal location uncomment these lines //import com.google.cloud.compute.v1.AddResourcePoliciesDiskRequest; //import com.google.cloud.compute.v1.DisksAddResourcePoliciesRequest; @@ -49,7 +48,7 @@ public static void main(String[] args) } // Adds a disk to a Consistency Group. - public static Disk addDiskToConsistencyGroup( + public static Operation.Status addDiskToConsistencyGroup( String project, String location, String diskName, String consistencyGroupName, String consistencyGroupLocation) throws IOException, ExecutionException, InterruptedException { @@ -83,9 +82,10 @@ public static Disk addDiskToConsistencyGroup( Operation response = disksClient.addResourcePoliciesAsync(disksRequest).get(); if (response.hasError()) { + System.out.printf("Error adding disk to consistency group: %s%n", response.getError()); return null; } - return disksClient.get(project, location, diskName); + return response.getStatus(); } } } diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java index 5670575aafb..c150a660bfb 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java @@ -48,8 +48,8 @@ public static void main(String[] args) } // Clones disks from a consistency group. - public static void cloneDisksFromConsistencyGroup(String project, String disksLocation, - String consistencyGroupName, String consistencyGroupLocation) + public static Operation.Status cloneDisksFromConsistencyGroup(String project, + String disksLocation, String consistencyGroupName, String consistencyGroupLocation) throws IOException, InterruptedException, ExecutionException, TimeoutException { String sourceConsistencyGroupPolicy = String.format( "projects/%s/regions/%s/resourcePolicies/%s", project, consistencyGroupLocation, @@ -81,9 +81,9 @@ public static void cloneDisksFromConsistencyGroup(String project, String disksLo if (response.hasError()) { System.out.printf("Error cloning disks: %s%n", response.getError()); - return; + return null; } - System.out.printf("Disks cloned from consistency group: %s\n", consistencyGroupName); + return response.getStatus(); } } } diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java index a2d0d1e3d23..0d649217062 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java @@ -40,7 +40,7 @@ public static void main(String[] args) // Creates a new disk consistency group resource policy in the specified project and region. // Return a link to the consistency group. - public static String createDiskConsistencyGroup( + public static Operation.Status createDiskConsistencyGroup( String project, String region, String consistencyGroupName) throws IOException, ExecutionException, InterruptedException { // Initialize client that will be used to send requests. This client only needs to be created @@ -58,9 +58,10 @@ public static String createDiskConsistencyGroup( regionResourcePoliciesClient.insertAsync(project, region, resourcePolicy).get(); if (response.hasError()) { + System.out.printf("Error creating consistency group: %s%n", response.getError()); return null; } - return regionResourcePoliciesClient.get(project, region, consistencyGroupName).getSelfLink(); + return response.getStatus(); } } } diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java index d80ef0c67dd..ea4a1b7e5d6 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java @@ -38,7 +38,7 @@ public static void main(String[] args) } // Deletes a disk consistency group resource policy in the specified project and region. - public static void deleteDiskConsistencyGroup( + public static Operation.Status deleteDiskConsistencyGroup( String project, String region, String consistencyGroupName) throws IOException, ExecutionException, InterruptedException { // Initialize client that will be used to send requests. This client only needs to be created @@ -48,11 +48,10 @@ public static void deleteDiskConsistencyGroup( .deleteAsync(project, region, consistencyGroupName).get(); if (response.hasError()) { - return; + System.out.printf("Error deleting disk: %s%n", response.getError()); + return null; } - System.out.println( - "Disk consistency group resource policy deleted successfully: " - + consistencyGroupName); + return response.getStatus(); } } } diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java index dc1cb80db36..0b16bdeeba2 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java @@ -17,7 +17,6 @@ package compute.disks.consistencygroup; // [START compute_consistency_group_remove_disk] -import com.google.cloud.compute.v1.Disk; import com.google.cloud.compute.v1.Operation; import com.google.cloud.compute.v1.RegionDisksClient; import com.google.cloud.compute.v1.RegionDisksRemoveResourcePoliciesRequest; @@ -50,7 +49,7 @@ public static void main(String[] args) } // Removes a disk from a Consistency Group. - public static Disk removeDiskFromConsistencyGroup( + public static Operation.Status removeDiskFromConsistencyGroup( String project, String location, String diskName, String consistencyGroupName, String consistencyGroupLocation) throws IOException, ExecutionException, InterruptedException { @@ -84,9 +83,10 @@ public static Disk removeDiskFromConsistencyGroup( Operation response = disksClient.removeResourcePoliciesAsync(disksRequest).get(); if (response.hasError()) { + System.out.printf("Error removing disk from consistency group: %s%n", response.getError()); return null; } - return disksClient.get(project, location, diskName); + return response.getStatus(); } } } diff --git a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java index 895be496cbc..2019a737ff2 100644 --- a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -18,17 +18,14 @@ import static com.google.common.truth.Truth.assertThat; import static com.google.common.truth.Truth.assertWithMessage; -import static org.junit.Assert.assertNotNull; -import com.google.cloud.compute.v1.Disk; +import com.google.cloud.compute.v1.Operation; import compute.Util; import compute.disks.consistencygroup.AddDiskToConsistencyGroup; import compute.disks.consistencygroup.CloneDisksFromConsistencyGroup; import compute.disks.consistencygroup.CreateDiskConsistencyGroup; import compute.disks.consistencygroup.DeleteDiskConsistencyGroup; -import java.io.ByteArrayOutputStream; import java.io.IOException; -import java.io.PrintStream; import java.util.Arrays; import java.util.List; import java.util.Optional; @@ -103,30 +100,26 @@ public static void cleanUp() @Order(1) public void testCreateDiskConsistencyGroupResourcePolicy() throws IOException, ExecutionException, InterruptedException { - String consistencyGroupLink = CreateDiskConsistencyGroup.createDiskConsistencyGroup( + Operation.Status status = CreateDiskConsistencyGroup.createDiskConsistencyGroup( PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); - assertNotNull(consistencyGroupLink); - assertThat(consistencyGroupLink.contains(CONSISTENCY_GROUP_NAME)); + assertThat(status).isEqualTo(Operation.Status.DONE); } @Test @Order(2) public void testAddRegionalDiskToConsistencyGroup() throws IOException, ExecutionException, InterruptedException { - Disk disk = AddDiskToConsistencyGroup.addDiskToConsistencyGroup( + Operation.Status status = AddDiskToConsistencyGroup.addDiskToConsistencyGroup( PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME, REGION); - assertNotNull(disk); - assertThat(disk.getResourcePoliciesList().get(0).contains(CONSISTENCY_GROUP_NAME)); + assertThat(status).isEqualTo(Operation.Status.DONE); } @Test @Order(3) public void testCloneDisksFromConsistencyGroup() throws IOException, ExecutionException, InterruptedException, TimeoutException { - ByteArrayOutputStream stdOut = new ByteArrayOutputStream(); - System.setOut(new PrintStream(stdOut)); CreateDiskSecondaryRegional.createDiskSecondaryRegional( PROJECT_ID, PROJECT_ID, DISK_NAME, SECONDARY_REGIONAL_DISK, REGION, REGION_SECONDARY, DISK_SIZE); @@ -138,12 +131,9 @@ public void testCloneDisksFromConsistencyGroup() SECONDARY_REGIONAL_DISK, CONSISTENCY_GROUP_SECONDARY, REGION_SECONDARY); TimeUnit.MINUTES.sleep(1); - CloneDisksFromConsistencyGroup.cloneDisksFromConsistencyGroup( + Operation.Status status = CloneDisksFromConsistencyGroup.cloneDisksFromConsistencyGroup( PROJECT_ID, REGION_SECONDARY, CONSISTENCY_GROUP_SECONDARY, REGION_SECONDARY); - assertThat(stdOut.toString()).contains("Disks cloned from consistency group: "); - - stdOut.close(); + assertThat(status).isEqualTo(Operation.Status.DONE); } - } From 5993a3ab86f4dfa1ffeb054e62953cfdd42851cb Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Tue, 26 Nov 2024 12:09:26 +0100 Subject: [PATCH 10/23] Fixed code following the comments --- .../compute/disks/StartDiskReplication.java | 6 +++--- .../compute/disks/StopDiskReplication.java | 6 +++--- .../AddDiskToConsistencyGroup.java | 6 ++++-- .../CloneDisksFromConsistencyGroup.java | 20 +++++++------------ .../DeleteDiskConsistencyGroup.java | 4 ++-- .../RemoveDiskFromConsistencyGroup.java | 6 ++++-- 6 files changed, 23 insertions(+), 25 deletions(-) diff --git a/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java b/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java index 82cb8dc59b1..d294e103678 100644 --- a/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java +++ b/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java @@ -57,8 +57,6 @@ public static Operation.Status startDiskAsyncReplication(String primaryProjectId throws IOException, ExecutionException, InterruptedException { String secondaryDiskPath = String.format("projects/%s/regions/%s/disks/%s", secondaryProjectId, secondaryDiskLocation, secondaryDiskName); - // Initialize client that will be used to send requests. This client only needs to be created - // once, and can be reused for multiple requests. // Uncomment these lines if your disk has zonal location. // try (DisksClient disksClient = DisksClient.create()) { @@ -67,6 +65,8 @@ public static Operation.Status startDiskAsyncReplication(String primaryProjectId // .setAsyncSecondaryDisk(secondaryDiskPath) // .build(); + // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { RegionDisksStartAsyncReplicationRequest replicationRequest = @@ -78,7 +78,7 @@ public static Operation.Status startDiskAsyncReplication(String primaryProjectId primaryProjectId, primaryDiskLocation, primaryDiskName, replicationRequest).get(); if (response.hasError()) { - System.out.println(response.getError()); + System.out.printf("Error starting disk replication: %s%n", response.getError()); return null; } return response.getStatus(); diff --git a/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java b/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java index c587bd1ca5a..01c6ecbdcf9 100644 --- a/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java +++ b/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java @@ -43,18 +43,18 @@ public static void main(String[] args) public static Operation.Status stopDiskAsyncReplication( String project, String diskLocation, String diskName) throws IOException, ExecutionException, InterruptedException { - // Initialize client that will be used to send requests. This client only needs to be created - // once, and can be reused for multiple requests. // Uncomment this line if your disk has zonal location. //try (DisksClient disksClient = DisksClient.create()) { + // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { Operation response = disksClient.stopAsyncReplicationAsync( project, diskLocation, diskName).get(); if (response.hasError()) { - System.out.println(response.getError()); + System.out.printf("Error stopping disk replication: %s%n", response.getError()); return null; } return response.getStatus(); diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java index 9d8fbb971fc..ccfe86a5122 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java @@ -60,14 +60,16 @@ public static Operation.Status addDiskToConsistencyGroup( // AddResourcePoliciesDiskRequest request = // AddResourcePoliciesDiskRequest.newBuilder() // .setDisk(diskName) + // .setZone(location) + // .setProject(project) // .setDisksAddResourcePoliciesRequestResource( // DisksAddResourcePoliciesRequest.newBuilder() // .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) // .build()) - // .setProject(project) - // .setZone(location) // .build(); + // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { AddResourcePoliciesRegionDiskRequest disksRequest = AddResourcePoliciesRegionDiskRequest.newBuilder() diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java index c150a660bfb..8107c2615de 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java @@ -54,30 +54,24 @@ public static Operation.Status cloneDisksFromConsistencyGroup(String project, String sourceConsistencyGroupPolicy = String.format( "projects/%s/regions/%s/resourcePolicies/%s", project, consistencyGroupLocation, consistencyGroupName); + // Initialize client that will be used to send requests. This client only needs to be created + // once, and can be reused for multiple requests. - // If your disk has zonal location uncomment this code + // Use this client if your disk has zonal location. //try (DisksClient disksClient = DisksClient.create()){ - // BulkInsertDiskRequest request = BulkInsertDiskRequest.newBuilder() - // .setProject(project) - // .setZone(disksLocation) - // .setBulkInsertDiskResourceResource( - // BulkInsertDiskResource.newBuilder() - // .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) - // .build()) - // .build(); - //Operation response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); - - try (RegionDisksClient regionDisksClient = RegionDisksClient.create()) { + try (RegionDisksClient disksClient = RegionDisksClient.create()) { BulkInsertRegionDiskRequest request = BulkInsertRegionDiskRequest.newBuilder() .setProject(project) .setRegion(disksLocation) + // Set the zone if your disk has zonal location instead of region. + // .setZone(disksLocation) .setBulkInsertDiskResourceResource( BulkInsertDiskResource.newBuilder() .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) .build()) .build(); - Operation response = regionDisksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); + Operation response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); if (response.hasError()) { System.out.printf("Error cloning disks: %s%n", response.getError()); diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java index ea4a1b7e5d6..8a09d9e1ca9 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java @@ -43,8 +43,8 @@ public static Operation.Status deleteDiskConsistencyGroup( throws IOException, ExecutionException, InterruptedException { // 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 (ResourcePoliciesClient regionResourcePoliciesClient = ResourcePoliciesClient.create()) { - Operation response = regionResourcePoliciesClient + try (ResourcePoliciesClient resourcePoliciesClient = ResourcePoliciesClient.create()) { + Operation response = resourcePoliciesClient .deleteAsync(project, region, consistencyGroupName).get(); if (response.hasError()) { diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java index 0b16bdeeba2..2d5b68f9f1c 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java @@ -61,14 +61,16 @@ public static Operation.Status removeDiskFromConsistencyGroup( // RemoveResourcePoliciesDiskRequest request = // RemoveResourcePoliciesDiskRequest.newBuilder() // .setDisk(diskName) + // .setZone(location) + // .setProject(project) // .setDisksRemoveResourcePoliciesRequestResource( // DisksRemoveResourcePoliciesRequest.newBuilder() // .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) // .build()) - // .setProject(project) - // .setZone(location) // .build(); + // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { RemoveResourcePoliciesRegionDiskRequest disksRequest = RemoveResourcePoliciesRegionDiskRequest.newBuilder() From aba231e254621d703b458603e4f5fdc321f2c7c8 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Wed, 27 Nov 2024 22:04:57 +0100 Subject: [PATCH 11/23] Fixed code --- .../compute/disks/CreateDiskSecondaryRegional.java | 11 +++++------ .../main/java/compute/disks/StartDiskReplication.java | 3 +-- .../main/java/compute/disks/StopDiskReplication.java | 3 +-- .../consistencygroup/AddDiskToConsistencyGroup.java | 3 +-- .../CloneDisksFromConsistencyGroup.java | 3 +-- .../consistencygroup/CreateDiskConsistencyGroup.java | 3 +-- .../consistencygroup/DeleteDiskConsistencyGroup.java | 3 +-- .../RemoveDiskFromConsistencyGroup.java | 3 +-- 8 files changed, 12 insertions(+), 20 deletions(-) diff --git a/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java b/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java index f55c8f2fd05..9b34f978b3f 100644 --- a/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java +++ b/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java @@ -56,9 +56,9 @@ public static void main(String[] args) } // Creates a secondary disk in a specified region. - public static Disk createDiskSecondaryRegional(String projectId, String secondaryProjectId, - String primaryDiskName, String secondaryDiskName, String primaryDiskRegion, - String secondaryDiskRegion, int diskSizeGb) + public static Operation.Status createDiskSecondaryRegional(String projectId, + String secondaryProjectId, String primaryDiskName, String secondaryDiskName, + String primaryDiskRegion, String secondaryDiskRegion, int diskSizeGb) throws IOException, ExecutionException, InterruptedException, TimeoutException { // An iterable collection of zone names in which you want to keep // the new disks' replicas. One of the replica zones of the clone must match @@ -95,10 +95,9 @@ public static Disk createDiskSecondaryRegional(String projectId, String secondar .get(3, TimeUnit.MINUTES); if (response.hasError()) { - System.out.printf("Error creating disk: %s%n", response.getError()); - return null; + throw new Error("Error creating disk! " + response.getError()); } - return disksClient.get(secondaryProjectId, secondaryDiskRegion, secondaryDiskName); + return response.getStatus(); } } } diff --git a/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java b/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java index d294e103678..a39fa3388e1 100644 --- a/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java +++ b/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java @@ -78,8 +78,7 @@ public static Operation.Status startDiskAsyncReplication(String primaryProjectId primaryProjectId, primaryDiskLocation, primaryDiskName, replicationRequest).get(); if (response.hasError()) { - System.out.printf("Error starting disk replication: %s%n", response.getError()); - return null; + throw new Error("Error starting disk replication! " + response.getError()); } return response.getStatus(); } diff --git a/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java b/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java index 01c6ecbdcf9..456789f45ae 100644 --- a/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java +++ b/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java @@ -54,8 +54,7 @@ public static Operation.Status stopDiskAsyncReplication( project, diskLocation, diskName).get(); if (response.hasError()) { - System.out.printf("Error stopping disk replication: %s%n", response.getError()); - return null; + throw new Error("Error stopping disk replication! " + response.getError()); } return response.getStatus(); } diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java index ccfe86a5122..a2828846531 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java @@ -84,8 +84,7 @@ public static Operation.Status addDiskToConsistencyGroup( Operation response = disksClient.addResourcePoliciesAsync(disksRequest).get(); if (response.hasError()) { - System.out.printf("Error adding disk to consistency group: %s%n", response.getError()); - return null; + throw new Error("Error adding disk to consistency group! " + response.getError()); } return response.getStatus(); } diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java index 8107c2615de..d4635ad815c 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java @@ -74,8 +74,7 @@ public static Operation.Status cloneDisksFromConsistencyGroup(String project, Operation response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); if (response.hasError()) { - System.out.printf("Error cloning disks: %s%n", response.getError()); - return null; + throw new Error("Error cloning disks! " + response.getError()); } return response.getStatus(); } diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java index 0d649217062..17d64c5ea4b 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java @@ -58,8 +58,7 @@ public static Operation.Status createDiskConsistencyGroup( regionResourcePoliciesClient.insertAsync(project, region, resourcePolicy).get(); if (response.hasError()) { - System.out.printf("Error creating consistency group: %s%n", response.getError()); - return null; + throw new Error("Error creating consistency group! " + response.getError()); } return response.getStatus(); } diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java index 8a09d9e1ca9..e53414d0828 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteDiskConsistencyGroup.java @@ -48,8 +48,7 @@ public static Operation.Status deleteDiskConsistencyGroup( .deleteAsync(project, region, consistencyGroupName).get(); if (response.hasError()) { - System.out.printf("Error deleting disk: %s%n", response.getError()); - return null; + throw new Error("Error deleting disk! " + response.getError()); } return response.getStatus(); } diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java index 2d5b68f9f1c..2f246e16999 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java @@ -85,8 +85,7 @@ public static Operation.Status removeDiskFromConsistencyGroup( Operation response = disksClient.removeResourcePoliciesAsync(disksRequest).get(); if (response.hasError()) { - System.out.printf("Error removing disk from consistency group: %s%n", response.getError()); - return null; + throw new Error("Error removing disk from consistency group! " + response.getError()); } return response.getStatus(); } From 35b479c8fdb5f4702c9d32715d49b8e9e33c6a33 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Thu, 28 Nov 2024 10:48:21 +0100 Subject: [PATCH 12/23] Created test with mocked client --- .../java/compute/disks/HyperdiskMockIT.java | 65 +++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 compute/cloud-client/src/test/java/compute/disks/HyperdiskMockIT.java diff --git a/compute/cloud-client/src/test/java/compute/disks/HyperdiskMockIT.java b/compute/cloud-client/src/test/java/compute/disks/HyperdiskMockIT.java new file mode 100644 index 00000000000..9f01ddcbff9 --- /dev/null +++ b/compute/cloud-client/src/test/java/compute/disks/HyperdiskMockIT.java @@ -0,0 +1,65 @@ +package compute.disks; + +import com.google.api.gax.longrunning.OperationFuture; +import com.google.cloud.compute.v1.InsertStoragePoolRequest; +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.StoragePool; +import com.google.cloud.compute.v1.StoragePoolsClient; +import compute.disks.storagepool.CreateHyperdiskStoragePool; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; +import org.mockito.MockedStatic; +import org.mockito.Mockito; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.mockStatic; +import static org.mockito.Mockito.when; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.times; +import static org.junit.Assert.assertEquals; + + +@RunWith(JUnit4.class) +@Timeout(value = 10) +public class HyperdiskMockIT { + private static final String PROJECT_ID = "project-id"; + private static final String ZONE = "us-west1-a"; + private static final String HYPERDISK_NAME = "test-hyperdisk"; + private static final String HYPERDISK_IN_POOL_NAME = "test-hyperdisk"; + private static final String STORAGE_POOL_NAME = "test-storage-pool"; + private static final String PERFORMANCE_PROVISIONING_TYPE = "advanced"; + private static final String CAPACITY_PROVISIONING_TYPE = "advanced"; + + @Test + public void testCreateHyperdiskStoragePool() throws Exception { + String poolType = String.format("projects/%s/zones/%s/storagePoolTypes/hyperdisk-balanced", + PROJECT_ID, ZONE); + + try (MockedStatic mockedStoragePoolsClient = mockStatic(StoragePoolsClient.class)) { +// StoragePool mockStoragePool = mock(StoragePool.class); + StoragePoolsClient mockClient = mock(StoragePoolsClient.class); + OperationFuture mockFuture = mock(OperationFuture.class); + Operation.Status mockOperationStatus = Operation.Status.DONE; +// OperationFuture mockFuture = mock(OperationFuture.class, Mockito.RETURNS_DEEP_STUBS); + StoragePool mockStoragePool = StoragePool.newBuilder().setName(STORAGE_POOL_NAME).build(); + mockedStoragePoolsClient.when(StoragePoolsClient::create).thenReturn(mockClient); + when(mockClient.insertAsync(any(InsertStoragePoolRequest.class))).thenReturn(mockFuture); + when(mockFuture.get()).thenReturn(mockOperationStatus); + when(mockClient.get(PROJECT_ID, ZONE, STORAGE_POOL_NAME)).thenReturn(mockStoragePool); + + + Operation.Status returnedStatus = CreateHyperdiskStoragePool + .createHyperdiskStoragePool(PROJECT_ID, ZONE, STORAGE_POOL_NAME, poolType, + CAPACITY_PROVISIONING_TYPE, 10240, 10000, 1024, + PERFORMANCE_PROVISIONING_TYPE); + + verify(mockClient, times(1)) + .insertAsync(any(InsertStoragePoolRequest.class)); + verify(mockFuture, times(1)).get(); + assertEquals(returnedStatus, mockOperationStatus); + } + } +} From 00d0b6056b7febc4a144a53008ad77474179ddf9 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Thu, 28 Nov 2024 11:19:36 +0100 Subject: [PATCH 13/23] Increased timeout --- .../storagepool/CreateDiskInStoragePool.java | 2 +- .../CreateHyperdiskStoragePool.java | 2 +- .../java/compute/disks/HyperdiskMockIT.java | 65 ------------------- 3 files changed, 2 insertions(+), 67 deletions(-) delete mode 100644 compute/cloud-client/src/test/java/compute/disks/HyperdiskMockIT.java diff --git a/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateDiskInStoragePool.java b/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateDiskInStoragePool.java index ddd9db3194d..5f8da609a64 100644 --- a/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateDiskInStoragePool.java +++ b/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateDiskInStoragePool.java @@ -80,7 +80,7 @@ public static Disk createDiskInStoragePool(String projectId, String zone, String .build(); // Wait for the insert disk operation to complete. - Operation operation = client.insertAsync(request).get(1, TimeUnit.MINUTES); + Operation operation = client.insertAsync(request).get(3, TimeUnit.MINUTES); if (operation.hasError()) { System.out.println("Disk creation failed!"); diff --git a/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateHyperdiskStoragePool.java b/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateHyperdiskStoragePool.java index 30cdde803d0..dc40e9112ef 100644 --- a/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateHyperdiskStoragePool.java +++ b/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateHyperdiskStoragePool.java @@ -84,7 +84,7 @@ public static StoragePool createHyperdiskStoragePool(String projectId, String zo .build(); // Wait for the insert disk operation to complete. - Operation operation = client.insertAsync(request).get(1, TimeUnit.MINUTES); + Operation operation = client.insertAsync(request).get(3, TimeUnit.MINUTES); if (operation.hasError()) { System.out.println("StoragePool creation failed!"); diff --git a/compute/cloud-client/src/test/java/compute/disks/HyperdiskMockIT.java b/compute/cloud-client/src/test/java/compute/disks/HyperdiskMockIT.java deleted file mode 100644 index 9f01ddcbff9..00000000000 --- a/compute/cloud-client/src/test/java/compute/disks/HyperdiskMockIT.java +++ /dev/null @@ -1,65 +0,0 @@ -package compute.disks; - -import com.google.api.gax.longrunning.OperationFuture; -import com.google.cloud.compute.v1.InsertStoragePoolRequest; -import com.google.cloud.compute.v1.Operation; -import com.google.cloud.compute.v1.StoragePool; -import com.google.cloud.compute.v1.StoragePoolsClient; -import compute.disks.storagepool.CreateHyperdiskStoragePool; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.Timeout; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; -import org.mockito.MockedStatic; -import org.mockito.Mockito; - -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.mockStatic; -import static org.mockito.Mockito.when; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.times; -import static org.junit.Assert.assertEquals; - - -@RunWith(JUnit4.class) -@Timeout(value = 10) -public class HyperdiskMockIT { - private static final String PROJECT_ID = "project-id"; - private static final String ZONE = "us-west1-a"; - private static final String HYPERDISK_NAME = "test-hyperdisk"; - private static final String HYPERDISK_IN_POOL_NAME = "test-hyperdisk"; - private static final String STORAGE_POOL_NAME = "test-storage-pool"; - private static final String PERFORMANCE_PROVISIONING_TYPE = "advanced"; - private static final String CAPACITY_PROVISIONING_TYPE = "advanced"; - - @Test - public void testCreateHyperdiskStoragePool() throws Exception { - String poolType = String.format("projects/%s/zones/%s/storagePoolTypes/hyperdisk-balanced", - PROJECT_ID, ZONE); - - try (MockedStatic mockedStoragePoolsClient = mockStatic(StoragePoolsClient.class)) { -// StoragePool mockStoragePool = mock(StoragePool.class); - StoragePoolsClient mockClient = mock(StoragePoolsClient.class); - OperationFuture mockFuture = mock(OperationFuture.class); - Operation.Status mockOperationStatus = Operation.Status.DONE; -// OperationFuture mockFuture = mock(OperationFuture.class, Mockito.RETURNS_DEEP_STUBS); - StoragePool mockStoragePool = StoragePool.newBuilder().setName(STORAGE_POOL_NAME).build(); - mockedStoragePoolsClient.when(StoragePoolsClient::create).thenReturn(mockClient); - when(mockClient.insertAsync(any(InsertStoragePoolRequest.class))).thenReturn(mockFuture); - when(mockFuture.get()).thenReturn(mockOperationStatus); - when(mockClient.get(PROJECT_ID, ZONE, STORAGE_POOL_NAME)).thenReturn(mockStoragePool); - - - Operation.Status returnedStatus = CreateHyperdiskStoragePool - .createHyperdiskStoragePool(PROJECT_ID, ZONE, STORAGE_POOL_NAME, poolType, - CAPACITY_PROVISIONING_TYPE, 10240, 10000, 1024, - PERFORMANCE_PROVISIONING_TYPE); - - verify(mockClient, times(1)) - .insertAsync(any(InsertStoragePoolRequest.class)); - verify(mockFuture, times(1)).get(); - assertEquals(returnedStatus, mockOperationStatus); - } - } -} From 2c9b306a522df6bf67f1717edf285716538d0c1a Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Fri, 29 Nov 2024 11:20:27 +0100 Subject: [PATCH 14/23] Added check for zonal location and code --- .../compute/disks/StartDiskReplication.java | 51 ++++++------- .../AddDiskToConsistencyGroup.java | 72 ++++++++++--------- .../CloneDisksFromConsistencyGroup.java | 55 ++++++++------ .../RemoveDiskFromConsistencyGroup.java | 72 ++++++++++--------- 4 files changed, 133 insertions(+), 117 deletions(-) diff --git a/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java b/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java index a39fa3388e1..6cda96624c7 100644 --- a/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java +++ b/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java @@ -17,9 +17,8 @@ package compute.disks; // [START compute_disk_start_replication] -// Uncomment this line if your disk has zonal location. -// import com.google.cloud.compute.v1.DisksClient; -// import com.google.cloud.compute.v1.DisksStartAsyncReplicationRequest; +import com.google.cloud.compute.v1.DisksClient; +import com.google.cloud.compute.v1.DisksStartAsyncReplicationRequest; import com.google.cloud.compute.v1.Operation; import com.google.cloud.compute.v1.RegionDisksClient; import com.google.cloud.compute.v1.RegionDisksStartAsyncReplicationRequest; @@ -57,31 +56,33 @@ public static Operation.Status startDiskAsyncReplication(String primaryProjectId throws IOException, ExecutionException, InterruptedException { String secondaryDiskPath = String.format("projects/%s/regions/%s/disks/%s", secondaryProjectId, secondaryDiskLocation, secondaryDiskName); + Operation response; + if (Character.isDigit(primaryDiskLocation.charAt(primaryDiskLocation.length() - 1))) { + // 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 (RegionDisksClient regionDisksClient = RegionDisksClient.create()) { + RegionDisksStartAsyncReplicationRequest replicationRequest = + RegionDisksStartAsyncReplicationRequest.newBuilder() + .setAsyncSecondaryDisk(secondaryDiskPath) + .build(); - // Uncomment these lines if your disk has zonal location. - // try (DisksClient disksClient = DisksClient.create()) { - // DisksStartAsyncReplicationRequest startAsyncReplicationRequest = - // DisksStartAsyncReplicationRequest.newBuilder() - // .setAsyncSecondaryDisk(secondaryDiskPath) - // .build(); - - // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { - - RegionDisksStartAsyncReplicationRequest replicationRequest = - RegionDisksStartAsyncReplicationRequest.newBuilder() - .setAsyncSecondaryDisk(secondaryDiskPath) - .build(); - - Operation response = disksClient.startAsyncReplicationAsync( - primaryProjectId, primaryDiskLocation, primaryDiskName, replicationRequest).get(); - - if (response.hasError()) { - throw new Error("Error starting disk replication! " + response.getError()); + response = regionDisksClient.startAsyncReplicationAsync( + primaryProjectId, primaryDiskLocation, primaryDiskName, replicationRequest).get(); + } + } else { + try (DisksClient disksClient = DisksClient.create()) { + DisksStartAsyncReplicationRequest replicationRequest = + DisksStartAsyncReplicationRequest.newBuilder() + .setAsyncSecondaryDisk(secondaryDiskPath) + .build(); + response = disksClient.startAsyncReplicationAsync( + primaryProjectId, primaryDiskLocation, primaryDiskName, replicationRequest).get(); } - return response.getStatus(); } + if (response.hasError()) { + throw new Error("Error starting disk replication! " + response.getError()); + } + return response.getStatus(); } } // [END compute_disk_start_replication] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java index a2828846531..042688fe5a8 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java @@ -17,11 +17,10 @@ package compute.disks.consistencygroup; // [START compute_consistency_group_add_disk] +import com.google.cloud.compute.v1.AddResourcePoliciesDiskRequest; import com.google.cloud.compute.v1.AddResourcePoliciesRegionDiskRequest; -// If your disk has zonal location uncomment these lines -//import com.google.cloud.compute.v1.AddResourcePoliciesDiskRequest; -//import com.google.cloud.compute.v1.DisksAddResourcePoliciesRequest; -//import com.google.cloud.compute.v1.DisksClient; +import com.google.cloud.compute.v1.DisksAddResourcePoliciesRequest; +import com.google.cloud.compute.v1.DisksClient; import com.google.cloud.compute.v1.Operation; import com.google.cloud.compute.v1.RegionDisksAddResourcePoliciesRequest; import com.google.cloud.compute.v1.RegionDisksClient; @@ -55,39 +54,42 @@ public static Operation.Status addDiskToConsistencyGroup( String consistencyGroupUrl = String.format( "https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s", project, consistencyGroupLocation, consistencyGroupName); - // If your disk has zonal location uncomment these lines - // try (DisksClient disksClient = DisksClient.create()) { - // AddResourcePoliciesDiskRequest request = - // AddResourcePoliciesDiskRequest.newBuilder() - // .setDisk(diskName) - // .setZone(location) - // .setProject(project) - // .setDisksAddResourcePoliciesRequestResource( - // DisksAddResourcePoliciesRequest.newBuilder() - // .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) - // .build()) - // .build(); - - // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { - AddResourcePoliciesRegionDiskRequest disksRequest = - AddResourcePoliciesRegionDiskRequest.newBuilder() - .setDisk(diskName) - .setRegion(location) - .setProject(project) - .setRegionDisksAddResourcePoliciesRequestResource( - RegionDisksAddResourcePoliciesRequest.newBuilder() - .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) - .build()) - .build(); - - Operation response = disksClient.addResourcePoliciesAsync(disksRequest).get(); - if (response.hasError()) { - throw new Error("Error adding disk to consistency group! " + response.getError()); + Operation response; + if (Character.isDigit(location.charAt(location.length() - 1))) { + // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { + AddResourcePoliciesRegionDiskRequest request = + AddResourcePoliciesRegionDiskRequest.newBuilder() + .setDisk(diskName) + .setRegion(location) + .setProject(project) + .setRegionDisksAddResourcePoliciesRequestResource( + RegionDisksAddResourcePoliciesRequest.newBuilder() + .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) + .build()) + .build(); + response = disksClient.addResourcePoliciesAsync(request).get(); } - return response.getStatus(); + } else { + try (DisksClient disksClient = DisksClient.create()) { + AddResourcePoliciesDiskRequest request = + AddResourcePoliciesDiskRequest.newBuilder() + .setDisk(diskName) + .setZone(location) + .setProject(project) + .setDisksAddResourcePoliciesRequestResource( + DisksAddResourcePoliciesRequest.newBuilder() + .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) + .build()) + .build(); + response = disksClient.addResourcePoliciesAsync(request).get(); + } + } + if (response.hasError()) { + throw new Error("Error adding disk to consistency group! " + response.getError()); } + return response.getStatus(); } } // [END compute_consistency_group_add_disk] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java index d4635ad815c..9cb5ead1a2c 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java @@ -17,11 +17,10 @@ package compute.disks.consistencygroup; // [START compute_consistency_group_clone] -// If your disk has zonal location uncomment these lines -//import com.google.cloud.compute.v1.DisksClient; -//import com.google.cloud.compute.v1.BulkInsertDiskRequest; +import com.google.cloud.compute.v1.BulkInsertDiskRequest; import com.google.cloud.compute.v1.BulkInsertDiskResource; import com.google.cloud.compute.v1.BulkInsertRegionDiskRequest; +import com.google.cloud.compute.v1.DisksClient; import com.google.cloud.compute.v1.Operation; import com.google.cloud.compute.v1.RegionDisksClient; import java.io.IOException; @@ -54,30 +53,40 @@ public static Operation.Status cloneDisksFromConsistencyGroup(String project, String sourceConsistencyGroupPolicy = String.format( "projects/%s/regions/%s/resourcePolicies/%s", project, consistencyGroupLocation, consistencyGroupName); - // Initialize client that will be used to send requests. This client only needs to be created - // once, and can be reused for multiple requests. + Operation response; + if (Character.isDigit(disksLocation.charAt(disksLocation.length() - 1))) { + // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { + BulkInsertRegionDiskRequest request = BulkInsertRegionDiskRequest.newBuilder() + .setProject(project) + .setRegion(disksLocation) + .setBulkInsertDiskResourceResource( + BulkInsertDiskResource.newBuilder() + .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) + .build()) + .build(); - // Use this client if your disk has zonal location. - //try (DisksClient disksClient = DisksClient.create()){ - try (RegionDisksClient disksClient = RegionDisksClient.create()) { - BulkInsertRegionDiskRequest request = BulkInsertRegionDiskRequest.newBuilder() - .setProject(project) - .setRegion(disksLocation) - // Set the zone if your disk has zonal location instead of region. - // .setZone(disksLocation) - .setBulkInsertDiskResourceResource( - BulkInsertDiskResource.newBuilder() - .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) - .build()) - .build(); - - Operation response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); + response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); + } + } else { + try (DisksClient disksClient = DisksClient.create()) { + BulkInsertDiskRequest request = BulkInsertDiskRequest.newBuilder() + .setProject(project) + .setZone(disksLocation) + .setBulkInsertDiskResourceResource( + BulkInsertDiskResource.newBuilder() + .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) + .build()) + .build(); - if (response.hasError()) { - throw new Error("Error cloning disks! " + response.getError()); + response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); } - return response.getStatus(); } + if (response.hasError()) { + throw new Error("Error cloning disks! " + response.getError()); + } + return response.getStatus(); } } // [END compute_consistency_group_clone] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java index 2f246e16999..772d9a5503f 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java @@ -17,14 +17,13 @@ package compute.disks.consistencygroup; // [START compute_consistency_group_remove_disk] +import com.google.cloud.compute.v1.DisksClient; +import com.google.cloud.compute.v1.DisksRemoveResourcePoliciesRequest; import com.google.cloud.compute.v1.Operation; import com.google.cloud.compute.v1.RegionDisksClient; import com.google.cloud.compute.v1.RegionDisksRemoveResourcePoliciesRequest; +import com.google.cloud.compute.v1.RemoveResourcePoliciesDiskRequest; import com.google.cloud.compute.v1.RemoveResourcePoliciesRegionDiskRequest; -// If your disk has zonal location uncomment these lines -//import com.google.cloud.compute.v1.DisksClient; -//import com.google.cloud.compute.v1.DisksRemoveResourcePoliciesRequest; -//import com.google.cloud.compute.v1.RemoveResourcePoliciesDiskRequest; import java.io.IOException; import java.util.Arrays; import java.util.concurrent.ExecutionException; @@ -44,6 +43,7 @@ public static void main(String[] args) String consistencyGroupName = "CONSISTENCY_GROUP"; // The region of the consistency group. String consistencyGroupLocation = "us-central1"; + removeDiskFromConsistencyGroup( project, location, diskName, consistencyGroupName, consistencyGroupLocation); } @@ -56,39 +56,43 @@ public static Operation.Status removeDiskFromConsistencyGroup( String consistencyGroupUrl = String.format( "https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s", project, consistencyGroupLocation, consistencyGroupName); - // If your disk has zonal location uncomment these lines - // try (DisksClient disksClient = DisksClient.create()) { - // RemoveResourcePoliciesDiskRequest request = - // RemoveResourcePoliciesDiskRequest.newBuilder() - // .setDisk(diskName) - // .setZone(location) - // .setProject(project) - // .setDisksRemoveResourcePoliciesRequestResource( - // DisksRemoveResourcePoliciesRequest.newBuilder() - // .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) - // .build()) - // .build(); - - // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { - RemoveResourcePoliciesRegionDiskRequest disksRequest = - RemoveResourcePoliciesRegionDiskRequest.newBuilder() - .setDisk(diskName) - .setRegion(location) - .setProject(project) - .setRegionDisksRemoveResourcePoliciesRequestResource( - RegionDisksRemoveResourcePoliciesRequest.newBuilder() - .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) - .build()) - .build(); + Operation response; + if (Character.isDigit(location.charAt(location.length() - 1))) { + // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { + RemoveResourcePoliciesRegionDiskRequest request = + RemoveResourcePoliciesRegionDiskRequest.newBuilder() + .setDisk(diskName) + .setRegion(location) + .setProject(project) + .setRegionDisksRemoveResourcePoliciesRequestResource( + RegionDisksRemoveResourcePoliciesRequest.newBuilder() + .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) + .build()) + .build(); - Operation response = disksClient.removeResourcePoliciesAsync(disksRequest).get(); - if (response.hasError()) { - throw new Error("Error removing disk from consistency group! " + response.getError()); + response = disksClient.removeResourcePoliciesAsync(request).get(); } - return response.getStatus(); + } else { + try (DisksClient disksClient = DisksClient.create()) { + RemoveResourcePoliciesDiskRequest request = + RemoveResourcePoliciesDiskRequest.newBuilder() + .setDisk(diskName) + .setZone(location) + .setProject(project) + .setDisksRemoveResourcePoliciesRequestResource( + DisksRemoveResourcePoliciesRequest.newBuilder() + .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) + .build()) + .build(); + response = disksClient.removeResourcePoliciesAsync(request).get(); + } + } + if (response.hasError()) { + throw new Error("Error removing disk from consistency group! " + response.getError()); } + return response.getStatus(); } } // [END compute_consistency_group_remove_disk] From 92670cecc04887f26e18b50d8463632918845909 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Fri, 29 Nov 2024 11:27:24 +0100 Subject: [PATCH 15/23] Fixed compute_disk_stop_replication sample --- .../compute/disks/StopDiskReplication.java | 32 ++++++++++--------- 1 file changed, 17 insertions(+), 15 deletions(-) diff --git a/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java b/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java index 456789f45ae..b59485f3390 100644 --- a/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java +++ b/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java @@ -17,8 +17,7 @@ package compute.disks; // [START compute_disk_stop_replication] -// Uncomment this line if your disk has zonal location. -// import com.google.cloud.compute.v1.DisksClient; +import com.google.cloud.compute.v1.DisksClient; import com.google.cloud.compute.v1.Operation; import com.google.cloud.compute.v1.RegionDisksClient; import java.io.IOException; @@ -43,21 +42,24 @@ public static void main(String[] args) public static Operation.Status stopDiskAsyncReplication( String project, String diskLocation, String diskName) throws IOException, ExecutionException, InterruptedException { - - // Uncomment this line if your disk has zonal location. - //try (DisksClient disksClient = DisksClient.create()) { - - // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { - Operation response = disksClient.stopAsyncReplicationAsync( - project, diskLocation, diskName).get(); - - if (response.hasError()) { - throw new Error("Error stopping disk replication! " + response.getError()); + Operation response; + if (Character.isDigit(diskLocation.charAt(diskLocation.length() - 1))) { + // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { + response = disksClient.stopAsyncReplicationAsync( + project, diskLocation, diskName).get(); } - return response.getStatus(); + } else { + try (DisksClient disksClient = DisksClient.create()) { + response = disksClient.stopAsyncReplicationAsync( + project, diskLocation, diskName).get(); + } + } + if (response.hasError()) { + throw new Error("Error stopping disk replication! " + response.getError()); } + return response.getStatus(); } } // [END compute_disk_stop_replication] \ No newline at end of file From f04073e26406a02aab4f8db96fb25d7c367ea111 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Fri, 29 Nov 2024 11:30:55 +0100 Subject: [PATCH 16/23] Fixed comment --- .../disks/consistencygroup/CreateDiskConsistencyGroup.java | 1 - 1 file changed, 1 deletion(-) diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java index 17d64c5ea4b..2916da95cfa 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateDiskConsistencyGroup.java @@ -39,7 +39,6 @@ public static void main(String[] args) } // Creates a new disk consistency group resource policy in the specified project and region. - // Return a link to the consistency group. public static Operation.Status createDiskConsistencyGroup( String project, String region, String consistencyGroupName) throws IOException, ExecutionException, InterruptedException { From eddb54169a5733a42b9585aa3bffd6d6ba6f4285 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Fri, 29 Nov 2024 14:52:14 +0100 Subject: [PATCH 17/23] added clea up method for Consistency Group --- .../src/test/java/compute/Util.java | 21 +++++++++++++++++++ .../compute/disks/ConsistencyGroupIT.java | 1 + 2 files changed, 22 insertions(+) diff --git a/compute/cloud-client/src/test/java/compute/Util.java b/compute/cloud-client/src/test/java/compute/Util.java index 510effed769..4957bf80c31 100644 --- a/compute/cloud-client/src/test/java/compute/Util.java +++ b/compute/cloud-client/src/test/java/compute/Util.java @@ -16,6 +16,8 @@ package compute; +import static compute.disks.consistencygroup.DeleteDiskConsistencyGroup.deleteDiskConsistencyGroup; + import com.google.cloud.compute.v1.DeleteStoragePoolRequest; import com.google.cloud.compute.v1.Disk; import com.google.cloud.compute.v1.DisksClient; @@ -30,6 +32,8 @@ 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.ResourcePoliciesClient; +import com.google.cloud.compute.v1.ResourcePolicy; import com.google.cloud.compute.v1.Snapshot; import com.google.cloud.compute.v1.SnapshotsClient; import com.google.cloud.compute.v1.StoragePool; @@ -52,6 +56,7 @@ import java.util.concurrent.TimeoutException; import java.util.stream.IntStream; + public abstract class Util { // Cleans existing test resources if any. // If the project contains too many instances, use "filter" when listing @@ -283,6 +288,22 @@ && isCreatedBeforeThresholdTime(disk.getCreationTimestamp())) { } } + // Delete ConsistencyGroup which starts with the given prefixToDelete and + // has creation timestamp >24 hours. + public static void cleanUpExistingConsistencyGroup( + String prefixToDelete, String projectId, String region) + throws IOException, ExecutionException, InterruptedException { + try (ResourcePoliciesClient client = ResourcePoliciesClient.create()) { + for (ResourcePolicy resourcePolicy : client.list(projectId, region).iterateAll()) { + if (resourcePolicy.getName().contains(prefixToDelete) + && resourcePolicy.getRegion().equals(region) + && isCreatedBeforeThresholdTime(resourcePolicy.getCreationTimestamp())) { + deleteDiskConsistencyGroup(projectId, region, resourcePolicy.getName()); + } + } + } + } + public static boolean containPrefixToDeleteAndZone( Object resource, String prefixToDelete, String zone) { boolean containPrefixAndZone = false; diff --git a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java index 2019a737ff2..c7f172bcddc 100644 --- a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -94,6 +94,7 @@ public static void cleanUp() Util.cleanUpExistingRegionalDisks("test-disk-for-consistency-", PROJECT_ID, REGION); Util.cleanUpExistingRegionalDisks( "gcloud-test-disk-secondary-regional-", PROJECT_ID, REGION_SECONDARY); + Util.cleanUpExistingConsistencyGroup("test-consistency-group-", PROJECT_ID, REGION); } @Test From 011ef645018dbd4cc812591ff16873682dbf4a10 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Fri, 29 Nov 2024 15:24:41 +0100 Subject: [PATCH 18/23] Changed zone --- .../cloud-client/src/test/java/compute/disks/HyperdisksIT.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java b/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java index 47342bd5596..1ebf5ed01b8 100644 --- a/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java @@ -44,7 +44,7 @@ @TestMethodOrder(MethodOrderer.OrderAnnotation.class) public class HyperdisksIT { private static final String PROJECT_ID = System.getenv("GOOGLE_CLOUD_PROJECT"); - private static final String ZONE = "us-west1-a"; + private static final String ZONE = "us-central1-a"; private static final String HYPERDISK_NAME = "test-hyperdisk-enc-" + UUID.randomUUID(); private static final String HYPERDISK_IN_POOL_NAME = "test-hyperdisk-enc-" + UUID.randomUUID(); private static final String STORAGE_POOL_NAME = "test-storage-pool-enc-" + UUID.randomUUID(); From 11ea034dc44f70c5cf73e21a2fce1ffa45faa3d4 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Sat, 30 Nov 2024 19:24:36 +0100 Subject: [PATCH 19/23] Deleted not related classes --- .../disks/CreateDiskSecondaryRegional.java | 104 ------------------ .../compute/disks/StartDiskReplication.java | 88 --------------- .../compute/disks/StopDiskReplication.java | 65 ----------- .../storagepool/CreateDiskInStoragePool.java | 2 +- .../CreateHyperdiskStoragePool.java | 2 +- 5 files changed, 2 insertions(+), 259 deletions(-) delete mode 100644 compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java delete mode 100644 compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java delete mode 100644 compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java diff --git a/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java b/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java deleted file mode 100644 index 9b34f978b3f..00000000000 --- a/compute/cloud-client/src/main/java/compute/disks/CreateDiskSecondaryRegional.java +++ /dev/null @@ -1,104 +0,0 @@ -/* - * 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.disks; - -// [START compute_disk_create_secondary_regional] -import com.google.cloud.compute.v1.Disk; -import com.google.cloud.compute.v1.DiskAsyncReplication; -import com.google.cloud.compute.v1.Operation; -import com.google.cloud.compute.v1.RegionDisksClient; -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; - -public class CreateDiskSecondaryRegional { - public static void main(String[] args) - throws IOException, ExecutionException, InterruptedException, TimeoutException { - // TODO(developer): Replace these variables before running the sample. - // The project that contains the primary disk. - String primaryProjectId = "PRIMARY_PROJECT_ID"; - // The project that contains the secondary disk. - String secondaryProjectId = "SECONDARY_PROJECT_ID"; - // Name of the primary disk you want to use. - String primaryDiskName = "PRIMARY_DISK_NAME"; - // Name of the disk you want to create. - String secondaryDiskName = "SECONDARY_DISK_NAME"; - // Name of the region in which your primary disk is located. - // Learn more about zones and regions: - // https://cloud.google.com/compute/docs/disks/async-pd/about#supported_region_pairs - String primaryDiskRegion = "us-central1"; - // Name of the region in which you want to create the secondary disk. - String secondaryDiskRegion = "us-east1"; - // Size of the new disk in gigabytes. - // Learn more about disk requirements: - // https://cloud.google.com/compute/docs/disks/async-pd/configure?authuser=0#disk_requirements - int diskSizeGb = 10; - - createDiskSecondaryRegional(primaryProjectId, secondaryProjectId, primaryDiskName, - secondaryDiskName, primaryDiskRegion, secondaryDiskRegion, diskSizeGb); - } - - // Creates a secondary disk in a specified region. - public static Operation.Status createDiskSecondaryRegional(String projectId, - String secondaryProjectId, String primaryDiskName, String secondaryDiskName, - String primaryDiskRegion, String secondaryDiskRegion, int diskSizeGb) - throws IOException, ExecutionException, InterruptedException, TimeoutException { - // An iterable collection of zone names in which you want to keep - // the new disks' replicas. One of the replica zones of the clone must match - // the zone of the source disk. - List replicaZones = Arrays.asList( - String.format("projects/%s/zones/%s-c", secondaryProjectId, secondaryDiskRegion), - String.format("projects/%s/zones/%s-b", secondaryProjectId, secondaryDiskRegion)); - - String diskType = String.format("projects/%s/regions/%s/diskTypes/pd-balanced", - secondaryProjectId, secondaryDiskRegion); - - String primaryDiskSource = String.format("projects/%s/regions/%s/disks/%s", - projectId, primaryDiskRegion, primaryDiskName); - - DiskAsyncReplication asyncReplication = DiskAsyncReplication.newBuilder() - .setDisk(primaryDiskSource) - .build(); - - // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { - - Disk disk = Disk.newBuilder() - .addAllReplicaZones(replicaZones) - .setName(secondaryDiskName) - .setSizeGb(diskSizeGb) - .setType(diskType) - .setRegion(secondaryDiskRegion) - .setAsyncPrimaryDisk(asyncReplication) - .build(); - - // Wait for the create disk operation to complete. - Operation response = disksClient.insertAsync(secondaryProjectId, secondaryDiskRegion, disk) - .get(3, TimeUnit.MINUTES); - - if (response.hasError()) { - throw new Error("Error creating disk! " + response.getError()); - } - return response.getStatus(); - } - } -} -// [END compute_disk_create_secondary_regional] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java b/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java deleted file mode 100644 index 6cda96624c7..00000000000 --- a/compute/cloud-client/src/main/java/compute/disks/StartDiskReplication.java +++ /dev/null @@ -1,88 +0,0 @@ -/* - * 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.disks; - -// [START compute_disk_start_replication] -import com.google.cloud.compute.v1.DisksClient; -import com.google.cloud.compute.v1.DisksStartAsyncReplicationRequest; -import com.google.cloud.compute.v1.Operation; -import com.google.cloud.compute.v1.RegionDisksClient; -import com.google.cloud.compute.v1.RegionDisksStartAsyncReplicationRequest; -import java.io.IOException; -import java.util.concurrent.ExecutionException; - -public class StartDiskReplication { - - public static void main(String[] args) - throws IOException, ExecutionException, InterruptedException { - // TODO(developer): Replace these variables before running the sample. - // The project that contains the primary disk. - String primaryProjectId = "PRIMARY_PROJECT_ID"; - // Name of the primary disk. - String primaryDiskName = "PRIMARY_DISK_NAME"; - // Name of the region in which your primary disk is located. - // Learn more about zones and regions: - // https://cloud.google.com/compute/docs/disks/async-pd/about#supported_region_pairs - String primaryDiskLocation = "YOUR_PRIMARY_DISK_LOCATION"; - // The project that contains the secondary disk. - String secondaryProjectId = "SECONDARY_PROJECT_ID"; - // Name of the region in which your secondary disk is located. - String secondaryDiskLocation = "YOUR_SECONDARY_DISK_LOCATION"; - // Name of the secondary disk. - String secondaryDiskName = "SECONDARY_DISK_NAME"; - - startDiskAsyncReplication(primaryProjectId, primaryDiskName, - primaryDiskLocation, secondaryProjectId, secondaryDiskLocation, secondaryDiskName); - } - - // Starts asynchronous replication for the specified disk. - public static Operation.Status startDiskAsyncReplication(String primaryProjectId, - String primaryDiskName, String primaryDiskLocation, String secondaryProjectId, - String secondaryDiskLocation, String secondaryDiskName) - throws IOException, ExecutionException, InterruptedException { - String secondaryDiskPath = String.format("projects/%s/regions/%s/disks/%s", - secondaryProjectId, secondaryDiskLocation, secondaryDiskName); - Operation response; - if (Character.isDigit(primaryDiskLocation.charAt(primaryDiskLocation.length() - 1))) { - // 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 (RegionDisksClient regionDisksClient = RegionDisksClient.create()) { - RegionDisksStartAsyncReplicationRequest replicationRequest = - RegionDisksStartAsyncReplicationRequest.newBuilder() - .setAsyncSecondaryDisk(secondaryDiskPath) - .build(); - - response = regionDisksClient.startAsyncReplicationAsync( - primaryProjectId, primaryDiskLocation, primaryDiskName, replicationRequest).get(); - } - } else { - try (DisksClient disksClient = DisksClient.create()) { - DisksStartAsyncReplicationRequest replicationRequest = - DisksStartAsyncReplicationRequest.newBuilder() - .setAsyncSecondaryDisk(secondaryDiskPath) - .build(); - response = disksClient.startAsyncReplicationAsync( - primaryProjectId, primaryDiskLocation, primaryDiskName, replicationRequest).get(); - } - } - if (response.hasError()) { - throw new Error("Error starting disk replication! " + response.getError()); - } - return response.getStatus(); - } -} -// [END compute_disk_start_replication] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java b/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java deleted file mode 100644 index b59485f3390..00000000000 --- a/compute/cloud-client/src/main/java/compute/disks/StopDiskReplication.java +++ /dev/null @@ -1,65 +0,0 @@ -/* - * 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.disks; - -// [START compute_disk_stop_replication] -import com.google.cloud.compute.v1.DisksClient; -import com.google.cloud.compute.v1.Operation; -import com.google.cloud.compute.v1.RegionDisksClient; -import java.io.IOException; -import java.util.concurrent.ExecutionException; - -public class StopDiskReplication { - - public static void main(String[] args) - throws IOException, ExecutionException, InterruptedException { - // 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"; - // Location of your disk. - String diskLocation = "us-central1-a"; - // Name of your disk. - String diskName = "YOUR_DISK_NAME"; - - stopDiskAsyncReplication(projectId, diskLocation, diskName); - } - - // Stops asynchronous replication for the specified disk. - public static Operation.Status stopDiskAsyncReplication( - String project, String diskLocation, String diskName) - throws IOException, ExecutionException, InterruptedException { - Operation response; - if (Character.isDigit(diskLocation.charAt(diskLocation.length() - 1))) { - // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { - response = disksClient.stopAsyncReplicationAsync( - project, diskLocation, diskName).get(); - } - } else { - try (DisksClient disksClient = DisksClient.create()) { - response = disksClient.stopAsyncReplicationAsync( - project, diskLocation, diskName).get(); - } - } - if (response.hasError()) { - throw new Error("Error stopping disk replication! " + response.getError()); - } - return response.getStatus(); - } -} -// [END compute_disk_stop_replication] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateDiskInStoragePool.java b/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateDiskInStoragePool.java index 5f8da609a64..ddd9db3194d 100644 --- a/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateDiskInStoragePool.java +++ b/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateDiskInStoragePool.java @@ -80,7 +80,7 @@ public static Disk createDiskInStoragePool(String projectId, String zone, String .build(); // Wait for the insert disk operation to complete. - Operation operation = client.insertAsync(request).get(3, TimeUnit.MINUTES); + Operation operation = client.insertAsync(request).get(1, TimeUnit.MINUTES); if (operation.hasError()) { System.out.println("Disk creation failed!"); diff --git a/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateHyperdiskStoragePool.java b/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateHyperdiskStoragePool.java index dc40e9112ef..30cdde803d0 100644 --- a/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateHyperdiskStoragePool.java +++ b/compute/cloud-client/src/main/java/compute/disks/storagepool/CreateHyperdiskStoragePool.java @@ -84,7 +84,7 @@ public static StoragePool createHyperdiskStoragePool(String projectId, String zo .build(); // Wait for the insert disk operation to complete. - Operation operation = client.insertAsync(request).get(3, TimeUnit.MINUTES); + Operation operation = client.insertAsync(request).get(1, TimeUnit.MINUTES); if (operation.hasError()) { System.out.println("StoragePool creation failed!"); From 99cb52818b93b1a3be6720c434e1f57a046e3f5f Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Tue, 10 Dec 2024 11:34:11 +0100 Subject: [PATCH 20/23] Created compute_consistency_group_clone_zonal_disk sample and test --- .../CloneDisksFromConsistencyGroup.java | 65 ++++++----------- .../CloneZonalDisksFromConsistencyGroup.java | 72 +++++++++++++++++++ .../compute/disks/ConsistencyGroupIT.java | 29 +++++++- 3 files changed, 122 insertions(+), 44 deletions(-) create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneZonalDisksFromConsistencyGroup.java diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java index 9cb5ead1a2c..39cc56c2a53 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java @@ -17,10 +17,8 @@ package compute.disks.consistencygroup; // [START compute_consistency_group_clone] -import com.google.cloud.compute.v1.BulkInsertDiskRequest; import com.google.cloud.compute.v1.BulkInsertDiskResource; import com.google.cloud.compute.v1.BulkInsertRegionDiskRequest; -import com.google.cloud.compute.v1.DisksClient; import com.google.cloud.compute.v1.Operation; import com.google.cloud.compute.v1.RegionDisksClient; import java.io.IOException; @@ -35,58 +33,39 @@ public static void main(String[] args) // 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"; - // Name of the region or zone in which your disk is located. - String disksLocation = "us-central1"; + // Region in which your disk and consistency group are located. + String region = "us-central1"; // Name of the consistency group you want to clone disks from. String consistencyGroupName = "YOUR_CONSISTENCY_GROUP_NAME"; - // Name of the region in which your consistency group is located. - String consistencyGroupLocation = "us-central1"; - cloneDisksFromConsistencyGroup( - project, disksLocation, consistencyGroupName, consistencyGroupLocation); + cloneDisksFromConsistencyGroup(project, region, consistencyGroupName); } - // Clones disks from a consistency group. - public static Operation.Status cloneDisksFromConsistencyGroup(String project, - String disksLocation, String consistencyGroupName, String consistencyGroupLocation) + // Clones disks with regional location from a consistency group. + public static Operation.Status cloneDisksFromConsistencyGroup( + String project, String region, String consistencyGroupName) throws IOException, InterruptedException, ExecutionException, TimeoutException { String sourceConsistencyGroupPolicy = String.format( - "projects/%s/regions/%s/resourcePolicies/%s", project, consistencyGroupLocation, - consistencyGroupName); - Operation response; - if (Character.isDigit(disksLocation.charAt(disksLocation.length() - 1))) { - // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { - BulkInsertRegionDiskRequest request = BulkInsertRegionDiskRequest.newBuilder() - .setProject(project) - .setRegion(disksLocation) - .setBulkInsertDiskResourceResource( - BulkInsertDiskResource.newBuilder() - .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) - .build()) - .build(); + "projects/%s/regions/%s/resourcePolicies/%s", project, region, consistencyGroupName); + // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { + BulkInsertRegionDiskRequest request = BulkInsertRegionDiskRequest.newBuilder() + .setProject(project) + .setRegion(region) + .setBulkInsertDiskResourceResource( + BulkInsertDiskResource.newBuilder() + .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) + .build()) + .build(); - response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); - } - } else { - try (DisksClient disksClient = DisksClient.create()) { - BulkInsertDiskRequest request = BulkInsertDiskRequest.newBuilder() - .setProject(project) - .setZone(disksLocation) - .setBulkInsertDiskResourceResource( - BulkInsertDiskResource.newBuilder() - .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) - .build()) - .build(); + Operation response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); - response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); + if (response.hasError()) { + throw new Error("Error cloning disks! " + response.getError()); } + return response.getStatus(); } - if (response.hasError()) { - throw new Error("Error cloning disks! " + response.getError()); - } - return response.getStatus(); } } // [END compute_consistency_group_clone] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneZonalDisksFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneZonalDisksFromConsistencyGroup.java new file mode 100644 index 00000000000..f86b9ecb6c3 --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneZonalDisksFromConsistencyGroup.java @@ -0,0 +1,72 @@ +/* + * 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.disks.consistencygroup; + +// [START compute_consistency_group_clone_zonal_disk] +import com.google.cloud.compute.v1.BulkInsertDiskRequest; +import com.google.cloud.compute.v1.BulkInsertDiskResource; +import com.google.cloud.compute.v1.DisksClient; +import com.google.cloud.compute.v1.Operation; +import java.io.IOException; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +public class CloneZonalDisksFromConsistencyGroup { + 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"; + // Zone in which your disk is located. + String disksLocation = "us-central1-a"; + // Name of the consistency group you want to clone disks from. + String consistencyGroupName = "YOUR_CONSISTENCY_GROUP_NAME"; + + cloneZonalDisksFromConsistencyGroup(project, disksLocation, consistencyGroupName); + } + + // Clones disks with zonal location from a consistency group. + public static Operation.Status cloneZonalDisksFromConsistencyGroup( + String project, String zone, String consistencyGroupName) + throws IOException, InterruptedException, ExecutionException, TimeoutException { + String region = zone.substring(0, zone.lastIndexOf('-')); + String sourceConsistencyGroupPolicy = String.format( + "projects/%s/regions/%s/resourcePolicies/%s", project, region, consistencyGroupName); + + // 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 (DisksClient disksClient = DisksClient.create()) { + BulkInsertDiskRequest request = BulkInsertDiskRequest.newBuilder() + .setProject(project) + .setZone(zone) + .setBulkInsertDiskResourceResource( + BulkInsertDiskResource.newBuilder() + .setSourceConsistencyGroupPolicy(sourceConsistencyGroupPolicy) + .build()) + .build(); + + Operation response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); + + if (response.hasError()) { + throw new Error("Error cloning disks! " + response.getError()); + } + return response.getStatus(); + } + } +} +// [END compute_consistency_group_clone_zonal_disk] diff --git a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java index 3f19db9a23d..35d20b2d3b0 100644 --- a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -27,7 +27,9 @@ import com.google.api.gax.longrunning.OperationFuture; import com.google.cloud.compute.v1.AddResourcePoliciesRegionDiskRequest; +import com.google.cloud.compute.v1.BulkInsertDiskRequest; import com.google.cloud.compute.v1.BulkInsertRegionDiskRequest; +import com.google.cloud.compute.v1.DisksClient; import com.google.cloud.compute.v1.InsertResourcePolicyRequest; import com.google.cloud.compute.v1.Operation; import com.google.cloud.compute.v1.RegionDisksClient; @@ -35,6 +37,7 @@ import com.google.cloud.compute.v1.ResourcePoliciesClient; import compute.disks.consistencygroup.AddDiskToConsistencyGroup; import compute.disks.consistencygroup.CloneDisksFromConsistencyGroup; +import compute.disks.consistencygroup.CloneZonalDisksFromConsistencyGroup; import compute.disks.consistencygroup.CreateConsistencyGroup; import compute.disks.consistencygroup.DeleteConsistencyGroup; import compute.disks.consistencygroup.RemoveDiskFromConsistencyGroup; @@ -163,7 +166,7 @@ public void testCloneDisksFromConsistencyGroup() throws Exception { when(operation.getStatus()).thenReturn(Operation.Status.DONE); Operation.Status status = CloneDisksFromConsistencyGroup.cloneDisksFromConsistencyGroup( - PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME, REGION); + PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); verify(mockClient, times(1)) .bulkInsertAsync(any(BulkInsertRegionDiskRequest.class)); @@ -171,4 +174,28 @@ public void testCloneDisksFromConsistencyGroup() throws Exception { assertEquals(Operation.Status.DONE, status); } } + + @Test + public void testCloneZonalDisksFromConsistencyGroup() throws Exception { + try (MockedStatic mockedRegionDisksClient = + mockStatic(DisksClient.class)) { + Operation operation = mock(Operation.class); + DisksClient mockClient = mock(DisksClient.class); + OperationFuture mockFuture = mock(OperationFuture.class); + + mockedRegionDisksClient.when(DisksClient::create).thenReturn(mockClient); + when(mockClient.bulkInsertAsync(any(BulkInsertDiskRequest.class))) + .thenReturn(mockFuture); + when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); + when(operation.getStatus()).thenReturn(Operation.Status.DONE); + + Operation.Status status = CloneZonalDisksFromConsistencyGroup + .cloneZonalDisksFromConsistencyGroup(PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); + + verify(mockClient, times(1)) + .bulkInsertAsync(any(BulkInsertDiskRequest.class)); + verify(mockFuture, times(1)).get(anyLong(), any(TimeUnit.class)); + assertEquals(Operation.Status.DONE, status); + } + } } From 18abd6d07ba58d575823b4f668defd2788896af8 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Fri, 13 Dec 2024 13:28:25 +0100 Subject: [PATCH 21/23] Fixed code for samples with zonal/regional disk location --- .../AddDiskToConsistencyGroup.java | 98 ----------------- .../AddRegionalDiskToConsistencyGroup.java | 76 +++++++++++++ .../AddZonalDiskToConsistencyGroup.java | 79 ++++++++++++++ ...oneRegionalDisksFromConsistencyGroup.java} | 17 +-- .../CloneZonalDisksFromConsistencyGroup.java | 6 +- .../ListRegionalDisksInConsistencyGroup.java | 21 ++-- .../ListZonalDisksInConsistencyGroup.java | 20 ++-- .../RemoveDiskFromConsistencyGroup.java | 100 ------------------ ...emoveRegionalDiskFromConsistencyGroup.java | 79 ++++++++++++++ .../RemoveZonalDiskFromConsistencyGroup.java | 80 ++++++++++++++ .../compute/disks/ConsistencyGroupIT.java | 80 +++++++++++--- 11 files changed, 412 insertions(+), 244 deletions(-) delete mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddRegionalDiskToConsistencyGroup.java create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddZonalDiskToConsistencyGroup.java rename compute/cloud-client/src/main/java/compute/disks/consistencygroup/{CloneDisksFromConsistencyGroup.java => CloneRegionalDisksFromConsistencyGroup.java} (83%) delete mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveRegionalDiskFromConsistencyGroup.java create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveZonalDiskFromConsistencyGroup.java diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java deleted file mode 100644 index 7c4650fad09..00000000000 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddDiskToConsistencyGroup.java +++ /dev/null @@ -1,98 +0,0 @@ -/* - * 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.disks.consistencygroup; - -// [START compute_consistency_group_add_disk] -import com.google.cloud.compute.v1.AddResourcePoliciesDiskRequest; -import com.google.cloud.compute.v1.AddResourcePoliciesRegionDiskRequest; -import com.google.cloud.compute.v1.DisksAddResourcePoliciesRequest; -import com.google.cloud.compute.v1.DisksClient; -import com.google.cloud.compute.v1.Operation; -import com.google.cloud.compute.v1.RegionDisksAddResourcePoliciesRequest; -import com.google.cloud.compute.v1.RegionDisksClient; -import java.io.IOException; -import java.util.Arrays; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; - -public class AddDiskToConsistencyGroup { - 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 that contains the disk. - String project = "YOUR_PROJECT_ID"; - // Zone or region of the disk. - String location = "us-central1"; - // Name of the disk. - String diskName = "DISK_NAME"; - // Name of the consistency group. - String consistencyGroupName = "CONSISTENCY_GROUP"; - // Region of the consistency group. - String consistencyGroupLocation = "us-central1"; - - addDiskToConsistencyGroup( - project, location, diskName, consistencyGroupName, consistencyGroupLocation); - } - - // Adds a disk to a consistency group. - public static Operation.Status addDiskToConsistencyGroup( - String project, String location, String diskName, - String consistencyGroupName, String consistencyGroupLocation) - throws IOException, ExecutionException, InterruptedException, TimeoutException { - String consistencyGroupUrl = String.format( - "https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s", - project, consistencyGroupLocation, consistencyGroupName); - Operation response; - if (Character.isDigit(location.charAt(location.length() - 1))) { - // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { - AddResourcePoliciesRegionDiskRequest request = - AddResourcePoliciesRegionDiskRequest.newBuilder() - .setDisk(diskName) - .setRegion(location) - .setProject(project) - .setRegionDisksAddResourcePoliciesRequestResource( - RegionDisksAddResourcePoliciesRequest.newBuilder() - .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) - .build()) - .build(); - response = disksClient.addResourcePoliciesAsync(request).get(1, TimeUnit.MINUTES); - } - } else { - try (DisksClient disksClient = DisksClient.create()) { - AddResourcePoliciesDiskRequest request = - AddResourcePoliciesDiskRequest.newBuilder() - .setDisk(diskName) - .setZone(location) - .setProject(project) - .setDisksAddResourcePoliciesRequestResource( - DisksAddResourcePoliciesRequest.newBuilder() - .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) - .build()) - .build(); - response = disksClient.addResourcePoliciesAsync(request).get(1, TimeUnit.MINUTES); - } - } - if (response.hasError()) { - throw new Error("Error adding disk to consistency group! " + response.getError()); - } - return response.getStatus(); - } -} -// [END compute_consistency_group_add_disk] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddRegionalDiskToConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddRegionalDiskToConsistencyGroup.java new file mode 100644 index 00000000000..3f27e34d0c8 --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddRegionalDiskToConsistencyGroup.java @@ -0,0 +1,76 @@ +/* + * 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.disks.consistencygroup; + +// [START compute_consistency_group_add_regional_disk] +import com.google.cloud.compute.v1.AddResourcePoliciesRegionDiskRequest; +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.RegionDisksAddResourcePoliciesRequest; +import com.google.cloud.compute.v1.RegionDisksClient; +import java.io.IOException; +import java.util.Arrays; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +public class AddRegionalDiskToConsistencyGroup { + 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 that contains the disk. + String project = "YOUR_PROJECT_ID"; + // Region in which your disk and consistency group are located. + String region = "us-central1"; + // Name of the disk. + String diskName = "DISK_NAME"; + // Name of the consistency group. + String consistencyGroupName = "CONSISTENCY_GROUP"; + + addRegionalDiskToConsistencyGroup(project, region, diskName, consistencyGroupName); + } + + // Adds regional disk to a consistency group. + public static Operation.Status addRegionalDiskToConsistencyGroup( + String project, String region, String diskName, String consistencyGroupName) + throws IOException, ExecutionException, InterruptedException, TimeoutException { + String consistencyGroupUrl = String.format( + "https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s", + project, region, consistencyGroupName); + + // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { + AddResourcePoliciesRegionDiskRequest request = + AddResourcePoliciesRegionDiskRequest.newBuilder() + .setDisk(diskName) + .setRegion(region) + .setProject(project) + .setRegionDisksAddResourcePoliciesRequestResource( + RegionDisksAddResourcePoliciesRequest.newBuilder() + .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) + .build()) + .build(); + Operation response = disksClient.addResourcePoliciesAsync(request).get(1, TimeUnit.MINUTES); + + if (response.hasError()) { + throw new Error("Error adding regional disk to consistency group! " + response.getError()); + } + return response.getStatus(); + } + } +} +// [END compute_consistency_group_add_regional_disk] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddZonalDiskToConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddZonalDiskToConsistencyGroup.java new file mode 100644 index 00000000000..f69e44cb3cb --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddZonalDiskToConsistencyGroup.java @@ -0,0 +1,79 @@ +/* + * 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.disks.consistencygroup; + +// [START compute_consistency_group_add_zonal_disk] +import com.google.cloud.compute.v1.AddResourcePoliciesDiskRequest; +import com.google.cloud.compute.v1.DisksAddResourcePoliciesRequest; +import com.google.cloud.compute.v1.DisksClient; +import com.google.cloud.compute.v1.Operation; +import java.io.IOException; +import java.util.Arrays; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +public class AddZonalDiskToConsistencyGroup { + 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 that contains the disk. + String project = "YOUR_PROJECT_ID"; + // Zone of the disk. + String diskLocation = "us-central1-a"; + // Name of the disk. + String diskName = "DISK_NAME"; + // Name of the consistency group. + String consistencyGroupName = "CONSISTENCY_GROUP"; + + addZonalDiskToConsistencyGroup( + project, diskLocation, diskName, consistencyGroupName); + } + + // Adds zonal disk to a consistency group. + public static Operation.Status addZonalDiskToConsistencyGroup( + String project, String diskLocation, String diskName, + String consistencyGroupName) + throws IOException, ExecutionException, InterruptedException, TimeoutException { + String region = diskLocation.substring(0, diskLocation.lastIndexOf('-')); + String consistencyGroupUrl = String.format( + "https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s", + project, region, consistencyGroupName); + + // 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 (DisksClient disksClient = DisksClient.create()) { + AddResourcePoliciesDiskRequest request = + AddResourcePoliciesDiskRequest.newBuilder() + .setDisk(diskName) + .setZone(diskLocation) + .setProject(project) + .setDisksAddResourcePoliciesRequestResource( + DisksAddResourcePoliciesRequest.newBuilder() + .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) + .build()) + .build(); + Operation response = disksClient.addResourcePoliciesAsync(request).get(1, TimeUnit.MINUTES); + + if (response.hasError()) { + throw new Error("Error adding disk to consistency group! " + response.getError()); + } + return response.getStatus(); + } + } +} +// [END compute_consistency_group_add_zonal_disk] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneRegionalDisksFromConsistencyGroup.java similarity index 83% rename from compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java rename to compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneRegionalDisksFromConsistencyGroup.java index 39cc56c2a53..24b0a97f449 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneDisksFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneRegionalDisksFromConsistencyGroup.java @@ -16,7 +16,7 @@ package compute.disks.consistencygroup; -// [START compute_consistency_group_clone] +// [START compute_consistency_group_clone_regional_disk] import com.google.cloud.compute.v1.BulkInsertDiskResource; import com.google.cloud.compute.v1.BulkInsertRegionDiskRequest; import com.google.cloud.compute.v1.Operation; @@ -26,27 +26,28 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; -public class CloneDisksFromConsistencyGroup { +public class CloneRegionalDisksFromConsistencyGroup { 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"; - // Region in which your disk and consistency group are located. + // Region in which your disks and consistency group are located. String region = "us-central1"; // Name of the consistency group you want to clone disks from. String consistencyGroupName = "YOUR_CONSISTENCY_GROUP_NAME"; - cloneDisksFromConsistencyGroup(project, region, consistencyGroupName); + cloneRegionalDisksFromConsistencyGroup(project, region, consistencyGroupName); } - // Clones disks with regional location from a consistency group. - public static Operation.Status cloneDisksFromConsistencyGroup( + // Clones regional disks from a consistency group. + public static Operation.Status cloneRegionalDisksFromConsistencyGroup( String project, String region, String consistencyGroupName) throws IOException, InterruptedException, ExecutionException, TimeoutException { String sourceConsistencyGroupPolicy = String.format( "projects/%s/regions/%s/resourcePolicies/%s", project, region, consistencyGroupName); + // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { @@ -62,10 +63,10 @@ public static Operation.Status cloneDisksFromConsistencyGroup( Operation response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); if (response.hasError()) { - throw new Error("Error cloning disks! " + response.getError()); + throw new Error("Error cloning regional disks! " + response.getError()); } return response.getStatus(); } } } -// [END compute_consistency_group_clone] \ No newline at end of file +// [END compute_consistency_group_clone_regional_disk] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneZonalDisksFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneZonalDisksFromConsistencyGroup.java index f86b9ecb6c3..91b9ddea2cf 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneZonalDisksFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneZonalDisksFromConsistencyGroup.java @@ -32,7 +32,7 @@ public static void main(String[] args) // 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"; - // Zone in which your disk is located. + // Zone in which your disks are located. String disksLocation = "us-central1-a"; // Name of the consistency group you want to clone disks from. String consistencyGroupName = "YOUR_CONSISTENCY_GROUP_NAME"; @@ -40,7 +40,7 @@ public static void main(String[] args) cloneZonalDisksFromConsistencyGroup(project, disksLocation, consistencyGroupName); } - // Clones disks with zonal location from a consistency group. + // Clones zonal disks from a consistency group. public static Operation.Status cloneZonalDisksFromConsistencyGroup( String project, String zone, String consistencyGroupName) throws IOException, InterruptedException, ExecutionException, TimeoutException { @@ -63,7 +63,7 @@ public static Operation.Status cloneZonalDisksFromConsistencyGroup( Operation response = disksClient.bulkInsertAsync(request).get(3, TimeUnit.MINUTES); if (response.hasError()) { - throw new Error("Error cloning disks! " + response.getError()); + throw new Error("Error cloning zonal disks! " + response.getError()); } return response.getStatus(); } diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/ListRegionalDisksInConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/ListRegionalDisksInConsistencyGroup.java index 36fe60cf2ad..d4889d543fa 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/ListRegionalDisksInConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/ListRegionalDisksInConsistencyGroup.java @@ -16,7 +16,7 @@ package compute.disks.consistencygroup; -// [START compute_consistency_group_list_disks_regional] +// [START compute_consistency_group_list_regional_disks] import com.google.cloud.compute.v1.Disk; import com.google.cloud.compute.v1.ListRegionDisksRequest; import com.google.cloud.compute.v1.RegionDisksClient; @@ -33,22 +33,19 @@ public static void main(String[] args) String project = "YOUR_PROJECT_ID"; // Name of the consistency group. String consistencyGroupName = "CONSISTENCY_GROUP_ID"; - // Region of the disk. - String disksLocation = "us-central1"; - // Region of the consistency group. - String consistencyGroupLocation = "us-central1"; + // Region in which your disks and consistency group are located. + String region = "us-central1"; listRegionalDisksInConsistencyGroup( - project, consistencyGroupName, consistencyGroupLocation, disksLocation); + project, consistencyGroupName, region); } // Lists disks in a consistency group. - public static List listRegionalDisksInConsistencyGroup(String project, - String consistencyGroupName, String consistencyGroupLocation, String disksLocation) - throws IOException { + public static List listRegionalDisksInConsistencyGroup( + String project, String consistencyGroupName, String region) throws IOException { String filter = String .format("https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s", - project, consistencyGroupLocation, consistencyGroupName); + project, region, consistencyGroupName); List disksList = new ArrayList<>(); // Initialize client that will be used to send requests. This client only needs to be created @@ -57,7 +54,7 @@ public static List listRegionalDisksInConsistencyGroup(String project, ListRegionDisksRequest request = ListRegionDisksRequest.newBuilder() .setProject(project) - .setRegion(disksLocation) + .setRegion(region) .build(); RegionDisksClient.ListPagedResponse response = disksClient.list(request); @@ -71,4 +68,4 @@ public static List listRegionalDisksInConsistencyGroup(String project, return disksList; } } -// [END compute_consistency_group_list_disks_regional] \ No newline at end of file +// [END compute_consistency_group_list_regional_disks] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/ListZonalDisksInConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/ListZonalDisksInConsistencyGroup.java index 2434802d860..05cd688ac7b 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/ListZonalDisksInConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/ListZonalDisksInConsistencyGroup.java @@ -16,7 +16,7 @@ package compute.disks.consistencygroup; -// [START compute_consistency_group_list_disks_zonal] +// [START compute_consistency_group_list_zonal_disks] import com.google.cloud.compute.v1.Disk; import com.google.cloud.compute.v1.DisksClient; import com.google.cloud.compute.v1.ListDisksRequest; @@ -33,23 +33,21 @@ public static void main(String[] args) String project = "YOUR_PROJECT_ID"; // Name of the consistency group. String consistencyGroupName = "CONSISTENCY_GROUP_ID"; - // Zone of the disk. + // Zone in which your disks are located. String disksLocation = "us-central1-a"; - // Region of the consistency group. - String consistencyGroupLocation = "us-central1"; - listZonalDisksInConsistencyGroup( - project, consistencyGroupName, consistencyGroupLocation, disksLocation); + listZonalDisksInConsistencyGroup(project, consistencyGroupName, disksLocation); } // Lists disks in a consistency group. - public static List listZonalDisksInConsistencyGroup(String project, - String consistencyGroupName, String consistencyGroupLocation, String disksLocation) - throws IOException { + public static List listZonalDisksInConsistencyGroup( + String project, String consistencyGroupName, String disksLocation) throws IOException { + String region = disksLocation.substring(0, disksLocation.lastIndexOf('-')); String filter = String .format("https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s", - project, consistencyGroupLocation, consistencyGroupName); + project, region, consistencyGroupName); List disksList = new ArrayList<>(); + // 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 (DisksClient disksClient = DisksClient.create()) { @@ -70,4 +68,4 @@ public static List listZonalDisksInConsistencyGroup(String project, return disksList; } } -// [END compute_consistency_group_list_disks_zonal] +// [END compute_consistency_group_list_zonal_disks] diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java deleted file mode 100644 index b791125b0dd..00000000000 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveDiskFromConsistencyGroup.java +++ /dev/null @@ -1,100 +0,0 @@ -/* - * 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.disks.consistencygroup; - -// [START compute_consistency_group_remove_disk] -import com.google.cloud.compute.v1.DisksClient; -import com.google.cloud.compute.v1.DisksRemoveResourcePoliciesRequest; -import com.google.cloud.compute.v1.Operation; -import com.google.cloud.compute.v1.RegionDisksClient; -import com.google.cloud.compute.v1.RegionDisksRemoveResourcePoliciesRequest; -import com.google.cloud.compute.v1.RemoveResourcePoliciesDiskRequest; -import com.google.cloud.compute.v1.RemoveResourcePoliciesRegionDiskRequest; -import java.io.IOException; -import java.util.Arrays; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; - -public class RemoveDiskFromConsistencyGroup { - - 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 that contains the disk. - String project = "YOUR_PROJECT_ID"; - // Zone or region of the disk. - String location = "us-central1"; - // Name of the disk. - String diskName = "DISK_NAME"; - // Name of the consistency group. - String consistencyGroupName = "CONSISTENCY_GROUP"; - // Region of the consistency group. - String consistencyGroupLocation = "us-central1"; - - removeDiskFromConsistencyGroup( - project, location, diskName, consistencyGroupName, consistencyGroupLocation); - } - - // Removes a disk from a consistency group. - public static Operation.Status removeDiskFromConsistencyGroup( - String project, String location, String diskName, - String consistencyGroupName, String consistencyGroupLocation) - throws IOException, ExecutionException, InterruptedException, TimeoutException { - String consistencyGroupUrl = String.format( - "https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s", - project, consistencyGroupLocation, consistencyGroupName); - Operation response; - if (Character.isDigit(location.charAt(location.length() - 1))) { - // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { - RemoveResourcePoliciesRegionDiskRequest request = - RemoveResourcePoliciesRegionDiskRequest.newBuilder() - .setDisk(diskName) - .setRegion(location) - .setProject(project) - .setRegionDisksRemoveResourcePoliciesRequestResource( - RegionDisksRemoveResourcePoliciesRequest.newBuilder() - .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) - .build()) - .build(); - - response = disksClient.removeResourcePoliciesAsync(request).get(1, TimeUnit.MINUTES); - } - } else { - try (DisksClient disksClient = DisksClient.create()) { - RemoveResourcePoliciesDiskRequest request = - RemoveResourcePoliciesDiskRequest.newBuilder() - .setDisk(diskName) - .setZone(location) - .setProject(project) - .setDisksRemoveResourcePoliciesRequestResource( - DisksRemoveResourcePoliciesRequest.newBuilder() - .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) - .build()) - .build(); - response = disksClient.removeResourcePoliciesAsync(request).get(1, TimeUnit.MINUTES); - } - } - if (response.hasError()) { - throw new Error("Error removing disk from consistency group! " + response.getError()); - } - return response.getStatus(); - } -} -// [END compute_consistency_group_remove_disk] \ No newline at end of file diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveRegionalDiskFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveRegionalDiskFromConsistencyGroup.java new file mode 100644 index 00000000000..3c92afe0bc9 --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveRegionalDiskFromConsistencyGroup.java @@ -0,0 +1,79 @@ +/* + * 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.disks.consistencygroup; + +// [START compute_consistency_group_remove_regional_disk] +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.RegionDisksClient; +import com.google.cloud.compute.v1.RegionDisksRemoveResourcePoliciesRequest; +import com.google.cloud.compute.v1.RemoveResourcePoliciesRegionDiskRequest; +import java.io.IOException; +import java.util.Arrays; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +public class RemoveRegionalDiskFromConsistencyGroup { + + 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 that contains the disk. + String project = "YOUR_PROJECT_ID"; + // Region in which your disk and consistency group are located. + String region = "us-central1"; + // Name of the disk. + String diskName = "DISK_NAME"; + // Name of the consistency group. + String consistencyGroupName = "CONSISTENCY_GROUP"; + + removeRegionalDiskFromConsistencyGroup(project, region, diskName, consistencyGroupName); + } + + // Removes a disk from a consistency group. + public static Operation.Status removeRegionalDiskFromConsistencyGroup( + String project, String region, String diskName, String consistencyGroupName) + throws IOException, ExecutionException, InterruptedException, TimeoutException { + String consistencyGroupUrl = String.format( + "https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s", + project, region, consistencyGroupName); + + // 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 (RegionDisksClient disksClient = RegionDisksClient.create()) { + RemoveResourcePoliciesRegionDiskRequest request = + RemoveResourcePoliciesRegionDiskRequest.newBuilder() + .setDisk(diskName) + .setRegion(region) + .setProject(project) + .setRegionDisksRemoveResourcePoliciesRequestResource( + RegionDisksRemoveResourcePoliciesRequest.newBuilder() + .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) + .build()) + .build(); + + Operation response = disksClient.removeResourcePoliciesAsync(request) + .get(1, TimeUnit.MINUTES); + + if (response.hasError()) { + throw new Error("Error removing disk from consistency group! " + response.getError()); + } + return response.getStatus(); + } + } +} +// [END compute_consistency_group_remove_regional_disk] diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveZonalDiskFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveZonalDiskFromConsistencyGroup.java new file mode 100644 index 00000000000..f8d4c26ac12 --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveZonalDiskFromConsistencyGroup.java @@ -0,0 +1,80 @@ +/* + * 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.disks.consistencygroup; + +// [START compute_consistency_group_remove_zonal_disk] +import com.google.cloud.compute.v1.DisksClient; +import com.google.cloud.compute.v1.DisksRemoveResourcePoliciesRequest; +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.RemoveResourcePoliciesDiskRequest; +import java.io.IOException; +import java.util.Arrays; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +public class RemoveZonalDiskFromConsistencyGroup { + + 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 that contains the disk. + String project = "YOUR_PROJECT_ID"; + // Zone of the disk. + String diskLocation = "us-central1-a"; + // Name of the disk. + String diskName = "DISK_NAME"; + // Name of the consistency group. + String consistencyGroupName = "CONSISTENCY_GROUP"; + + removeZonalDiskFromConsistencyGroup(project, diskLocation, diskName, consistencyGroupName); + } + + // Removes a disk from a consistency group. + public static Operation.Status removeZonalDiskFromConsistencyGroup( + String project, String diskLocation, String diskName, String consistencyGroupName) + throws IOException, ExecutionException, InterruptedException, TimeoutException { + String region = diskLocation.substring(0, diskLocation.lastIndexOf('-')); + String consistencyGroupUrl = String.format( + "https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s", + project, region, consistencyGroupName); + + // 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 (DisksClient disksClient = DisksClient.create()) { + RemoveResourcePoliciesDiskRequest request = + RemoveResourcePoliciesDiskRequest.newBuilder() + .setDisk(diskName) + .setZone(diskLocation) + .setProject(project) + .setDisksRemoveResourcePoliciesRequestResource( + DisksRemoveResourcePoliciesRequest.newBuilder() + .addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)) + .build()) + .build(); + Operation response = disksClient.removeResourcePoliciesAsync(request) + .get(1, TimeUnit.MINUTES); + + + if (response.hasError()) { + throw new Error("Error removing disk from consistency group! " + response.getError()); + } + return response.getStatus(); + } + } +} +// [END compute_consistency_group_remove_zonal_disk] \ No newline at end of file diff --git a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java index 7c5cbebfa54..bb7c62f4cf8 100644 --- a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -26,6 +26,7 @@ import static org.mockito.Mockito.when; import com.google.api.gax.longrunning.OperationFuture; +import com.google.cloud.compute.v1.AddResourcePoliciesDiskRequest; import com.google.cloud.compute.v1.AddResourcePoliciesRegionDiskRequest; import com.google.cloud.compute.v1.BulkInsertDiskRequest; import com.google.cloud.compute.v1.BulkInsertRegionDiskRequest; @@ -35,16 +36,19 @@ import com.google.cloud.compute.v1.ListRegionDisksRequest; import com.google.cloud.compute.v1.Operation; import com.google.cloud.compute.v1.RegionDisksClient; +import com.google.cloud.compute.v1.RemoveResourcePoliciesDiskRequest; import com.google.cloud.compute.v1.RemoveResourcePoliciesRegionDiskRequest; import com.google.cloud.compute.v1.ResourcePoliciesClient; -import compute.disks.consistencygroup.AddDiskToConsistencyGroup; -import compute.disks.consistencygroup.CloneDisksFromConsistencyGroup; +import compute.disks.consistencygroup.AddRegionalDiskToConsistencyGroup; +import compute.disks.consistencygroup.AddZonalDiskToConsistencyGroup; +import compute.disks.consistencygroup.CloneRegionalDisksFromConsistencyGroup; import compute.disks.consistencygroup.CloneZonalDisksFromConsistencyGroup; import compute.disks.consistencygroup.CreateConsistencyGroup; import compute.disks.consistencygroup.DeleteConsistencyGroup; import compute.disks.consistencygroup.ListRegionalDisksInConsistencyGroup; import compute.disks.consistencygroup.ListZonalDisksInConsistencyGroup; -import compute.disks.consistencygroup.RemoveDiskFromConsistencyGroup; +import compute.disks.consistencygroup.RemoveRegionalDiskFromConsistencyGroup; +import compute.disks.consistencygroup.RemoveZonalDiskFromConsistencyGroup; import java.util.concurrent.TimeUnit; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Timeout; @@ -56,6 +60,7 @@ @Timeout(value = 2, unit = TimeUnit.MINUTES) public class ConsistencyGroupIT { private static final String PROJECT_ID = "project-id"; + private static final String ZONE = "asia-east1-c"; private static final String REGION = "asia-east1"; private static final String CONSISTENCY_GROUP_NAME = "consistency-group"; private static final String DISK_NAME = "disk-for-consistency"; @@ -97,8 +102,8 @@ public void testAddRegionalDiskToConsistencyGroup() throws Exception { when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); when(operation.getStatus()).thenReturn(Operation.Status.DONE); - Operation.Status status = AddDiskToConsistencyGroup.addDiskToConsistencyGroup( - PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME, REGION); + Operation.Status status = AddRegionalDiskToConsistencyGroup.addRegionalDiskToConsistencyGroup( + PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME); verify(mockClient, times(1)) .addResourcePoliciesAsync(any(AddResourcePoliciesRegionDiskRequest.class)); @@ -108,7 +113,31 @@ public void testAddRegionalDiskToConsistencyGroup() throws Exception { } @Test - public void testRemoveDiskFromConsistencyGroup() throws Exception { + public void testAddZonalDiskToConsistencyGroup() throws Exception { + try (MockedStatic mockedRegionDisksClient = + mockStatic(DisksClient.class)) { + Operation operation = mock(Operation.class); + DisksClient mockClient = mock(DisksClient.class); + OperationFuture mockFuture = mock(OperationFuture.class); + + mockedRegionDisksClient.when(DisksClient::create).thenReturn(mockClient); + when(mockClient.addResourcePoliciesAsync(any(AddResourcePoliciesDiskRequest.class))) + .thenReturn(mockFuture); + when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); + when(operation.getStatus()).thenReturn(Operation.Status.DONE); + + Operation.Status status = AddZonalDiskToConsistencyGroup.addZonalDiskToConsistencyGroup( + PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME); + + verify(mockClient, times(1)) + .addResourcePoliciesAsync(any(AddResourcePoliciesDiskRequest.class)); + verify(mockFuture, times(1)).get(anyLong(), any(TimeUnit.class)); + assertEquals(Operation.Status.DONE, status); + } + } + + @Test + public void testRemoveRegionalDiskFromConsistencyGroup() throws Exception { try (MockedStatic mockedRegionDisksClient = mockStatic(RegionDisksClient.class)) { Operation operation = mock(Operation.class); @@ -121,8 +150,9 @@ public void testRemoveDiskFromConsistencyGroup() throws Exception { when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); when(operation.getStatus()).thenReturn(Operation.Status.DONE); - Operation.Status status = RemoveDiskFromConsistencyGroup.removeDiskFromConsistencyGroup( - PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME, REGION); + Operation.Status status = RemoveRegionalDiskFromConsistencyGroup + .removeRegionalDiskFromConsistencyGroup( + PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME); verify(mockClient, times(1)) .removeResourcePoliciesAsync(any(RemoveResourcePoliciesRegionDiskRequest.class)); @@ -131,6 +161,31 @@ public void testRemoveDiskFromConsistencyGroup() throws Exception { } } + @Test + public void testRemoveZonalDiskFromConsistencyGroup() throws Exception { + try (MockedStatic mockedRegionDisksClient = + mockStatic(DisksClient.class)) { + Operation operation = mock(Operation.class); + DisksClient mockClient = mock(DisksClient.class); + OperationFuture mockFuture = mock(OperationFuture.class); + + mockedRegionDisksClient.when(DisksClient::create).thenReturn(mockClient); + when(mockClient.removeResourcePoliciesAsync( + any(RemoveResourcePoliciesDiskRequest.class))).thenReturn(mockFuture); + when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); + when(operation.getStatus()).thenReturn(Operation.Status.DONE); + + Operation.Status status = RemoveZonalDiskFromConsistencyGroup + .removeZonalDiskFromConsistencyGroup( + PROJECT_ID, ZONE, DISK_NAME, CONSISTENCY_GROUP_NAME); + + verify(mockClient, times(1)) + .removeResourcePoliciesAsync(any(RemoveResourcePoliciesDiskRequest.class)); + verify(mockFuture, times(1)).get(anyLong(), any(TimeUnit.class)); + assertEquals(Operation.Status.DONE, status); + } + } + @Test public void testDeleteConsistencyGroup() throws Exception { try (MockedStatic mockedResourcePoliciesClient = @@ -168,7 +223,7 @@ public void testListRegionalDisksInConsistencyGroup() throws Exception { .thenReturn(mockResponse); ListRegionalDisksInConsistencyGroup.listRegionalDisksInConsistencyGroup( - PROJECT_ID, CONSISTENCY_GROUP_NAME, REGION, REGION); + PROJECT_ID, CONSISTENCY_GROUP_NAME, REGION); verify(mockClient, times(1)) .list(any(ListRegionDisksRequest.class)); @@ -177,7 +232,7 @@ public void testListRegionalDisksInConsistencyGroup() throws Exception { } @Test - public void testCloneDisksFromConsistencyGroup() throws Exception { + public void testCloneRegionalDisksFromConsistencyGroup() throws Exception { try (MockedStatic mockedRegionDisksClient = mockStatic(RegionDisksClient.class)) { Operation operation = mock(Operation.class); @@ -190,7 +245,8 @@ public void testCloneDisksFromConsistencyGroup() throws Exception { when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); when(operation.getStatus()).thenReturn(Operation.Status.DONE); - Operation.Status status = CloneDisksFromConsistencyGroup.cloneDisksFromConsistencyGroup( + Operation.Status status = CloneRegionalDisksFromConsistencyGroup + .cloneRegionalDisksFromConsistencyGroup( PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); verify(mockClient, times(1)) @@ -237,7 +293,7 @@ public void testListZonalDisksInConsistencyGroup() throws Exception { .thenReturn(mockResponse); ListZonalDisksInConsistencyGroup.listZonalDisksInConsistencyGroup( - PROJECT_ID, CONSISTENCY_GROUP_NAME, REGION, REGION); + PROJECT_ID, CONSISTENCY_GROUP_NAME, ZONE); verify(mockClient, times(1)) .list(any(ListDisksRequest.class)); From 6109822c35d9d1644610a06ec6ee2af7da268a88 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Wed, 18 Dec 2024 15:40:39 +0100 Subject: [PATCH 22/23] Fixed Util class --- .../cloud-client/src/test/java/compute/Util.java | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/compute/cloud-client/src/test/java/compute/Util.java b/compute/cloud-client/src/test/java/compute/Util.java index d16d32cbefa..7629e4b913e 100644 --- a/compute/cloud-client/src/test/java/compute/Util.java +++ b/compute/cloud-client/src/test/java/compute/Util.java @@ -213,22 +213,6 @@ && isCreatedBeforeThresholdTime(disk.getCreationTimestamp())) { } } - // Delete regional disks which starts with the given prefixToDelete and - // has creation timestamp >24 hours. - public static void cleanUpExistingRegionalDisks( - String prefixToDelete, String projectId, String region) - throws IOException, ExecutionException, InterruptedException, TimeoutException { - try (RegionDisksClient disksClient = RegionDisksClient.create()) { - for (Disk disk : disksClient.list(projectId, region).iterateAll()) { - if (disk.getName().contains(prefixToDelete) - && disk.getRegion().equals(region) - && isCreatedBeforeThresholdTime(disk.getCreationTimestamp())) { - RegionalDelete.deleteRegionalDisk(projectId, region, disk.getName()); - } - } - } - } - // Delete snapshots which starts with the given prefixToDelete and // has creation timestamp >24 hours. public static void cleanUpExistingSnapshots(String prefixToDelete, String projectId) From ed0be287cff6c27b3176f565eb9075ddac46734d Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Wed, 18 Dec 2024 21:09:09 +0100 Subject: [PATCH 23/23] Fixed code --- .../compute/disks/CreateReplicatedDisk.java | 3 +- .../AddRegionalDiskToConsistencyGroup.java | 3 +- .../AddZonalDiskToConsistencyGroup.java | 3 +- ...loneRegionalDisksFromConsistencyGroup.java | 3 +- .../CloneZonalDisksFromConsistencyGroup.java | 3 +- .../CreateConsistencyGroup.java | 3 +- .../DeleteConsistencyGroup.java | 3 +- ...emoveRegionalDiskFromConsistencyGroup.java | 3 +- .../RemoveZonalDiskFromConsistencyGroup.java | 3 +- .../compute/disks/ConsistencyGroupIT.java | 49 ++++++++++--------- .../src/test/java/compute/disks/DisksIT.java | 5 +- 11 files changed, 46 insertions(+), 35 deletions(-) diff --git a/compute/cloud-client/src/main/java/compute/disks/CreateReplicatedDisk.java b/compute/cloud-client/src/main/java/compute/disks/CreateReplicatedDisk.java index e2ad1fc40cc..384921da4f9 100644 --- a/compute/cloud-client/src/main/java/compute/disks/CreateReplicatedDisk.java +++ b/compute/cloud-client/src/main/java/compute/disks/CreateReplicatedDisk.java @@ -20,6 +20,7 @@ import com.google.cloud.compute.v1.Disk; import com.google.cloud.compute.v1.InsertRegionDiskRequest; import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.Operation.Status; import com.google.cloud.compute.v1.RegionDisksClient; import java.io.IOException; import java.util.ArrayList; @@ -55,7 +56,7 @@ public static void main(String[] args) } // Create a disk for synchronous data replication between two zones in the same region - public static Operation.Status createReplicatedDisk(String projectId, String region, + public static Status createReplicatedDisk(String projectId, String region, List replicaZones, String diskName, int diskSizeGb, String diskType) throws IOException, InterruptedException, ExecutionException, TimeoutException { // Initialize client that will be used to send requests. This client only needs to be created diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddRegionalDiskToConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddRegionalDiskToConsistencyGroup.java index 3f27e34d0c8..bd88639d370 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddRegionalDiskToConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddRegionalDiskToConsistencyGroup.java @@ -19,6 +19,7 @@ // [START compute_consistency_group_add_regional_disk] import com.google.cloud.compute.v1.AddResourcePoliciesRegionDiskRequest; import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.Operation.Status; import com.google.cloud.compute.v1.RegionDisksAddResourcePoliciesRequest; import com.google.cloud.compute.v1.RegionDisksClient; import java.io.IOException; @@ -44,7 +45,7 @@ public static void main(String[] args) } // Adds regional disk to a consistency group. - public static Operation.Status addRegionalDiskToConsistencyGroup( + public static Status addRegionalDiskToConsistencyGroup( String project, String region, String diskName, String consistencyGroupName) throws IOException, ExecutionException, InterruptedException, TimeoutException { String consistencyGroupUrl = String.format( diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddZonalDiskToConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddZonalDiskToConsistencyGroup.java index f69e44cb3cb..8f817ef4725 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddZonalDiskToConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/AddZonalDiskToConsistencyGroup.java @@ -21,6 +21,7 @@ import com.google.cloud.compute.v1.DisksAddResourcePoliciesRequest; import com.google.cloud.compute.v1.DisksClient; import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.Operation.Status; import java.io.IOException; import java.util.Arrays; import java.util.concurrent.ExecutionException; @@ -45,7 +46,7 @@ public static void main(String[] args) } // Adds zonal disk to a consistency group. - public static Operation.Status addZonalDiskToConsistencyGroup( + public static Status addZonalDiskToConsistencyGroup( String project, String diskLocation, String diskName, String consistencyGroupName) throws IOException, ExecutionException, InterruptedException, TimeoutException { diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneRegionalDisksFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneRegionalDisksFromConsistencyGroup.java index 24b0a97f449..f6d458c76bf 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneRegionalDisksFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneRegionalDisksFromConsistencyGroup.java @@ -20,6 +20,7 @@ import com.google.cloud.compute.v1.BulkInsertDiskResource; import com.google.cloud.compute.v1.BulkInsertRegionDiskRequest; import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.Operation.Status; import com.google.cloud.compute.v1.RegionDisksClient; import java.io.IOException; import java.util.concurrent.ExecutionException; @@ -42,7 +43,7 @@ public static void main(String[] args) } // Clones regional disks from a consistency group. - public static Operation.Status cloneRegionalDisksFromConsistencyGroup( + public static Status cloneRegionalDisksFromConsistencyGroup( String project, String region, String consistencyGroupName) throws IOException, InterruptedException, ExecutionException, TimeoutException { String sourceConsistencyGroupPolicy = String.format( diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneZonalDisksFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneZonalDisksFromConsistencyGroup.java index 91b9ddea2cf..546388ad95a 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneZonalDisksFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CloneZonalDisksFromConsistencyGroup.java @@ -21,6 +21,7 @@ import com.google.cloud.compute.v1.BulkInsertDiskResource; import com.google.cloud.compute.v1.DisksClient; import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.Operation.Status; import java.io.IOException; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; @@ -41,7 +42,7 @@ public static void main(String[] args) } // Clones zonal disks from a consistency group. - public static Operation.Status cloneZonalDisksFromConsistencyGroup( + public static Status cloneZonalDisksFromConsistencyGroup( String project, String zone, String consistencyGroupName) throws IOException, InterruptedException, ExecutionException, TimeoutException { String region = zone.substring(0, zone.lastIndexOf('-')); diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateConsistencyGroup.java index df6c324d8d5..b1769f6fd1b 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/CreateConsistencyGroup.java @@ -19,6 +19,7 @@ // [START compute_consistency_group_create] import com.google.cloud.compute.v1.InsertResourcePolicyRequest; import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.Operation.Status; import com.google.cloud.compute.v1.ResourcePoliciesClient; import com.google.cloud.compute.v1.ResourcePolicy; import java.io.IOException; @@ -42,7 +43,7 @@ public static void main(String[] args) } // Creates a new consistency group resource policy in the specified project and region. - public static Operation.Status createConsistencyGroup( + public static Status createConsistencyGroup( String project, String region, String consistencyGroupName) throws IOException, ExecutionException, InterruptedException, TimeoutException { // Initialize client that will be used to send requests. This client only needs to be created diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteConsistencyGroup.java index 89ab6f756e0..89eaae58e01 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/DeleteConsistencyGroup.java @@ -18,6 +18,7 @@ // [START compute_consistency_group_delete] import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.Operation.Status; import com.google.cloud.compute.v1.ResourcePoliciesClient; import java.io.IOException; import java.util.concurrent.ExecutionException; @@ -40,7 +41,7 @@ public static void main(String[] args) } // Deletes a consistency group resource policy in the specified project and region. - public static Operation.Status deleteConsistencyGroup( + public static Status deleteConsistencyGroup( String project, String region, String consistencyGroupName) throws IOException, ExecutionException, InterruptedException, TimeoutException { // Initialize client that will be used to send requests. This client only needs to be created diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveRegionalDiskFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveRegionalDiskFromConsistencyGroup.java index 3c92afe0bc9..7c20de4b7f2 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveRegionalDiskFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveRegionalDiskFromConsistencyGroup.java @@ -18,6 +18,7 @@ // [START compute_consistency_group_remove_regional_disk] import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.Operation.Status; import com.google.cloud.compute.v1.RegionDisksClient; import com.google.cloud.compute.v1.RegionDisksRemoveResourcePoliciesRequest; import com.google.cloud.compute.v1.RemoveResourcePoliciesRegionDiskRequest; @@ -45,7 +46,7 @@ public static void main(String[] args) } // Removes a disk from a consistency group. - public static Operation.Status removeRegionalDiskFromConsistencyGroup( + public static Status removeRegionalDiskFromConsistencyGroup( String project, String region, String diskName, String consistencyGroupName) throws IOException, ExecutionException, InterruptedException, TimeoutException { String consistencyGroupUrl = String.format( diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveZonalDiskFromConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveZonalDiskFromConsistencyGroup.java index f8d4c26ac12..5d7b6200711 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveZonalDiskFromConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/RemoveZonalDiskFromConsistencyGroup.java @@ -20,6 +20,7 @@ import com.google.cloud.compute.v1.DisksClient; import com.google.cloud.compute.v1.DisksRemoveResourcePoliciesRequest; import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.Operation.Status; import com.google.cloud.compute.v1.RemoveResourcePoliciesDiskRequest; import java.io.IOException; import java.util.Arrays; @@ -45,7 +46,7 @@ public static void main(String[] args) } // Removes a disk from a consistency group. - public static Operation.Status removeZonalDiskFromConsistencyGroup( + public static Status removeZonalDiskFromConsistencyGroup( String project, String diskLocation, String diskName, String consistencyGroupName) throws IOException, ExecutionException, InterruptedException, TimeoutException { String region = diskLocation.substring(0, diskLocation.lastIndexOf('-')); diff --git a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java index bb7c62f4cf8..ec767be15db 100644 --- a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -35,6 +35,7 @@ import com.google.cloud.compute.v1.ListDisksRequest; import com.google.cloud.compute.v1.ListRegionDisksRequest; import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.Operation.Status; import com.google.cloud.compute.v1.RegionDisksClient; import com.google.cloud.compute.v1.RemoveResourcePoliciesDiskRequest; import com.google.cloud.compute.v1.RemoveResourcePoliciesRegionDiskRequest; @@ -77,14 +78,14 @@ public void testCreateConsistencyGroupResourcePolicy() throws Exception { when(mockClient.insertAsync(any(InsertResourcePolicyRequest.class))) .thenReturn(mockFuture); when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); - when(operation.getStatus()).thenReturn(Operation.Status.DONE); + when(operation.getStatus()).thenReturn(Status.DONE); - Operation.Status status = CreateConsistencyGroup.createConsistencyGroup( + Status status = CreateConsistencyGroup.createConsistencyGroup( PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); verify(mockClient, times(1)).insertAsync(any(InsertResourcePolicyRequest.class)); verify(mockFuture, times(1)).get(anyLong(), any(TimeUnit.class)); - assertEquals(Operation.Status.DONE, status); + assertEquals(Status.DONE, status); } } @@ -100,15 +101,15 @@ public void testAddRegionalDiskToConsistencyGroup() throws Exception { when(mockClient.addResourcePoliciesAsync(any(AddResourcePoliciesRegionDiskRequest.class))) .thenReturn(mockFuture); when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); - when(operation.getStatus()).thenReturn(Operation.Status.DONE); + when(operation.getStatus()).thenReturn(Status.DONE); - Operation.Status status = AddRegionalDiskToConsistencyGroup.addRegionalDiskToConsistencyGroup( + Status status = AddRegionalDiskToConsistencyGroup.addRegionalDiskToConsistencyGroup( PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME); verify(mockClient, times(1)) .addResourcePoliciesAsync(any(AddResourcePoliciesRegionDiskRequest.class)); verify(mockFuture, times(1)).get(anyLong(), any(TimeUnit.class)); - assertEquals(Operation.Status.DONE, status); + assertEquals(Status.DONE, status); } } @@ -124,15 +125,15 @@ public void testAddZonalDiskToConsistencyGroup() throws Exception { when(mockClient.addResourcePoliciesAsync(any(AddResourcePoliciesDiskRequest.class))) .thenReturn(mockFuture); when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); - when(operation.getStatus()).thenReturn(Operation.Status.DONE); + when(operation.getStatus()).thenReturn(Status.DONE); - Operation.Status status = AddZonalDiskToConsistencyGroup.addZonalDiskToConsistencyGroup( + Status status = AddZonalDiskToConsistencyGroup.addZonalDiskToConsistencyGroup( PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME); verify(mockClient, times(1)) .addResourcePoliciesAsync(any(AddResourcePoliciesDiskRequest.class)); verify(mockFuture, times(1)).get(anyLong(), any(TimeUnit.class)); - assertEquals(Operation.Status.DONE, status); + assertEquals(Status.DONE, status); } } @@ -148,16 +149,16 @@ public void testRemoveRegionalDiskFromConsistencyGroup() throws Exception { when(mockClient.removeResourcePoliciesAsync( any(RemoveResourcePoliciesRegionDiskRequest.class))).thenReturn(mockFuture); when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); - when(operation.getStatus()).thenReturn(Operation.Status.DONE); + when(operation.getStatus()).thenReturn(Status.DONE); - Operation.Status status = RemoveRegionalDiskFromConsistencyGroup + Status status = RemoveRegionalDiskFromConsistencyGroup .removeRegionalDiskFromConsistencyGroup( PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME); verify(mockClient, times(1)) .removeResourcePoliciesAsync(any(RemoveResourcePoliciesRegionDiskRequest.class)); verify(mockFuture, times(1)).get(anyLong(), any(TimeUnit.class)); - assertEquals(Operation.Status.DONE, status); + assertEquals(Status.DONE, status); } } @@ -173,16 +174,16 @@ public void testRemoveZonalDiskFromConsistencyGroup() throws Exception { when(mockClient.removeResourcePoliciesAsync( any(RemoveResourcePoliciesDiskRequest.class))).thenReturn(mockFuture); when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); - when(operation.getStatus()).thenReturn(Operation.Status.DONE); + when(operation.getStatus()).thenReturn(Status.DONE); - Operation.Status status = RemoveZonalDiskFromConsistencyGroup + Status status = RemoveZonalDiskFromConsistencyGroup .removeZonalDiskFromConsistencyGroup( PROJECT_ID, ZONE, DISK_NAME, CONSISTENCY_GROUP_NAME); verify(mockClient, times(1)) .removeResourcePoliciesAsync(any(RemoveResourcePoliciesDiskRequest.class)); verify(mockFuture, times(1)).get(anyLong(), any(TimeUnit.class)); - assertEquals(Operation.Status.DONE, status); + assertEquals(Status.DONE, status); } } @@ -198,15 +199,15 @@ public void testDeleteConsistencyGroup() throws Exception { when(mockClient.deleteAsync(PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME)) .thenReturn(mockFuture); when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); - when(operation.getStatus()).thenReturn(Operation.Status.DONE); + when(operation.getStatus()).thenReturn(Status.DONE); - Operation.Status status = DeleteConsistencyGroup.deleteConsistencyGroup( + Status status = DeleteConsistencyGroup.deleteConsistencyGroup( PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); verify(mockClient, times(1)) .deleteAsync(PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); verify(mockFuture, times(1)).get(anyLong(), any(TimeUnit.class)); - assertEquals(Operation.Status.DONE, status); + assertEquals(Status.DONE, status); } } @@ -243,16 +244,16 @@ public void testCloneRegionalDisksFromConsistencyGroup() throws Exception { when(mockClient.bulkInsertAsync(any(BulkInsertRegionDiskRequest.class))) .thenReturn(mockFuture); when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); - when(operation.getStatus()).thenReturn(Operation.Status.DONE); + when(operation.getStatus()).thenReturn(Status.DONE); - Operation.Status status = CloneRegionalDisksFromConsistencyGroup + Status status = CloneRegionalDisksFromConsistencyGroup .cloneRegionalDisksFromConsistencyGroup( PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); verify(mockClient, times(1)) .bulkInsertAsync(any(BulkInsertRegionDiskRequest.class)); verify(mockFuture, times(1)).get(anyLong(), any(TimeUnit.class)); - assertEquals(Operation.Status.DONE, status); + assertEquals(Status.DONE, status); } } @@ -268,15 +269,15 @@ public void testCloneZonalDisksFromConsistencyGroup() throws Exception { when(mockClient.bulkInsertAsync(any(BulkInsertDiskRequest.class))) .thenReturn(mockFuture); when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); - when(operation.getStatus()).thenReturn(Operation.Status.DONE); + when(operation.getStatus()).thenReturn(Status.DONE); - Operation.Status status = CloneZonalDisksFromConsistencyGroup + Status status = CloneZonalDisksFromConsistencyGroup .cloneZonalDisksFromConsistencyGroup(PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); verify(mockClient, times(1)) .bulkInsertAsync(any(BulkInsertDiskRequest.class)); verify(mockFuture, times(1)).get(anyLong(), any(TimeUnit.class)); - assertEquals(Operation.Status.DONE, status); + assertEquals(Status.DONE, status); } } diff --git a/compute/cloud-client/src/test/java/compute/disks/DisksIT.java b/compute/cloud-client/src/test/java/compute/disks/DisksIT.java index cd293c0c82f..94e1dec864e 100644 --- a/compute/cloud-client/src/test/java/compute/disks/DisksIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/DisksIT.java @@ -31,6 +31,7 @@ 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.Operation.Status; import com.google.cloud.compute.v1.Snapshot; import com.google.cloud.compute.v1.SnapshotsClient; import compute.DeleteInstance; @@ -305,9 +306,9 @@ public void testDiskAttachResize() @Test public void testCreateReplicatedDisk() throws IOException, ExecutionException, InterruptedException, TimeoutException { - Operation.Status status = CreateReplicatedDisk.createReplicatedDisk(PROJECT_ID, REGION, + Status status = CreateReplicatedDisk.createReplicatedDisk(PROJECT_ID, REGION, replicaZones, REGIONAL_REPLICATED_DISK, 100, DISK_TYPE); - assertThat(status).isEqualTo(Operation.Status.DONE); + assertThat(status).isEqualTo(Status.DONE); } }