使用和锁定保留政策

namespace gcs = ::google::cloud::storage; using ::google::cloud::StatusOr; [](gcs::Client client, std::string const& bucket_name,    std::chrono::seconds period) {   StatusOr<gcs::BucketMetadata> original =       client.GetBucketMetadata(bucket_name);   if (!original) throw std::move(original).status();    StatusOr<gcs::BucketMetadata> patched = client.PatchBucket(       bucket_name,       gcs::BucketMetadataPatchBuilder().SetRetentionPolicy(period),       gcs::IfMetagenerationMatch(original->metageneration()));   if (!patched) throw std::move(patched).status();    if (!patched->has_retention_policy()) {     std::cout << "The bucket " << patched->name()               << " does not have a retention policy set.\n";     return;   }    std::cout << "The bucket " << patched->name()             << " retention policy is set to " << patched->retention_policy()             << "\n"; }

namespace gcs = ::google::cloud::storage; using ::google::cloud::StatusOr; [](gcs::Client client, std::string const& bucket_name) {   StatusOr<gcs::BucketMetadata> original =       client.GetBucketMetadata(bucket_name);   if (!original) throw std::move(original).status();    StatusOr<gcs::BucketMetadata> patched = client.PatchBucket(       bucket_name, gcs::BucketMetadataPatchBuilder().ResetRetentionPolicy(),       gcs::IfMetagenerationMatch(original->metageneration()));   if (!patched) throw std::move(patched).status();    if (!patched->has_retention_policy()) {     std::cout << "The bucket " << patched->name()               << " does not have a retention policy set.\n";     return;   }    std::cout << "The bucket " << patched->name()             << " retention policy is set to " << patched->retention_policy()             << ". This is unexpected, maybe a concurrent change by another"             << " application?\n"; }

 using Google.Cloud.Storage.V1; using System; using static Google.Apis.Storage.v1.Data.Bucket;  public class SetRetentionPolicySample {     /// <summary>     /// Sets the bucket's retention policy.     /// </summary>     /// <param name="bucketName">The name of the bucket.</param>     /// <param name="retentionPeriod">The duration in seconds that objects need to be retained. The retention policy enforces a minimum retention     /// time for all objects contained in the bucket, based on their creation time. Any     /// attempt to overwrite or delete objects younger than the retention period will     /// result in a PERMISSION_DENIED error. An unlocked retention policy can be modified     /// or removed from the bucket via a storage.buckets.update operation. A locked retention     /// policy cannot be removed or shortened in duration for the lifetime of the bucket.     /// Attempting to remove or decrease the period of a locked retention policy will result     /// in a PERMISSION_DENIED error.</param>     public RetentionPolicyData SetRetentionPolicy(         string bucketName = "your-unique-bucket-name",         long retentionPeriod = 10)     {         var storage = StorageClient.Create();         var bucket = storage.GetBucket(bucketName);         bucket.RetentionPolicy = new RetentionPolicyData { RetentionPeriod = retentionPeriod };          bucket = storage.UpdateBucket(bucket);          Console.WriteLine($"Retention policy for {bucketName} was set to {retentionPeriod}");         return bucket.RetentionPolicy;     } }

 using Google.Cloud.Storage.V1; using System;  public class RemoveRetentionPolicySample {     public void RemoveRetentionPolicy(string bucketName = "your-unique-bucket-name")     {         var storage = StorageClient.Create();         var bucket = storage.GetBucket(bucketName);         if (bucket.RetentionPolicy != null)         {             bool isLocked = bucket.RetentionPolicy.IsLocked ?? false;             if (isLocked)             {                 throw new Exception("Retention Policy is locked.");             }              bucket.RetentionPolicy.RetentionPeriod = null;             storage.UpdateBucket(bucket);              Console.WriteLine($"Retention period for {bucketName} has been removed.");         }     } }

import ( 	"context" 	"fmt" 	"io" 	"time"  	"cloud.google.com/go/storage" )  // setRetentionPolicy sets the bucket retention period. func setRetentionPolicy(w io.Writer, bucketName string, retentionPeriod time.Duration) error { 	// bucketName := "bucket-name" 	// retentionPeriod := time.Second 	ctx := context.Background() 	client, err := storage.NewClient(ctx) 	if err != nil { 		return fmt.Errorf("storage.NewClient: %w", err) 	} 	defer client.Close()  	ctx, cancel := context.WithTimeout(ctx, time.Second*10) 	defer cancel()  	bucket := client.Bucket(bucketName) 	bucketAttrsToUpdate := storage.BucketAttrsToUpdate{ 		RetentionPolicy: &storage.RetentionPolicy{ 			RetentionPeriod: retentionPeriod, 		}, 	} 	if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil { 		return fmt.Errorf("Bucket(%q).Update: %w", bucketName, err) 	} 	fmt.Fprintf(w, "Retention policy for %v was set to %v\n", bucketName, bucketAttrsToUpdate.RetentionPolicy.RetentionPeriod) 	return nil } 

import ( 	"context" 	"fmt" 	"io" 	"time"  	"cloud.google.com/go/storage" )  // removeRetentionPolicy removes bucket retention policy. func removeRetentionPolicy(w io.Writer, bucketName string) error { 	// bucketName := "bucket-name" 	ctx := context.Background() 	client, err := storage.NewClient(ctx) 	if err != nil { 		return fmt.Errorf("storage.NewClient: %w", err) 	} 	defer client.Close()  	ctx, cancel := context.WithTimeout(ctx, time.Second*50) 	defer cancel()  	bucket := client.Bucket(bucketName) 	attrs, err := bucket.Attrs(ctx) 	if err != nil { 		return fmt.Errorf("Bucket(%q).Attrs: %w", bucketName, err) 	} 	if attrs.RetentionPolicy.IsLocked { 		return fmt.Errorf("retention policy is locked") 	}  	bucketAttrsToUpdate := storage.BucketAttrsToUpdate{ 		RetentionPolicy: &storage.RetentionPolicy{}, 	} 	if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil { 		return fmt.Errorf("Bucket(%q).Update: %w", bucketName, err) 	} 	fmt.Fprintf(w, "Retention period for %v has been removed\n", bucketName) 	return nil } 

 import com.google.cloud.storage.Bucket; import com.google.cloud.storage.Storage; import com.google.cloud.storage.Storage.BucketTargetOption; import com.google.cloud.storage.StorageException; import com.google.cloud.storage.StorageOptions; import java.time.Duration;  public class SetRetentionPolicy {   public static void setRetentionPolicy(       String projectId, String bucketName, Long retentionPeriodSeconds) throws StorageException {     // The ID of your GCP project     // String projectId = "your-project-id";      // The ID of your GCS bucket     // String bucketName = "your-unique-bucket-name";      // The retention period for objects in bucket     // Long retentionPeriodSeconds = 3600L; // 1 hour in seconds      Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();      // first look up the bucket so we will have its metageneration     Bucket bucket = storage.get(bucketName);     Bucket bucketWithRetentionPolicy =         storage.update(             bucket.toBuilder()                 .setRetentionPeriodDuration(Duration.ofSeconds(retentionPeriodSeconds))                 .build(),             BucketTargetOption.metagenerationMatch());      System.out.println(         "Retention period for "             + bucketName             + " is now "             + bucketWithRetentionPolicy.getRetentionPeriodDuration());   } }

 import com.google.cloud.storage.Bucket; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageException; import com.google.cloud.storage.StorageOptions;  public class RemoveRetentionPolicy {   public static void removeRetentionPolicy(String projectId, String bucketName)       throws StorageException, IllegalArgumentException {     // The ID of your GCP project     // String projectId = "your-project-id";      // The ID of your GCS bucket     // String bucketName = "your-unique-bucket-name";      Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();      Bucket bucket =         storage.get(             bucketName, Storage.BucketGetOption.fields(Storage.BucketField.RETENTION_POLICY));     if (bucket.retentionPolicyIsLocked() != null && bucket.retentionPolicyIsLocked()) {       throw new IllegalArgumentException(           "Unable to remove retention policy as retention policy is locked.");     }      bucket.toBuilder().setRetentionPeriod(null).build().update();      System.out.println("Retention policy for " + bucketName + " has been removed");   } }

/**  * TODO(developer): Uncomment the following lines before running the sample.  */ // The ID of your GCS bucket // const bucketName = 'your-unique-bucket-name';  // The retention period for objects in bucket // const retentionPeriod = 3600; // 1 hour in seconds  // Imports the Google Cloud client library const {Storage} = require('@google-cloud/storage');  // Creates a client const storage = new Storage();  async function setRetentionPolicy() {   const [metadata] = await storage     .bucket(bucketName)     .setRetentionPeriod(retentionPeriod);   console.log(     `Bucket ${bucketName} retention period set for ${metadata.retentionPolicy.retentionPeriod} seconds.`   ); }  setRetentionPolicy().catch(console.error);

/**  * TODO(developer): Uncomment the following lines before running the sample.  */ // The ID of your GCS bucket // const bucketName = 'your-unique-bucket-name';  // Imports the Google Cloud client library const {Storage} = require('@google-cloud/storage');  // Creates a client const storage = new Storage();  async function removeRetentionPolicy() {   const [metadata] = await storage.bucket(bucketName).getMetadata();   if (metadata.retentionPolicy && metadata.retentionPolicy.isLocked) {     console.log(       'Unable to remove retention period as retention policy is locked.'     );     return null;   } else {     const results = await storage.bucket(bucketName).removeRetentionPeriod();     console.log(`Removed bucket ${bucketName} retention policy.`);     return results;   } }  removeRetentionPolicy().catch(console.error);

use Google\Cloud\Storage\StorageClient;  /**  * Sets a bucket's retention policy.  *  * @param string $bucketName The name of your Cloud Storage bucket.  *        (e.g. 'my-bucket')  * @param int $retentionPeriod The retention period for objects in bucket, in seconds.  *        (e.g. 3600)  */ function set_retention_policy(string $bucketName, int $retentionPeriod): void {     $storage = new StorageClient();     $bucket = $storage->bucket($bucketName);     $bucket->update([         'retentionPolicy' => [             'retentionPeriod' => $retentionPeriod         ]]);     printf('Bucket %s retention period set to %s seconds' . PHP_EOL, $bucketName,         $retentionPeriod); }

use Google\Cloud\Storage\StorageClient;  /**  * Removes a bucket's retention policy.  *  * @param string $bucketName The name of your Cloud Storage bucket.  *        (e.g. 'my-bucket')  */ function remove_retention_policy(string $bucketName): void {     $storage = new StorageClient();     $bucket = $storage->bucket($bucketName);     $bucket->reload();      if (array_key_exists('isLocked', $bucket->info()['retentionPolicy']) &&         $bucket->info()['retentionPolicy']['isLocked']) {         printf('Unable to remove retention period as retention policy is locked.' . PHP_EOL);         return;     }      $bucket->update([         'retentionPolicy' => []     ]);     printf('Removed bucket %s retention policy' . PHP_EOL, $bucketName); }

from google.cloud import storage   def set_retention_policy(bucket_name, retention_period):     """Defines a retention policy on a given bucket"""     # bucket_name = "my-bucket"     # retention_period = 10      storage_client = storage.Client()     bucket = storage_client.bucket(bucket_name)      bucket.retention_period = retention_period     bucket.patch()      print(         "Bucket {} retention period set for {} seconds".format(             bucket.name, bucket.retention_period         )     )  

from google.cloud import storage   def remove_retention_policy(bucket_name):     """Removes the retention policy on a given bucket"""     # bucket_name = "my-bucket"      storage_client = storage.Client()     bucket = storage_client.bucket(bucket_name)     bucket.reload()      if bucket.retention_policy_locked:         print(             "Unable to remove retention period as retention policy is locked."         )         return      bucket.retention_period = None     bucket.patch()      print(f"Removed bucket {bucket.name} retention policy")  

def set_retention_policy bucket_name:, retention_period:   # The ID of your GCS bucket   # bucket_name = "your-unique-bucket-name"    # The retention period for objects in bucket   # retention_period = 3600 # 1 hour in seconds    require "google/cloud/storage"    storage = Google::Cloud::Storage.new   bucket  = storage.bucket bucket_name    bucket.retention_period = retention_period    puts "Retention period for #{bucket_name} is now #{bucket.retention_period} seconds." end

def remove_retention_policy bucket_name:   # The ID of your GCS bucket   # bucket_name = "your-unique-bucket-name"    require "google/cloud/storage"    storage = Google::Cloud::Storage.new   bucket  = storage.bucket bucket_name    if !bucket.retention_policy_locked?     bucket.retention_period = nil     puts "Retention policy for #{bucket_name} has been removed."   else     puts "Policy is locked and retention policy can't be removed."   end end

namespace gcs = ::google::cloud::storage; using ::google::cloud::StatusOr; [](gcs::Client client, std::string const& bucket_name) {   StatusOr<gcs::BucketMetadata> original =       client.GetBucketMetadata(bucket_name);   if (!original) throw std::move(original).status();    StatusOr<gcs::BucketMetadata> updated_metadata =       client.LockBucketRetentionPolicy(bucket_name,                                        original->metageneration());   if (!updated_metadata) throw std::move(updated_metadata).status();    if (!updated_metadata->has_retention_policy()) {     std::cerr << "The bucket " << updated_metadata->name()               << " does not have a retention policy, even though the"               << " operation to set it was successful.\n"               << "This is unexpected, and may indicate that another"               << " application has modified the bucket concurrently.\n";     return;   }    std::cout << "Retention policy successfully locked for bucket "             << updated_metadata->name() << "\nNew retention policy is: "             << updated_metadata->retention_policy()             << "\nFull metadata: " << *updated_metadata << "\n"; }

 using Google.Cloud.Storage.V1; using System;  public class LockRetentionPolicySample {     /// <summary>     /// Locks the retention policy of a bucket. This is a one-way process: once a retention     /// policy is locked, it cannot be shortened, removed or unlocked, although it can     /// be increased in duration. The lock persists until the bucket is deleted.     /// </summary>     /// <param name="bucketName">The name of the bucket whose retention policy should be locked.</param>     public bool? LockRetentionPolicy(string bucketName = "your-unique-bucket-name")     {         var storage = StorageClient.Create();         var bucket = storage.GetBucket(bucketName);         storage.LockBucketRetentionPolicy(bucketName, bucket.Metageneration.Value);         bucket = storage.GetBucket(bucketName);         Console.WriteLine($"Retention policy for {bucketName} is now locked");         Console.WriteLine($"Retention policy effective as of {bucket.RetentionPolicy.EffectiveTime}");          return bucket.RetentionPolicy.IsLocked;     } }

import ( 	"context" 	"fmt" 	"io" 	"time"  	"cloud.google.com/go/storage" )  // lockRetentionPolicy locks bucket retention policy. func lockRetentionPolicy(w io.Writer, bucketName string) error { 	// bucketName := "bucket-name" 	ctx := context.Background() 	client, err := storage.NewClient(ctx) 	if err != nil { 		return fmt.Errorf("storage.NewClient: %w", err) 	} 	defer client.Close()  	ctx, cancel := context.WithTimeout(ctx, time.Second*50) 	defer cancel()  	bucket := client.Bucket(bucketName) 	attrs, err := bucket.Attrs(ctx) 	if err != nil { 		return fmt.Errorf("Bucket(%q).Attrs: %w", bucketName, err) 	}  	conditions := storage.BucketConditions{ 		MetagenerationMatch: attrs.MetaGeneration, 	} 	if err := bucket.If(conditions).LockRetentionPolicy(ctx); err != nil { 		return fmt.Errorf("Bucket(%q).LockRetentionPolicy: %w", bucketName, err) 	}  	lockedAttrs, err := bucket.Attrs(ctx) 	if err != nil { 		return fmt.Errorf("Bucket(%q).Attrs: lockedAttrs: %w", bucketName, err) 	}  	fmt.Fprintf(w, "Retention policy for %v is now locked\n", bucketName) 	fmt.Fprintf(w, "Retention policy effective as of %v\n", lockedAttrs.RetentionPolicy.EffectiveTime) 	return nil } 

 import com.google.cloud.storage.Bucket; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageException; import com.google.cloud.storage.StorageOptions; import java.util.Date;  public class LockRetentionPolicy {   public static void lockRetentionPolicy(String projectId, String bucketName)       throws StorageException {     // The ID of your GCP project     // String projectId = "your-project-id";      // The ID of your GCS bucket     // String bucketName = "your-unique-bucket-name";      Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();     Bucket bucket =         storage.get(bucketName, Storage.BucketGetOption.fields(Storage.BucketField.METAGENERATION));     Bucket lockedBucket =         bucket.lockRetentionPolicy(Storage.BucketTargetOption.metagenerationMatch());      System.out.println("Retention period for " + bucketName + " is now locked");     System.out.println(         "Retention policy effective as of " + new Date(lockedBucket.getRetentionEffectiveTime()));   } }

/**  * TODO(developer): Uncomment the following lines before running the sample.  */ // The ID of your GCS bucket // const bucketName = 'your-unique-bucket-name';  // Imports the Google Cloud client library const {Storage} = require('@google-cloud/storage');  // Creates a client const storage = new Storage();  async function lockRetentionPolicy() {   // Gets the current metageneration value for the bucket, required by   // lock_retention_policy   const [unlockedMetadata] = await storage.bucket(bucketName).getMetadata();    // Warning: Once a retention policy is locked, it cannot be unlocked. The   // retention period can only be increased   const [lockedMetadata] = await storage     .bucket(bucketName)     .lock(unlockedMetadata.metageneration);   console.log(`Retention policy for ${bucketName} is now locked`);   console.log(     `Retention policy effective as of ${lockedMetadata.retentionPolicy.effectiveTime}`   );    return lockedMetadata; }  lockRetentionPolicy().catch(console.error);

use Google\Cloud\Storage\StorageClient;  /**  * Locks a bucket's retention policy.  *  * @param string $bucketName The name of your Cloud Storage bucket.  *        (e.g. 'my-bucket')  */ function lock_retention_policy(string $bucketName): void {     $storage = new StorageClient();     $bucket = $storage->bucket($bucketName);     $bucket->reload();     $bucket->lockRetentionPolicy();     printf('Bucket %s retention policy locked' . PHP_EOL, $bucketName); }

from google.cloud import storage   def lock_retention_policy(bucket_name):     """Locks the retention policy on a given bucket"""     # bucket_name = "my-bucket"      storage_client = storage.Client()     # get_bucket gets the current metageneration value for the bucket,     # required by lock_retention_policy.     bucket = storage_client.get_bucket(bucket_name)      # Warning: Once a retention policy is locked it cannot be unlocked     # and retention period can only be increased.     bucket.lock_retention_policy()      print(f"Retention policy for {bucket_name} is now locked")     print(         f"Retention policy effective as of {bucket.retention_policy_effective_time}"     )  

def lock_retention_policy bucket_name:   # The ID of your GCS bucket   # bucket_name = "your-unique-bucket-name"    require "google/cloud/storage"    storage = Google::Cloud::Storage.new   bucket  = storage.bucket bucket_name    # Warning: Once a retention policy is locked it cannot be unlocked   # and retention period can only be increased.   # Uses Bucket#metageneration as a precondition.   bucket.lock_retention_policy!    puts "Retention policy for #{bucket_name} is now locked."   puts "Retention policy effective as of #{bucket.retention_effective_at}." end

namespace gcs = ::google::cloud::storage; using ::google::cloud::StatusOr; [](gcs::Client client, std::string const& bucket_name) {   StatusOr<gcs::BucketMetadata> bucket_metadata =       client.GetBucketMetadata(bucket_name);   if (!bucket_metadata) throw std::move(bucket_metadata).status();    if (!bucket_metadata->has_retention_policy()) {     std::cout << "The bucket " << bucket_metadata->name()               << " does not have a retention policy set.\n";     return;   }    std::cout << "The bucket " << bucket_metadata->name()             << " retention policy is set to "             << bucket_metadata->retention_policy() << "\n"; }

 using Google.Cloud.Storage.V1; using System; using static Google.Apis.Storage.v1.Data.Bucket;  public class GetRetentionPolicySample {     public RetentionPolicyData GetRetentionPolicy(string bucketName = "your-unique-bucket-name")     {         var storage = StorageClient.Create();         var bucket = storage.GetBucket(bucketName);          if (bucket.RetentionPolicy != null)         {             Console.WriteLine("Retention policy:");             Console.WriteLine($"Period: {bucket.RetentionPolicy.RetentionPeriod}");             Console.WriteLine($"Effective time: {bucket.RetentionPolicy.EffectiveTime}");             bool isLocked = bucket.RetentionPolicy.IsLocked ?? false;             Console.WriteLine($"Policy locked: {isLocked}");         }         return bucket.RetentionPolicy;     } }

import ( 	"context" 	"fmt" 	"io" 	"time"  	"cloud.google.com/go/storage" )  // getRetentionPolicy gets bucket retention policy. func getRetentionPolicy(w io.Writer, bucketName string) (*storage.BucketAttrs, error) { 	// bucketName := "bucket-name" 	ctx := context.Background() 	client, err := storage.NewClient(ctx) 	if err != nil { 		return nil, fmt.Errorf("storage.NewClient: %w", err) 	} 	defer client.Close()  	ctx, cancel := context.WithTimeout(ctx, time.Second*10) 	defer cancel()  	attrs, err := client.Bucket(bucketName).Attrs(ctx) 	if err != nil { 		return nil, fmt.Errorf("Bucket(%q).Attrs: %w", bucketName, err) 	} 	if attrs.RetentionPolicy != nil { 		fmt.Fprintln(w, "Retention Policy") 		fmt.Fprintf(w, "period: %v\n", attrs.RetentionPolicy.RetentionPeriod) 		fmt.Fprintf(w, "effective time: %v\n", attrs.RetentionPolicy.EffectiveTime) 		fmt.Fprintf(w, "policy locked: %v\n", attrs.RetentionPolicy.IsLocked) 	} 	return attrs, nil } 

 import com.google.cloud.storage.Bucket; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageException; import com.google.cloud.storage.StorageOptions; import java.util.Date;  public class GetRetentionPolicy {   public static void getRetentionPolicy(String projectId, String bucketName)       throws StorageException {     // The ID of your GCP project     // String projectId = "your-project-id";      // The ID of your GCS bucket     // String bucketName = "your-unique-bucket-name";      Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();     Bucket bucket =         storage.get(             bucketName, Storage.BucketGetOption.fields(Storage.BucketField.RETENTION_POLICY));      System.out.println("Retention Policy for " + bucketName);     System.out.println("Retention Period: " + bucket.getRetentionPeriod());     if (bucket.retentionPolicyIsLocked() != null && bucket.retentionPolicyIsLocked()) {       System.out.println("Retention Policy is locked");     }     if (bucket.getRetentionEffectiveTime() != null) {       System.out.println("Effective Time: " + new Date(bucket.getRetentionEffectiveTime()));     }   } }

/**  * TODO(developer): Uncomment the following lines before running the sample.  */ // The ID of your GCS bucket // const bucketName = 'your-unique-bucket-name';  // Imports the Google Cloud client library const {Storage} = require('@google-cloud/storage');  // Creates a client const storage = new Storage();  async function getRetentionPolicy() {   const [metadata] = await storage.bucket(bucketName).getMetadata();   if (metadata.retentionPolicy) {     const retentionPolicy = metadata.retentionPolicy;     console.log('A retention policy exists!');     console.log(`Period: ${retentionPolicy.retentionPeriod}`);     console.log(`Effective time: ${retentionPolicy.effectiveTime}`);     if (retentionPolicy.isLocked) {       console.log('Policy is locked');     } else {       console.log('Policy is unlocked');     }   } }  getRetentionPolicy().catch(console.error);

use Google\Cloud\Storage\StorageClient;  /**  * Gets a bucket's retention policy.  *  * @param string $bucketName The name of your Cloud Storage bucket.  *        (e.g. 'my-bucket')  */ function get_retention_policy(string $bucketName): void {     $storage = new StorageClient();     $bucket = $storage->bucket($bucketName);     $bucket->reload();      printf('Retention Policy for ' . $bucketName . PHP_EOL);     printf('Retention Period: ' . $bucket->info()['retentionPolicy']['retentionPeriod'] . PHP_EOL);     if (array_key_exists('isLocked', $bucket->info()['retentionPolicy']) &&         $bucket->info()['retentionPolicy']['isLocked']) {         printf('Retention Policy is locked' . PHP_EOL);     }     if ($bucket->info()['retentionPolicy']['effectiveTime']) {         printf('Effective Time: ' . $bucket->info()['retentionPolicy']['effectiveTime'] . PHP_EOL);     } }

from google.cloud import storage   def get_retention_policy(bucket_name):     """Gets the retention policy on a given bucket"""     # bucket_name = "my-bucket"      storage_client = storage.Client()     bucket = storage_client.bucket(bucket_name)     bucket.reload()      print(f"Retention Policy for {bucket_name}")     print(f"Retention Period: {bucket.retention_period}")     if bucket.retention_policy_locked:         print("Retention Policy is locked")      if bucket.retention_policy_effective_time:         print(             f"Effective Time: {bucket.retention_policy_effective_time}"         )  

def get_retention_policy bucket_name:   # The ID of your GCS bucket   # bucket_name = "your-unique-bucket-name"    require "google/cloud/storage"    storage = Google::Cloud::Storage.new   bucket  = storage.bucket bucket_name    puts "Retention policy:"   puts "period: #{bucket.retention_period}"   puts "effective time: #{bucket.retention_effective_at}"   puts "policy locked: #{bucket.retention_policy_locked?}" end