Use versioned objects

namespacegcs=::google::cloud::storage;
[](gcs::Clientclient,std::stringconst&bucket_name){
for(auto&&object_metadata:
client.ListObjects(bucket_name,gcs::Versions{true})){
if(!object_metadata)throwstd::move(object_metadata).status();
std::cout << "bucket_name=" << object_metadata->bucket()
 << ", object_name=" << object_metadata->name()
 << ", generation=" << object_metadata->generation() << "\n";
}
}

usingGoogle.Cloud.Storage.V1 ;
usingSystem;
usingSystem.Collections.Generic;
publicclassListFileArchivedGenerationSample
{
publicIEnumerable<Google.Apis.Storage.v1.Data.Object>ListFileArchivedGeneration(stringbucketName="your-bucket-name")
{
varstorage=StorageClient .Create ();
varstorageObjects=storage.ListObjects(bucketName,options:newListObjectsOptions
{
Versions=true
});
foreach(varstorageObjectinstorageObjects)
{
Console.WriteLine($"Filename: {storageObject.Name}, Generation: {storageObject.Generation}");
}
returnstorageObjects;
}
}

import(
"context"
"fmt"
"io"
"time"
"cloud.google.com/go/storage"
"google.golang.org/api/iterator"
)
// listFilesAllVersion lists both live and noncurrent versions of objects within specified bucket.
funclistFilesAllVersion(wio.Writer ,bucketstring)error{
// bucket := "bucket-name"
ctx:=context.Background()
client,err:=storage.NewClient(ctx)
iferr!=nil{
returnfmt.Errorf("storage.NewClient: %w",err)
}
deferclient.Close()
ctx,cancel:=context.WithTimeout(ctx,time.Second*10)
defercancel()
it:=client.Bucket (bucket).Objects (ctx,&storage.Query {
// Versions true to output all generations of objects
Versions:true,
})
for{
attrs,err:=it.Next()
iferr==iterator.Done{
break
}
iferr!=nil{
returnfmt.Errorf("Bucket(%q).Objects(): %w",bucket,err)
}
fmt.Fprintln(w,attrs.Name,attrs.Generation ,attrs.Metageneration)
}
returnnil
}

importcom.google.api.gax.paging.Page ;
importcom.google.cloud.storage.Blob ;
importcom.google.cloud.storage.Bucket ;
importcom.google.cloud.storage.Storage ;
importcom.google.cloud.storage.StorageOptions ;
publicclass ListObjectsWithOldVersions{
publicstaticvoidlistObjectsWithOldVersions(StringprojectId,StringbucketName){
// 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);
Page<Blob>blobs=bucket.list (Storage.BlobListOption.versions(true));
for(Blob blob:blobs.iterateAll()){
System.out.println(blob.getName()+","+blob.getGeneration());
}
}
}

/**
 * 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
conststorage=newStorage();
asyncfunctionlistFilesWithOldVersions(){
const[files]=awaitstorage.bucket(bucketName).getFiles ({
versions:true,
});
console.log('Files:');
files.forEach(file=>{
console.log(file.name,file.generation);
});
}
listFilesWithOldVersions().catch(console.error);

use Google\Cloud\Storage\StorageClient;
/**
 * List objects in a specified bucket with all archived generations.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * (e.g. 'my-bucket')
 */
function list_file_archived_generations(string $bucketName): void
{
 $storage = new StorageClient();
 $bucket = $storage->bucket($bucketName);
 $objects = $bucket->objects([
 'versions' => true,
 ]);
 foreach ($objects as $object) {
 print($object->name() . ',' . $object->info()['generation'] . PHP_EOL);
 }
}

fromgoogle.cloudimport storage
deflist_file_archived_generations(bucket_name):
"""Lists all the blobs in the bucket with generation."""
 # bucket_name = "your-bucket-name"
 storage_client = storage .Client ()
 blobs = storage_client.list_blobs (bucket_name, versions=True)
 for blob in blobs:
 print(f"{blob.name},{blob.generation}")

