Keyvault samples unique key names

Keyvault tests and samples could fail if aprevious run had failed between key delete and completion of key purge due to duplicate name error.  Resolved by adding systemtime to key name strings

sdk/android/azure-samples/src/main/java/com/azure/android/keyvault/certificates/BackupAndRestoreOperationsKeyvaultCertificates.java

@@ -53,6 +53,8 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
                 .credential(clientSecretCredential)
             .buildClient();
 
+        String certificateName = "certificateName" + System.currentTimeMillis();
+
         // Let's create a self-signed certificate valid for 1 year. If the certificate already exists in the key vault,
         // then a new version of the certificate is created.
         CertificatePolicy policy = new CertificatePolicy("Self", "CN=SelfSignedJavaPkcs12")
@@ -64,23 +66,23 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
         tags.put("foo", "bar");
 
         SyncPoller<CertificateOperation, KeyVaultCertificateWithPolicy> certificatePoller =
-            certificateClient.beginCreateCertificate("certificateName", policy, true, tags);
+            certificateClient.beginCreateCertificate(certificateName, policy, true, tags);
         certificatePoller.waitUntil(LongRunningOperationStatus.SUCCESSFULLY_COMPLETED);
 
         KeyVaultCertificate cert = certificatePoller.getFinalResult();
 
         // Backups are good to have, if in case certificates get accidentally deleted by you.
         // For long term storage, it is ideal to write the backup to a file.
         String backupFilePath = "YOUR_BACKUP_FILE_PATH";
-        byte[] certificateBackup = certificateClient.backupCertificate("certificateName");
+        byte[] certificateBackup = certificateClient.backupCertificate(certificateName);
 
         System.out.printf("Backed up certificate with back up blob length %d", certificateBackup.length);
 
         writeBackupToFile(certificateBackup, backupFilePath);
 
         // The certificate is no longer in use, so you delete it.
         SyncPoller<DeletedCertificate, Void> deletedCertificatePoller =
-            certificateClient.beginDeleteCertificate("certificateName");
+            certificateClient.beginDeleteCertificate(certificateName);
         // Deleted Certificate is accessible as soon as polling beings.
         PollResponse<DeletedCertificate> pollResponse = deletedCertificatePoller.poll();
 
@@ -93,7 +95,7 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
         Thread.sleep(30000);
 
         // If the vault is soft-delete enabled, then you need to purge the certificate as well for permanent deletion.
-        certificateClient.purgeDeletedCertificateWithResponse("certificateName", new Context("key1", "value1"));
+        certificateClient.purgeDeletedCertificateWithResponse(certificateName, new Context("key1", "value1"));
 
         // To ensure the certificate is purged server-side.
         Thread.sleep(15000);

sdk/android/azure-samples/src/main/java/com/azure/android/keyvault/certificates/HelloWorldKeyvaultCertificates.java

@@ -47,6 +47,9 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
                 .credential(clientSecretCredential)
                 .buildClient();
 
+        String certificateName = "certificateName" + System.currentTimeMillis();
+        String myCertificate = "myCertificate" + System.currentTimeMillis();
+
         // Let's create a self-signed certificate valid for 1 year. If the certificate already exists in the key vault,
         // then a new version of the certificate is created.
         CertificatePolicy policy = new CertificatePolicy("Self", "CN=SelfSignedJavaPkcs12")
@@ -59,13 +62,13 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
         tags.put("foo", "bar");
 
         SyncPoller<CertificateOperation, KeyVaultCertificateWithPolicy> certificatePoller =
-            certificateClient.beginCreateCertificate("certificateName", policy, true, tags);
+            certificateClient.beginCreateCertificate(certificateName, policy, true, tags);
         certificatePoller.waitUntil(LongRunningOperationStatus.SUCCESSFULLY_COMPLETED);
 
         KeyVaultCertificate cert = certificatePoller.getFinalResult();
 
         // Let's get the latest version of the certificate from the key vault.
