Class: Gcloud::Storage::Connection

Inherits:
Object
  • Object
show all
Defined in:
lib/gcloud/storage/connection.rb

Overview

Represents the connection to Storage, as well as expose the API calls.

Constant Summary collapse

API_VERSION =

:nodoc:

"v1"

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(project, credentials) ⇒ Connection

Creates a new Connection instance.



35
36
37
38
39
40
41
42
 
# File 'lib/gcloud/storage/connection.rb', line 35

def initialize project, credentials
  @project = project
  @credentials = credentials
  @client = Google::APIClient.new application_name:    "gcloud-ruby",
                                  application_version: Gcloud::VERSION
  @client.authorization = @credentials.client
  @storage = @client.discovered_api "storage", API_VERSION
end

Instance Attribute Details

#credentials ⇒ Object

:nodoc:



31
32
33
 
# File 'lib/gcloud/storage/connection.rb', line 31

def credentials
  @credentials
end

#project ⇒ Object

Returns the value of attribute project.



30
31
32
 
# File 'lib/gcloud/storage/connection.rb', line 30

def project
  @project
end

Instance Method Details

#copy_file(source_bucket_name, source_file_path, destination_bucket_name, destination_file_path, options = {}) ⇒ Object

Copy a file from source bucket/object to a destination bucket/object.



214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/gcloud/storage/connection.rb', line 214

def copy_file source_bucket_name, source_file_path,
              destination_bucket_name, destination_file_path, options = {}
  @client.execute(
    api_method: @storage.objects.copy,
    parameters: { sourceBucket: source_bucket_name,
                  sourceObject: source_file_path,
                  sourceGeneration: options[:generation],
                  destinationBucket: destination_bucket_name,
                  destinationObject: destination_file_path,
                  predefinedAcl: options[:acl]
                }.delete_if { |_, v| v.nil? })
end

#delete_bucket(bucket_name, opts = {}) ⇒ Object

Permanently deletes an empty bucket.



100
101
102
103
104
105
106
107
 
# File 'lib/gcloud/storage/connection.rb', line 100

def delete_bucket bucket_name, opts = {}
  incremental_backoff opts do
    @client.execute(
      api_method: @storage.buckets.delete,
      parameters: { bucket: bucket_name }
    )
  end
end

#delete_bucket_acl(bucket_name, entity) ⇒ Object

Permanently deletes a bucket ACL.



130
131
132
133
134
135
 
# File 'lib/gcloud/storage/connection.rb', line 130

def delete_bucket_acl bucket_name, entity
  @client.execute(
    api_method: @storage.bucket_access_controls.delete,
    parameters: { bucket: bucket_name, entity: entity }
  )
end

#delete_default_acl(bucket_name, entity) ⇒ Object

Permanently deletes a default ACL.



158
159
160
161
162
163
 
# File 'lib/gcloud/storage/connection.rb', line 158

def delete_default_acl bucket_name, entity
  @client.execute(
    api_method: @storage.default_object_access_controls.delete,
    parameters: { bucket: bucket_name, entity: entity }
  )
end

#delete_file(bucket_name, file_path) ⇒ Object

Permanently deletes a file.



255
256
257
258
259
260
261
 
# File 'lib/gcloud/storage/connection.rb', line 255

def delete_file bucket_name, file_path
  @client.execute(
    api_method: @storage.objects.delete,
    parameters: { bucket: bucket_name,
                  object: file_path }
  )
end

#delete_file_acl(bucket_name, file_name, entity, options = {}) ⇒ Object

Permanently deletes a file ACL.



287
288
289
290
291
292
293
294
295
 
# File 'lib/gcloud/storage/connection.rb', line 287

def delete_file_acl bucket_name, file_name, entity, options = {}
  query = { bucket: bucket_name, object: file_name, entity: entity }
  query[:generation] = options[:generation] if options[:generation]

  @client.execute(
    api_method: @storage.object_access_controls.delete,
    parameters: query
  )
