chore: add IT for CopyBackupSample.

googleapis · arpan14 · Feb 23, 2024 · Feb 6, 2023 · Feb 8, 2023 · Feb 8, 2023
commit 0dcce23c944609e847b8454ccdfceca17ac8c1e6
@@ -19,13 +19,13 @@
 // [START spanner_copy_backup]
 
 import com.google.cloud.Timestamp;
-import com.google.cloud.spanner.Backup;
-import com.google.cloud.spanner.BackupId;
-import com.google.cloud.spanner.DatabaseAdminClient;
-import com.google.cloud.spanner.Spanner;
 import com.google.cloud.spanner.SpannerException;
 import com.google.cloud.spanner.SpannerExceptionFactory;
-import com.google.cloud.spanner.SpannerOptions;
+import com.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;
+import com.google.spanner.admin.database.v1.Backup;
+import com.google.spanner.admin.database.v1.BackupName;
+import com.google.spanner.admin.database.v1.InstanceName;
+import java.io.IOException;
 import java.time.Instant;
 import java.time.OffsetDateTime;
 import java.time.ZoneId;
@@ -34,15 +34,14 @@
 
 public class CopyBackupSample {
 
- static void copyBackup() {
+ static void copyBackup() throws IOException {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project";
  String instanceId = "my-instance";
  String sourceBackupId = "my-backup";
  String destinationBackupId = "my-destination-backup";
- try (Spanner spanner =
- SpannerOptions.newBuilder().setProjectId(projectId).build().getService()) {
- DatabaseAdminClient databaseAdminClient = spanner.getDatabaseAdminClient();
+
+ try (DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.create()) {
  copyBackup(databaseAdminClient, projectId, instanceId, sourceBackupId, destinationBackupId);
  }
  }
@@ -59,39 +58,36 @@ static void copyBackup(
  TimeUnit.MICROSECONDS.convert(
  System.currentTimeMillis() + TimeUnit.DAYS.toMillis(14),
  TimeUnit.MILLISECONDS));
- Backup destinationBackup =
- databaseAdminClient
- .newBackupBuilder(BackupId.of(projectId, instanceId, destinationBackupId))
- .setExpireTime(expireTime)
- .build();
 
  // Initiate the request which returns an OperationFuture.
- System.out.println("Copying backup [" + destinationBackup.getId() + "]...");
+ System.out.println("Copying backup [" + destinationBackupId + "]...");
+ Backup destinationBackup;
  try {
  // Creates a copy of an existing backup.
  // Wait for the backup operation to complete.
- destinationBackup = databaseAdminClient.copyBackup(
- BackupId.of(projectId, instanceId, sourceBackupId), destinationBackup).get();
- System.out.println("Copied backup [" + destinationBackup.getId() + "]");
+ destinationBackup = databaseAdminClient.copyBackupAsync(
+ InstanceName.of(projectId, instanceId), destinationBackupId,
+ BackupName.of(projectId, instanceId, sourceBackupId), expireTime.toProto()).get();
+ System.out.println("Copied backup [" + destinationBackup.getName() + "]");
  } catch (ExecutionException e) {
  throw (SpannerException) e.getCause();
  } catch (InterruptedException e) {
  throw SpannerExceptionFactory.propagateInterrupt(e);
  }
  // Load the metadata of the new backup from the server.
- destinationBackup = destinationBackup.reload();
+ destinationBackup = databaseAdminClient.getBackup(destinationBackup.getName());
  System.out.println(
  String.format(
  "Backup %s of size %d bytes was copied at %s for version of database at %s",
- destinationBackup.getId().getName(),
- destinationBackup.getSize(),
+ destinationBackup.getName(),
+ destinationBackup.getSizeBytes(),
  OffsetDateTime.ofInstant(
- Instant.ofEpochSecond(destinationBackup.getProto().getCreateTime().getSeconds(),
- destinationBackup.getProto().getCreateTime().getNanos()),
+ Instant.ofEpochSecond(destinationBackup.getCreateTime().getSeconds(),
+ destinationBackup.getCreateTime().getNanos()),
  ZoneId.systemDefault()),
  OffsetDateTime.ofInstant(
- Instant.ofEpochSecond(destinationBackup.getProto().getVersionTime().getSeconds(),
- destinationBackup.getProto().getVersionTime().getNanos()),
+ Instant.ofEpochSecond(destinationBackup.getVersionTime().getSeconds(),
+ destinationBackup.getVersionTime().getNanos()),
  ZoneId.systemDefault())));
  }
 }

@@ -70,6 +70,8 @@
 import com.google.spanner.admin.database.v1.RestoreDatabaseRequest;
 import com.google.spanner.admin.database.v1.RestoreInfo;
 import com.google.spanner.v1.ExecuteSqlRequest.QueryOptions;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
 import java.math.BigDecimal;
 import java.time.Instant;
 import java.time.ZoneId;
@@ -1920,8 +1922,8 @@ static void deleteBackup(DatabaseAdminClient dbAdminClient,
  // Verify that the backup is deleted.
  try {
  dbAdminClient.getBackup(backupName);
- } catch (SpannerException e) {
- if (e.getErrorCode() == ErrorCode.NOT_FOUND) {
+ } catch (StatusRuntimeException e) {
+ if (e.getStatus().getCode() == Status.Code.NOT_FOUND) {
  System.out.println("Deleted backup [" + backupId + "]");
  } else {
  System.out.println("Delete backup [" + backupId + "] failed");

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.spanner.admin.generated;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.example.spanner.SampleRunner;
+import com.google.cloud.spanner.ErrorCode;
+import com.google.cloud.spanner.SpannerException;
+import com.google.cloud.spanner.SpannerExceptionFactory;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.Uninterruptibles;
+import com.google.spanner.admin.database.v1.BackupName;
+import com.google.spanner.admin.database.v1.DatabaseName;
+import com.google.spanner.admin.database.v1.InstanceName;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Predicate;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+@Ignore
+public class CopyBackupIT extends SampleTestBaseV2 {
+
+ private static String key;
+
+ @BeforeClass
+ public static void setUp() {
+ String keyLocation = Preconditions
+ .checkNotNull(System.getProperty("spanner.test.key.location"));
+ String keyRing = Preconditions.checkNotNull(System.getProperty("spanner.test.key.ring"));
+ String keyName = Preconditions.checkNotNull(System.getProperty("spanner.test.key.name"));
+ key = "projects/" + projectId + "/locations/" + keyLocation + "/keyRings/" + keyRing
+ + "/cryptoKeys/" + keyName;
+ }
+
+ @Test
+ public void testEncryptedDatabaseAndBackupAndRestore() throws Exception {
+ final String databaseId = idGenerator.generateDatabaseId();
+ final String sourceBackupId = idGenerator.generateBackupId();
+ final String destinationBackupId = idGenerator.generateBackupId();
+
+ String out = SampleRunner.runSample(() ->
+ SpannerSample.createDatabase(
+ databaseAdminClient, InstanceName.of(projectId, instanceId), databaseId));
+ assertThat(out).contains(String.format(
+ "Created database [%s]", DatabaseName.of(projectId, instanceId, databaseId)));
+
+ out = SampleRunner.runSampleWithRetry(() ->
+ CreateBackupWithEncryptionKey.createBackupWithEncryptionKey(
+ databaseAdminClient, projectId, instanceId, databaseId, sourceBackupId, key
+ ), new ShouldRetryBackupOperation());
+ assertThat(out).contains("Created backup [" +
+ BackupName.of(projectId, instanceId, sourceBackupId) + "]");
+
+ out = SampleRunner.runSampleWithRetry(() ->
+ CopyBackupSample.copyBackup(
+ databaseAdminClient, projectId, instanceId, sourceBackupId, destinationBackupId
+ ), new ShouldRetryBackupOperation());
+
+ assertThat(out).contains("Copied backup [" + BackupName.of(
+ projectId, instanceId, destinationBackupId).toString() + "]");
+ assertThat(out).containsMatch(String.format(
+ "Backup projects/%s/instances/%s/backups/%s of size \\d+ bytes was copied at (.*)",
+ projectId, instanceId, destinationBackupId, key));
+ }
+
+ static class ShouldRetryBackupOperation implements Predicate<SpannerException> {
+
+ private static final int MAX_ATTEMPTS = 20;
+ private int attempts = 0;
+
+ @Override
+ public boolean test(SpannerException e) {
+ if (e.getErrorCode() == ErrorCode.FAILED_PRECONDITION
+ && e.getMessage().contains("Please retry the operation once the pending")) {
+ attempts++;
+ if (attempts == MAX_ATTEMPTS) {
+ // Throw custom exception so it is easier to locate in the log why it went wrong.
+ throw SpannerExceptionFactory.newSpannerException(ErrorCode.DEADLINE_EXCEEDED,
+ String.format("Operation failed %d times because of other pending operations. "
+ + "Giving up operation.\n", attempts),
+ e);
+ }
+ // Wait one minute before retrying.
+ Uninterruptibles.sleepUninterruptibly(60L, TimeUnit.SECONDS);
+ return true;
+ }
+ return false;
+ }
+ }
+}
+
@@ -375,6 +375,7 @@ public void testBackupSamples_withoutEncryption() {
  String databaseId = idGenerator.generateDatabaseId();
  DatabaseId dbId = DatabaseId.of(projectId, instanceId, databaseId);
  String restoreDatabaseId = idGenerator.generateDatabaseId();
+ String backupId = idGenerator.generateBackupId();
 
  try {
  assertThat(instanceId).isNotNull();
@@ -385,7 +386,6 @@ public void testBackupSamples_withoutEncryption() {
  assertThat(out).contains("Created database");
  assertThat(out).contains(dbId.getName());
 
- String backupId = idGenerator.generateBackupId();
  BackupName backupName = BackupName.of(projectId, instanceId, backupId);
 
  System.out.println("Creating Backup ...");