-        KeyVaultCertificate certificate = certificateClient.getCertificate("certificateName");
+        KeyVaultCertificate certificate = certificateClient.getCertificate(certificateName);
 
         System.out.printf("Certificate is returned with name %s and secret id %s \n",
             certificate.getProperties().getName(), certificate.getSecretId());
@@ -90,19 +93,19 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
         System.out.printf("Issuer retrieved with name %s and provider %s", myIssuer.getName(), myIssuer.getProvider());
 
         // Let's create a certificate signed by our issuer.
-        certificateClient.beginCreateCertificate("myCertificate",
+        certificateClient.beginCreateCertificate(myCertificate,
                 new CertificatePolicy("myIssuer", "CN=SelfSignedJavaPkcs12"), true, tags)
             .waitUntil(LongRunningOperationStatus.SUCCESSFULLY_COMPLETED);
 
         // Let's get the latest version of our certificate from the key vault.
-        KeyVaultCertificate myCert = certificateClient.getCertificate("myCertificate");
+        KeyVaultCertificate myCert = certificateClient.getCertificate(myCertificate);
 
         System.out.printf("Certificate is returned with name %s and secret id %s \n", myCert.getProperties().getName(),
             myCert.getSecretId());
 
         // The certificates and issuers are no longer needed, need to delete it from the key vault.
         SyncPoller<DeletedCertificate, Void> deletedCertificatePoller =
-            certificateClient.beginDeleteCertificate("certificateName");
+            certificateClient.beginDeleteCertificate(certificateName);
         // Deleted certificate is accessible as soon as polling beings.
         PollResponse<DeletedCertificate> pollResponse = deletedCertificatePoller.poll();
 
@@ -112,7 +115,7 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
         deletedCertificatePoller.waitForCompletion();
 
         SyncPoller<DeletedCertificate, Void> deletedCertPoller =
-            certificateClient.beginDeleteCertificate("myCertificate");
+            certificateClient.beginDeleteCertificate(myCertificate);
         // Deleted certificate is accessible as soon as polling beings.
         PollResponse<DeletedCertificate> deletePollResponse = deletedCertPoller.poll();
 
@@ -130,7 +133,7 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
         Thread.sleep(30000);
 
         // If the key vault is soft-delete enabled, then deleted certificates need to be purged for permanent deletion.
-        certificateClient.purgeDeletedCertificate("certificateName");
-        certificateClient.purgeDeletedCertificate("myCertificate");
+        certificateClient.purgeDeletedCertificate(certificateName);
+        certificateClient.purgeDeletedCertificate(myCertificate);
     }
 }

sdk/android/azure-samples/src/main/java/com/azure/android/keyvault/certificates/ListOperationsKeyvaultCertificates.java

@@ -44,14 +44,17 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
                 .credential(clientSecretCredential)
                 .buildClient();
 
+        String certName = "certName" + System.currentTimeMillis();
+        String myCertificate = "myCertificate" + System.currentTimeMillis();
+
         // Let's create a self-signed certificate valid for 1 year. If the certificate already exists in the key vault,
         // then a new version of the certificate is created.
         CertificatePolicy policy = new CertificatePolicy("Self", "CN=SelfSignedJavaPkcs12");
         Map<String, String> tags = new HashMap<>();
         tags.put("foo", "bar");
 
         SyncPoller<CertificateOperation, KeyVaultCertificateWithPolicy> certificatePoller =
-            certificateClient.beginCreateCertificate("certName", policy, true, tags);
+            certificateClient.beginCreateCertificate(certName, policy, true, tags);
         certificatePoller.waitUntil(LongRunningOperationStatus.SUCCESSFULLY_COMPLETED);
 
         KeyVaultCertificate cert = certificatePoller.getFinalResult();
@@ -63,7 +66,7 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
         System.out.printf("Issuer created with name %s and provider %s", myIssuer.getName(), myIssuer.getProvider());
 
         // Let's create a certificate signed by our issuer.
