Package com.google.cloud.storage (2.34.0)

Access Control List for buckets or blobs. See Also: About Access Control Lists

Builder for Acl objects.

Class for ACL Domain entities.

Base class for Access Control List entities.

Class for ACL Group entities.

Class for ACL Project entities.

Class for ACL User entities.

An object in Google Cloud Storage. A Blob object includes the BlobId instance, the set of properties inherited from the BlobInfo class and the Storage instance. The class provides methods to perform operations on the object. Reading a property value does not issue any RPC calls. The object content is not stored within the Blob instance. Operations that access the content issue one or multiple RPC calls, depending on the content size.

Objects of this class are immutable. Operations that modify the blob like #update and #copyTo return a new object. Any changes to the object in Google Cloud Storage made after creation of the Blob are not visible in the Blob. To get a Blob object with the most recent information use #reload.

Example of getting the content of the object in Google Cloud Storage:

 BlobId blobId = BlobId.of(bucketName, blobName);
 Blob blob = storage.get(blobId);
 long size = blob.getSize(); // no RPC call is required
 byte[] content = blob.getContent(); // one or multiple RPC calls will be issued
 

Class for specifying blob source options when Blob methods are used.

Builder for Blob.

Google Storage Object identifier. A BlobId object includes the name of the containing bucket, the blob's name and possibly the blob's generation. If #getGeneration() is null the identifier refers to the latest blob's generation.

Information about an object in Google Cloud Storage. A BlobInfo object includes the BlobId instance and the set of properties, such as the blob's access control configuration, user provided metadata, the CRC32C checksum, etc. Instances of this class are used to create a new object in Google Cloud Storage or update the properties of an existing object. To deal with existing Storage objects the API includes the Blob class which extends BlobInfo and declares methods to perform operations on the object. Neither BlobInfo nor Blob instances keep the object content, just the object properties.

Example of usage BlobInfo to create an object in Google Cloud Storage:

 BlobId blobId = BlobId.of(bucketName, blobName);
 BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType("text/plain").build();
 Blob blob = storage.create(blobInfo, "Hello, world".getBytes(StandardCharsets.UTF_8));
 

See Also: Concepts and Terminology

Builder for BlobInfo.

Objects of this class hold information on the customer-supplied encryption key, if the blob is encrypted using such a key.

This class is meant for internal use only. Users are discouraged from using this class.

Defines a blob's Retention policy. Can only be used on objects in a retention-enabled bucket.

A sealed internal implementation only class which provides the means of configuring a BlobWriteSession.

A BlobWriteSessionConfig will be used to configure all BlobWriteSessions produced by an instance of Storage. See Also: Storage#blobWriteSession(BlobInfo, BlobWriteOption...), BlobWriteSessionConfigs, GrpcStorageOptions.Builder#setBlobWriteSessionConfig(BlobWriteSessionConfig)

Factory class to select and construct BlobWriteSessionConfigs.

There are several strategies which can be used to upload a Blob to Google Cloud Storage. This class provides factories which allow you to select the appropriate strategy for your workload.

A Google cloud storage bucket.

Objects of this class are immutable. Operations that modify the bucket like #update return a new object. To get a Bucket object with the most recent information use #reload. Bucket adds a layer of service-related functionality over BucketInfo.

Class for specifying blob target options when Bucket methods are used.

Class for specifying blob write options when Bucket methods are used.

Class for specifying bucket source options when Bucket methods are used.

Builder for Bucket.

Google Storage bucket metadata; See Also: Concepts and Terminology

Deprecated. Use a LifecycleRule with a DeleteLifecycleAction and use LifecycleCondition.Builder.setAge instead.

For example, new DeleteLifecycleAction(1) is equivalent to new LifecycleRule( LifecycleAction.newDeleteAction(), LifecycleCondition.newBuilder().setAge(1).build()))

Delete rule class that sets a Time To Live for blobs in the bucket. See Also: Object Lifecycle Management

Configuration for the Autoclass settings of a bucket. See Also: https://cloud.google.com/storage/docs/autoclass

Builder for BucketInfo.

Deprecated. Use a LifecycleRule with an action DeleteLifecycleAction and a condition LifecycleCondition.Builder.setCreatedBefore instead.

Delete rule class for blobs in the bucket that have been created before a certain date. See Also: Object Lifecycle Management

The bucket's custom placement configuration for Custom Dual Regions. If using location is also required.

Deprecated. Use a LifecycleRule with a DeleteLifecycleAction and a LifecycleCondition which is equivalent to a subclass of DeleteRule instead.

Base class for bucket's delete rules. Allows to configure automatic deletion of blobs and blobs versions. See Also: Object Lifecycle Management

The Bucket's IAM Configuration. See Also: public-access-prevention, uniform bucket-level access

