Class: Google::Cloud::Storage::Bucket

Inherits:
Object
  • Object
show all
Defined in:
lib/google/cloud/storage/bucket.rb,
lib/google/cloud/storage/bucket/acl.rb,
lib/google/cloud/storage/bucket/cors.rb,
lib/google/cloud/storage/bucket/list.rb,
lib/google/cloud/storage/bucket/lifecycle.rb

Overview

Bucket

Represents a Storage bucket. Belongs to a Project and has many Files.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"
file = bucket.file "path/to/my-file.ext"

Direct Known Subclasses

Updater

Defined Under Namespace

Classes: Acl, Cors, DefaultAcl, Lifecycle, List, Updater

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#user_projectObject

A boolean value or a project ID string to indicate the project to be billed for operations on the bucket and its files. If this attribute is set to true, transit costs for operations on the bucket will be billed to the current project for this client. (See Project#project for the ID of the current project.) If this attribute is set to a project ID, and that project is authorized for the currently authenticated service account, transit costs will be billed to that project. This attribute is required with requester pays-enabled buckets. The default is nil.

In general, this attribute should be set when first retrieving the bucket by providing the user_project option to Project#bucket.

See also #requester_pays= and #requester_pays.

Examples:

Setting a non-default project:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "other-project-bucket", user_project: true
files = bucket.files # Billed to current project
bucket.user_project = "my-other-project"
files = bucket.files # Billed to "my-other-project"


83
84
85
# File 'lib/google/cloud/storage/bucket.rb', line 83

def user_project
  @user_project
end

Instance Method Details

#aclBucket::Acl

The Acl instance used to control access to the bucket.

A bucket has owners, writers, and readers. Permissions can be granted to an individual user's email address, a group's email address, as well as many predefined lists.

Examples:

Grant access to a user by prepending "user-" to an email:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"

email = "heidi@example.net"
bucket.acl.add_reader "user-#{email}"

Grant access to a group by prepending "group-" to an email:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"

email = "authors@example.net"
bucket.acl.add_reader "group-#{email}"

Or, grant access via a predefined permissions list:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"

bucket.acl.public!

Returns:

See Also:



1685
1686
1687
# File 'lib/google/cloud/storage/bucket.rb', line 1685

def acl
  @acl ||= Bucket::Acl.new self
end

#api_urlString

A URL that can be used to access the bucket using the REST API.

Returns:

  • (String)


126
127
128
# File 'lib/google/cloud/storage/bucket.rb', line 126

def api_url
  @gapi.self_link
end

#compose(sources, destination, acl: nil, encryption_key: nil) {|file| ... } ⇒ Google::Cloud::Storage::File Also known as: compose_file, combine

Concatenates a list of existing files in the bucket into a new file in the bucket. There is a limit (currently 32) to the number of files that can be composed in a single operation.

To compose files encrypted with a customer-supplied encryption key, use the encryption_key option. All source files must have been encrypted with the same key, and the resulting destination file will also be encrypted with the same key.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

sources = ["path/to/my-file-1.ext", "path/to/my-file-2.ext"]

new_file = bucket.compose sources, "path/to/new-file.ext"

Set the properties of the new file in a block:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

sources = ["path/to/my-file-1.ext", "path/to/my-file-2.ext"]

new_file = bucket.compose sources, "path/to/new-file.ext" do |f|
  f.cache_control = "private, max-age=0, no-cache"
  f.content_disposition = "inline; filename=filename.ext"
  f.content_encoding = "deflate"
  f.content_language = "de"
  f.content_type = "application/json"
end

Specify the generation of source files (but skip retrieval):

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

file_1 = bucket.file "path/to/my-file-1.ext",
                     generation: 1490390259479000, skip_lookup: true
file_2 = bucket.file "path/to/my-file-2.ext",
                     generation: 1490310974144000, skip_lookup: true

new_file = bucket.compose [file_1, file_2], "path/to/new-file.ext"

Parameters:

  • sources (Array<String, Google::Cloud::Storage::File>)

    The list of source file names or objects that will be concatenated into a single file.

  • destination (String)

    The name of the new file.

  • acl (String)

    A predefined set of access controls to apply to this file.

    Acceptable values are:

    • auth, auth_read, authenticated, authenticated_read, authenticatedRead - File owner gets OWNER access, and allAuthenticatedUsers get READER access.
    • owner_full, bucketOwnerFullControl - File owner gets OWNER access, and project team owners get OWNER access.
    • owner_read, bucketOwnerRead - File owner gets OWNER access, and project team owners get READER access.
    • private - File owner gets OWNER access.
    • project_private, projectPrivate - File owner gets OWNER access, and project team members get access according to their roles.
    • public, public_read, publicRead - File owner gets OWNER access, and allUsers get READER access.
  • encryption_key (String, nil)

    Optional. The customer-supplied, AES-256 encryption key used to encrypt the source files, if one was used. All source files must have been encrypted with the same key, and the resulting destination file will also be encrypted with the key.

Yields:

  • (file)

    A block yielding a delegate file object for setting the properties of the destination file.

Returns:



1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
# File 'lib/google/cloud/storage/bucket.rb', line 1361

def compose sources, destination, acl: nil, encryption_key: nil
  ensure_service!
  sources = Array sources
  if sources.size < 2
    raise ArgumentError, "must provide at least two source files"
  end

  options = { acl: File::Acl.predefined_rule_for(acl),
              key: encryption_key,
              user_project: user_project }
  destination_gapi = nil
  if block_given?
    destination_gapi = API::Object.new
    updater = File::Updater.new destination_gapi
    yield updater
    updater.check_for_changed_metadata!
  end
  gapi = service.compose_file name, sources, destination,
                              destination_gapi, options
  File.from_gapi gapi, service, user_project: user_project
end

#cors {|cors| ... } ⇒ Bucket::Cors

Returns the current CORS configuration for a static website served from the bucket.

The return value is a frozen (unmodifiable) array of hashes containing the attributes specified for the Bucket resource field cors.

This method also accepts a block for updating the bucket's CORS rules. See Cors for details.

Examples:

Retrieving the bucket's CORS rules.

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"
bucket.cors.size #=> 2
rule = bucket.cors.first
rule.origin #=> ["http://example.org"]
rule.methods #=> ["GET","POST","DELETE"]
rule.headers #=> ["X-My-Custom-Header"]
rule.max_age #=> 3600

Updating the bucket's CORS rules inside a block.

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket = storage.bucket "my-todo-app"

bucket.update do |b|
  b.cors do |c|
    c.add_rule ["http://example.org", "https://example.org"],
               "*",
               headers: ["X-My-Custom-Header"],
               max_age: 3600
  end
end

Yields:

  • (cors)

    a block for setting CORS rules

Yield Parameters:

Returns:

See Also:



195
196
197
198
199
200
201
202
203
204
205
# File 'lib/google/cloud/storage/bucket.rb', line 195

def cors
  cors_builder = Bucket::Cors.from_gapi @gapi.cors_configurations
  if block_given?
    yield cors_builder
    if cors_builder.changed?
      @gapi.cors_configurations = cors_builder.to_gapi
      patch_gapi! :cors_configurations
    end
  end
  cors_builder.freeze # always return frozen objects
end

#create_file(file, path = nil, acl: nil, cache_control: nil, content_disposition: nil, content_encoding: nil, content_language: nil, content_type: nil, crc32c: nil, md5: nil, metadata: nil, storage_class: nil, encryption_key: nil, kms_key: nil, temporary_hold: nil, event_based_hold: nil) ⇒ Google::Cloud::Storage::File Also known as: upload_file, new_file

Creates a new File object by providing a path to a local file (or any File-like object such as StringIO) to upload, along with the path at which to store it in the bucket.

Customer-supplied encryption keys

By default, Google Cloud Storage manages server-side encryption keys on your behalf. However, a customer-supplied encryption key can be provided with the encryption_key option. If given, the same key must be provided to subsequently download or copy the file. If you use customer-supplied encryption keys, you must securely manage your keys and ensure that they are not lost. Also, please note that file metadata is not encrypted, with the exception of the CRC32C checksum and MD5 hash. The names of files and buckets are also not encrypted, and you can read or update the metadata of an encrypted file without providing the encryption key.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

bucket.create_file "path/to/local.file.ext"

Specifying a destination path:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

bucket.create_file "path/to/local.file.ext",
                   "destination/path/file.ext"

Providing a customer-supplied encryption key:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket = storage.bucket "my-bucket"

# Key generation shown for example purposes only. Write your own.
cipher = OpenSSL::Cipher.new "aes-256-cfb"
cipher.encrypt
key = cipher.random_key

bucket.create_file "path/to/local.file.ext",
                   "destination/path/file.ext",
                   encryption_key: key

# Store your key and hash securely for later use.
file = bucket.file "destination/path/file.ext",
                   encryption_key: key

Providing a customer-managed Cloud KMS encryption key:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket = storage.bucket "my-bucket"

# KMS key ring must use the same location as the bucket.
kms_key_name = "projects/a/locations/b/keyRings/c/cryptoKeys/d"

bucket.create_file "path/to/local.file.ext",
                   "destination/path/file.ext",
                   kms_key: kms_key_name

file = bucket.file "destination/path/file.ext"
file.kms_key #=> kms_key_name

Create a file with gzip-encoded data.

require "zlib"
require "google/cloud/storage"

storage = Google::Cloud::Storage.new

gz = StringIO.new ""
z = Zlib::GzipWriter.new gz
z.write "Hello world!"
z.close
data = StringIO.new gz.string

bucket = storage.bucket "my-bucket"

bucket.create_file data, "path/to/gzipped.txt",
                   content_encoding: "gzip"

file = bucket.file "path/to/gzipped.txt"

# The downloaded data is decompressed by default.
file.download "path/to/downloaded/hello.txt"

# The downloaded data remains compressed with skip_decompress.
file.download "path/to/downloaded/gzipped.txt",
              skip_decompress: true

Parameters:

  • file (String, ::File)

    Path of the file on the filesystem to upload. Can be an File object, or File-like object such as StringIO. (If the object does not have path, a path argument must be also be provided.)

  • path (String) (defaults to: nil)

    Path to store the file in Google Cloud Storage.

  • acl (String)

    A predefined set of access controls to apply to this file.

    Acceptable values are:

    • auth, auth_read, authenticated, authenticated_read, authenticatedRead - File owner gets OWNER access, and allAuthenticatedUsers get READER access.
    • owner_full, bucketOwnerFullControl - File owner gets OWNER access, and project team owners get OWNER access.
    • owner_read, bucketOwnerRead - File owner gets OWNER access, and project team owners get READER access.
    • private - File owner gets OWNER access.
    • project_private, projectPrivate - File owner gets OWNER access, and project team members get access according to their roles.
    • public, public_read, publicRead - File owner gets OWNER access, and allUsers get READER access.
  • cache_control (String)

    The Cache-Control response header to be returned when the file is downloaded.

  • content_disposition (String)

    The Content-Disposition response header to be returned when the file is downloaded.

  • content_encoding (String)

    The Content-Encoding response header to be returned when the file is downloaded. For example, content_encoding: "gzip" can indicate to clients that the uploaded data is gzip-compressed. However, there is no check to guarantee the specified Content-Encoding has actually been applied to the file data, and incorrectly specifying the file's encoding could lead to unintended behavior on subsequent download requests.

  • content_language (String)

    The Content-Language response header to be returned when the file is downloaded.

  • content_type (String)

    The Content-Type response header to be returned when the file is downloaded.

  • crc32c (String)

    The CRC32c checksum of the file data, as described in RFC 4960, Appendix B. If provided, Cloud Storage will only create the file if the value matches the value calculated by the service. See Validation for more information.

  • md5 (String)

    The MD5 hash of the file data. If provided, Cloud Storage will only create the file if the value matches the value calculated by the service. See Validation for more information.

  • metadata (Hash)

    A hash of custom, user-provided web-safe keys and arbitrary string values that will returned with requests for the file as "x-goog-meta-" response headers.

  • storage_class (Symbol, String)

    Storage class of the file. Determines how the file is stored and determines the SLA and the cost of storage. Accepted values include :standard, :nearline, and :coldline, as well as the equivalent strings returned by #storage_class. :multi_regional, :regional, and durable_reduced_availability are accepted legacy storage classes. For more information, see Storage Classes and Per-Object Storage Class. The default value is the default storage class for the bucket.

  • encryption_key (String)

    Optional. A customer-supplied, AES-256 encryption key that will be used to encrypt the file. Do not provide if kms_key is used.

  • kms_key (String)

    Optional. Resource name of the Cloud KMS key, of the form projects/my-prj/locations/kr-loc/keyRings/my-kr/cryptoKeys/my-key, that will be used to encrypt the file. The KMS key ring must use the same location as the bucket.The Service Account associated with your project requires access to this encryption key. Do not provide if encryption_key is used.

Returns:

Raises:

  • (ArgumentError)


1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
# File 'lib/google/cloud/storage/bucket.rb', line 1247

def create_file file, path = nil, acl: nil, cache_control: nil,
                content_disposition: nil, content_encoding: nil,
                content_language: nil, content_type: nil,
                crc32c: nil, md5: nil, metadata: nil,
                storage_class: nil, encryption_key: nil, kms_key: nil,
                temporary_hold: nil, event_based_hold: nil
  ensure_service!
  options = { acl: File::Acl.predefined_rule_for(acl), md5: md5,
              cache_control: cache_control, content_type: content_type,
              content_disposition: content_disposition, crc32c: crc32c,
              content_encoding: content_encoding, metadata: ,
              content_language: content_language, key: encryption_key,
              kms_key: kms_key,
              storage_class: storage_class_for(storage_class),
              temporary_hold: temporary_hold,
              event_based_hold: event_based_hold,
              user_project: user_project }
  ensure_io_or_file_exists! file
  path ||= file.path if file.respond_to? :path
  path ||= file if file.is_a? String
  raise ArgumentError, "must provide path" if path.nil?

  gapi = service.insert_file name, file, path, options
  File.from_gapi gapi, service, user_project: user_project
end

#create_notification(topic, custom_attrs: nil, event_types: nil, prefix: nil, payload: nil) ⇒ Google::Cloud::Storage::Notification Also known as: new_notification

Creates a new Pub/Sub notification subscription for the bucket.

Examples:

require "google/cloud/pubsub"
require "google/cloud/storage"

pubsub = Google::Cloud::Pubsub.new
storage = Google::Cloud::Storage.new

topic = pubsub.create_topic "my-topic"
topic.policy do |p|
  p.add "roles/pubsub.publisher",
        "serviceAccount:#{storage.}"
end

bucket = storage.bucket "my-bucket"

notification = bucket.create_notification topic.name

Parameters:

  • topic (String)

    The name of the Cloud PubSub topic to which the notification subscription will publish.

  • custom_attrs (Hash(String => String))

    The custom attributes for the notification. An optional list of additional attributes to attach to each Cloud Pub/Sub message published for the notification subscription.

  • event_types (Symbol, String, Array<Symbol, String>)

    The event types for the notification subscription. If provided, messages will only be sent for the listed event types. If empty, messages will be sent for all event types.

    Acceptable values are:

    • :finalize - Sent when a new object (or a new generation of an existing object) is successfully created in the bucket. This includes copying or rewriting an existing object. A failed upload does not trigger this event.
    • :update - Sent when the metadata of an existing object changes.
    • :delete - Sent when an object has been permanently deleted. This includes objects that are overwritten or are deleted as part of the bucket's lifecycle configuration. For buckets with object versioning enabled, this is not sent when an object is archived (see OBJECT_ARCHIVE), even if archival occurs via the File#delete method.
    • :archive - Only sent when the bucket has enabled object versioning. This event indicates that the live version of an object has become an archived version, either because it was archived or because it was overwritten by the upload of an object of the same name.
  • prefix (String)

    The file name prefix for the notification subscription. If provided, the notification will only be applied to file names that begin with this prefix.

  • payload (Symbol, String, Boolean)

    The desired content of the Pub/Sub message payload. Acceptable values are:

    • :json or true - The Pub/Sub message payload will be a UTF-8 string containing the resource representation of the file's metadata.
    • :none or false - No payload is included with the notification.

    The default value is :json.

Returns:

See Also:



1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
# File 'lib/google/cloud/storage/bucket.rb', line 1989

def create_notification topic, custom_attrs: nil, event_types: nil,
                        prefix: nil, payload: nil
  ensure_service!
  options = { custom_attrs: custom_attrs, event_types: event_types,
              prefix: prefix, payload: payload,
              user_project: user_project }

  gapi = service.insert_notification name, topic, options
  Notification.from_gapi name, gapi, service, user_project: user_project
end

#created_atDateTime

Creation time of the bucket.

Returns:

  • (DateTime)


135
136
137
# File 'lib/google/cloud/storage/bucket.rb', line 135

def created_at
  @gapi.time_created
end

#default_aclBucket::DefaultAcl

The DefaultAcl instance used to control access to the bucket's files.

A bucket's files have owners, writers, and readers. Permissions can be granted to an individual user's email address, a group's email address, as well as many predefined lists.

Examples:

Grant access to a user by prepending "user-" to an email:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"

email = "heidi@example.net"
bucket.default_acl.add_reader "user-#{email}"

Grant access to a group by prepending "group-" to an email

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"

email = "authors@example.net"
bucket.default_acl.add_reader "group-#{email}"

Or, grant access via a predefined permissions list:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"

bucket.default_acl.public!

Returns:

See Also:



1731
1732
1733
# File 'lib/google/cloud/storage/bucket.rb', line 1731

def default_acl
  @default_acl ||= Bucket::DefaultAcl.new self
end

#default_event_based_hold=(new_default_event_based_hold) ⇒ Object

Updates the default event-based hold field for the bucket. This field controls the initial state of the event_based_hold field for newly-created files in the bucket.

See File#event_based_hold? and File#set_event_based_hold!.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

bucket.update do |b|
  b.retention_period = 2592000 # 30 days in seconds
  b.default_event_based_hold = true
end

file = bucket.create_file "path/to/local.file.ext"
file.event_based_hold? # true
file.delete # raises Google::Cloud::PermissionDeniedError
file.release_event_based_hold!

# The end of the retention period is calculated from the time that
# the event-based hold was released.
file.retention_expires_at

Parameters:

  • new_default_event_based_hold (Boolean)

    The default event-based hold field for the bucket.



732
733
734
735
# File 'lib/google/cloud/storage/bucket.rb', line 732

def default_event_based_hold= new_default_event_based_hold
  @gapi.default_event_based_hold = new_default_event_based_hold
  patch_gapi! :default_event_based_hold
end

#default_event_based_hold?Boolean

Whether the event_based_hold field for newly-created files in the bucket will be initially set to true. See #default_event_based_hold=, File#event_based_hold? and File#set_event_based_hold!.

Returns:

  • (Boolean)

    Returns true if the event_based_hold field for newly-created files in the bucket will be initially set to true, otherwise false.



697
698
699
# File 'lib/google/cloud/storage/bucket.rb', line 697

def default_event_based_hold?
  !@gapi.default_event_based_hold.nil? && @gapi.default_event_based_hold
end

#default_kms_keyString?

The Cloud KMS encryption key that will be used to protect files. For example: projects/a/locations/b/keyRings/c/cryptoKeys/d

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

# KMS key ring must use the same location as the bucket.
kms_key_name = "projects/a/locations/b/keyRings/c/cryptoKeys/d"
bucket.default_kms_key = kms_key_name

bucket.default_kms_key #=> kms_key_name

Returns:

  • (String, nil)

    A Cloud KMS encryption key, or nil if none has been configured.



552
553
554
# File 'lib/google/cloud/storage/bucket.rb', line 552

def default_kms_key
  @gapi.encryption && @gapi.encryption.default_kms_key_name
end

#default_kms_key=(new_default_kms_key) ⇒ Object

Set the Cloud KMS encryption key that will be used to protect files. For example: projects/a/locations/b/keyRings/c/cryptoKeys/d

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

# KMS key ring must use the same location as the bucket.
kms_key_name = "projects/a/locations/b/keyRings/c/cryptoKeys/d"

bucket.default_kms_key = kms_key_name

Parameters:

  • new_default_kms_key (String)

    New Cloud KMS key name.



574
575
576
577
578
# File 'lib/google/cloud/storage/bucket.rb', line 574

def default_kms_key= new_default_kms_key
  @gapi.encryption = API::Bucket::Encryption.new \
    default_kms_key_name: new_default_kms_key
  patch_gapi! :encryption
end

#deleteBoolean

Permanently deletes the bucket. The bucket must be empty before it can be deleted.

The API call to delete the bucket may be retried under certain conditions. See Google::Cloud#storage to control this behavior.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"
bucket.delete

Returns:

  • (Boolean)

    Returns true if the bucket was deleted.



953
954
955
956
957
# File 'lib/google/cloud/storage/bucket.rb', line 953

def delete
  ensure_service!
  service.delete_bucket name, user_project: user_project
  true
end

#exists?Boolean

Determines whether the bucket exists in the Storage service.

Returns:

  • (Boolean)

    true if the bucket exists in the Storage service.



2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
# File 'lib/google/cloud/storage/bucket.rb', line 2018

def exists?
  # Always true if we have a grpc object
  return true unless lazy?
  # If we have a value, return it
  return @exists unless @exists.nil?
  ensure_gapi!
  @exists = true
rescue Google::Cloud::NotFoundError
  @exists = false
end

#file(path, generation: nil, skip_lookup: nil, encryption_key: nil) ⇒ Google::Cloud::Storage::File? Also known as: find_file

Retrieves a file matching the path.

If a customer-supplied encryption key was used with #create_file, the encryption_key option must be provided or else the file's CRC32C checksum and MD5 hash will not be returned.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

file = bucket.file "path/to/my-file.ext"
puts file.name

Parameters:

  • path (String)

    Name (path) of the file.

  • generation (Integer)

    When present, selects a specific revision of this object. Default is the latest version.

  • skip_lookup (Boolean)

    Optionally create a Bucket object without verifying the bucket resource exists on the Storage service. Calls made on this object will raise errors if the bucket resource does not exist. Default is false.

  • encryption_key (String)

    Optional. The customer-supplied, AES-256 encryption key used to encrypt the file, if one was provided to #create_file. (Not used if skip_lookup is also set.)

Returns:



1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
# File 'lib/google/cloud/storage/bucket.rb', line 1051

def file path, generation: nil, skip_lookup: nil, encryption_key: nil
  ensure_service!
  if skip_lookup
    return File.new_lazy name, path, service,
                         generation: generation,
                         user_project: user_project
  end
  gapi = service.get_file name, path, generation: generation,
                                      key: encryption_key,
                                      user_project: user_project
  File.from_gapi gapi, service, user_project: user_project
rescue Google::Cloud::NotFoundError
  nil
end

#files(prefix: nil, delimiter: nil, token: nil, max: nil, versions: nil) ⇒ Array<Google::Cloud::Storage::File> Also known as: find_files

Retrieves a list of files matching the criteria.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"
files = bucket.files
files.each do |file|
  puts file.name
end

Retrieve all files: (See File::List#all)

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"
files = bucket.files
files.all do |file|
  puts file.name
end

Parameters:

  • prefix (String)

    Filter results to files whose names begin with this prefix.

  • delimiter (String)

    Returns results in a directory-like mode. items will contain only objects whose names, aside from the prefix, do not contain delimiter. Objects whose names, aside from the prefix, contain delimiter will have their name, truncated after the delimiter, returned in prefixes. Duplicate prefixes are omitted.

  • token (String)

    A previously-returned page token representing part of the larger set of results to view.

  • max (Integer)

    Maximum number of items plus prefixes to return. As duplicate prefixes are omitted, fewer total results may be returned than requested. The default value of this parameter is 1,000 items.

  • versions (Boolean)

    If true, lists all versions of an object as distinct results. The default is false. For more information, see Object Versioning .

Returns:



1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
# File 'lib/google/cloud/storage/bucket.rb', line 1006

def files prefix: nil, delimiter: nil, token: nil, max: nil,
          versions: nil
  ensure_service!
  gapi = service.list_files name, prefix: prefix, delimiter: delimiter,
                                  token: token, max: max,
                                  versions: versions,
                                  user_project: user_project
  File::List.from_gapi gapi, service, name, prefix, delimiter, max,
                       versions, user_project: user_project
end

#idString

The ID of the bucket.

Returns:

  • (String)


108
109
110
# File 'lib/google/cloud/storage/bucket.rb', line 108

def id
  @gapi.id
end

#kindString

The kind of item this is. For buckets, this is always storage#bucket.

Returns:

  • (String)


99
100
101
# File 'lib/google/cloud/storage/bucket.rb', line 99

def kind
  @gapi.kind
end

#labelsHash(String => String)

A hash of user-provided labels. The hash is frozen and changes are not allowed.

Returns:

  • (Hash(String => String))


461
462
463
464
465
# File 'lib/google/cloud/storage/bucket.rb', line 461

def labels
  m = @gapi.labels
  m = m.to_h if m.respond_to? :to_h
  m.dup.freeze
end

#labels=(labels) ⇒ Object

Updates the hash of user-provided labels.

Parameters:

  • labels (Hash(String => String))

    The user-provided labels.



472
473
474
475
# File 'lib/google/cloud/storage/bucket.rb', line 472

def labels= labels
  @gapi.labels = labels
  patch_gapi! :labels
end

#lifecycle {|lifecycle| ... } ⇒ Bucket::Lifecycle

Returns the current Object Lifecycle Management rules configuration for the bucket.

This method also accepts a block for updating the bucket's Object Lifecycle Management rules. See Lifecycle for details.

Examples:

Retrieving a bucket's lifecycle management rules.

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket = storage.bucket "my-bucket"

bucket.lifecycle.size #=> 2
rule = bucket.lifecycle.first
rule.action #=> "SetStorageClass"
rule.storage_class #=> "COLDLINE"
rule.age #=> 10
rule.matches_storage_class #=> ["MULTI_REGIONAL", "REGIONAL"]

Updating the bucket's lifecycle management rules in a block.

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket = storage.bucket "my-bucket"

bucket.update do |b|
  b.lifecycle do |l|
    # Remove the last rule from the array
    l.pop
    # Remove rules with the given condition
    l.delete_if do |r|
      r.matches_storage_class.include? "NEARLINE"
    end
    # Update rules
    l.each do |r|
      r.age = 90 if r.action == "Delete"
    end
    # Add a rule
    l.add_set_storage_class_rule "COLDLINE", age: 10
  end
end

Yields:

  • (lifecycle)

    a block for setting Object Lifecycle Management rules

Yield Parameters:

  • lifecycle (Bucket::Lifecycle)

    the object accepting Object Lifecycle Management rules

Returns:

See Also:



262
263
264
265
266
267
268
269
270
271
272
# File 'lib/google/cloud/storage/bucket.rb', line 262

def lifecycle
  lifecycle_builder = Bucket::Lifecycle.from_gapi @gapi.lifecycle
  if block_given?
    yield lifecycle_builder
    if lifecycle_builder.changed?
      @gapi.lifecycle = lifecycle_builder.to_gapi
      patch_gapi! :lifecycle
    end
  end
  lifecycle_builder.freeze # always return frozen objects
end

#locationString

The location of the bucket. Object data for objects in the bucket resides in physical storage within this region. Defaults to US. See the developer's guide for the authoritative list.



284
285
286
# File 'lib/google/cloud/storage/bucket.rb', line 284

def location
  @gapi.location
end

#location_typeString

The bucket's location type. Location type defines the geographic placement of the bucket's data and affects cost, performance, and availability. There are three possible values:

  • region - Lowest latency within a single region
  • multi-region - Highest availability across largest area
  • dual-region - High availability and low latency across 2 regions

Returns:

  • (String)

    The location type code: "region", "multi-region", or "dual-region"



300
301
302
# File 'lib/google/cloud/storage/bucket.rb', line 300

def location_type
  @gapi.location_type
end

#lock_retention_policy!Boolean

PERMANENTLY locks the retention policy (see #retention_period=) on the bucket if one exists. The policy is transitioned to a locked state in which its duration cannot be reduced.

Locked policies can be extended in duration by setting #retention_period= to a higher value. Such an extension is permanent, and it cannot later be reduced. The extended duration will apply retroactively to all files currently in the bucket.

This method also creates a lien on the resourcemanager.projects.delete permission for the project containing the bucket.

The bucket's metageneration value is required for the lock policy API call. Attempting to call this method on a bucket that was loaded with the skip_lookup: true option will result in an error.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

bucket.retention_period = 2592000 # 30 days in seconds
bucket.lock_retention_policy!
bucket.retention_policy_locked? # true

file = bucket.create_file "path/to/local.file.ext"
file.delete # raises Google::Cloud::PermissionDeniedError

# Locked policies can be extended in duration
bucket.retention_period = 7776000 # 90 days in seconds

Returns:

  • (Boolean)

    Returns true if the lock operation is successful.



775
776
777
778
779
780
# File 'lib/google/cloud/storage/bucket.rb', line 775

def lock_retention_policy!
  ensure_service!
  @gapi = service.lock_bucket_retention_policy \
    name, metageneration, user_project: user_project
  true
end

#logging_bucketString

The destination bucket name for the bucket's logs.

Returns:

  • (String)

See Also:



311
312
313
# File 'lib/google/cloud/storage/bucket.rb', line 311

def logging_bucket
  @gapi.logging.log_bucket if @gapi.logging
end

#logging_bucket=(logging_bucket) ⇒ Object

Updates the destination bucket for the bucket's logs.

Parameters:

  • logging_bucket (String)

    The bucket to hold the logging output

See Also:



322
323
324
325
326
# File 'lib/google/cloud/storage/bucket.rb', line 322

def logging_bucket= logging_bucket
  @gapi.logging ||= API::Bucket::Logging.new
  @gapi.logging.log_bucket = logging_bucket
  patch_gapi! :logging
end

#logging_prefixString

The logging object prefix for the bucket's logs. For more information,

Returns:

  • (String)

See Also:



335
336
337
# File 'lib/google/cloud/storage/bucket.rb', line 335

def logging_prefix
  @gapi.logging.log_object_prefix if @gapi.logging
end

#logging_prefix=(logging_prefix) ⇒ Object

Updates the logging object prefix. This prefix will be used to create log object names for the bucket. It can be at most 900 characters and must be a valid object name. By default, the object prefix is the name of the bucket for which the logs are enabled.

Parameters:

  • logging_prefix (String)

    The logging object prefix.

See Also:



351
352
353
354
355
# File 'lib/google/cloud/storage/bucket.rb', line 351

def logging_prefix= logging_prefix
  @gapi.logging ||= API::Bucket::Logging.new
  @gapi.logging.log_object_prefix = logging_prefix
  patch_gapi! :logging
end

#metagenerationInteger

The metadata generation of the bucket.

Returns:

  • (Integer)

    The metageneration.



144
145
146
# File 'lib/google/cloud/storage/bucket.rb', line 144

def metageneration
  @gapi.metageneration
end

#nameString

The name of the bucket.

Returns:

  • (String)


117
118
119
# File 'lib/google/cloud/storage/bucket.rb', line 117

def name
  @gapi.name
end

#notification(id) ⇒ Google::Cloud::Storage::Notification? Also known as: find_notification

Retrieves a Pub/Sub notification subscription for the bucket.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

notification = bucket.notification "1"
puts notification.id

Parameters:

  • id (String)

    The Notification ID.

Returns:

See Also:



1911
1912
1913
1914
1915
1916
1917
# File 'lib/google/cloud/storage/bucket.rb', line 1911

def notification id
  ensure_service!
  gapi = service.get_notification name, id, user_project: user_project
  Notification.from_gapi name, gapi, service, user_project: user_project
rescue Google::Cloud::NotFoundError
  nil
end

#notificationsArray<Google::Cloud::Storage::Notification> Also known as: find_notifications

Retrieves the entire list of Pub/Sub notification subscriptions for the bucket.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"
notifications = bucket.notifications
notifications.each do |notification|
  puts notification.id
end

Returns:

See Also:



1880
1881
1882
1883
1884
1885
1886
1887
# File 'lib/google/cloud/storage/bucket.rb', line 1880

def notifications
  ensure_service!
  gapi = service.list_notifications name, user_project: user_project
  Array(gapi.items).map do |gapi_object|
    Notification.from_gapi name, gapi_object, service,
                           user_project: user_project
  end
end

#policy(force: nil) {|policy| ... } ⇒ Policy

Gets and updates the Cloud IAM access control policy for this bucket.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"

policy = bucket.policy

Retrieve the latest policy and update it in a block:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"

bucket.policy do |p|
  p.add "roles/owner", "user:owner@example.com"
end

Parameters:

  • force (Boolean)

    [Deprecated] Force the latest policy to be retrieved from the Storage service when true. Deprecated because the latest policy is now always retrieved. The default is nil.

Yields:

  • (policy)

    A block for updating the policy. The latest policy will be read from the service and passed to the block. After the block completes, the modified policy will be written to the service.

Yield Parameters:

  • policy (Policy)

    the current Cloud IAM Policy for this bucket

Returns:

  • (Policy)

    the current Cloud IAM Policy for this bucket

See Also:



1776
1777
1778
1779
1780
1781
1782
1783
1784
# File 'lib/google/cloud/storage/bucket.rb', line 1776

def policy force: nil
  warn "DEPRECATED: 'force' in Bucket#policy" unless force.nil?
  ensure_service!
  gapi = service.get_bucket_policy name, user_project: user_project
  policy = Policy.from_gapi gapi
  return policy unless block_given?
  yield policy
  update_policy policy
end

#policy_only=(new_policy_only) ⇒ Object

If enabled, access checks only use bucket-level IAM policies or above, all object ACLs within the bucket are no longer evaluated, and access-control is configured solely through the bucket's IAM policy. Any requests which attempt to use the ACL API to view or manipulate ACLs will fail with 400 errors.

Before enabling Bucket Policy Only please review feature documentation, as well as Should you use Bucket Policy Only?.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

bucket.policy_only = true
bucket.policy_only? # true

bucket.default_acl.public! # Google::Cloud::InvalidArgumentError

# The deadline for disabling Bucket Policy Only.
puts bucket.policy_only_locked_at

Parameters:

  • new_policy_only (Boolean)

    When set to true, Bucket Policy Only is enabled in the bucket's IAM configuration.



845
846
847
848
849
850
851
852
853
854
855
# File 'lib/google/cloud/storage/bucket.rb', line 845

def policy_only= new_policy_only
  @gapi.iam_configuration ||= API::Bucket::IamConfiguration.new
  @gapi.iam_configuration.bucket_policy_only ||= \
    API::Bucket::IamConfiguration::BucketPolicyOnly.new
  @gapi.iam_configuration.uniform_bucket_level_access ||= \
    API::Bucket::IamConfiguration::UniformBucketLevelAccess.new
  @gapi.iam_configuration.bucket_policy_only.enabled = new_policy_only
  @gapi.iam_configuration.uniform_bucket_level_access.enabled = \
    new_policy_only
  patch_gapi! :iam_configuration
end

#policy_only?Boolean

Whether the bucket's file IAM configuration enables Bucket Policy Only. The default is false. This value can be modified by calling #policy_only=.

If true, access checks only use bucket-level IAM policies or above, all object ACLs within the bucket are no longer evaluated, and access-control is configured solely through the bucket's IAM policy. Any requests which attempt to use the ACL API to view or manipulate ACLs will fail with 400 errors.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

bucket.policy_only = true
bucket.policy_only? # true

Returns:

  • (Boolean)

    Returns false if the bucket has no IAM configuration or if Bucket Policy Only is not enabled in the IAM configuration. Returns true if Bucket Policy Only is enabled in the IAM configuration.



808
809
810
811
812
813
# File 'lib/google/cloud/storage/bucket.rb', line 808

def policy_only?
  return false unless @gapi.iam_configuration &&
                      @gapi.iam_configuration.bucket_policy_only
  !@gapi.iam_configuration.bucket_policy_only.enabled.nil? &&
    @gapi.iam_configuration.bucket_policy_only.enabled
end

#policy_only_locked_atDateTime?

The deadline time for disabling Bucket Policy Only by calling #policy_only=. After the locked time the Bucket Policy Only setting cannot be changed from true to false. Corresponds to the property locked_time.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

bucket.policy_only = true

# The deadline for disabling Bucket Policy Only.
puts bucket.policy_only_locked_at

Returns:



879
880
881
882
883
# File 'lib/google/cloud/storage/bucket.rb', line 879

def policy_only_locked_at
  return nil unless @gapi.iam_configuration &&
                    @gapi.iam_configuration.bucket_policy_only
  @gapi.iam_configuration.bucket_policy_only.locked_time
end

#post_object(path, policy: nil, issuer: nil, client_email: nil, signing_key: nil, private_key: nil) ⇒ PostObject

Generate a PostObject that includes the fields and url to upload objects via html forms.

Generating a PostObject requires service account credentials, either by connecting with a service account when calling Google::Cloud.storage, or by passing in the service account issuer and signing_key values. Although the private key can be passed as a string for convenience, creating and storing an instance of # OpenSSL::PKey::RSA is more efficient when making multiple calls to post_object.

A SignedUrlUnavailable is raised if the service account credentials are missing. Service account credentials are acquired by following the steps in Service Account Authentication.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"
post = bucket.post_object "avatars/heidi/400x400.png"

post.url #=> "https://storage.googleapis.com"
post.fields[:key] #=> "my-todo-app/avatars/heidi/400x400.png"
post.fields[:GoogleAccessId] #=> "0123456789@gserviceaccount.com"
post.fields[:signature] #=> "ABC...XYZ="
post.fields[:policy] #=> "ABC...XYZ="

Using a policy to define the upload authorization:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

policy = {
  expiration: (Time.now + 3600).iso8601,
  conditions: [
    ["starts-with", "$key", ""],
    {acl: "bucket-owner-read"},
    {bucket: "travel-maps"},
    {success_action_redirect: "http://example.com/success.html"},
    ["eq", "$Content-Type", "image/jpeg"],
    ["content-length-range", 0, 1000000]
  ]
}

bucket = storage.bucket "my-todo-app"
post = bucket.post_object "avatars/heidi/400x400.png",
                           policy: policy

post.url #=> "https://storage.googleapis.com"
post.fields[:key] #=> "my-todo-app/avatars/heidi/400x400.png"
post.fields[:GoogleAccessId] #=> "0123456789@gserviceaccount.com"
post.fields[:signature] #=> "ABC...XYZ="
post.fields[:policy] #=> "ABC...XYZ="

Using the issuer and signing_key options:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"
key = OpenSSL::PKey::RSA.new
post = bucket.post_object "avatars/heidi/400x400.png",
                          issuer: "service-account@gcloud.com",
                          signing_key: key

post.url #=> "https://storage.googleapis.com"
post.fields[:key] #=> "my-todo-app/avatars/heidi/400x400.png"
post.fields[:GoogleAccessId] #=> "0123456789@gserviceaccount.com"
post.fields[:signature] #=> "ABC...XYZ="
post.fields[:policy] #=> "ABC...XYZ="

Parameters:

  • path (String)

    Path to the file in Google Cloud Storage.

  • policy (Hash)

    The security policy that describes what can and cannot be uploaded in the form. When provided, the PostObject fields will include a Signature based on the JSON representation of this Hash and the same policy in Base64 format. If you do not provide a security policy, requests are considered to be anonymous and will only work with buckets that have granted WRITE or FULL_CONTROL permission to anonymous users. See Policy Document for more information.

  • issuer (String)

    Service Account's Client Email.

  • client_email (String)

    Service Account's Client Email.

  • signing_key (OpenSSL::PKey::RSA, String)

    Service Account's Private Key.

  • private_key (OpenSSL::PKey::RSA, String)

    Service Account's Private Key.

Returns:

See Also:



1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
# File 'lib/google/cloud/storage/bucket.rb', line 1633

def post_object path, policy: nil, issuer: nil,
                client_email: nil, signing_key: nil,
                private_key: nil
  ensure_service!

  signer = File::SignerV2.from_bucket self, path
  signer.post_object issuer: issuer, client_email: client_email,
                     signing_key: signing_key, private_key: private_key,
                     policy: policy
end

#reload!Object Also known as: refresh!

Reloads the bucket with current data from the Storage service.



2004
2005
2006
2007
2008
2009
2010
# File 'lib/google/cloud/storage/bucket.rb', line 2004

def reload!
  ensure_service!
  @gapi = service.get_bucket name, user_project: user_project
  # If NotFound then lazy will never be unset
  @lazy = nil
  self
end

#requester_paysBoolean? Also known as: requester_pays?

Indicates that a client accessing the bucket or a file it contains must assume the transit costs related to the access. The requester must pass the user_project option to Project#bucket and Project#buckets to indicate the project to which the access costs should be billed.

Returns:

  • (Boolean, nil)

    Returns true if requester pays is enabled for the bucket.



500
501
502
# File 'lib/google/cloud/storage/bucket.rb', line 500

def requester_pays
  @gapi.billing.requester_pays if @gapi.billing
end

#requester_pays=(new_requester_pays) ⇒ Object

Enables requester pays for the bucket. If enabled, a client accessing the bucket or a file it contains must assume the transit costs related to the access. The requester must pass the user_project option to Project#bucket and Project#buckets to indicate the project to which the access costs should be billed.

Examples:

Enable requester pays for a bucket:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

bucket.requester_pays = true # API call
# Other projects must now provide `user_project` option when calling
# Project#bucket or Project#buckets to access this bucket.

Parameters:

  • new_requester_pays (Boolean)

    When set to true, requester pays is enabled for the bucket.



526
527
528
529
530
# File 'lib/google/cloud/storage/bucket.rb', line 526

def requester_pays= new_requester_pays
  @gapi.billing ||= API::Bucket::Billing.new
  @gapi.billing.requester_pays = new_requester_pays
  patch_gapi! :billing
end

#retention_effective_atDateTime?

The time from which the retention policy was effective. Whenever a retention policy is created or extended, GCS updates the effective date of the policy. The effective date signals the date starting from which objects were guaranteed to be retained for the full duration of the policy.

This field is updated when the retention policy is created or modified, including extension of a locked policy.

Returns:

  • (DateTime, nil)

    The effective date of the bucket's retention policy, if a policy exists.



650
651
652
# File 'lib/google/cloud/storage/bucket.rb', line 650

def retention_effective_at
  @gapi.retention_policy && @gapi.retention_policy.effective_time
end

#retention_periodInteger?

The period of time (in seconds) that files in the bucket must be retained, and cannot be deleted, overwritten, or archived. The value must be between 0 and 100 years (in seconds.)

See also: #retention_period=, #retention_effective_at, and #retention_policy_locked?.

Returns:

  • (Integer, nil)

    The retention period defined in seconds, if a retention policy exists for the bucket.



591
592
593
# File 'lib/google/cloud/storage/bucket.rb', line 591

def retention_period
  @gapi.retention_policy && @gapi.retention_policy.retention_period
end

#retention_period=(new_retention_period) ⇒ Object

The period of time (in seconds) that files in the bucket must be retained, and cannot be deleted, overwritten, or archived. Passing a valid Integer value will add a new retention policy to the bucket if none exists. Passing nil will remove the retention policy from the bucket if it exists, unless the policy is locked.

Locked policies can be extended in duration by using this method to set a higher value. Such an extension is permanent, and it cannot later be reduced. The extended duration will apply retroactively to all files currently in the bucket.

See also: #lock_retention_policy!, #retention_period, #retention_effective_at, and #retention_policy_locked?.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

bucket.retention_period = 2592000 # 30 days in seconds

file = bucket.create_file "path/to/local.file.ext"
file.delete # raises Google::Cloud::PermissionDeniedError

Parameters:

  • new_retention_period (Integer, nil)

    The retention period defined in seconds. The value must be between 0 and 100 years (in seconds), or nil.



626
627
628
629
630
631
632
633
634
635
# File 'lib/google/cloud/storage/bucket.rb', line 626

def retention_period= new_retention_period
  if new_retention_period.nil?
    @gapi.retention_policy = nil
  else
    @gapi.retention_policy ||= API::Bucket::RetentionPolicy.new
    @gapi.retention_policy.retention_period = new_retention_period
  end

  patch_gapi! :retention_policy
end

#retention_policy_locked?Boolean

Whether the bucket's file retention policy is locked and its retention period cannot be reduced. See #retention_period= and #lock_retention_policy!.

This value can only be set to true by calling #lock_retention_policy!.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-bucket"

bucket.retention_period = 2592000 # 30 days in seconds
bucket.lock_retention_policy!
bucket.retention_policy_locked? # true

file = bucket.create_file "path/to/local.file.ext"
file.delete # raises Google::Cloud::PermissionDeniedError

Returns:

  • (Boolean)

    Returns false if there is no retention policy or if the retention policy is unlocked and the retention period can be reduced. Returns true if the retention policy is locked and the retention period cannot be reduced.



681
682
683
684
685
# File 'lib/google/cloud/storage/bucket.rb', line 681

def retention_policy_locked?
  return false unless @gapi.retention_policy
  !@gapi.retention_policy.is_locked.nil? &&
    @gapi.retention_policy.is_locked
end

#signed_url(path = nil, method: nil, expires: nil, content_type: nil, content_md5: nil, headers: nil, issuer: nil, client_email: nil, signing_key: nil, private_key: nil, query: nil, version: nil) ⇒ String

Generates a signed URL. See Signed URLs for more information.

Generating a signed URL requires service account credentials, either by connecting with a service account when calling Google::Cloud.storage, or by passing in the service account issuer and signing_key values. Although the private key can be passed as a string for convenience, creating and storing an instance of OpenSSL::PKey::RSA is more efficient when making multiple calls to signed_url.

A SignedUrlUnavailable is raised if the service account credentials are missing. Service account credentials are acquired by following the steps in Service Account Authentication.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"
shared_url = bucket.signed_url "avatars/heidi/400x400.png"

Using the expires and version options:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"
shared_url = bucket.signed_url "avatars/heidi/400x400.png",
                               expires: 300, # 5 minutes from now
                               version: :v4

Using the issuer and signing_key options:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"
key = OpenSSL::PKey::RSA.new "-----BEGIN PRIVATE KEY-----\n..."
shared_url = bucket.signed_url "avatars/heidi/400x400.png",
                               issuer: "service-account@gcloud.com",
                               signing_key: key

Using the headers option:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"
shared_url = bucket.signed_url "avatars/heidi/400x400.png",
                               headers: {
                                 "x-goog-acl" => "private",
                                 "x-goog-meta-foo" => "bar,baz"
                               }

Generating a signed URL for resumable upload:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"
url = bucket.signed_url "avatars/heidi/400x400.png",
                        method: "POST",
                        content_type: "image/png",
                        headers: {
                          "x-goog-resumable" => "start"
                        }
# Send the `x-goog-resumable:start` header and the content type
# with the resumable upload POST request.

Omitting path for a URL to list all files in the bucket.

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"
list_files_url = bucket.signed_url version: :v4

Parameters:

  • path (String, nil) (defaults to: nil)

    Path to the file in Google Cloud Storage, or nil to generate a URL for listing all files in the bucket.

  • method (String)

    The HTTP verb to be used with the signed URL. Signed URLs can be used with GET, HEAD, PUT, and DELETE requests. Default is GET.

  • expires (Integer)

    The number of seconds until the URL expires. If the version is :v2, the default is 300 (5 minutes). If the version is :v4, the default is 604800 (7 days).

  • content_type (String)

    When provided, the client (browser) must send this value in the HTTP header. e.g. text/plain. This param is not used if the version is :v4.

  • content_md5 (String)

    The MD5 digest value in base64. If you provide this in the string, the client (usually a browser) must provide this HTTP header with this same value in its request. This param is not used if the version is :v4.

  • headers (Hash)

    Google extension headers (custom HTTP headers that begin with x-goog-) that must be included in requests that use the signed URL.

  • issuer (String)

    Service Account's Client Email.

  • client_email (String)

    Service Account's Client Email.

  • signing_key (OpenSSL::PKey::RSA, String)

    Service Account's Private Key.

  • private_key (OpenSSL::PKey::RSA, String)

    Service Account's Private Key.

  • query (Hash)

    Query string parameters to include in the signed URL. The given parameters are not verified by the signature.

    Parameters such as response-content-disposition and response-content-type can alter the behavior of the response when using the URL, but only when the file resource is missing the corresponding values. (These values can be permanently set using File#content_disposition= and File#content_type=.)

  • version (Symbol, String)

    The version of the signed credential to create. Must be one of :v2 or :v4. The default value is :v2.

Returns:

  • (String)

See Also:



1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
# File 'lib/google/cloud/storage/bucket.rb', line 1510

def signed_url path = nil, method: nil, expires: nil, content_type: nil,
               content_md5: nil, headers: nil, issuer: nil,
               client_email: nil, signing_key: nil, private_key: nil,
               query: nil, version: nil
  ensure_service!
  version ||= :v2
  case version.to_sym
  when :v2
    signer = File::SignerV2.from_bucket self, path
    signer.signed_url method: method, expires: expires,
                      headers: headers, content_type: content_type,
                      content_md5: content_md5, issuer: issuer,
                      client_email: client_email,
                      signing_key: signing_key,
                      private_key: private_key, query: query
  when :v4
    signer = File::SignerV4.from_bucket self, path
    signer.signed_url method: method, expires: expires,
                      headers: headers, issuer: issuer,
                      client_email: client_email,
                      signing_key: signing_key,
                      private_key: private_key, query: query
  else
    raise ArgumentError, "version '#{version}' not supported"
  end
end

#storage_classString

The bucket's storage class. This defines how objects in the bucket are stored and determines the SLA and the cost of storage. Values include STANDARD, NEARLINE, and COLDLINE. REGIONAL,MULTI_REGIONAL, and DURABLE_REDUCED_AVAILABILITY are supported as legacy storage classes.

Returns:

  • (String)


366
367
368
# File 'lib/google/cloud/storage/bucket.rb', line 366

def storage_class
  @gapi.storage_class
end

#storage_class=(new_storage_class) ⇒ Object

Updates the bucket's storage class. This defines how objects in the bucket are stored and determines the SLA and the cost of storage. Accepted values include :standard, :nearline, and :coldline, as well as the equivalent strings returned by #storage_class. :multi_regional, :regional, and durable_reduced_availability are accepted as legacy storage classes. For more information, see Storage Classes.

Parameters:

  • new_storage_class (Symbol, String)

    Storage class of the bucket.



382
383
384
385
# File 'lib/google/cloud/storage/bucket.rb', line 382

def storage_class= new_storage_class
  @gapi.storage_class = storage_class_for new_storage_class
  patch_gapi! :storage_class
end

#test_permissions(*permissions) ⇒ Array<String>

Tests the specified permissions against the Cloud IAM access control policy.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"

permissions = bucket.test_permissions "storage.buckets.get",
                                      "storage.buckets.delete"
permissions.include? "storage.buckets.get"    #=> true
permissions.include? "storage.buckets.delete" #=> false

Parameters:

  • permissions (String, Array<String>)

    The set of permissions against which to check access. Permissions must be of the format storage.resource.capability, where resource is one of buckets or objects.

Returns:

  • (Array<String>)

    The permissions held by the caller.

See Also:



1852
1853
1854
1855
1856
1857
1858
# File 'lib/google/cloud/storage/bucket.rb', line 1852

def test_permissions *permissions
  permissions = Array(permissions).flatten
  ensure_service!
  gapi = service.test_bucket_permissions name, permissions,
                                         user_project: user_project
  gapi.permissions
end

#update {|bucket| ... } ⇒ Object

Updates the bucket with changes made in the given block in a single PATCH request. The following attributes may be set: #cors, #logging_bucket=, #logging_prefix=, #versioning=, #website_main=, #website_404=, and #requester_pays=.

In addition, the #cors configuration accessible in the block is completely mutable and will be included in the request. (See Cors)

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"
bucket.update do |b|
  b.website_main = "index.html"
  b.website_404 = "not_found.html"
  b.cors[0].methods = ["GET","POST","DELETE"]
  b.cors[1].headers << "X-Another-Custom-Header"
end

New CORS rules can also be added in a nested block:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket = storage.bucket "my-todo-app"

bucket.update do |b|
  b.cors do |c|
    c.add_rule ["http://example.org", "https://example.org"],
               "*",
               headers: ["X-My-Custom-Header"],
               max_age: 300
  end
end

Yields:

  • (bucket)

    a block yielding a delegate object for updating the file



926
927
928
929
930
931
932
933
934
# File 'lib/google/cloud/storage/bucket.rb', line 926

def update
  updater = Updater.new @gapi
  yield updater
  # Add check for mutable cors
  updater.check_for_changed_labels!
  updater.check_for_mutable_cors!
  updater.check_for_mutable_lifecycle!
  patch_gapi! updater.updates unless updater.updates.empty?
end

#update_policy(new_policy) ⇒ Policy Also known as: policy=

Updates the Cloud IAM access control policy for this bucket. The policy should be read from #policy. See Policy for an explanation of the policy etag property and how to modify policies.

You can also update the policy by passing a block to #policy, which will call this method internally after the block completes.

Examples:

require "google/cloud/storage"

storage = Google::Cloud::Storage.new

bucket = storage.bucket "my-todo-app"

policy = bucket.policy # API call

policy.add "roles/owner", "user:owner@example.com"

bucket.update_policy policy # API call

Parameters:

  • new_policy (Policy)

    a new or modified Cloud IAM Policy for this bucket

Returns:

  • (Policy)

    The policy returned by the API update operation.

See Also:



1818
1819
1820
1821
1822
1823
# File 'lib/google/cloud/storage/bucket.rb', line 1818

def update_policy new_policy
  ensure_service!
  gapi = service.set_bucket_policy name, new_policy.to_gapi,
                                   user_project: user_project
  Policy.from_gapi gapi
end

#versioning=(new_versioning) ⇒ Object

Updates whether Object Versioning is enabled for the bucket.

Parameters:

  • new_versioning (Boolean)

    true if versioning is to be enabled for the bucket.



406
407
408
409
410
# File 'lib/google/cloud/storage/bucket.rb', line 406

def versioning= new_versioning
  @gapi.versioning ||= API::Bucket::Versioning.new
  @gapi.versioning.enabled = new_versioning
  patch_gapi! :versioning
end

#versioning?Boolean

Whether Object Versioning is enabled for the bucket.

Returns:

  • (Boolean)


394
395
396
# File 'lib/google/cloud/storage/bucket.rb', line 394

def versioning?
  @gapi.versioning.enabled? unless @gapi.versioning.nil?
end

#website_404String

The page returned from a static website served from the bucket when a site visitor requests a resource that does not exist.

Returns:

  • (String)

See Also:



451
452
453
# File 'lib/google/cloud/storage/bucket.rb', line 451

def website_404
  @gapi.website.not_found_page if @gapi.website
end

#website_404=(website_404) ⇒ Object

Updates the page returned from a static website served from the bucket when a site visitor requests a resource that does not exist.



484
485
486
487
488
# File 'lib/google/cloud/storage/bucket.rb', line 484

def website_404= website_404
  @gapi.website ||= API::Bucket::Website.new
  @gapi.website.not_found_page = website_404
  patch_gapi! :website
end

#website_mainString

The main page suffix for a static website. If the requested object path is missing, the service will ensure the path has a trailing '/', append this suffix, and attempt to retrieve the resulting object. This allows the creation of index.html objects to represent directory pages.

Returns:

  • (String)

    The main page suffix.

See Also:



424
425
426
# File 'lib/google/cloud/storage/bucket.rb', line 424

def website_main
  @gapi.website.main_page_suffix if @gapi.website
end

#website_main=(website_main) ⇒ Object

Updates the main page suffix for a static website.

Parameters:

  • website_main (String)

    The main page suffix.

See Also:



436
437
438
439
440
# File 'lib/google/cloud/storage/bucket.rb', line 436

def website_main= website_main
  @gapi.website ||= API::Bucket::Website.new
  @gapi.website.main_page_suffix = website_main
  patch_gapi! :website
end