changes to samples

asthamohta · asthamohta · commit 698cd97585db · 2022-04-04T10:37:12.000+05:30
diff --git a/samples/snippets/src/main/java/com/example/spanner/CopyBackupSample.java b/samples/snippets/src/main/java/com/example/spanner/CopyBackupSample.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2022 Google Inc.
+ *
+ * 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;
+
+// [START spanner_copy_backup]
+
+import com.google.api.gax.longrunning.OperationFuture;
+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.spanner.admin.database.v1.CopyBackupMetadata;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+
+public class CopyBackupSample {
+
+    public static void main(String[] args) {
+        if (args.length != 4) {
+            throw new IllegalArgumentException(
+                    "Invalid number of arguments. "
+                            + "Usage: CopyBackupSample "
+                            + "<project-id> <instance-id> <source-backup-id> <destination-backup-id>");
+        }
+        String projectId = args[0];
+        String instanceId = args[1];
+        String sourceBackupId = args[2];
+        String destinationBackupId = args[3];
+
+        try (Spanner spanner =
+                     SpannerOptions.newBuilder().setProjectId(projectId).build().getService()) {
+            DatabaseAdminClient databaseAdminClient = spanner.getDatabaseAdminClient();
+            copyBackup(databaseAdminClient, projectId, instanceId, sourceBackupId, destinationBackupId);
+        }
+    }
+
+    static void copyBackup() {
+        // 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();
+            copyBackup(databaseAdminClient, projectId, instanceId, sourceBackupId, destinationBackupId);
+        }
+    }
+
+    static Void copyBackup(
+            DatabaseAdminClient databaseAdminClient,
+            String projectId,
+            String instanceId,
+            String sourceBackupId,
+            String destinationBackupId) {
+
+        Timestamp expireTime =
+                Timestamp.ofTimeMicroseconds(
+                        TimeUnit.MICROSECONDS.convert(
+                                System.currentTimeMillis() + TimeUnit.DAYS.toMillis(14), TimeUnit.MILLISECONDS));
+        // Creates a copy of an existing backup.
+        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() + "]...");
+        OperationFuture<Backup, CopyBackupMetadata> op =
+                databaseAdminClient.copyBackup(
+                        BackupId.of(projectId, instanceId, sourceBackupId), destinationBackup);
+        try {
+            // Wait for the backup operation to complete.
+            destinationBackup = op.get();
+            System.out.println("Copied backup [" + destinationBackup.getId() + "]");
+        } catch (ExecutionException e) {
+            throw (SpannerException) e.getCause();
+        } catch (InterruptedException e) {
+            throw SpannerExceptionFactory.propagateInterrupt(e);
+        }
+
+        // Reload the metadata of the backup from the server.
+        destinationBackup = destinationBackup.reload();
+        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(),
+                        LocalDateTime.ofEpochSecond(
+                                destinationBackup.getProto().getCreateTime().getSeconds(),
+                                destinationBackup.getProto().getCreateTime().getNanos(),
+                                OffsetDateTime.now().getOffset()),
+                        LocalDateTime.ofEpochSecond(
+                                destinationBackup.getProto().getVersionTime().getSeconds(),
+                                destinationBackup.getProto().getVersionTime().getNanos(),
+                                OffsetDateTime.now().getOffset())));
+
+        return null;
+    }
+}
+// [END spanner_copy_backup]
diff --git a/samples/snippets/src/main/java/com/example/spanner/SpannerSample.java b/samples/snippets/src/main/java/com/example/spanner/SpannerSample.java
@@ -57,6 +57,7 @@
 import com.google.longrunning.Operation;
 import com.google.protobuf.InvalidProtocolBufferException;
 import com.google.spanner.admin.database.v1.CreateBackupMetadata;
+import com.google.spanner.admin.database.v1.CopyBackupMetadata;
 import com.google.spanner.admin.database.v1.CreateDatabaseMetadata;
 import com.google.spanner.admin.database.v1.OptimizeRestoredDatabaseMetadata;
 import com.google.spanner.admin.database.v1.RestoreDatabaseMetadata;