Builder for IamConfiguration

Deprecated. Use a LifecycleRule with a DeleteLifecycleAction and a condition LifecycleCondition.Builder.setIsLive instead.

Delete rule class to distinguish between live and archived blobs. See Also: Object Lifecycle Management

Lifecycle rule for a bucket. Allows supported Actions, such as deleting and changing storage class, to be executed when certain Conditions are met.

Versions 1.50.0-1.111.2 of this library don’t support the CustomTimeBefore, DaysSinceCustomTime, DaysSinceNoncurrentTime and NoncurrentTimeBefore lifecycle conditions. To read GCS objects with those lifecycle conditions, update your Java client library to the latest version. See Also: Object Lifecycle Management

Base class for the Action to take when a Lifecycle Condition is met. Supported Actions are expressed as subclasses of this class, accessed by static factory methods.

Condition for a Lifecycle rule, specifies under what criteria an Action should be executed. See Also: Object Lifecycle Management

Builder for LifecycleCondition.

The bucket's logging configuration, which defines the destination bucket and optional name prefix for the current bucket's logs.

Deprecated. Use a LifecycleRule with a DeleteLifecycleAction and a condition LifecycleCondition.Builder.setNumberOfNewerVersions instead.

Delete rule class for versioned blobs. Specifies when to delete a blob's version according to the number of available newer versions for that blob. See Also: Object Lifecycle Management

There are scenarios in which disk space is more plentiful than memory space. This new BlobWriteSessionConfig allows augmenting an instance of storage to produce BlobWriteSessions which will buffer to disk rather than holding things in memory.

Once the file on disk is closed, the entire file will then be uploaded to GCS. See Also: BlobWriteSessionConfigs#bufferToDiskThenUpload(Path), Storage#blobWriteSession(BlobInfo, BlobWriteOption...), BlobWriteSessionConfigs#bufferToDiskThenUpload(Collection), GrpcStorageOptions.Builder#setBlobWriteSessionConfig(BlobWriteSessionConfig)

Canonical extension header serializer. See Also: Canonical Extension Headers

Google Storage blob copy writer. A CopyWriter object allows to copy both blob's data and information. To override source blob's information supply a BlobInfo to the CopyRequest using either Storage.CopyRequest.Builder#setTarget(BlobInfo, Storage.BlobTargetOption...) or Storage.CopyRequest.Builder#setTarget(BlobInfo, Iterable).

This class holds the result of a copy request. If source and destination blobs share the same location and storage class the copy is completed in one RPC call otherwise one or more #copyChunk calls are necessary to complete the copy. In addition, CopyWriter#getResult() can be used to automatically complete the copy and return information on the newly created blob. See Also: Rewrite

Cross-Origin Resource Sharing (CORS) configuration for a bucket. See Also: Cross-Origin Resource Sharing (CORS)

CORS configuration builder.

Class for a CORS origin.

Default Configuration to represent uploading to Google Cloud Storage in a chunked manner.

Perform a resumable upload, uploading at most chunkSize bytes each PUT.

Configuration of chunk size can be performed via DefaultBlobWriteSessionConfig#withChunkSize(int).

An instance of this class will provide a BlobWriteSession is logically equivalent to the following:

 Storage storage = ...;
 WriteChannel writeChannel = storage.writer(BlobInfo, BlobWriteOption);
 writeChannel.setChunkSize(chunkSize);
 

Internal implementation detail, only public to allow for java.io.Serializable compatibility in com.google.cloud.ServiceOptions.

To access an instance of this class instead use GrpcStorageOptions.defaults().getDefaultServiceFactory(). See Also: GrpcStorageOptions.GrpcStorageDefaults#getDefaultServiceFactory(), GrpcStorageOptions#defaults()

Internal implementation detail, only public to allow for java.io.Serializable compatibility in com.google.cloud.ServiceOptions.

To access an instance of this class instead use GrpcStorageOptions.defaults().getDefaultRpcFactory(). See Also: GrpcStorageOptions.GrpcStorageDefaults#getDefaultRpcFactory(), GrpcStorageOptions#defaults()

HMAC key for a service account.

Builder for HmacKey objects. *

The metadata for a service account HMAC key. This class holds all data associated with an HMAC key other than the secret key.

Builder for HmacKeyMetadata objects. *

Http method supported by Storage service.

Internal implementation detail, only public to allow for java.io.Serializable.

To access an instance of this class instead use HttpStorageOptions.defaults().getDefaultServiceFactory(). See Also: HttpStorageOptions#defaults(), HttpStorageDefaults#getDefaultServiceFactory()

Internal implementation detail, only public to allow for java.io.Serializable.