deflist_file_archived_generationsbucket_name:
# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
require"google/cloud/storage"
storage=Google::Cloud::Storage .new
bucket=storage.bucketbucket_name
bucket.files .each do|file|
puts"#{file.name},#{file.generation}"
end
end

namespacegcs=::google::cloud::storage;
using::google::cloud::StatusOr;
[](gcs::Clientclient,std::stringconst&source_bucket_name,
std::stringconst&source_object_name,
std::stringconst&destination_bucket_name,
std::stringconst&destination_object_name,
std::int64_tsource_object_generation){
StatusOr<gcs::ObjectMetadata>copy=
client.CopyObject(source_bucket_name,source_object_name,
destination_bucket_name,destination_object_name,
gcs::SourceGeneration{source_object_generation});
if(!copy)throwstd::move(copy).status();
std::cout << "Successfully copied " << source_object_name << " generation "
 << source_object_generation << " in bucket " << source_bucket_name
 << " to bucket " << copy->bucket() << " with name "
 << copy->name()
 << ".\nThe full metadata after the copy is: " << *copy << "\n";
}

usingGoogle.Cloud.Storage.V1 ;
usingSystem;
publicclassCopyFileArchivedGenerationSample
{
publicGoogle.Apis.Storage.v1.Data.ObjectCopyFileArchivedGeneration(
stringsourceBucketName="source-bucket-name",
stringsourceObjectName="source-file",
stringdestBucketName="destination-bucket-name",
stringdestObjectName="destination-file-name",
long?generation=1579287380533984)
{
varstorage=StorageClient .Create ();
varcopyOptions=newCopyObjectOptions
{
SourceGeneration=generation
};
varcopiedFile=storage.CopyObject(sourceBucketName,sourceObjectName,
destBucketName,destObjectName,copyOptions);
Console.WriteLine($"Generation {generation} of the object {sourceBucketName}/{sourceObjectName} "+
$"was copied to to {destBucketName}/{destObjectName}.");
returncopiedFile;
}
}

import(
"context"
"fmt"
"io"
"time"
"cloud.google.com/go/storage"
)
// copyOldVersionOfObject copies a noncurrent version of an object.
funccopyOldVersionOfObject(wio.Writer ,bucket,srcObject,dstObjectstring,genint64)error{
// bucket := "bucket-name"
// srcObject := "source-object-name"
// dstObject := "destination-object-name"
// gen is the generation of srcObject to copy.
// gen := 1587012235914578
ctx:=context.Background()
client,err:=storage.NewClient(ctx)
iferr!=nil{
returnfmt.Errorf("storage.NewClient: %w",err)
}
deferclient.Close()
ctx,cancel:=context.WithTimeout(ctx,time.Second*10)
defercancel()
src:=client.Bucket (bucket).Object (srcObject)
dst:=client.Bucket (bucket).Object (dstObject)
// Optional: set a generation-match precondition to avoid potential race
// conditions and data corruptions. The request to copy is aborted if the
// object's generation number does not match your precondition.
// For a dst object that does not yet exist, set the DoesNotExist precondition.
dst=dst.If(storage.Conditions {DoesNotExist:true})
// If the destination object already exists in your bucket, set instead a
// generation-match precondition using its generation number.
// attrs, err := dst.Attrs(ctx)
// if err != nil {
// 	return fmt.Errorf("object.Attrs: %w", err)
// }
// dst = dst.If(storage.Conditions{GenerationMatch: attrs.Generation})
if_,err:=dst.CopierFrom (src.Generation (gen)).Run(ctx);err!=nil{
returnfmt.Errorf("Object(%q).CopierFrom(%q).Generation(%v).Run: %w",dstObject,srcObject,gen,err)
}
fmt.Fprintf(w,"Generation %v of object %v in bucket %v was copied to %v\n",gen,srcObject,bucket,dstObject)
returnnil
}

