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.



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

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 



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

def credentials
  @credentials
end

#project ⇒ Object

Returns the value of attribute project.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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 



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

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

#list_bucket_acls(bucket_name) ⇒ Object

Retrieves a list of ACLs for the given bucket.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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



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

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