To access an instance of this class instead use HttpStorageOptions.defaults().getDefaultRpcFactory(). See Also: HttpStorageDefaults#getDefaultRpcFactory(), HttpStorageOptions#defaults()

There are scenarios in which disk space is more plentiful than memory space. This new BlobWriteSessionConfig allows augmenting an instance of storage to produce BlobWriteSessions which will buffer to disk rather than holding things in memory.

If we have disk available we can checkpoint the contents of an object to disk before transmitting to GCS. The checkpointed data on disk allows arbitrary rewind in the case of failure but allows the upload to happen as soon as the checkpoint ack is complete.

Due to the details of how Resumable Upload Sessions are implemented in the GCS gRPC API this is possible. However, this approach will not work with the HTTP transports Resumable Upload Session spec. See Also: Storage#blobWriteSession(BlobInfo, BlobWriteOption...), GrpcStorageOptions.Builder#setBlobWriteSessionConfig(BlobWriteSessionConfig)

The class representing Pub/Sub notifications for the Storage. See pubsub-notifications for details.

Builder for Notification.

The class representing Pub/Sub Notification metadata for the Storage.

Builder for NotificationInfo.

Builder for NotificationInfo.

Base class for Storage operation option.

Immutable config builder to configure BlobWriteSession instances to perform Parallel Composite Uploads.

Parallel Composite Uploads can yield higher throughput when uploading large objects. However, there are some things which must be kept in mind when choosing to use this strategy.

1. Performing parallel composite uploads costs more money. Class A operations are performed to create each part and to perform each compose. If a storage tier other than STANDARD is used, early deletion fees apply to deletion of the parts.

   An illustrative example. Upload a 5GiB object using 64MiB as the max size per part.
   

   1. 80 Parts will be created (Class A)
   2. 3 compose calls will be performed (Class A)
   3. Delete 80 Parts along with 2 intermediary Compose objects (Free tier as long as STANDARD class)
   Once the parts and intermediary compose objects are deleted, there will be no storage charges related to those temporary objects.
2. The service account/credentials used to perform the parallel composite upload require storage.objects.delete in order to cleanup the temporary part and intermediary compose objects.
   To handle handle part and intermediary compose object deletion out of band passing PartCleanupStrategy#never() to ParallelCompositeUploadBlobWriteSessionConfig#withPartCleanupStrategy(PartCleanupStrategy) will prevent automatic cleanup.
3. Please see the Parallel composite uploads documentation for a more in depth explanation of the limitations of Parallel composite uploads.
4. A failed upload can leave part and intermediary compose objects behind which will count as storage usage, and you will be billed for it.
   By default if an upload fails, an attempt to cleanup the part and intermediary compose will be made. However if the program were to crash there is no means for the client to perform the cleanup.
   Every part and intermediary compose object will be created with a name which ends in .part. An Object Lifecycle Management rule can be setup on your bucket to automatically cleanup objects with the suffix after some period of time. See Object Lifecycle Management for full details and a guide on how to setup a Delete rule with a suffix match condition.
5. Using parallel composite uploads are not a a one size fits all solution. They have very real overhead until uploading a large enough object. The inflection point is dependent upon many factors, and there is no one size fits all value. You will need to experiment with your deployment and workload to determine if parallel composite uploads are useful to you.

In general if you object sizes are smaller than several hundred megabytes it is unlikely parallel composite uploads will be beneficial to overall throughput. See Also: BlobWriteSessionConfigs#parallelCompositeUpload(), Storage#blobWriteSession(BlobInfo, BlobWriteOption...), GrpcStorageOptions.Builder#setBlobWriteSessionConfig(BlobWriteSessionConfig), https://cloud.google.com/storage/docs/parallel-composite-uploads

A strategy which dictates how buffers are to be used for individual parts. The chosen strategy will apply to all instances of BlobWriteSession created from a single instance of Storage. See Also: #withBufferAllocationStrategy(BufferAllocationStrategy)

Class which will be used to supply an Executor where work will be submitted when performing a parallel composite upload. See Also: #withExecutorSupplier(ExecutorSupplier)

A cleanup strategy which will dictate what cleanup operations are performed automatically when performing a parallel composite upload. See Also: #withPartCleanupStrategy(PartCleanupStrategy)

A naming strategy which will be used to generate a name for a part or intermediary compose object. See Also: #withPartNamingStrategy(PartNamingStrategy)

Presigned V4 post policy. Instances of PostPolicyV4 include a URL and a map of fields that can be specified in an HTML form to submit a POST request to upload an object.

See POST Object for details of upload by using HTML forms.

See Storage#generateSignedPostPolicyV4(BlobInfo, long, TimeUnit, PostPolicyV4.PostFieldsV4, PostPolicyV4.PostConditionsV4, Storage.PostPolicyV4Option...) for example of usage.