importcom.google.cloud.storage.BlobId ;
importcom.google.cloud.storage.Storage ;
importcom.google.cloud.storage.StorageOptions ;
publicclass CopyOldVersionOfObject{
publicstaticvoidcopyOldVersionOfObject(
StringprojectId,
StringbucketName,
StringobjectToCopy,
longgenerationToCopy,
StringnewObjectName){
// The ID of your GCP project
// String projectId = "your-project-id";
// The ID of your GCS bucket
// String bucketName = "your-unique-bucket-name";
// The ID of the GCS object to copy an old version of
// String objectToCopy = "your-object-name";
// The generation of objectToCopy to copy
// long generationToCopy = 1579287380533984;
// What to name the new object with the old data from objectToCopy
// String newObjectName = "your-new-object";
Storage storage=StorageOptions .newBuilder().setProjectId(projectId).build().getService ();
// Optional: set a generation-match precondition to avoid potential race
// conditions and data corruptions. The request returns a 412 error if the
// preconditions are not met.
Storage .BlobTargetOptionprecondition;
if(storage.get (bucketName,newObjectName)==null){
// For a target object that does not yet exist, set the DoesNotExist precondition.
// This will cause the request to fail if the object is created before the request runs.
precondition=Storage .BlobTargetOption.doesNotExist();
}else{
// If the destination already exists in your bucket, instead set a generation-match
// precondition. This will cause the request to fail if the existing object's generation
// changes before the request runs.
precondition=
Storage .BlobTargetOption.generationMatch(
storage.get (bucketName,newObjectName).getGeneration());
}
Storage .CopyRequest copyRequest=
Storage .CopyRequest.newBuilder()
.setSource(BlobId .of(bucketName,objectToCopy,generationToCopy))
.setTarget(BlobId .of(bucketName,newObjectName),precondition)
.build();
storage.copy (copyRequest);
System.out.println(
"Generation "
+generationToCopy
+" of object "
+objectToCopy
+" in bucket "
+bucketName
+" was copied to "
+newObjectName);
}
}

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const srcBucketName = "your-unique-bucket-name";
// The ID of the GCS file to copy an old version of
// const srcFilename = "your-file-name";
// The generation of fileToCopy to copy
// const generation = 1579287380533984;
// The ID of the bucket to copy the file to
// const destBucketName = 'target-file-bucket';
// What to name the new file with the old data from srcFilename
// const destFileName = "your-new-file";
// Imports the Google Cloud client library
const{Storage}=require('@google-cloud/storage');
// Creates a client
conststorage=newStorage();
asyncfunctioncopyOldVersionOfFile(){
// Copies the file to the other bucket
// Optional:
// Set a generation-match precondition to avoid potential race conditions
// and data corruptions. The request to copy is aborted if the object's
// generation number does not match your precondition. For a destination
// object that does not yet exist, set the ifGenerationMatch precondition to 0
// If the destination object already exists in your bucket, set instead a
// generation-match precondition using its generation number.
constcopyOptions={
preconditionOpts:{
ifGenerationMatch:destinationGenerationMatchPrecondition,
},
};
awaitstorage
.bucket(srcBucketName)
.file(srcFilename,{
generation,
})
.copy (storage.bucket(destBucketName).file(destFileName),copyOptions);
console.log(
`Generation ${generation} of file ${srcFilename} in bucket ${srcBucketName} was copied to ${destFileName} in bucket ${destBucketName}`
);
}
copyOldVersionOfFile().catch(console.error);

use Google\Cloud\Storage\StorageClient;
/**
 * Copy archived generation of a given object to a new object.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * (e.g. 'my-bucket')
 * @param string $objectToCopy The name of the object to copy.
 * (e.g. 'my-object')
 * @param string $generationToCopy The generation of the object to copy.
 * (e.g. 1579287380533984)
 * @param string $newObjectName The name of the target object.
 * (e.g. 'my-object-1579287380533984')
 */
function copy_file_archived_generation(string $bucketName, string $objectToCopy, string $generationToCopy, string $newObjectName): void
{
 $storage = new StorageClient();
 $bucket = $storage->bucket($bucketName);
 $object = $bucket->object($objectToCopy, [
 'generation' => $generationToCopy,
 ]);
 $object->copy($bucket, [
 'name' => $newObjectName,
 ]);
 printf(
 'Generation %s of object %s in bucket %s was copied to %s',
 $generationToCopy,
 $objectToCopy,
 $bucketName,
 $newObjectName
 );
}