end

#download_file(bucket_name, file_path) ⇒ Object

Download contents of a file.



229
230
231
232
233
234
235
236
 
# File 'lib/gcloud/storage/connection.rb', line 229

def download_file bucket_name, file_path
  @client.execute(
    api_method: @storage.objects.get,
    parameters: { bucket: bucket_name,
                  object: file_path,
                  alt: :media }
  )
end

#get_bucket(bucket_name) ⇒ Object

Retrieves bucket by name.



60
61
62
63
64
65
 
# File 'lib/gcloud/storage/connection.rb', line 60

def get_bucket bucket_name
  @client.execute(
    api_method: @storage.buckets.get,
    parameters: { bucket: bucket_name }
  )
end

#get_file(bucket_name, file_path, options = {}) ⇒ Object

Retrieves an object or its metadata.



202
203
204
205
206
207
208
209
210
 
# File 'lib/gcloud/storage/connection.rb', line 202

def get_file bucket_name, file_path, options = {}
  query = { bucket: bucket_name, object: file_path }
  query[:generation] = options[:generation] if options[:generation]

  @client.execute(
    api_method: @storage.objects.get,
    parameters: query
  )
end

#insert_bucket(bucket_name, options = {}) ⇒ Object

Creates a new bucket.



69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/gcloud/storage/connection.rb', line 69

def insert_bucket bucket_name, options = {}
  params = { project: @project, predefinedAcl: options[:acl],
             predefinedDefaultObjectAcl: options[:default_acl]
           }.delete_if { |_, v| v.nil? }

  incremental_backoff options do
    @client.execute(
      api_method: @storage.buckets.insert,
      parameters: params,
      body_object: insert_bucket_request(bucket_name, options)
    )
  end
end

#insert_bucket_acl(bucket_name, entity, role) ⇒ Object

Creates a new bucket ACL.



120
121
122
123
124
125
126
 
# File 'lib/gcloud/storage/connection.rb', line 120

def insert_bucket_acl bucket_name, entity, role
  @client.execute(
    api_method: @storage.bucket_access_controls.insert,
    parameters: { bucket: bucket_name },
    body_object: { entity: entity, role: role }
  )
end

#insert_default_acl(bucket_name, entity, role) ⇒ Object

Creates a new default ACL.



148
149
150
151
152
153
154
 
# File 'lib/gcloud/storage/connection.rb', line 148

def insert_default_acl bucket_name, entity, role
  @client.execute(
    api_method: @storage.default_object_access_controls.insert,
    parameters: { bucket: bucket_name },
    body_object: { entity: entity, role: role }
  )
end

#insert_file_acl(bucket_name, file_name, entity, role, options = {}) ⇒ Object

Creates a new file ACL.



274
275
276
277
278
279
280
281
282
283
 
# File 'lib/gcloud/storage/connection.rb', line 274

def insert_file_acl bucket_name, file_name, entity, role, options = {}
  query = { bucket: bucket_name, object: file_name }
  query[:generation] = options[:generation] if options[:generation]

  @client.execute(
    api_method: @storage.object_access_controls.insert,
    parameters: query,
    body_object: { entity: entity, role: role }
  )
end

#inspect ⇒ Object

:nodoc:



304
305
306
 
# File 'lib/gcloud/storage/connection.rb', line 304

def inspect #:nodoc:
  "#{self.class}(#{@project})"
end

#list_bucket_acls(bucket_name) ⇒ Object

Retrieves a list of ACLs for the given bucket.



111
112
113
114
115
116
 
# File 'lib/gcloud/storage/connection.rb', line 111

def list_bucket_acls bucket_name
  @client.execute(
    api_method: @storage.bucket_access_controls.list,
    parameters: { bucket: bucket_name }
  )
end

#list_buckets(options = {}) ⇒ Object

Retrieves a list of buckets for the given project.



46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/gcloud/storage/connection.rb', line 46

