From 594de00027cbd37313bf01cbc9804d4129b03986 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Tue, 5 Nov 2024 15:42:16 +0100 Subject: [PATCH 01/18] 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 b9d35696660ead8b48a36a53505e2e7788387ef0 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Thu, 21 Nov 2024 13:50:37 +0100 Subject: [PATCH 02/18] Implemented compute_consistency_group_stop_replication sample --- .../StopAsyncReplicationConsistencyGroup.java | 67 +++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopAsyncReplicationConsistencyGroup.java diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopAsyncReplicationConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopAsyncReplicationConsistencyGroup.java new file mode 100644 index 00000000000..bcd08ad6ab5 --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopAsyncReplicationConsistencyGroup.java @@ -0,0 +1,67 @@ +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 StopAsyncReplicationConsistencyGroup { + + public static void main(String[] args) + throws IOException, InterruptedException, ExecutionException, TimeoutException { + // TODO(developer): Replace these variables before running the sample. + String project = "tyaho-softserve-project"; + String disksLocation = "us-central1"; // either zone or region + String consistencyGroupName = "consistency-group-2"; + String consistencyGroupLocation = "northamerica-northeast1"; // region + + + stopReplicationConsistencyGroup(project, disksLocation, consistencyGroupName, + consistencyGroupLocation); + } + + public static void stopReplicationConsistencyGroup(String project, String disksLocation, + String consistencyGroupName, String consistencyGroupLocation) + throws IOException, InterruptedException, ExecutionException, TimeoutException { + + String resourcePolicy = String.format( + "projects/%s/regions/%s/resourcePolicies/%s", project, consistencyGroupLocation, + consistencyGroupName); + +// try (DisksClient disksClient = DisksClient.create()) { +// // Depending on whether the disksLocation is zone or region - use different clients. +// Operation operation; +// if (disksLocation.contains("-")) { // Zone +// StopGroupAsyncReplicationDiskRequest request = +// StopGroupAsyncReplicationDiskRequest.newBuilder() +// .setProject(project) +// .setZone(disksLocation) +// .setDisksStopGroupAsyncReplicationResourceResource( +// DisksStopGroupAsyncReplicationResource.newBuilder() +// .setResourcePolicy(resourcePolicy).build()) +// .build(); +// operation = disksClient.stopGroupAsyncReplicationAsync(request).get(3, TimeUnit.MINUTES); + try (RegionDisksClient disksClient = RegionDisksClient.create()) { + // Depending on whether the disksLocation is zone or region - use different clients. + Operation operation; + StopGroupAsyncReplicationRegionDiskRequest request = + StopGroupAsyncReplicationRegionDiskRequest.newBuilder() + .setProject(project) + .setRegion(disksLocation) + .setDisksStopGroupAsyncReplicationResourceResource( + DisksStopGroupAsyncReplicationResource.newBuilder() + .setResourcePolicy(resourcePolicy).build()) + .build(); + operation = disksClient.stopGroupAsyncReplicationAsync(request).get(3, TimeUnit.MINUTES); + + if (operation.hasError()) { + return; + } + + System.out.printf("Replication stopped for consistency group: %s\n", consistencyGroupName); + } + } +} From 3bf823615fe05dd259367a66098f1cfb14381923 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Fri, 22 Nov 2024 13:32:30 +0100 Subject: [PATCH 03/18] Implemented compute_consistency_group_stop_replication sample --- .../StopAsyncReplicationConsistencyGroup.java | 121 ++++++++++-------- 1 file changed, 70 insertions(+), 51 deletions(-) diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopAsyncReplicationConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopAsyncReplicationConsistencyGroup.java index bcd08ad6ab5..83cc4ff0742 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopAsyncReplicationConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopAsyncReplicationConsistencyGroup.java @@ -1,8 +1,29 @@ -package compute.disks.consistencygroup; - +/* + * 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. + */ -import com.google.cloud.compute.v1.*; +package compute.disks.consistencygroup; +// [START compute_consistency_group_stop_replication] +// Uncomment these lines if your disk has zonal location. +//import com.google.cloud.compute.v1.DisksClient; +//import com.google.cloud.compute.v1.StopGroupAsyncReplicationDiskRequest; +import com.google.cloud.compute.v1.DisksStopGroupAsyncReplicationResource; +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.RegionDisksClient; +import com.google.cloud.compute.v1.StopGroupAsyncReplicationRegionDiskRequest; import java.io.IOException; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; @@ -10,58 +31,56 @@ public class StopAsyncReplicationConsistencyGroup { - public static void main(String[] args) - throws IOException, InterruptedException, ExecutionException, TimeoutException { - // TODO(developer): Replace these variables before running the sample. - String project = "tyaho-softserve-project"; - String disksLocation = "us-central1"; // either zone or region - String consistencyGroupName = "consistency-group-2"; - String consistencyGroupLocation = "northamerica-northeast1"; // region - - - stopReplicationConsistencyGroup(project, disksLocation, consistencyGroupName, - consistencyGroupLocation); - } + public static void main(String[] args) + throws IOException, InterruptedException, ExecutionException, TimeoutException { + // TODO(developer): Replace these variables before running the sample. + String project = "tyaho-softserve-project"; + String disksLocation = "us-central1-a"; // either zone or region + String consistencyGroupName = "consistency-group-3"; + String consistencyGroupLocation = "us-central1"; // region - public static void stopReplicationConsistencyGroup(String project, String disksLocation, - String consistencyGroupName, String consistencyGroupLocation) - throws IOException, InterruptedException, ExecutionException, TimeoutException { + stopReplicationConsistencyGroup(project, disksLocation, consistencyGroupName, + consistencyGroupLocation); + } - String resourcePolicy = String.format( - "projects/%s/regions/%s/resourcePolicies/%s", project, consistencyGroupLocation, - consistencyGroupName); + public static void stopReplicationConsistencyGroup(String project, String disksLocation, + String consistencyGroupName, String consistencyGroupLocation) + throws IOException, InterruptedException, ExecutionException, TimeoutException { + String resourcePolicy = 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. -// try (DisksClient disksClient = DisksClient.create()) { -// // Depending on whether the disksLocation is zone or region - use different clients. -// Operation operation; -// if (disksLocation.contains("-")) { // Zone -// StopGroupAsyncReplicationDiskRequest request = -// StopGroupAsyncReplicationDiskRequest.newBuilder() -// .setProject(project) -// .setZone(disksLocation) -// .setDisksStopGroupAsyncReplicationResourceResource( -// DisksStopGroupAsyncReplicationResource.newBuilder() -// .setResourcePolicy(resourcePolicy).build()) -// .build(); -// operation = disksClient.stopGroupAsyncReplicationAsync(request).get(3, TimeUnit.MINUTES); - try (RegionDisksClient disksClient = RegionDisksClient.create()) { - // Depending on whether the disksLocation is zone or region - use different clients. - Operation operation; - StopGroupAsyncReplicationRegionDiskRequest request = - StopGroupAsyncReplicationRegionDiskRequest.newBuilder() - .setProject(project) - .setRegion(disksLocation) - .setDisksStopGroupAsyncReplicationResourceResource( - DisksStopGroupAsyncReplicationResource.newBuilder() - .setResourcePolicy(resourcePolicy).build()) - .build(); - operation = disksClient.stopGroupAsyncReplicationAsync(request).get(3, TimeUnit.MINUTES); + // Depending on whether the disksLocation is zone or region - use different clients. + // Uncomment these lines if your disk has zonal location. + //try (DisksClient disksClient = DisksClient.create()) { + // StopGroupAsyncReplicationDiskRequest request = + // StopGroupAsyncReplicationDiskRequest.newBuilder() + // .setProject(project) + // .setZone(disksLocation) + // .setDisksStopGroupAsyncReplicationResourceResource( + // DisksStopGroupAsyncReplicationResource.newBuilder() + // .setResourcePolicy(resourcePolicy).build()) + // .build(); - if (operation.hasError()) { - return; - } + try (RegionDisksClient disksClient = RegionDisksClient.create()) { + StopGroupAsyncReplicationRegionDiskRequest request = + StopGroupAsyncReplicationRegionDiskRequest.newBuilder() + .setProject(project) + .setRegion(disksLocation) + .setDisksStopGroupAsyncReplicationResourceResource( + DisksStopGroupAsyncReplicationResource.newBuilder() + .setResourcePolicy(resourcePolicy).build()) + .build(); + Operation operation = disksClient.stopGroupAsyncReplicationAsync(request) + .get(3, TimeUnit.MINUTES); - System.out.printf("Replication stopped for consistency group: %s\n", consistencyGroupName); - } + if (operation.hasError()) { + return; + } + System.out.printf("Replication stopped for consistency group: %s\n", consistencyGroupName); } + } } +// [END compute_consistency_group_stop_replication] From 9a12b30b59571a1d1fb4e9969e714eb3d8acb7a4 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Fri, 22 Nov 2024 14:03:01 +0100 Subject: [PATCH 04/18] Created test and added needed classes for testing --- .../disks/CreateDiskSecondaryRegional.java | 106 ++++++++++++++++++ .../compute/disks/StartDiskReplication.java | 83 ++++++++++++++ .../compute/disks/StopDiskReplication.java | 63 +++++++++++ .../AddDiskToConsistencyGroup.java | 92 +++++++++++++++ .../src/test/java/compute/Util.java | 17 +++ .../compute/disks/ConsistencyGroupIT.java | 68 ++++++++++- .../test/java/compute/disks/HyperdisksIT.java | 4 + 7 files changed, 430 insertions(+), 3 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 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..deefcc4a83d --- /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..826cd893a4f --- /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] 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..aec8d85a24b --- /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..5a7a5346979 --- /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/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 ea720937306..49f3611a07f 100644 --- a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -20,26 +20,50 @@ import static com.google.common.truth.Truth.assertWithMessage; 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.CreateDiskConsistencyGroup; import compute.disks.consistencygroup.DeleteDiskConsistencyGroup; +import compute.disks.consistencygroup.StopAsyncReplicationConsistencyGroup; +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; @RunWith(JUnit4.class) @Timeout(value = 3, 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 REGION_SECONDARY = "northamerica-northeast1"; + static String randomUUID = UUID.randomUUID().toString().split("-")[0]; private static final String CONSISTENCY_GROUP_NAME = "test-consistency-group-" + UUID.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; + 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) { @@ -50,17 +74,32 @@ public static void requireEnvVar(String envVarName) { @BeforeAll public static void setUp() throws Exception { requireEnvVar("GOOGLE_CLOUD_PROJECT"); + requireEnvVar("GOOGLE_APPLICATION_CREDENTIALS"); + + RegionalCreateFromSource.createRegionalDisk(PROJECT_ID, REGION, replicaZones, + DISK_NAME, DISK_TYPE, 10, Optional.empty(), Optional.empty()); } @AfterAll public static void cleanUp() - throws IOException, ExecutionException, InterruptedException { - // Delete created consistency group + 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); DeleteDiskConsistencyGroup.deleteDiskConsistencyGroup( - PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); + PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); + + // 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 + @Order(1) public void testCreateDiskConsistencyGroupResourcePolicy() throws IOException, ExecutionException, InterruptedException { String consistencyGroupLink = CreateDiskConsistencyGroup.createDiskConsistencyGroup( @@ -70,4 +109,27 @@ public void testCreateDiskConsistencyGroupResourcePolicy() assertNotNull(consistencyGroupLink); assertThat(consistencyGroupLink.contains(CONSISTENCY_GROUP_NAME)); } + + @Test + @Order(2) + public void testStopAsyncReplicationConsistencyGroup() + throws IOException, ExecutionException, InterruptedException, TimeoutException { + ByteArrayOutputStream stdOut = new ByteArrayOutputStream(); + System.setOut(new PrintStream(stdOut)); + AddDiskToConsistencyGroup.addDiskToConsistencyGroup( + PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME, REGION); + Disk disk = CreateDiskSecondaryRegional.createDiskSecondaryRegional( + PROJECT_ID, PROJECT_ID, DISK_NAME, SECONDARY_REGIONAL_DISK, + REGION, REGION_SECONDARY, DISK_SIZE, DISK_TYPE); + assert disk != null; + StartDiskReplication.startDiskAsyncReplication( + PROJECT_ID, DISK_NAME, REGION, disk.getSelfLink()); + + StopAsyncReplicationConsistencyGroup.stopReplicationConsistencyGroup( + PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME, REGION); + + assertThat(stdOut.toString()).contains("Replication stopped for consistency group: "); + + stdOut.close(); + } } 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 e2db968a139deacc78a0ef75233ea249c6e49214 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Fri, 22 Nov 2024 14:43:35 +0100 Subject: [PATCH 05/18] Fixed test --- .../src/test/java/compute/disks/HyperdisksIT.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) 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..0aaa681beab 100644 --- a/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java @@ -62,6 +62,10 @@ public static void setUp() throws IOException, ExecutionException, InterruptedException, TimeoutException { requireEnvVar("GOOGLE_APPLICATION_CREDENTIALS"); requireEnvVar("GOOGLE_CLOUD_PROJECT"); + + // Clean up stale resources + Util.cleanUpExistingDisks("test-hyperdisk-enc-", PROJECT_ID, ZONE); + Util.cleanUpExistingStoragePool("test-storage-pool-enc-", PROJECT_ID, ZONE); } @AfterAll @@ -73,9 +77,6 @@ public static void cleanup() 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 d116264328586c8ded8d15fa48ba4538dbf45a35 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Sun, 24 Nov 2024 14:22:30 +0100 Subject: [PATCH 06/18] Moved clean up methods --- .../src/test/java/compute/disks/HyperdisksIT.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) 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 0aaa681beab..9d89fa64faf 100644 --- a/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java @@ -63,9 +63,6 @@ public static void setUp() requireEnvVar("GOOGLE_APPLICATION_CREDENTIALS"); requireEnvVar("GOOGLE_CLOUD_PROJECT"); - // Clean up stale resources - Util.cleanUpExistingDisks("test-hyperdisk-enc-", PROJECT_ID, ZONE); - Util.cleanUpExistingStoragePool("test-storage-pool-enc-", PROJECT_ID, ZONE); } @AfterAll @@ -77,6 +74,9 @@ public static void cleanup() 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 df976368f7659626d30e27d0885e20e692df1599 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Sun, 24 Nov 2024 15:37:02 +0100 Subject: [PATCH 07/18] Added clean up methods for reservations --- .../java/compute/reservation/ConsumeReservationsIT.java | 5 +++++ .../compute/reservation/CreateReservationFromVmIT.java | 8 ++++---- .../compute/reservation/CrudOperationsReservationIT.java | 4 ++++ .../src/test/java/compute/reservation/ReservationIT.java | 8 ++++++++ .../reservation/WithoutConsumingReservationIT.java | 6 ++++++ 5 files changed, 27 insertions(+), 4 deletions(-) diff --git a/compute/cloud-client/src/test/java/compute/reservation/ConsumeReservationsIT.java b/compute/cloud-client/src/test/java/compute/reservation/ConsumeReservationsIT.java index 96c8b22a4e0..663c517e938 100644 --- a/compute/cloud-client/src/test/java/compute/reservation/ConsumeReservationsIT.java +++ b/compute/cloud-client/src/test/java/compute/reservation/ConsumeReservationsIT.java @@ -29,6 +29,7 @@ import com.google.cloud.compute.v1.Reservation; import com.google.cloud.compute.v1.ReservationsClient; import compute.DeleteInstance; +import compute.Util; import java.io.IOException; import java.util.UUID; import java.util.concurrent.ExecutionException; @@ -90,6 +91,10 @@ public static void cleanup() Assertions.assertThrows( NotFoundException.class, () -> GetReservation.getReservation(PROJECT_ID, RESERVATION_NAME, ZONE)); + + // Clean up stale resources + Util.cleanUpExistingInstances("test-instance-", PROJECT_ID, ZONE); + Util.cleanUpExistingReservations("test-reservation-", PROJECT_ID, ZONE); } @Test diff --git a/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java b/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java index e98dd20ba22..c14cdc2e966 100644 --- a/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java +++ b/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java @@ -71,10 +71,6 @@ public static void setUp() instanceForReservation = "test-instance-for-reserv-" + javaVersion + "-" + UUID.randomUUID().toString().substring(0, 8); - // Cleanup existing stale resources. - Util.cleanUpExistingInstances("test-instance-for-reserv-" + javaVersion, PROJECT_ID, ZONE); - Util.cleanUpExistingReservations("test-reservation-from-vm-" + javaVersion, PROJECT_ID, ZONE); - CreateInstance.createInstance(PROJECT_ID, ZONE, instanceForReservation); } @@ -84,6 +80,10 @@ public static void cleanup() // Delete resources created for testing. DeleteInstance.deleteInstance(PROJECT_ID, ZONE, instanceForReservation); + // Clean up stale resources + Util.cleanUpExistingReservations("test-reservation-from-vm-", PROJECT_ID, ZONE); + Util.cleanUpExistingInstances("test-instance-for-reserv-", PROJECT_ID, ZONE); + reservationsClient.close(); instancesClient.close(); } diff --git a/compute/cloud-client/src/test/java/compute/reservation/CrudOperationsReservationIT.java b/compute/cloud-client/src/test/java/compute/reservation/CrudOperationsReservationIT.java index 0dd9209ae5f..91b08a779eb 100644 --- a/compute/cloud-client/src/test/java/compute/reservation/CrudOperationsReservationIT.java +++ b/compute/cloud-client/src/test/java/compute/reservation/CrudOperationsReservationIT.java @@ -22,6 +22,7 @@ import com.google.api.gax.rpc.NotFoundException; import com.google.cloud.compute.v1.Reservation; +import compute.Util; import java.io.IOException; import java.util.List; import java.util.UUID; @@ -69,6 +70,9 @@ public static void cleanup() Assertions.assertThrows( NotFoundException.class, () -> GetReservation.getReservation(PROJECT_ID, RESERVATION_NAME, ZONE)); + + // Clean up stale resources + Util.cleanUpExistingReservations("test-reservation-", PROJECT_ID, ZONE); } @Test diff --git a/compute/cloud-client/src/test/java/compute/reservation/ReservationIT.java b/compute/cloud-client/src/test/java/compute/reservation/ReservationIT.java index 22be75ea98a..fa0532789ae 100644 --- a/compute/cloud-client/src/test/java/compute/reservation/ReservationIT.java +++ b/compute/cloud-client/src/test/java/compute/reservation/ReservationIT.java @@ -36,6 +36,7 @@ import compute.CreateRegionalInstanceTemplate; import compute.DeleteInstanceTemplate; import compute.DeleteRegionalInstanceTemplate; +import compute.Util; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.PrintStream; @@ -145,6 +146,13 @@ public static void cleanup() NotFoundException.class, () -> GetReservation.getReservation(PROJECT_ID, RESERVATION_NAME_REGIONAL, ZONE)); + // Clean up stale resources + Util.cleanUpExistingReservations("test-reservation-", PROJECT_ID, ZONE); + Util.cleanUpExistingInstanceTemplates("test-global-inst-temp-", PROJECT_ID); + Util.cleanUpExistingInstanceTemplates("test-shared-inst-temp-", PROJECT_ID); + Util.cleanUpExistingRegionalInstanceTemplates( + "test-regional-inst-temp-", PROJECT_ID, ZONE); + stdOut.close(); System.setOut(out); } diff --git a/compute/cloud-client/src/test/java/compute/reservation/WithoutConsumingReservationIT.java b/compute/cloud-client/src/test/java/compute/reservation/WithoutConsumingReservationIT.java index 763b1e2df5f..06dd16d0d01 100644 --- a/compute/cloud-client/src/test/java/compute/reservation/WithoutConsumingReservationIT.java +++ b/compute/cloud-client/src/test/java/compute/reservation/WithoutConsumingReservationIT.java @@ -23,6 +23,7 @@ import com.google.cloud.compute.v1.InstanceTemplate; import compute.DeleteInstance; import compute.DeleteInstanceTemplate; +import compute.Util; import java.io.IOException; import java.util.UUID; import java.util.concurrent.ExecutionException; @@ -71,6 +72,11 @@ public static void cleanup() DeleteInstance.deleteInstance(PROJECT_ID, ZONE, INSTANCE_NOT_CONSUME_RESERVATION_NAME); DeleteInstanceTemplate.deleteInstanceTemplate( PROJECT_ID, TEMPLATE_NOT_CONSUME_RESERVATION_NAME); + + // Clean up stale resources + Util.cleanUpExistingReservations("test-reservation-", PROJECT_ID, ZONE); + Util.cleanUpExistingInstances("test-instance-not-consume-", PROJECT_ID, ZONE); + Util.cleanUpExistingInstanceTemplates("test-template-not-consume-", PROJECT_ID); } @Test From c7306ce745d0d8287b25e5e514edb4440398c6b1 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Sun, 24 Nov 2024 18:54:16 +0100 Subject: [PATCH 08/18] Fixed clean up method --- .../src/test/java/compute/disks/HyperdisksIT.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) 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 9d89fa64faf..0aaa681beab 100644 --- a/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java @@ -63,6 +63,9 @@ public static void setUp() requireEnvVar("GOOGLE_APPLICATION_CREDENTIALS"); requireEnvVar("GOOGLE_CLOUD_PROJECT"); + // Clean up stale resources + Util.cleanUpExistingDisks("test-hyperdisk-enc-", PROJECT_ID, ZONE); + Util.cleanUpExistingStoragePool("test-storage-pool-enc-", PROJECT_ID, ZONE); } @AfterAll @@ -74,9 +77,6 @@ public static void cleanup() 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 834d52a905ca20c17235a304217d52b0d608d46c Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Sun, 24 Nov 2024 19:35:20 +0100 Subject: [PATCH 09/18] Fixed clean up method --- .../src/test/java/compute/disks/HyperdisksIT.java | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) 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 0aaa681beab..47342bd5596 100644 --- a/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/HyperdisksIT.java @@ -62,10 +62,6 @@ public static void setUp() throws IOException, ExecutionException, InterruptedException, TimeoutException { requireEnvVar("GOOGLE_APPLICATION_CREDENTIALS"); requireEnvVar("GOOGLE_CLOUD_PROJECT"); - - // Clean up stale resources - Util.cleanUpExistingDisks("test-hyperdisk-enc-", PROJECT_ID, ZONE); - Util.cleanUpExistingStoragePool("test-storage-pool-enc-", PROJECT_ID, ZONE); } @AfterAll @@ -77,6 +73,9 @@ public static void cleanup() 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 9c6dc481b85a2d610c734e687a8acab5c0a09f48 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Mon, 25 Nov 2024 09:57:58 +0100 Subject: [PATCH 10/18] Added timeout --- .../src/test/java/compute/disks/ConsistencyGroupIT.java | 1 + 1 file changed, 1 insertion(+) 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 49f3611a07f..cd49ad25bde 100644 --- a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -84,6 +84,7 @@ public static void setUp() throws Exception { public static void cleanUp() throws IOException, ExecutionException, InterruptedException, TimeoutException { StopDiskReplication.stopDiskAsyncReplication(PROJECT_ID, REGION, DISK_NAME); + TimeUnit.SECONDS.sleep(30); StopDiskReplication.stopDiskAsyncReplication( PROJECT_ID, REGION_SECONDARY, SECONDARY_REGIONAL_DISK); From c30e81b367f7ac26491b653b4077bd53e62616a2 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Sat, 30 Nov 2024 19:56:46 +0100 Subject: [PATCH 11/18] Reverted not related changes --- .../java/compute/reservation/ConsumeReservationsIT.java | 5 ----- .../compute/reservation/CreateReservationFromVmIT.java | 5 ----- .../compute/reservation/CrudOperationsReservationIT.java | 4 ---- .../src/test/java/compute/reservation/ReservationIT.java | 8 -------- .../reservation/WithoutConsumingReservationIT.java | 6 ------ 5 files changed, 28 deletions(-) diff --git a/compute/cloud-client/src/test/java/compute/reservation/ConsumeReservationsIT.java b/compute/cloud-client/src/test/java/compute/reservation/ConsumeReservationsIT.java index 663c517e938..96c8b22a4e0 100644 --- a/compute/cloud-client/src/test/java/compute/reservation/ConsumeReservationsIT.java +++ b/compute/cloud-client/src/test/java/compute/reservation/ConsumeReservationsIT.java @@ -29,7 +29,6 @@ import com.google.cloud.compute.v1.Reservation; import com.google.cloud.compute.v1.ReservationsClient; import compute.DeleteInstance; -import compute.Util; import java.io.IOException; import java.util.UUID; import java.util.concurrent.ExecutionException; @@ -91,10 +90,6 @@ public static void cleanup() Assertions.assertThrows( NotFoundException.class, () -> GetReservation.getReservation(PROJECT_ID, RESERVATION_NAME, ZONE)); - - // Clean up stale resources - Util.cleanUpExistingInstances("test-instance-", PROJECT_ID, ZONE); - Util.cleanUpExistingReservations("test-reservation-", PROJECT_ID, ZONE); } @Test diff --git a/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java b/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java index c14cdc2e966..a3c0cf0b5d8 100644 --- a/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java +++ b/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java @@ -26,7 +26,6 @@ import com.google.cloud.compute.v1.ReservationsClient; import compute.CreateInstance; import compute.DeleteInstance; -import compute.Util; import java.io.IOException; import java.util.UUID; import java.util.concurrent.ExecutionException; @@ -80,10 +79,6 @@ public static void cleanup() // Delete resources created for testing. DeleteInstance.deleteInstance(PROJECT_ID, ZONE, instanceForReservation); - // Clean up stale resources - Util.cleanUpExistingReservations("test-reservation-from-vm-", PROJECT_ID, ZONE); - Util.cleanUpExistingInstances("test-instance-for-reserv-", PROJECT_ID, ZONE); - reservationsClient.close(); instancesClient.close(); } diff --git a/compute/cloud-client/src/test/java/compute/reservation/CrudOperationsReservationIT.java b/compute/cloud-client/src/test/java/compute/reservation/CrudOperationsReservationIT.java index 91b08a779eb..0dd9209ae5f 100644 --- a/compute/cloud-client/src/test/java/compute/reservation/CrudOperationsReservationIT.java +++ b/compute/cloud-client/src/test/java/compute/reservation/CrudOperationsReservationIT.java @@ -22,7 +22,6 @@ import com.google.api.gax.rpc.NotFoundException; import com.google.cloud.compute.v1.Reservation; -import compute.Util; import java.io.IOException; import java.util.List; import java.util.UUID; @@ -70,9 +69,6 @@ public static void cleanup() Assertions.assertThrows( NotFoundException.class, () -> GetReservation.getReservation(PROJECT_ID, RESERVATION_NAME, ZONE)); - - // Clean up stale resources - Util.cleanUpExistingReservations("test-reservation-", PROJECT_ID, ZONE); } @Test diff --git a/compute/cloud-client/src/test/java/compute/reservation/ReservationIT.java b/compute/cloud-client/src/test/java/compute/reservation/ReservationIT.java index fa0532789ae..22be75ea98a 100644 --- a/compute/cloud-client/src/test/java/compute/reservation/ReservationIT.java +++ b/compute/cloud-client/src/test/java/compute/reservation/ReservationIT.java @@ -36,7 +36,6 @@ import compute.CreateRegionalInstanceTemplate; import compute.DeleteInstanceTemplate; import compute.DeleteRegionalInstanceTemplate; -import compute.Util; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.PrintStream; @@ -146,13 +145,6 @@ public static void cleanup() NotFoundException.class, () -> GetReservation.getReservation(PROJECT_ID, RESERVATION_NAME_REGIONAL, ZONE)); - // Clean up stale resources - Util.cleanUpExistingReservations("test-reservation-", PROJECT_ID, ZONE); - Util.cleanUpExistingInstanceTemplates("test-global-inst-temp-", PROJECT_ID); - Util.cleanUpExistingInstanceTemplates("test-shared-inst-temp-", PROJECT_ID); - Util.cleanUpExistingRegionalInstanceTemplates( - "test-regional-inst-temp-", PROJECT_ID, ZONE); - stdOut.close(); System.setOut(out); } diff --git a/compute/cloud-client/src/test/java/compute/reservation/WithoutConsumingReservationIT.java b/compute/cloud-client/src/test/java/compute/reservation/WithoutConsumingReservationIT.java index 06dd16d0d01..763b1e2df5f 100644 --- a/compute/cloud-client/src/test/java/compute/reservation/WithoutConsumingReservationIT.java +++ b/compute/cloud-client/src/test/java/compute/reservation/WithoutConsumingReservationIT.java @@ -23,7 +23,6 @@ import com.google.cloud.compute.v1.InstanceTemplate; import compute.DeleteInstance; import compute.DeleteInstanceTemplate; -import compute.Util; import java.io.IOException; import java.util.UUID; import java.util.concurrent.ExecutionException; @@ -72,11 +71,6 @@ public static void cleanup() DeleteInstance.deleteInstance(PROJECT_ID, ZONE, INSTANCE_NOT_CONSUME_RESERVATION_NAME); DeleteInstanceTemplate.deleteInstanceTemplate( PROJECT_ID, TEMPLATE_NOT_CONSUME_RESERVATION_NAME); - - // Clean up stale resources - Util.cleanUpExistingReservations("test-reservation-", PROJECT_ID, ZONE); - Util.cleanUpExistingInstances("test-instance-not-consume-", PROJECT_ID, ZONE); - Util.cleanUpExistingInstanceTemplates("test-template-not-consume-", PROJECT_ID); } @Test From 1f082976a9277b7774e52ee6c258cfcf99f1e72b Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Sat, 30 Nov 2024 19:58:48 +0100 Subject: [PATCH 12/18] Reverted not related changes --- .../java/compute/reservation/CreateReservationFromVmIT.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java b/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java index a3c0cf0b5d8..b69c5091509 100644 --- a/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java +++ b/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java @@ -26,6 +26,7 @@ import com.google.cloud.compute.v1.ReservationsClient; import compute.CreateInstance; import compute.DeleteInstance; +import compute.Util; import java.io.IOException; import java.util.UUID; import java.util.concurrent.ExecutionException; @@ -79,6 +80,10 @@ public static void cleanup() // Delete resources created for testing. DeleteInstance.deleteInstance(PROJECT_ID, ZONE, instanceForReservation); + // Cleanup existing stale resources. + Util.cleanUpExistingInstances("test-instance-for-reserv-" + javaVersion, PROJECT_ID, ZONE); + Util.cleanUpExistingReservations("test-reservation-from-vm-" + javaVersion, PROJECT_ID, ZONE); + reservationsClient.close(); instancesClient.close(); } From 9d1635bfd79787c5aa361fedec8b5e8aa2864579 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Sat, 30 Nov 2024 19:59:51 +0100 Subject: [PATCH 13/18] Reverted not related changes --- .../compute/reservation/CreateReservationFromVmIT.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java b/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java index b69c5091509..e98dd20ba22 100644 --- a/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java +++ b/compute/cloud-client/src/test/java/compute/reservation/CreateReservationFromVmIT.java @@ -71,6 +71,10 @@ public static void setUp() instanceForReservation = "test-instance-for-reserv-" + javaVersion + "-" + UUID.randomUUID().toString().substring(0, 8); + // Cleanup existing stale resources. + Util.cleanUpExistingInstances("test-instance-for-reserv-" + javaVersion, PROJECT_ID, ZONE); + Util.cleanUpExistingReservations("test-reservation-from-vm-" + javaVersion, PROJECT_ID, ZONE); + CreateInstance.createInstance(PROJECT_ID, ZONE, instanceForReservation); } @@ -80,10 +84,6 @@ public static void cleanup() // Delete resources created for testing. DeleteInstance.deleteInstance(PROJECT_ID, ZONE, instanceForReservation); - // Cleanup existing stale resources. - Util.cleanUpExistingInstances("test-instance-for-reserv-" + javaVersion, PROJECT_ID, ZONE); - Util.cleanUpExistingReservations("test-reservation-from-vm-" + javaVersion, PROJECT_ID, ZONE); - reservationsClient.close(); instancesClient.close(); } From f2ca349308810887593fe03b1f43979139fe1f25 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Sat, 30 Nov 2024 20:01:09 +0100 Subject: [PATCH 14/18] Reverted not related changes --- .../src/test/java/compute/Util.java | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/compute/cloud-client/src/test/java/compute/Util.java b/compute/cloud-client/src/test/java/compute/Util.java index 510effed769..5c89de8faa8 100644 --- a/compute/cloud-client/src/test/java/compute/Util.java +++ b/compute/cloud-client/src/test/java/compute/Util.java @@ -37,7 +37,6 @@ 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; @@ -267,22 +266,6 @@ 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; From 63dd42fd96444858bb30179fe4dc147cf3f9cfaf Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Wed, 18 Dec 2024 18:40:01 +0100 Subject: [PATCH 15/18] Fixed code --- .../RemoveDiskFromConsistencyGroup.java | 3 +- .../compute/disks/ConsistencyGroupIT.java | 31 ++++++++++--------- 2 files changed, 18 insertions(+), 16 deletions(-) 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 b791125b0dd..fd877947d51 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 @@ -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.RegionDisksClient; import com.google.cloud.compute.v1.RegionDisksRemoveResourcePoliciesRequest; import com.google.cloud.compute.v1.RemoveResourcePoliciesDiskRequest; @@ -51,7 +52,7 @@ public static void main(String[] args) } // Removes a disk from a consistency group. - public static Operation.Status removeDiskFromConsistencyGroup( + public static Status removeDiskFromConsistencyGroup( String project, String location, String diskName, String consistencyGroupName, String consistencyGroupLocation) throws IOException, ExecutionException, InterruptedException, TimeoutException { 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 3fc4147467a..0ba55de5e46 100644 --- a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -32,6 +32,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.RemoveResourcePoliciesRegionDiskRequest; import com.google.cloud.compute.v1.ResourcePoliciesClient; @@ -70,14 +71,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); } } @@ -93,15 +94,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 = AddDiskToConsistencyGroup.addDiskToConsistencyGroup( + Status status = AddDiskToConsistencyGroup.addDiskToConsistencyGroup( PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME, REGION); 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); } } @@ -117,15 +118,15 @@ public void testRemoveDiskFromConsistencyGroup() 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 = RemoveDiskFromConsistencyGroup.removeDiskFromConsistencyGroup( + Status status = RemoveDiskFromConsistencyGroup.removeDiskFromConsistencyGroup( PROJECT_ID, REGION, DISK_NAME, CONSISTENCY_GROUP_NAME, REGION); 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); } } @@ -141,15 +142,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); } } @@ -186,16 +187,16 @@ public void testStopDiskReplicationConsistencyGroup() throws Exception { when(mockClient.stopGroupAsyncReplicationAsync( any(StopGroupAsyncReplicationRegionDiskRequest.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 = + Status status = StopDiskReplicationConsistencyGroup.stopDiskReplicationConsistencyGroup( PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME, REGION); verify(mockClient, times(1)).stopGroupAsyncReplicationAsync( any(StopGroupAsyncReplicationRegionDiskRequest.class)); verify(mockFuture, times(1)).get(anyLong(), any(TimeUnit.class)); - assertEquals(Operation.Status.DONE, status); + assertEquals(Status.DONE, status); } } From 12e6d11af9c905ddc779f4113b08b136f25b6035 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Wed, 18 Dec 2024 19:22:10 +0100 Subject: [PATCH 16/18] Split samples for zonal location --- .../StopDiskReplicationConsistencyGroup.java | 91 ------------------- ...gionalDiskReplicationConsistencyGroup.java | 71 +++++++++++++++ ...pZonalDiskReplicationConsistencyGroup.java | 72 +++++++++++++++ .../compute/disks/ConsistencyGroupIT.java | 62 +++++++++---- 4 files changed, 188 insertions(+), 108 deletions(-) delete mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopDiskReplicationConsistencyGroup.java create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopRegionalDiskReplicationConsistencyGroup.java create mode 100644 compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopZonalDiskReplicationConsistencyGroup.java diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopDiskReplicationConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopDiskReplicationConsistencyGroup.java deleted file mode 100644 index a097cc08866..00000000000 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopDiskReplicationConsistencyGroup.java +++ /dev/null @@ -1,91 +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_stop_replication] -import com.google.cloud.compute.v1.DisksClient; -import com.google.cloud.compute.v1.DisksStopGroupAsyncReplicationResource; -import com.google.cloud.compute.v1.Operation; -import com.google.cloud.compute.v1.RegionDisksClient; -import com.google.cloud.compute.v1.StopGroupAsyncReplicationDiskRequest; -import com.google.cloud.compute.v1.StopGroupAsyncReplicationRegionDiskRequest; -import java.io.IOException; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; - -public class StopDiskReplicationConsistencyGroup { - - public static void main(String[] args) - throws IOException, InterruptedException, ExecutionException, 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 consistency group. - String consistencyGroupName = "CONSISTENCY_GROUP"; - // Region of the consistency group. - String consistencyGroupLocation = "us-central1"; - - stopDiskReplicationConsistencyGroup(project, location, consistencyGroupName, - consistencyGroupLocation); - } - - public static Operation.Status stopDiskReplicationConsistencyGroup(String project, - String location, String consistencyGroupName, String consistencyGroupLocation) - throws IOException, InterruptedException, ExecutionException, TimeoutException { - String resourcePolicy = String.format( - "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()) { - StopGroupAsyncReplicationRegionDiskRequest request = - StopGroupAsyncReplicationRegionDiskRequest.newBuilder() - .setProject(project) - .setRegion(location) - .setDisksStopGroupAsyncReplicationResourceResource( - DisksStopGroupAsyncReplicationResource.newBuilder() - .setResourcePolicy(resourcePolicy).build()) - .build(); - response = disksClient.stopGroupAsyncReplicationAsync(request) - .get(3, TimeUnit.MINUTES); - } - } else { - try (DisksClient disksClient = DisksClient.create()) { - StopGroupAsyncReplicationDiskRequest request = - StopGroupAsyncReplicationDiskRequest.newBuilder() - .setProject(project) - .setZone(location) - .setDisksStopGroupAsyncReplicationResourceResource( - DisksStopGroupAsyncReplicationResource.newBuilder() - .setResourcePolicy(resourcePolicy).build()) - .build(); - response = disksClient.stopGroupAsyncReplicationAsync(request) - .get(3, TimeUnit.MINUTES); - } - } - if (response.hasError()) { - throw new Error("Error stopping disk replication! " + response.getError()); - } - return response.getStatus(); - } -} -// [END compute_consistency_group_stop_replication] diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopRegionalDiskReplicationConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopRegionalDiskReplicationConsistencyGroup.java new file mode 100644 index 00000000000..56dc45ebc4d --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopRegionalDiskReplicationConsistencyGroup.java @@ -0,0 +1,71 @@ +/* + * 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_regional_stop_replication] +import com.google.cloud.compute.v1.DisksStopGroupAsyncReplicationResource; +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.StopGroupAsyncReplicationRegionDiskRequest; +import java.io.IOException; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +public class StopRegionalDiskReplicationConsistencyGroup { + + public static void main(String[] args) + throws IOException, InterruptedException, ExecutionException, 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 of the disk. + String region = "us-central1"; + // Name of the consistency group. + String consistencyGroupName = "CONSISTENCY_GROUP"; + + stopRegionalDiskReplicationConsistencyGroup(project, region, consistencyGroupName); + } + + public static Status stopRegionalDiskReplicationConsistencyGroup( + String project, String region, String consistencyGroupName) + throws IOException, InterruptedException, ExecutionException, TimeoutException { + String resourcePolicy = 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()) { + StopGroupAsyncReplicationRegionDiskRequest request = + StopGroupAsyncReplicationRegionDiskRequest.newBuilder() + .setProject(project) + .setRegion(region) + .setDisksStopGroupAsyncReplicationResourceResource( + DisksStopGroupAsyncReplicationResource.newBuilder() + .setResourcePolicy(resourcePolicy).build()) + .build(); + Operation response = disksClient.stopGroupAsyncReplicationAsync(request) + .get(3, TimeUnit.MINUTES); + + if (response.hasError()) { + throw new Error("Error stopping disk replication! " + response.getError()); + } + return response.getStatus(); + } + } +} +// [END compute_consistency_group_regional_stop_replication] diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopZonalDiskReplicationConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopZonalDiskReplicationConsistencyGroup.java new file mode 100644 index 00000000000..773e81c69ec --- /dev/null +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopZonalDiskReplicationConsistencyGroup.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_stop_replication] +import com.google.cloud.compute.v1.DisksClient; +import com.google.cloud.compute.v1.DisksStopGroupAsyncReplicationResource; +import com.google.cloud.compute.v1.Operation; +import com.google.cloud.compute.v1.Operation.Status; +import com.google.cloud.compute.v1.StopGroupAsyncReplicationDiskRequest; +import java.io.IOException; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +public class StopZonalDiskReplicationConsistencyGroup { + public static void main(String[] args) + throws IOException, InterruptedException, ExecutionException, 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 zone = "us-central1-a"; + // Name of the consistency group. + String consistencyGroupName = "CONSISTENCY_GROUP"; + + stopZonalDiskReplicationConsistencyGroup(project, zone, consistencyGroupName); + } + + public static Status stopZonalDiskReplicationConsistencyGroup( + String project, String zone, String consistencyGroupName) + throws IOException, InterruptedException, ExecutionException, TimeoutException { + String region = zone.substring(0, zone.lastIndexOf('-')); + + String resourcePolicy = 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()) { + StopGroupAsyncReplicationDiskRequest request = + StopGroupAsyncReplicationDiskRequest.newBuilder() + .setProject(project) + .setZone(zone) + .setDisksStopGroupAsyncReplicationResourceResource( + DisksStopGroupAsyncReplicationResource.newBuilder() + .setResourcePolicy(resourcePolicy).build()) + .build(); + Operation response = disksClient.stopGroupAsyncReplicationAsync(request) + .get(3, TimeUnit.MINUTES); + + if (response.hasError()) { + throw new Error("Error stopping disk replication! " + response.getError()); + } + return response.getStatus(); + } + } +} +// [END compute_consistency_group_stop_replication] 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 0ba55de5e46..e7038724d45 100644 --- a/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java +++ b/compute/cloud-client/src/test/java/compute/disks/ConsistencyGroupIT.java @@ -36,6 +36,7 @@ import com.google.cloud.compute.v1.RegionDisksClient; import com.google.cloud.compute.v1.RemoveResourcePoliciesRegionDiskRequest; import com.google.cloud.compute.v1.ResourcePoliciesClient; +import com.google.cloud.compute.v1.StopGroupAsyncReplicationDiskRequest; import com.google.cloud.compute.v1.StopGroupAsyncReplicationRegionDiskRequest; import compute.disks.consistencygroup.AddDiskToConsistencyGroup; import compute.disks.consistencygroup.CreateConsistencyGroup; @@ -43,7 +44,8 @@ import compute.disks.consistencygroup.ListRegionalDisksInConsistencyGroup; import compute.disks.consistencygroup.ListZonalDisksInConsistencyGroup; import compute.disks.consistencygroup.RemoveDiskFromConsistencyGroup; -import compute.disks.consistencygroup.StopDiskReplicationConsistencyGroup; +import compute.disks.consistencygroup.StopRegionalDiskReplicationConsistencyGroup; +import compute.disks.consistencygroup.StopZonalDiskReplicationConsistencyGroup; import java.util.concurrent.TimeUnit; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Timeout; @@ -56,6 +58,7 @@ public class ConsistencyGroupIT { private static final String PROJECT_ID = "project-id"; private static final String REGION = "asia-east1"; + private static final String ZONE = "asia-east1-c"; private static final String CONSISTENCY_GROUP_NAME = "consistency-group"; private static final String DISK_NAME = "disk-for-consistency"; @@ -176,7 +179,28 @@ public void testListRegionalDisksInConsistencyGroup() throws Exception { } @Test - public void testStopDiskReplicationConsistencyGroup() throws Exception { + public void testListZonalDisksInConsistencyGroup() throws Exception { + try (MockedStatic mockedRegionDisksClient = + mockStatic(DisksClient.class)) { + DisksClient mockClient = mock(DisksClient.class); + DisksClient.ListPagedResponse mockResponse = + mock(DisksClient.ListPagedResponse.class); + + mockedRegionDisksClient.when(DisksClient::create).thenReturn(mockClient); + when(mockClient.list(any(ListDisksRequest.class))) + .thenReturn(mockResponse); + + ListZonalDisksInConsistencyGroup.listZonalDisksInConsistencyGroup( + PROJECT_ID, CONSISTENCY_GROUP_NAME, REGION, REGION); + + verify(mockClient, times(1)) + .list(any(ListDisksRequest.class)); + verify(mockResponse, times(1)).iterateAll(); + } + } + + @Test + public void testStopRegionalDiskReplicationConsistencyGroup() throws Exception { try (MockedStatic mockedRegionDisksClient = mockStatic(RegionDisksClient.class)) { Operation operation = mock(Operation.class); @@ -189,9 +213,9 @@ public void testStopDiskReplicationConsistencyGroup() throws Exception { when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); when(operation.getStatus()).thenReturn(Status.DONE); - Status status = - StopDiskReplicationConsistencyGroup.stopDiskReplicationConsistencyGroup( - PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME, REGION); + Status status = StopRegionalDiskReplicationConsistencyGroup + .stopRegionalDiskReplicationConsistencyGroup( + PROJECT_ID, REGION, CONSISTENCY_GROUP_NAME); verify(mockClient, times(1)).stopGroupAsyncReplicationAsync( any(StopGroupAsyncReplicationRegionDiskRequest.class)); @@ -201,23 +225,27 @@ public void testStopDiskReplicationConsistencyGroup() throws Exception { } @Test - public void testListZonalDisksInConsistencyGroup() throws Exception { - try (MockedStatic mockedRegionDisksClient = + public void testStopZonalDiskReplicationConsistencyGroup() throws Exception { + try (MockedStatic mockedDisksClient = mockStatic(DisksClient.class)) { + Operation operation = mock(Operation.class); DisksClient mockClient = mock(DisksClient.class); - DisksClient.ListPagedResponse mockResponse = - mock(DisksClient.ListPagedResponse.class); + OperationFuture mockFuture = mock(OperationFuture.class); - mockedRegionDisksClient.when(DisksClient::create).thenReturn(mockClient); - when(mockClient.list(any(ListDisksRequest.class))) - .thenReturn(mockResponse); + mockedDisksClient.when(DisksClient::create).thenReturn(mockClient); + when(mockClient.stopGroupAsyncReplicationAsync( + any(StopGroupAsyncReplicationDiskRequest.class))).thenReturn(mockFuture); + when(mockFuture.get(anyLong(), any(TimeUnit.class))).thenReturn(operation); + when(operation.getStatus()).thenReturn(Status.DONE); - ListZonalDisksInConsistencyGroup.listZonalDisksInConsistencyGroup( - PROJECT_ID, CONSISTENCY_GROUP_NAME, REGION, REGION); + Status status = StopZonalDiskReplicationConsistencyGroup + .stopZonalDiskReplicationConsistencyGroup( + PROJECT_ID, ZONE, CONSISTENCY_GROUP_NAME); - verify(mockClient, times(1)) - .list(any(ListDisksRequest.class)); - verify(mockResponse, times(1)).iterateAll(); + verify(mockClient, times(1)).stopGroupAsyncReplicationAsync( + any(StopGroupAsyncReplicationDiskRequest.class)); + verify(mockFuture, times(1)).get(anyLong(), any(TimeUnit.class)); + assertEquals(Status.DONE, status); } } } \ No newline at end of file From 4b99978829d35faf4cab4ba876a8376317c6be7b Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Thu, 19 Dec 2024 15:09:35 +0100 Subject: [PATCH 17/18] Added comments for methods --- .../StopRegionalDiskReplicationConsistencyGroup.java | 1 + .../StopZonalDiskReplicationConsistencyGroup.java | 1 + 2 files changed, 2 insertions(+) diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopRegionalDiskReplicationConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopRegionalDiskReplicationConsistencyGroup.java index 56dc45ebc4d..cfe16475f44 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopRegionalDiskReplicationConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopRegionalDiskReplicationConsistencyGroup.java @@ -42,6 +42,7 @@ public static void main(String[] args) stopRegionalDiskReplicationConsistencyGroup(project, region, consistencyGroupName); } + // Stops replication for a consistency group for a project in a given region. public static Status stopRegionalDiskReplicationConsistencyGroup( String project, String region, String consistencyGroupName) throws IOException, InterruptedException, ExecutionException, TimeoutException { diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopZonalDiskReplicationConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopZonalDiskReplicationConsistencyGroup.java index 773e81c69ec..c9d13f1d340 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopZonalDiskReplicationConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopZonalDiskReplicationConsistencyGroup.java @@ -41,6 +41,7 @@ public static void main(String[] args) stopZonalDiskReplicationConsistencyGroup(project, zone, consistencyGroupName); } + // Stops replication for a consistency group for a project in a given zone. public static Status stopZonalDiskReplicationConsistencyGroup( String project, String zone, String consistencyGroupName) throws IOException, InterruptedException, ExecutionException, TimeoutException { From 78a3f24978c0941e044a4b802ac53408e336fb03 Mon Sep 17 00:00:00 2001 From: Tetiana Yahodska Date: Mon, 23 Dec 2024 14:05:54 +0100 Subject: [PATCH 18/18] Fixed comments --- .../StopRegionalDiskReplicationConsistencyGroup.java | 2 +- .../StopZonalDiskReplicationConsistencyGroup.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopRegionalDiskReplicationConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopRegionalDiskReplicationConsistencyGroup.java index cfe16475f44..6e293eef0cf 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopRegionalDiskReplicationConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopRegionalDiskReplicationConsistencyGroup.java @@ -42,7 +42,7 @@ public static void main(String[] args) stopRegionalDiskReplicationConsistencyGroup(project, region, consistencyGroupName); } - // Stops replication for a consistency group for a project in a given region. + // Stops replication of a consistency group for a project in a given region. public static Status stopRegionalDiskReplicationConsistencyGroup( String project, String region, String consistencyGroupName) throws IOException, InterruptedException, ExecutionException, TimeoutException { diff --git a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopZonalDiskReplicationConsistencyGroup.java b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopZonalDiskReplicationConsistencyGroup.java index c9d13f1d340..38c31e1850d 100644 --- a/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopZonalDiskReplicationConsistencyGroup.java +++ b/compute/cloud-client/src/main/java/compute/disks/consistencygroup/StopZonalDiskReplicationConsistencyGroup.java @@ -41,7 +41,7 @@ public static void main(String[] args) stopZonalDiskReplicationConsistencyGroup(project, zone, consistencyGroupName); } - // Stops replication for a consistency group for a project in a given zone. + // Stops replication of a consistency group for a project in a given zone. public static Status stopZonalDiskReplicationConsistencyGroup( String project, String zone, String consistencyGroupName) throws IOException, InterruptedException, ExecutionException, TimeoutException {