fromgoogle.cloudimport storage
defcopy_file_archived_generation(
 bucket_name, blob_name, destination_bucket_name, destination_blob_name, generation
):
"""Copies a blob from one bucket to another with a new name with the same generation."""
 # bucket_name = "your-bucket-name"
 # blob_name = "your-object-name"
 # destination_bucket_name = "destination-bucket-name"
 # destination_blob_name = "destination-object-name"
 # generation = 1579287380533984
 storage_client = storage .Client ()
 source_bucket = storage_client.bucket (bucket_name)
 source_blob = source_bucket.blob(blob_name)
 destination_bucket = storage_client.bucket (destination_bucket_name)
 # Optional: set a generation-match precondition to avoid potential race conditions
 # and data corruptions. The request to copy is aborted if the object's
 # generation number does not match your precondition. For a destination
 # object that does not yet exist, set the if_generation_match precondition to 0.
 # If the destination object already exists in your bucket, set instead a
 # generation-match precondition using its generation number.
 destination_generation_match_precondition = 0
 # source_generation selects a specific revision of the source object, as opposed to the latest version.
 blob_copy = source_bucket.copy_blob (
 source_blob, destination_bucket, destination_blob_name, source_generation=generation, if_generation_match=destination_generation_match_precondition
 )
 print(
 "Generation {} of the blob {} in bucket {} copied to blob {} in bucket {}.".format(
 generation,
 source_blob.name,
 source_bucket.name,
 blob_copy.name,
 destination_bucket.name,
 )
 )

defcopy_file_archived_generationsource_bucket_name:,
source_file_name:,
generation:,
destination_bucket_name:,
destination_file_name:
# The ID of the bucket the original object is in
# source_bucket_name = "source-bucket-name"
# The ID of the GCS object to copy
# source_file_name = "source-file-name"
# The generation of your GCS object to copy
# generation = 1579287380533984
# The ID of the bucket to copy the object to
# destination_bucket_name = "destination-bucket-name"
# The ID of the new GCS object
# destination_file_name = "destination-file-name"
require"google/cloud/storage"
storage=Google::Cloud::Storage .new
source_bucket=storage.bucketsource_bucket_name,skip_lookup:true
source_file=source_bucket.file source_file_name
destination_bucket=storage.bucketdestination_bucket_name,skip_lookup:true
destination_file=source_file.copy destination_bucket,destination_file_name,generation:generation
puts"Generation #{generation} of the file #{source_file.name} in bucket #{source_bucket.name} copied to file "\
"#{destination_file.name} in bucket #{destination_bucket.name}"
end

namespacegcs=::google::cloud::storage;
[](gcs::Clientclient,std::stringconst&bucket_name,
std::stringconst&object_name,std::int64_tobject_generation){
google::cloud::Statusstatus=client.DeleteObject(
bucket_name,object_name,gcs::Generation{object_generation});
if(!status.ok())throwstd::runtime_error(status.message());
std::cout << "Deleted " << object_name << " generation "
 << object_generation << " in bucket " << bucket_name << "\n";
}

usingGoogle.Cloud.Storage.V1 ;
usingSystem;
publicclassDeleteFileArchivedGenerationSample
{
publicvoidDeleteFileArchivedGeneration(
stringbucketName="your-bucket-name",
stringobjectName="your-object-name",
long?generation=1579287380533984)
{
varstorage=StorageClient .Create ();
storage.DeleteObject(bucketName,objectName,newDeleteObjectOptions
{
Generation=generation
});
Console.WriteLine($"Generation ${generation} of file {objectName} was deleted from bucket {bucketName}.");
}
}

