Class: Gcloud::Storage::Connection

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

Overview

as well as expose the API calls.

Constant Summary collapse

API_VERSION = 
"v1"

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(project, credentials) ⇒ Connection

Creates a new Connection instance.



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

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 



33
34
35
 
# File 'lib/gcloud/storage/connection.rb', line 33

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.



218
219
220
221
222
223
224
225
226
227
228
229
 
# File 'lib/gcloud/storage/connection.rb', line 218

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.



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

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.



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

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.



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

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.



259
260
261
262
263
264
265
 
# File 'lib/gcloud/storage/connection.rb', line 259

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.



291
292
293
294
295
296
297
298
299
 
# File 'lib/gcloud/storage/connection.rb', line 291

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.



233
234
235
236
237
238
239
240
 
# File 'lib/gcloud/storage/connection.rb', line 233

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.



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

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.



206
207
208
209
210
211
212
213
214
 
# File 'lib/gcloud/storage/connection.rb', line 206

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.



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

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.



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

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.



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

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.



278
279
280
281
282
283
284
285
286
287
 
# File 'lib/gcloud/storage/connection.rb', line 278

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 



309
310
311
 
# File 'lib/gcloud/storage/connection.rb', line 309

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

#list_bucket_acls(bucket_name) ⇒ Object

Retrieves a list of ACLs for the given bucket.



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

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.



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

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.



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

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.



269
270
271
272
273
274
 
# File 'lib/gcloud/storage/connection.rb', line 269

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.



169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/gcloud/storage/connection.rb', line 169

def list_files bucket_name, options = {}
  params = {
    bucket:     bucket_name,
    prefix:     options[:prefix],
    delimiter:  options[:delimiter],
    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.



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

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.



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

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.



244
245
246
247
248
249
250
251
252
253
254
255
 
# File 'lib/gcloud/storage/connection.rb', line 244

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 = {}



192
193
194
195
196
197
198
199
200
201
202
 
# File 'lib/gcloud/storage/connection.rb', line 192

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