-        certificateClient.beginCreateCertificate("myCertificate",
+        certificateClient.beginCreateCertificate(myCertificate,
             new CertificatePolicy("myIssuer", "CN=SignedJavaPkcs12"), true, tags)
             .waitUntil(LongRunningOperationStatus.SUCCESSFULLY_COMPLETED);
 
@@ -78,7 +81,7 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
         }
 
         // Let's list all certificate versions of the certificate.
-        for (CertificateProperties certificate : certificateClient.listPropertiesOfCertificateVersions("myCertificate")) {
+        for (CertificateProperties certificate : certificateClient.listPropertiesOfCertificateVersions(myCertificate)) {
             KeyVaultCertificate certificateWithAllProperties =
                 certificateClient.getCertificateVersion(certificate.getName(), certificate.getVersion());
 

sdk/android/azure-samples/src/main/java/com/azure/android/keyvault/certificates/ManagingDeletedCertificatesAsyncKeyvaultCertificates.java

@@ -44,6 +44,8 @@ deleted certificates to be retained for a given retention period (90 days). Duri
                 .credential(clientSecretCredential)
                 .buildAsyncClient();
 
+        String certificateName = "certificateName" + System.currentTimeMillis();
+
         // Let's create a self-signed certificate valid for 1 year. If the certificate already exists in the key vault,
         // then a new version of the certificate is created.
         CertificatePolicy policy = new CertificatePolicy("Self", "CN=SelfSignedJavaPkcs12")
@@ -54,7 +56,7 @@ deleted certificates to be retained for a given retention period (90 days). Duri
         Map<String, String> tags = new HashMap<>();
         tags.put("foo", "bar");
 
-        certificateAsyncClient.beginCreateCertificate("certificateName", policy, true, tags)
+        certificateAsyncClient.beginCreateCertificate(certificateName, policy, true, tags)
             .subscribe(pollResponse -> {
                 System.out.println("---------------------------------------------------------------------------------");
                 System.out.println(pollResponse.getStatus());
@@ -65,7 +67,7 @@ deleted certificates to be retained for a given retention period (90 days). Duri
         Thread.sleep(22000);
 
         // The certificate is no longer needed, need to delete it from the key vault.
-        certificateAsyncClient.beginDeleteCertificate("certificateName")
+        certificateAsyncClient.beginDeleteCertificate(certificateName)
             .subscribe(pollResponse -> {
                 System.out.println("Delete Status: " + pollResponse.getStatus().toString());
                 System.out.println("Delete Certificate Name: " + pollResponse.getValue().getName());
@@ -77,7 +79,7 @@ deleted certificates to be retained for a given retention period (90 days). Duri
 
         // We accidentally deleted the certificate. Let's recover it.
         // A deleted certificate can only be recovered if the key vault is soft-delete enabled.
-        certificateAsyncClient.beginRecoverDeletedCertificate("certificateName")
+        certificateAsyncClient.beginRecoverDeletedCertificate(certificateName)
             .subscribe(pollResponse -> {
                 System.out.println("Recovery Status: " + pollResponse.getStatus().toString());
                 System.out.println("Recover Certificate Name: " + pollResponse.getValue().getName());
@@ -88,7 +90,7 @@ deleted certificates to be retained for a given retention period (90 days). Duri
         Thread.sleep(10000);
 
         // The certificate is no longer needed, need to delete it from the key vault.
-        certificateAsyncClient.beginDeleteCertificate("certificateName")
+        certificateAsyncClient.beginDeleteCertificate(certificateName)
             .subscribe(pollResponse -> {
                 System.out.println("Delete Status: " + pollResponse.getStatus().toString());
                 System.out.println("Delete Certificate Name: " + pollResponse.getValue().getName());
@@ -106,7 +108,7 @@ deleted certificates to be retained for a given retention period (90 days). Duri
         Thread.sleep(15000);
 
         // If the keyvault is soft-delete enabled, then deleted certificates need to be purged for permanent deletion.
-        certificateAsyncClient.purgeDeletedCertificateWithResponse("certificateName")
+        certificateAsyncClient.purgeDeletedCertificateWithResponse(certificateName)
             .subscribe(purgeResponse ->
                 System.out.printf("Purge Status response %d %n", purgeResponse.getStatusCode()));
 

sdk/android/azure-samples/src/main/java/com/azure/android/keyvault/keys/BackupAndRestoreOperationsKeyvaultKeys.java

@@ -52,21 +52,23 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
             .credential(clientSecretCredential)
             .buildClient();
 
+        String backupCloudRsaKey = "BackupCloudRsaKey" + System.currentTimeMillis();
+
         // Let's create an RSA key valid for 1 year. If the key already exists in the key vault, then a new version of
         // the key is created.
-        keyClient.createRsaKey(new CreateRsaKeyOptions("BackupCloudRsaKey")
+        keyClient.createRsaKey(new CreateRsaKeyOptions(backupCloudRsaKey)
             .setExpiresOn(OffsetDateTime.now().plusYears(1))
             .setKeySize(2048));
 
         // Backups are good to have, if in case keys get accidentally deleted by you.
         // For long term storage, it is ideal to write the backup to a file.
         String backupFilePath = "java/com/azuresamples/keyvault";
-        byte[] keyBackup = keyClient.backupKey("BackupCloudRsaKey");
+        byte[] keyBackup = keyClient.backupKey(backupCloudRsaKey);
 
         writeBackupToFile(keyBackup, backupFilePath);
 
         // The RSA key is no longer in use, so you delete it.
-        SyncPoller<DeletedKey, Void> rsaDeletedKeyPoller = keyClient.beginDeleteKey("BackupCloudRsaKey");
+        SyncPoller<DeletedKey, Void> rsaDeletedKeyPoller = keyClient.beginDeleteKey(backupCloudRsaKey);
         PollResponse<DeletedKey> pollResponse = rsaDeletedKeyPoller.poll();
         DeletedKey rsaDeletedKey = pollResponse.getValue();
 
@@ -80,7 +82,7 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
         Thread.sleep(30000);
 
         // If the vault is soft-delete enabled, then you need to purge the key as well for permanent deletion.
-        keyClient.purgeDeletedKey("BackupCloudRsaKey");
+        keyClient.purgeDeletedKey(backupCloudRsaKey);
 
         // To ensure the key is purged server-side.
         Thread.sleep(15000);

sdk/android/azure-samples/src/main/java/com/azure/android/keyvault/keys/HelloWorldKeyvaultKeys.java

@@ -48,18 +48,20 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
             .credential(clientSecretCredential)
             .buildClient();
 
+        String helloCloudRsaKey = "HelloCloudRsaKey" + System.currentTimeMillis();
+
         // Let's create an RSA key valid for 1 year. If the key already exists in the key vault, then a new version of
         // the key is created.
         Response<KeyVaultKey> createKeyResponse =
-            keyClient.createRsaKeyWithResponse(new CreateRsaKeyOptions("HelloCloudRsaKey")
+            keyClient.createRsaKeyWithResponse(new CreateRsaKeyOptions(helloCloudRsaKey)
                 .setExpiresOn(OffsetDateTime.now().plusYears(1))
                 .setKeySize(2048), new Context("key1", "value1"));
 
         // Let's validate the create key operation succeeded using the status code information in the response.
         Log.i(TAG, String.format("Create Key operation succeeded with status code %s \n", createKeyResponse.getStatusCode()));
 
         // Let's get the RSA key from the key vault.
-        KeyVaultKey cloudRsaKey = keyClient.getKey("HelloCloudRsaKey");
+        KeyVaultKey cloudRsaKey = keyClient.getKey(helloCloudRsaKey);
 
         Log.i(TAG, String.format("Key is returned with name %s and type %s \n", cloudRsaKey.getName(),
             cloudRsaKey.getKeyType()));
@@ -75,12 +77,12 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
         // We need the RSA key with bigger key size, so you want to update the key in key vault to ensure it has the
         // required size. Calling createRsaKey() on an existing key creates a new version of the key in the key vault
         // with the new specified size.
-        keyClient.createRsaKey(new CreateRsaKeyOptions("HelloCloudRsaKey")
+        keyClient.createRsaKey(new CreateRsaKeyOptions(helloCloudRsaKey)
             .setExpiresOn(OffsetDateTime.now().plusYears(1))
             .setKeySize(4096));
 
         // The RSA key is no longer needed, need to delete it from the key vault.
-        SyncPoller<DeletedKey, Void> rsaDeletedKeyPoller = keyClient.beginDeleteKey("HelloCloudRsaKey");
+        SyncPoller<DeletedKey, Void> rsaDeletedKeyPoller = keyClient.beginDeleteKey(helloCloudRsaKey);
         PollResponse<DeletedKey> pollResponse = rsaDeletedKeyPoller.poll();
         DeletedKey rsaDeletedKey = pollResponse.getValue();
 
@@ -94,7 +96,7 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
         Thread.sleep(30000);
 
         // If the keyvault is soft-delete enabled, then deleted keys need to be purged for permanent deletion.
-        keyClient.purgeDeletedKey("HelloCloudRsaKey");
+        keyClient.purgeDeletedKey(helloCloudRsaKey);
         Log.i(TAG, "HelloCloudRsaKey purged from vault");
     }
 }

sdk/android/azure-samples/src/main/java/com/azure/android/keyvault/keys/KeyRotationAsyncKeyvaultKeys.java

@@ -46,7 +46,7 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
             .buildAsyncClient();
 
         // Let's create an RSA key.
-        String keyName = "MyKey";
+        String keyName = "MyKey" + System.currentTimeMillis();
         keyAsyncClient.createRsaKey(new CreateRsaKeyOptions(keyName).setKeySize(2048))
             .subscribe(originalKey ->
                 Log.i(TAG, String.format("Key created with name: %s, and type: %s%n", originalKey.getName(),

sdk/android/azure-samples/src/main/java/com/azure/android/keyvault/secrets/BackupAndRestoreOperationsKeyvaultSecrets.java

@@ -51,22 +51,24 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
                 .credential(clientSecretCredential)
                 .buildClient();
 
+        String storageAccountPassword = "StorageAccountPassword" + System.currentTimeMillis();
+
         // Let's create secrets holding storage account credentials valid for 1 year. If the secret already exists in
         // the key vault, then a new version of the secret is created.
-        client.setSecret(new KeyVaultSecret("StorageAccountPassword", "f4G34fMh8v-fdsgjsk2323=-asdsdfsdf")
+        client.setSecret(new KeyVaultSecret(storageAccountPassword, "f4G34fMh8v-fdsgjsk2323=-asdsdfsdf")
             .setProperties(new SecretProperties()
                 .setExpiresOn(OffsetDateTime.now().plusYears(1))));
 
         // Backups are good to have, if in case secrets get accidentally deleted by you.
         // For long term storage, it is ideal to write the backup to a file.
         String backupFilePath = "YOUR_BACKUP_FILE_PATH";
-        byte[] secretBackup = client.backupSecret("StorageAccountPassword");
+        byte[] secretBackup = client.backupSecret(storageAccountPassword);
 
         writeBackupToFile(secretBackup, backupFilePath);
 
         // The storage account secret is no longer in use, so you delete it.
         SyncPoller<DeletedSecret, Void> deletedStorageSecretPoller =
-            client.beginDeleteSecret("StorageAccountPassword");
+            client.beginDeleteSecret(storageAccountPassword);
         PollResponse<DeletedSecret>  pollResponse = deletedStorageSecretPoller.poll();
         DeletedSecret deletedStorageSecret = pollResponse.getValue();
 
@@ -80,7 +82,7 @@ public static void main(String endpoint, ClientSecretCredential clientSecretCred
         Thread.sleep(30000);
 
         // If the vault is soft-delete enabled, then you need to purge the secret as well for permanent deletion.
-        client.purgeDeletedSecret("StorageAccountPassword");
+        client.purgeDeletedSecret(storageAccountPassword);
 
         // To ensure the secret is purged server-side.
         Thread.sleep(15000);