import(
"context"
"fmt"
"io"
"time"
"cloud.google.com/go/storage"
)
// deleteOldVersionOfObject deletes a noncurrent version of an object.
funcdeleteOldVersionOfObject(wio.Writer ,bucketName,objectNamestring,genint64)error{
// bucketName := "bucket-name"
// objectName := "object-name"
// gen is the generation of objectName to delete.
// gen := 1587012235914578
ctx:=context.Background()
client,err:=storage.NewClient(ctx)
iferr!=nil{
returnfmt.Errorf("storage.NewClient: %w",err)
}
deferclient.Close()
ctx,cancel:=context.WithTimeout(ctx,time.Second*10)
defercancel()
obj:=client.Bucket (bucketName).Object (objectName)
iferr:=obj.Generation (gen).Delete(ctx);err!=nil{
returnfmt.Errorf("Bucket(%q).Object(%q).Generation(%v).Delete: %w",bucketName,objectName,gen,err)
}
fmt.Fprintf(w,"Generation %v of object %v was deleted from %v\n",gen,objectName,bucketName)
returnnil
}

importcom.google.cloud.storage.BlobId ;
importcom.google.cloud.storage.Storage ;
importcom.google.cloud.storage.StorageOptions ;
publicclass DeleteOldVersionOfObject{
publicstaticvoiddeleteOldVersionOfObject(
StringprojectId,StringbucketName,StringobjectName,longgenerationToDelete){
// The ID of your GCP project
// String projectId = "your-project-id";
// The ID of your GCS bucket
// String bucketName = "your-unique-bucket-name";
// The ID of your GCS object
// String objectName = "your-object-name";
// The generation of objectName to delete
// long generationToDelete = 1579287380533984;
Storage storage=StorageOptions .newBuilder().setProjectId(projectId).build().getService ();
storage.delete (BlobId.of(bucketName,objectName,generationToDelete));
System.out.println(
"Generation "
+generationToDelete
+" of object "
+objectName
+" was deleted from "
+bucketName);
}
}

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';
// The ID of your GCS file
// const fileName = 'your-file-name';
// The generation of fileName to delete
// const generation = 1579287380533984;
// Imports the Google Cloud client library
const{Storage}=require('@google-cloud/storage');
// Creates a client
conststorage=newStorage();
asyncfunctiondeleteOldVersionOfFile(){
// Deletes the file from the bucket with given version
awaitstorage
.bucket(bucketName)
.file(fileName,{
generation,
})
.delete();
console.log(
`Generation ${generation} of file ${fileName} was deleted from ${bucketName}`
);
}
deleteOldVersionOfFile().catch(console.error);

use Google\Cloud\Storage\StorageClient;
/**
 * Delete an archived generation of the given object.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 * (e.g. 'my-object')
 * @param string $generationToDelete the generation of the object to delete.
 * (e.g. 1579287380533984)
 */
function delete_file_archived_generation(string $bucketName, string $objectName, string $generationToDelete): void
{
 $storage = new StorageClient();
 $bucket = $storage->bucket($bucketName);
 $object = $bucket->object($objectName, [
 'generation' => $generationToDelete,
 ]);
 $object->delete();
 printf(
 'Generation %s of object %s was deleted from %s',
 $generationToDelete,
 $objectName,
 $bucketName
 );
}

fromgoogle.cloudimport storage
defdelete_file_archived_generation(bucket_name, blob_name, generation):
"""Delete a blob in the bucket with the given generation."""
 # bucket_name = "your-bucket-name"
 # blob_name = "your-object-name"
 # generation = 1579287380533984
 storage_client = storage .Client ()
 bucket = storage_client.get_bucket (bucket_name)
 bucket.delete_blob (blob_name, generation=generation)
 print(
 f"Generation {generation} of blob {blob_name} was deleted from {bucket_name}"
 )

defdelete_file_archived_generationbucket_name:,file_name:,generation:
# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# The ID of your GCS object
# file_name = "your-file-name"
# The generation of the file to delete
# generation = 1579287380533984
require"google/cloud/storage"
storage=Google::Cloud::Storage .new
bucket=storage.bucketbucket_name,skip_lookup:true
file=bucket.file file_name
file.deletegeneration:generation
puts"Generation #{generation} of file #{file_name} was deleted from #{bucket_name}"
end