def list_buckets options = {}
  params = { project: @project }
  params["prefix"]     = options[:prefix] if options[:prefix]
  params["pageToken"]  = options[:token]  if options[:token]
  params["maxResults"] = options[:max]    if options[:max]

  @client.execute(
    api_method: @storage.buckets.list,
    parameters: params
  )
end

#list_default_acls(bucket_name) ⇒ Object

Retrieves a list of default ACLs for the given bucket.



139
140
141
142
143
144
 
# File 'lib/gcloud/storage/connection.rb', line 139

def list_default_acls bucket_name
  @client.execute(
    api_method: @storage.default_object_access_controls.list,
    parameters: { bucket: bucket_name }
  )
end

#list_file_acls(bucket_name, file_name) ⇒ Object

Retrieves a list of ACLs for the given file.



265
266
267
268
269
270
 
# File 'lib/gcloud/storage/connection.rb', line 265

def list_file_acls bucket_name, file_name
  @client.execute(
    api_method: @storage.object_access_controls.list,
    parameters: { bucket: bucket_name, object: file_name }
  )
end

#list_files(bucket_name, options = {}) ⇒ Object

Retrieves a list of files matching the criteria.



167
168
169
170
171
172
173
174
175
176
177
178
179
 
# File 'lib/gcloud/storage/connection.rb', line 167

def list_files bucket_name, options = {}
  params = { bucket:     bucket_name,
             prefix:     options[:prefix],
             pageToken:  options[:token],
             maxResults: options[:max],
             versions:   options[:versions]
           }.delete_if { |_, v| v.nil? }

  @client.execute(
    api_method: @storage.objects.list,
    parameters: params
  )
end

#mime_type_for(path) ⇒ Object

Retrieves the mime-type for a file path. An empty string is returned if no mime-type can be found.



300
301
302
 
# File 'lib/gcloud/storage/connection.rb', line 300

def mime_type_for path
  MIME::Types.of(path).first.to_s
end

#patch_bucket(bucket_name, options = {}) ⇒ Object

Updates a bucket, including its ACL metadata.



85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/gcloud/storage/connection.rb', line 85

def patch_bucket bucket_name, options = {}
  params = { bucket: bucket_name,
             predefinedAcl: options[:predefined_acl],
             predefinedDefaultObjectAcl: options[:predefined_default_acl]
           }.delete_if { |_, v| v.nil? }

  @client.execute(
    api_method: @storage.buckets.patch,
    parameters: params,
    body_object: patch_bucket_request(options)
  )
end

#patch_file(bucket_name, file_path, options = {}) ⇒ Object

Updates a file’s metadata.



240
241
242
243
244
245
246
247
248
249
250
251
 
# File 'lib/gcloud/storage/connection.rb', line 240

def patch_file bucket_name, file_path, options = {}
  params = { bucket: bucket_name,
             object: file_path,
             predefinedAcl: options[:predefined_acl]
           }.delete_if { |_, v| v.nil? }

  @client.execute(
    api_method: @storage.objects.patch,
    parameters: params,
    body_object: patch_file_request(options)
  )
end

#upload_file(resumable, bucket_name, file, path = nil, options = {}) ⇒ Object

Stores a new object and metadata. If resumable is true, a resumable upload, otherwise uses a multipart form post.

UploadIO comes from Faraday, which gets it from multipart-post The initializer signature is: filename_or_io, content_type, filename = nil, opts = {}



188
189
190
191
192
193
194
195
196
197
198
 
# File 'lib/gcloud/storage/connection.rb', line 188

def upload_file resumable, bucket_name, file, path = nil, options = {}
  local_path = Pathname(file).to_path
  options[:content_type] ||= mime_type_for(local_path)
  media = file_media local_path, options, resumable
  upload_path = Pathname(path || local_path).to_path
  result = insert_file resumable, bucket_name, upload_path, media, options
  return result unless resumable
  upload = result.resumable_upload
  result = @client.execute upload while upload.resumable?
  result
end