Struct Storage 

pub struct Storage<S = DefaultStorage>
where
    S: Storage + 'static,
{ /* private fields */ }

Implements a client for the Cloud Storage API.

Example

let client = Storage::builder().build().await?;
// use `client` to make requests to Cloud Storage.

Configuration

To configure Storage use the with_* methods in the type returned by builder(). The default configuration should work for most applications. Common configuration changes include

• with_endpoint(): by default this client uses the global default endpoint (https://storage.googleapis.com). Applications using regional endpoints or running in restricted networks (e.g. a network configured with Private Google Access with VPC Service Controls) may want to override this default.
• with_credentials(): by default this client uses Application Default Credentials. Applications using custom authentication may need to override this default.

Pooling and Cloning

Storage holds a connection pool internally, it is advised to create one and then reuse it. You do not need to wrap Storage in an Rc or Arc to reuse it, because it already uses an Arc internally.

Service Description

The Cloud Storage API allows applications to read and write data through the abstractions of buckets and objects. For a description of these abstractions please see https://cloud.google.com/storage/docs.

Resources are named as follows:

• Projects are referred to as they are defined by the Resource Manager API, using strings like projects/123456 or projects/my-string-id.

• Buckets are named using string names of the form: projects/{project}/buckets/{bucket} For globally unique buckets, _ may be substituted for the project.

• Objects are uniquely identified by their name along with the name of the bucket they belong to, as separate strings in this API. For example:

  bucket = "projects/_/buckets/my-bucket"
  object = "my-object/with/a/folder-like/name"

  Note that object names can contain / characters, which are treated as any other character (no special directory semantics).

Implementations

impl Storage

pub fn builder() -> ClientBuilder

Returns a builder for Storage.

Example

let client = Storage::builder().build().await?;

impl<S> Storage<S>

where S: Storage + 'static,

pub fn from_stub(stub: S) -> Self

where S: Storage + 'static,

Creates a new client from the provided stub.

The most common case for calling this function is in tests mocking the client’s behavior.

pub fn write_object<B, O, T, P>( &self, bucket: B, object: O, payload: T, ) -> WriteObject<P, S>

where B: Into<String>, O: Into<String>, T: Into<Payload<P>>,

Write an object with data from any data source.

Example

let response = client
    .write_object("projects/_/buckets/my-bucket", "my-object", "hello world")
    .send_buffered()
    .await?;
println!("response details={response:?}");

Example

let response = client
    .write_object("projects/_/buckets/my-bucket", "my-object", "hello world")
    .send_unbuffered()
    .await?;
println!("response details={response:?}");

You can use many different types as the payload. For example, a string, a bytes::Bytes, a tokio::fs::File, or a custom type that implements the StreamingSource trait.

If your data source also implements Seek, prefer send_unbuffered() to start the write. Otherwise use send_buffered().

Parameters

• bucket - the bucket name containing the object. In projects/_/buckets/{bucket_id} format.
• object - the object name.
• payload - the object data.

pub fn read_object<B, O>(&self, bucket: B, object: O) -> ReadObject<S>

where B: Into<String>, O: Into<String>,

Reads the contents of an object.

Example

let mut resp = client
    .read_object("projects/_/buckets/my-bucket", "my-object")
    .send()
    .await?;
let mut contents = Vec::new();
while let Some(chunk) = resp.next().await.transpose()? {
  contents.extend_from_slice(&chunk);
}
println!("object contents={:?}", bytes::Bytes::from_owner(contents));

Parameters

• bucket - the bucket name containing the object. In projects/_/buckets/{bucket_id} format.
• object - the object name.

Trait Implementations

impl<S> Clone for Storage<S>

where S: Storage + 'static + Clone,

fn clone(&self) -> Storage<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S> Debug for Storage<S>

where S: Storage + 'static + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.