Change object storage classes

namespacegcs=::google::cloud::storage;
using::google::cloud::StatusOr;
[](gcs::Clientclient,std::stringconst&bucket_name,
std::stringconst&object_name,std::stringconst&storage_class){
StatusOr<gcs::ObjectMetadata>object_metadata=
client.RewriteObjectBlocking(
bucket_name,object_name,bucket_name,object_name,
gcs::WithObjectMetadata(
gcs::ObjectMetadata().set_storage_class(storage_class)));
if(!object_metadata)throwstd::move(object_metadata).status();
std::cout << "Changed storage class of object " << object_metadata->name()
 << " in bucket " << object_metadata->bucket() << " to "
 << object_metadata->storage_class() << "\n";
}

usingGoogle.Cloud.Storage.V1 ;
usingSystem;
publicclassChangeFileStorageClassSample
{
publicGoogle.Apis.Storage.v1.Data.ObjectChangeFileStorageClass(
stringbucketName="your-bucket-name",
stringobjectName="your-object-name",
stringstorageClass=StorageClasses .Standard )
{
varstorage=StorageClient .Create ();
// Changing storage class requires a rewrite operation, which can only be done
// by the underlying service
varobj=newGoogle.Apis.Storage.v1.Data.Object{StorageClass=storageClass};
storage.Service.Objects.Rewrite(obj,bucketName,objectName,bucketName,objectName).Execute();
varfile=storage.GetObject(bucketName,objectName);
Console.WriteLine($"Object {objectName} in bucket {bucketName} had"+
$" its storage class set to {storageClass}.");
returnfile;
}
}

import(
"context"
"fmt"
"io"
"time"
"cloud.google.com/go/storage"
)
// changeObjectStorageClass changes the storage class of a single object.
funcchangeObjectStorageClass(wio.Writer ,bucket,objectstring)error{
// bucket := "bucket-name"
// object := "object-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()
o:=client.Bucket (bucket).Object (object)
// 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.
attrs,err:=o.Attrs(ctx)
iferr!=nil{
returnfmt.Errorf("object.Attrs: %w",err)
}
o=o.If(storage.Conditions {GenerationMatch:attrs.Generation })
// See the StorageClass documentation for other valid storage classes:
// https://cloud.google.com/storage/docs/storage-classes
newStorageClass:="COLDLINE"
// You can't change an object's storage class directly, the only way is
// to rewrite the object with the desired storage class.
copier:=o.CopierFrom (o)
copier.StorageClass=newStorageClass
if_,err:=copier.Run(ctx);err!=nil{
returnfmt.Errorf("copier.Run: %w",err)
}
fmt.Fprintf(w,"Object %v in bucket %v had its storage class set to %v\n",object,bucket,newStorageClass)
returnnil
}

importcom.google.cloud.storage.Blob ;
importcom.google.cloud.storage.BlobId ;
importcom.google.cloud.storage.BlobInfo ;
importcom.google.cloud.storage.Storage ;
importcom.google.cloud.storage.StorageClass ;
importcom.google.cloud.storage.StorageOptions ;
publicclass ChangeObjectStorageClass{
publicstaticvoidchangeObjectStorageClass(
StringprojectId,StringbucketName,StringobjectName){
// 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";
Storage storage=StorageOptions .newBuilder().setProjectId(projectId).build().getService ();
BlobId blobId=BlobId .of(bucketName,objectName);
Blob sourceBlob=storage.get (blobId);
if(sourceBlob==null){
System.out.println("The object "+objectName+" wasn't found in "+bucketName);
return;
}
// See the StorageClass documentation for other valid storage classes:
// https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
StorageClass storageClass=StorageClass .COLDLINE;
// You can't change an object's storage class directly, the only way is to rewrite the object
// with the desired storage class
BlobInfo targetBlob=BlobInfo .newBuilder(blobId).setStorageClass(storageClass).build();
// Optional: set a generation-match precondition to avoid potential race
// conditions and data corruptions. The request to upload returns a 412 error if
// the object's generation number does not match your precondition.
Storage .BlobSourceOptionprecondition=
Storage .BlobSourceOption.generationMatch(sourceBlob.getGeneration());
Storage .CopyRequest request=
Storage .CopyRequest.newBuilder()
.setSource(blobId)
.setSourceOptions(precondition)// delete this line to run without preconditions
.setTarget(targetBlob)
.build();
Blob updatedBlob=storage.copy (request).getResult();
System.out.println(
"Object "
+objectName
+" in bucket "
+bucketName
+" had its storage class set to "
+updatedBlob.getStorageClass().name ());
}
}

// Imports the Google Cloud client library
const{Storage}=require('@google-cloud/storage');
// Creates a client
conststorage=newStorage();
/**
 * 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 name of a storage class
// See the StorageClass documentation for other valid storage classes:
// https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
// const storageClass = 'coldline';
asyncfunctionfileChangeStorageClass(){
// 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.
constsetStorageClassOptions={
ifGenerationMatch:generationMatchPrecondition,
};
awaitstorage
.bucket(bucketName)
.file(fileName)
.setStorageClass(storageClass,setStorageClassOptions);
console.log(`${fileName} has been set to ${storageClass}`);
}
fileChangeStorageClass().catch(console.error);

use Google\Cloud\Storage\StorageClient;
/**
 * Change the storage class of the given file.
 *
 * @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 $storageClass The storage class of the new object.
 * (e.g. 'COLDLINE')
 */
function change_file_storage_class(string $bucketName, string $objectName, string $storageClass): void
{
 $storage = new StorageClient();
 $bucket = $storage->bucket($bucketName);
 $object = $bucket->object($objectName);
 // Storage class cannot be changed directly. But we can rewrite the object
 // using the new storage class.
 $newObject = $object->rewrite($bucket, [
 'storageClass' => $storageClass,
 ]);
 printf(
 'Object %s in bucket %s had its storage class set to %s',
 $objectName,
 $bucketName,
 $newObject->info()['storageClass']
 );
}

fromgoogle.cloudimport storage
defchange_file_storage_class(bucket_name, blob_name):
"""Change the default storage class of the blob"""
 # bucket_name = "your-bucket-name"
 # blob_name = "your-object-name"
 storage_client = storage .Client ()
 bucket = storage_client.bucket (bucket_name)
 blob = bucket.blob(blob_name)
 generation_match_precondition = None
 # Optional: set a generation-match precondition to avoid potential race
 # conditions and data corruptions. The request is aborted if the
 # object's generation number does not match your precondition.
 blob.reload() # Fetch blob metadata to use in generation_match_precondition.
 generation_match_precondition = blob.generation
 blob.update_storage_class ("NEARLINE", if_generation_match=generation_match_precondition)
 print(
 "Blob {} in bucket {} had its storage class set to {}".format(
 blob_name,
 bucket_name,
 blob.storage_class
 )
 )
 return blob

defchange_file_storage_classbucket_name:,file_name:
# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# The ID of your GCS object
# file_name = "your-file-name"
require"google/cloud/storage"
storage=Google::Cloud::Storage .new
bucket=storage.bucketbucket_name,skip_lookup:true
file=bucket.file file_name
file.storage_class="NEARLINE"
puts"File #{file_name} in bucket #{bucket_name} had its storage class set to #{file.storage_class}"
end