Class for a specific POST policy document condition. See Also: Policy document

A helper class for specifying conditions in a V4 POST Policy document. Used in: Storage#generateSignedPostPolicyV4(BlobInfo, long, TimeUnit, PostPolicyV4.PostFieldsV4, PostPolicyV4.PostConditionsV4, Storage.PostPolicyV4Option...). See Also: Policy document

A helper class to define fields to be specified in a V4 POST request. Instance of this class helps to construct PostPolicyV4 objects. Used in: Storage#generateSignedPostPolicyV4(BlobInfo, long, TimeUnit, PostPolicyV4.PostFieldsV4, PostPolicyV4.PostConditionsV4, Storage.PostPolicyV4Option...). See Also: POST Object Form fields

Class for a V4 POST Policy document. Used by Storage to construct PostPolicyV4 objects. See Also: Policy document

Enums for the Recovery Point Objective (RPO) of dual-region buckets, which determines how fast data is replicated between regions. See Also: https://cloud.google.com/storage/docs/turbo-replication

A service account, with its specified scopes, authorized for this instance. See Also: Authenticating from Google Cloud Storage

Signature Info holds payload components of the string that requires signing. See Also: Components

Class for specifying blob get options.

Class for specifying blob list options.

Class for specifying blob source options.

Class for specifying blob target options.

Class for specifying blob write options.

Class for specifying bucket get options.

Class for specifying bucket list options.

Class for specifying bucket source options.

Class for specifying bucket target options.

A class to contain all information needed for a Google Cloud Storage Compose operation. See Also: Compose Operation

Class for Compose source blobs.

A class to contain all information needed for a Google Cloud Storage Copy operation.

Class for specifying createHmacKey options

Class for specifying deleteHmacKey options

Class for specifying getHmacKey options

Class for specifying listHmacKeys options

Class for specifying Post Policy V4 options. *

Class for specifying signed URL options.

Class for specifying updateHmacKey options

A batch of operations to be submitted to Google Cloud Storage using a single RPC request.

Example of using a batch request to delete, update and get a blob:

 StorageBatch batch = storage.batch();
 BlobId firstBlob = BlobId.of("bucket", "blob1"));
 BlobId secondBlob = BlobId.of("bucket", "blob2"));
 batch.delete(firstBlob).notify(new BatchResult.Callback<Boolean, StorageException>() {
   public void success(Boolean result) {
     // deleted successfully
   }

   public void error(StorageException exception) {
     // delete failed
   }
 });
 batch.update(BlobInfo.builder(secondBlob).contentType("text/plain").build());
 StorageBatchResult<Blob> result = batch.get(secondBlob);
 batch.submit();
 Blob blob = result.get(); // returns get result or throws StorageException
 

Enums for the storage classes. See https://cloud.google.com/storage/docs/storage-classes for details.

Deprecated. Use HttpStorageFactory

Deprecated. Use HttpStorageRpcFactory

IAM roles specific to Storage. An overview of the permissions available to Storage and the capabilities they grant can be found in the Google Cloud Storage IAM documentation.

A session to write an object to Google Cloud Storage.

A session can only write a single version of an object. If writing multiple versions of an object a new session must be created each time.

Provides an api that allows writing to and retrieving the resulting BlobInfo after write finalization.

The underlying implementation is dictated based upon the specified BlobWriteSessionConfig provided at StorageOptions creation time. See Also: BlobWriteSessionConfigs, GrpcStorageOptions.Builder#setBlobWriteSessionConfig(BlobWriteSessionConfig), BlobWriteSessionConfig

An interface for Google Cloud Storage. See Also: Google Cloud Storage

An interface for Storage factories.

A factory class which is used to provide access to ResultRetryAlgorithm for idempotent and non-idempotent calls made via Storage. Before Storage performs an operation it will determine if the operation is idempotent and select the appropriate ResultRetryAlgorithm to use for that invocation. See Also: #getDefaultStorageRetryStrategy(), #getUniformStorageRetryStrategy()

Public Access Prevention enum with expected values. See Also: public-access-prevention

Enum representing the transports com.google.cloud.storage classes have implementations for.

An exception which provides access to created objects during a Parallel Composite Upload that did not finish successfully.

This exception can occur when calling any method on the java.nio.channels.WritableByteChannel returned from BlobWriteSession#open(), in which case it will be the cause of a StorageException.

Similarly, this exception will be the cause of a java.util.concurrent.CancellationException thrown by the BlobWriteSession#getResult().

This class holds a single result of a batch call to Cloud Storage.

Storage service exception. See Also: Google Cloud Storage error codes

Annotation which is used to convey which Cloud Storage API a class or method has compatibility with.

Not all operations are compatible with all transports.