@@ -1659,21 +1660,21 @@ static void cancelCreateBackup(
   // [END spanner_cancel_backup_create]
 
   // [START spanner_list_backup_operations]
-  static void listBackupOperations(InstanceAdminClient instanceAdminClient, DatabaseId databaseId) {
+  static void listBackupOperations(
+          InstanceAdminClient instanceAdminClient, DatabaseId databaseId, BackupId backupId) {
     Instance instance = instanceAdminClient.getInstance(databaseId.getInstanceId().getInstance());
     // Get create backup operations for the sample database.
     Timestamp last24Hours = Timestamp.ofTimeSecondsAndNanos(TimeUnit.SECONDS.convert(
         TimeUnit.HOURS.convert(Timestamp.now().getSeconds(), TimeUnit.SECONDS) - 24,
         TimeUnit.HOURS), 0);
     String filter =
         String.format(
-            "(metadata.database:%s) AND "
-                + "(metadata.@type:type.googleapis.com/"
-                + "google.spanner.admin.database.v1.CreateBackupMetadata) AND "
-                + "(metadata.progress.start_time > \"%s\")",
-            databaseId.getName(), last24Hours);
-    Page<Operation> operations = instance.listBackupOperations(Options.filter(filter));
-    for (Operation op : operations.iterateAll()) {
+                "(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata) "
+                        + "AND (metadata.database:%s)",
+                databaseId.getName());
+      Page<Operation> createBackupOperations = instance.listBackupOperations(Options.filter(filter));
+      System.out.println("Create Backup Operations:");
+      for (Operation op : createBackupOperations.iterateAll()) {
       try {
         CreateBackupMetadata metadata = op.getMetadata().unpack(CreateBackupMetadata.class);
         System.out.println(
@@ -1687,6 +1688,29 @@ static void listBackupOperations(InstanceAdminClient instanceAdminClient, Databa
         System.err.println(e.getMessage());
       }
     }
+      // Get copy backup operations for the sample database.
+      filter =
+              String.format(
+                      "(metadata.@type:type.googleapis.com/"
+                              + "google.spanner.admin.database.v1.CopyBackupMetadata) "
+                              + "AND (metadata.source_backup:%s)",
+                      backupId.getName());
+      Page<Operation>  copyBackupOperations = instance.listBackupOperations(Options.filter(filter));
+      System.out.println("Copy Backup Operations:");
+      for (Operation op : copyBackupOperations.iterateAll()) {
+          try {
+              CopyBackupMetadata copyBackupMetadata = op.getMetadata().unpack(CopyBackupMetadata.class);
+              System.out.println(
+                      String.format(
+                              "Copy Backup %s on backup %s pending: %d%% complete",
+                              copyBackupMetadata.getName(),
+                              copyBackupMetadata.getSourceBackup(),
+                              copyBackupMetadata.getProgress().getProgressPercent()));
+          } catch (InvalidProtocolBufferException e) {
+              // The returned operation does not contain CopyBackupMetadata.
+              System.err.println(e.getMessage());
+          }
+      }
   }
   // [END spanner_list_backup_operations]
 
@@ -1840,7 +1864,12 @@ static void updateBackup(DatabaseAdminClient dbAdminClient, BackupId backupId) {
             TimeUnit.SECONDS.toMicros(backup.getExpireTime().getSeconds())
                 + TimeUnit.NANOSECONDS.toMicros(backup.getExpireTime().getNanos())
                 + TimeUnit.DAYS.toMicros(30L));
-    System.out.println(String.format(
+      // New Expire Time must be less than Max Expire Time
+      expireTime = expireTime.compareTo(backup.getMaxExpireTime())<0?expireTime:backup.getMaxExpireTime();
+      int timeDiff = expireTime.compareTo(backup.getExpireTime());
+      Timestamp newExpireTime = (timeDiff < 0) ? expireTime : backup.getExpireTime();
+
+      System.out.println(String.format(
         "Updating expire time of backup [%s] to %s...",
         backupId.toString(),
         LocalDateTime.ofEpochSecond(
@@ -2048,7 +2077,7 @@ static void run(
             BackupId.of(backup.getInstanceId(), backup.getBackup() + "_cancel"));
         break;
       case "listbackupoperations":
-        listBackupOperations(instanceAdminClient, database);
+        listBackupOperations(instanceAdminClient, database, backup);
         break;
       case "listdatabaseoperations":
         listDatabaseOperations(instanceAdminClient, dbAdminClient, database.getInstanceId());
@@ -2144,14 +2173,14 @@ static void printUsageAndExit() {
     System.err.println("    SpannerExample querywithqueryoptions my-instance example-db");
     System.err.println("    SpannerExample createbackup my-instance example-db");
     System.err.println("    SpannerExample listbackups my-instance example-db");
-    System.err.println("    SpannerExample listbackupoperations my-instance example-db");
+    System.err.println("    SpannerExample listbackupoperations my-instance example-db backup-id");
     System.err.println("    SpannerExample listdatabaseoperations my-instance example-db");
     System.err.println("    SpannerExample restorebackup my-instance example-db");
     System.exit(1);
   }
 
   public static void main(String[] args) throws Exception {
-    if (args.length != 3) {
+      if (args.length != 3 && args.length != 4) {
       printUsageAndExit();
     }
     // [START init_client]
@@ -2176,6 +2205,9 @@ public static void main(String[] args) throws Exception {
               "%s_%02d",
               db.getDatabase(), LocalDate.now().get(ChronoField.ALIGNED_WEEK_OF_YEAR));
       BackupId backup = BackupId.of(db.getInstanceId(), backupName);
+      if( args.length == 4) {
+          backupName = args[3];
+      }
 
       // [START init_client]
       DatabaseClient dbClient = spanner.getDatabaseClient(db);
diff --git a/samples/snippets/src/test/java/com/example/spanner/SpannerSampleIT.java b/samples/snippets/src/test/java/com/example/spanner/SpannerSampleIT.java
@@ -95,7 +95,7 @@ public static void setUp() throws Exception {
     key = String.format("projects/%s/locations/%s/keyRings/%s/cryptoKeys/%s",
         options.getProjectId(), keyLocation, keyRing, keyName);
   }
-  
+
   static void deleteStaleTestDatabases(String instanceId, String baseDbId) {
     Timestamp now = Timestamp.now();
     Pattern samplePattern = getTestDbIdPattern(baseDbId);
@@ -328,6 +328,9 @@ public void testSample() throws Exception {
               "Backup %s on database %s pending:",
               backupId.getName(),
               dbId.getName()));
+      assertThat(out).contains(
+              "Copy Backup Operations"
+      );
     } catch (SpannerException e) {
       assertThat(e.getErrorCode()).isEqualTo(ErrorCode.INVALID_ARGUMENT);
       assertThat(e.getMessage()).contains("Cannot evaluate filter expression");
@@ -407,7 +410,7 @@ public void testSample() throws Exception {
     out = runSample("deletebackup");
     assertThat(out).contains("Deleted backup [" + backupId + "]");
   }
-  
+
   @Test
   public void testEncryptedDatabaseAndBackupSamples() throws Exception {
     String projectId = spanner.getOptions().getProjectId();
@@ -510,7 +513,7 @@ public void testCreateInstanceSample() {
   private static int countOccurrences(String input, String search) {
     return input.split(search).length - 1;
   }
-  
+
   private static String toComparableId(String baseId, String existingId) {
     String zeroUuid = "00000000-0000-0000-0000-0000-00000000";
     int shouldBeLength = (baseId + "-" + zeroUuid).length();
@@ -523,7 +526,7 @@ private static Pattern getTestDbIdPattern(String baseDbId) {
         baseDbId + "-[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{8}",
         Pattern.CASE_INSENSITIVE);
   }
-  
+
   static String formatForTest(String name) {
     return name + "-" + UUID.randomUUID().toString().substring(0, DBID_LENGTH);
   }
