Class: Fog::Storage::HP::Real

Inherits:
Object
  • Object
show all
Includes:
Utils
Defined in:
lib/fog/hp/storage.rb,
lib/fog/hp/requests/storage/get_object.rb,
lib/fog/hp/requests/storage/put_object.rb,
lib/fog/hp/requests/storage/head_object.rb,
lib/fog/hp/requests/storage/delete_object.rb,
lib/fog/hp/requests/storage/get_container.rb,
lib/fog/hp/requests/storage/put_container.rb,
lib/fog/hp/requests/storage/get_containers.rb,
lib/fog/hp/requests/storage/head_container.rb,
lib/fog/hp/requests/storage/head_containers.rb,
lib/fog/hp/requests/storage/delete_container.rb,
lib/fog/hp/requests/storage/get_shared_object.rb,
lib/fog/hp/requests/storage/put_shared_object.rb,
lib/fog/hp/requests/storage/head_shared_object.rb,
lib/fog/hp/requests/storage/get_object_temp_url.rb,
lib/fog/hp/requests/storage/delete_shared_object.rb,
lib/fog/hp/requests/storage/get_shared_container.rb,
lib/fog/hp/requests/storage/head_shared_container.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Utils

#cdn, #generate_object_temp_url, #header_to_perm_acl, #perm_acl_to_header, #perm_to_acl, #public_url, #url

Constructor Details

#initialize(options = {}) ⇒ Real

Returns a new instance of Real.



236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
# File 'lib/fog/hp/storage.rb', line 236

def initialize(options={})
  require 'mime/types'
  # deprecate hp_account_id
  if options[:hp_account_id]
    Fog::Logger.deprecation(":hp_account_id is deprecated, please use :hp_access_key instead.")
    options[:hp_access_key] = options.delete(:hp_account_id)
  end
  @hp_access_key = options[:hp_access_key]
  unless @hp_access_key
    raise ArgumentError.new("Missing required arguments: hp_access_key. :hp_account_id is deprecated, please use :hp_access_key instead.")
  end
  @hp_secret_key = options[:hp_secret_key]
  @hp_auth_uri   = options[:hp_auth_uri]
  @hp_cdn_ssl    = options[:hp_cdn_ssl]
  @connection_options = options[:connection_options] || {}
  ### Set an option to use the style of authentication desired; :v1 or :v2 (default)
  auth_version = options[:hp_auth_version] || :v2
  ### Pass the service name for object storage to the authentication call
  options[:hp_service_type] = "Object Storage"
  @hp_tenant_id = options[:hp_tenant_id]
  @hp_avl_zone  = options[:hp_avl_zone]

  ### Make the authentication call
  if (auth_version == :v2)
    # Call the control services authentication
    credentials = Fog::HP.authenticate_v2(options, @connection_options)
    # the CS service catalog returns the cdn endpoint
    @hp_storage_uri = credentials[:endpoint_url]
    @hp_cdn_uri  = credentials[:cdn_endpoint_url]
  else
    # Call the legacy v1.0/v1.1 authentication
    credentials = Fog::HP.authenticate_v1(options, @connection_options)
    # the user sends in the cdn endpoint
    @hp_storage_uri = options[:hp_auth_uri]
    @hp_cdn_uri  = options[:hp_cdn_uri]
  end

  @auth_token = credentials[:auth_token]

  uri = URI.parse(@hp_storage_uri)
  @host   = uri.host
  @path   = uri.path
  @persistent = options[:persistent] || false
  @port   = uri.port
  @scheme = uri.scheme

  @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
end

Instance Attribute Details

#hp_cdn_sslObject (readonly)

Returns the value of attribute hp_cdn_ssl.



234
235
236
# File 'lib/fog/hp/storage.rb', line 234

def hp_cdn_ssl
  @hp_cdn_ssl
end

Instance Method Details

#delete_container(name) ⇒ Object

Delete an existing container

Parameters

  • name<~String> - Name of container to delete



11
12
13
14
15
16
17
18
# File 'lib/fog/hp/requests/storage/delete_container.rb', line 11

def delete_container(name)
  response = request(
    :expects  => 204,
    :method   => 'DELETE',
    :path     => Fog::HP.escape(name)
  )
  response
end

#delete_object(container, object) ⇒ Object

Delete an existing object

Parameters

  • container<~String> - Name of container to delete

  • object<~String> - Name of object to delete



12
13
14
15
16
17
18
19
# File 'lib/fog/hp/requests/storage/delete_object.rb', line 12

def delete_object(container, object)
  response = request(
    :expects  => 204,
    :method   => 'DELETE',
    :path     => "#{Fog::HP.escape(container)}/#{Fog::HP.escape(object)}"
  )
  response
end

#delete_shared_object(shared_object_url) ⇒ Object

Delete a shared object

Parameters

  • shared_object_url<~String> - Url of the shared object



11
12
13
14
15
16
17
18
19
20
21
22
# File 'lib/fog/hp/requests/storage/delete_shared_object.rb', line 11

def delete_shared_object(shared_object_url)
  # split up the shared object url
  uri = URI.parse(shared_object_url)
  path   = uri.path

  response = shared_request(
    :expects  => 204,
    :method   => 'DELETE',
    :path     => path
  )
  response
end

#get_container(container, options = {}) ⇒ Object

Get details for container and total bytes stored

Parameters

  • container<~String> - Name of container to retrieve info for

  • options<~String>:

    • ‘limit’<~String> - Maximum number of objects to return

    • ‘marker’<~String> - Only return objects whose name is greater than marker

    • ‘prefix’<~String> - Limits results to those starting with prefix

    • ‘path’<~String> - Return objects nested in the pseudo path

Returns

  • response<~Excon::Response>:

    • headers<~Hash>:

      • ‘X-Account-Container-Count’<~String> - Count of containers

      • ‘X-Account-Bytes-Used’<~String> - Bytes used

    • body<~Array>:

      • ‘bytes’<~Integer> - Number of bytes used by container

      • ‘count’<~Integer> - Number of items in container

      • ‘name’<~String> - Name of container

      • item<~Hash>:

        • ‘bytes’<~String> - Size of object

        • ‘content_type’<~String> Content-Type of object

        • ‘hash’<~String> - Hash of object (etag?)

        • ‘last_modified’<~String> - Last modified timestamp

        • ‘name’<~String> - Name of object



31
32
33
34
35
36
37
38
39
40
# File 'lib/fog/hp/requests/storage/get_container.rb', line 31

def get_container(container, options = {})
  options = options.reject {|key, value| value.nil?}
  response = request(
    :expects  => 200,
    :method   => 'GET',
    :path     => Fog::HP.escape(container),
    :query    => {'format' => 'json'}.merge!(options)
  )
  response
end

#get_containers(options = {}) ⇒ Object

List existing storage containers

Parameters

  • options<~Hash>:

    • ‘limit’<~Integer> - Upper limit to number of results returned

    • ‘marker’<~String> - Only return objects with name greater than this value

Returns

  • response<~Excon::Response>:

    • body<~Array>:

      • container<~Hash>:

        • ‘bytes’<~Integer>: - Number of bytes used by container

        • ‘count’<~Integer>: - Number of items in container

        • ‘name’<~String>: - Name of container



20
21
22
23
24
25
26
27
28
29
# File 'lib/fog/hp/requests/storage/get_containers.rb', line 20

def get_containers(options = {})
  options = options.reject {|key, value| value.nil?}
  response = request(
    :expects  => [200, 204],
    :method   => 'GET',
    :path     => '',
    :query    => {'format' => 'json'}.merge!(options)
  )
  response
end

#get_object(container, object, &block) ⇒ Object

Get details for an object

Parameters

  • container<~String> - Name of container to look in

  • object<~String> - Name of object to look for



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# File 'lib/fog/hp/requests/storage/get_object.rb', line 12

def get_object(container, object, &block)
  if block_given?
    response = request(
      :response_block  => block,
      :expects  => 200,
      :method   => 'GET',
      :path     => "#{Fog::HP.escape(container)}/#{Fog::HP.escape(object)}"
    )
  else
    response = request({
      :expects  => 200,
      :method   => 'GET',
      :path     => "#{Fog::HP.escape(container)}/#{Fog::HP.escape(object)}"
    }, false, &block)
  end
  response
end

#get_object_temp_url(container, object, expires, method) ⇒ Object

Generate a temporary url for an object

Parameters

  • container<~String> - Name of container

  • object<~String> - Name of object

  • expires<~Integer> - Time the temporary url expire in secs.

  • method<~String> - Allowed HTTP method GET, PUT, HEAD only



14
15
16
# File 'lib/fog/hp/requests/storage/get_object_temp_url.rb', line 14

def get_object_temp_url(container, object, expires, method)
  generate_object_temp_url(container, object, expires, method)
end

#get_shared_container(shared_container_url, options = {}) ⇒ Object

Get details for a shared container

Parameters

  • shared_container_url<~String> - Url of the shared container

  • options<~String>:

    • ‘limit’<~String> - Maximum number of objects to return

    • ‘marker’<~String> - Only return objects whose name is greater than marker

    • ‘prefix’<~String> - Limits results to those starting with prefix

    • ‘path’<~String> - Return objects nested in the pseudo path

Returns

  • response<~Excon::Response>:

    • headers<~Hash>:

      • ‘X-Container-Object-Count’<~String> - Count of objects in container

      • ‘X-Container-Bytes-Used’<~String> - Bytes used

      • ‘X-Trans-Id’<~String> - Trans Id

    • body<~Array>:

      • item<~Hash>:

        • ‘bytes’<~String> - Size of object

        • ‘content_type’<~String> Content-Type of object

        • ‘hash’<~String> - Hash of object (etag?)

        • ‘last_modified’<~String> - Last modified timestamp

        • ‘name’<~String> - Name of object



29
30
31
32
33
34
35
36
37
38
39
40
41
42
# File 'lib/fog/hp/requests/storage/get_shared_container.rb', line 29

def get_shared_container(shared_container_url, options = {})
  options = options.reject {|key, value| value.nil?}
  # split up the shared container url
  uri = URI.parse(shared_container_url)
  path   = uri.path

  response = shared_request(
    :expects  => 200,
    :method   => 'GET',
    :path     => path,
    :query    => {'format' => 'json'}.merge!(options)
  )
  response
end

#get_shared_object(shared_object_url, &block) ⇒ Object

Get details for a shared object

Parameters

  • shared_object_url<~String> - Url of the shared object



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# File 'lib/fog/hp/requests/storage/get_shared_object.rb', line 11

def get_shared_object(shared_object_url, &block)
  # split up the shared object url
  uri = URI.parse(shared_object_url)
  path   = uri.path

  if block_given?
    response = shared_request(
      :response_block  => block,
      :expects  => 200,
      :method   => 'GET',
      :path     => path
    )
  else
    response = shared_request({
      :expects  => 200,
      :method   => 'GET',
      :path     => path
    }, false, &block)
  end
  response
end

#head_container(container) ⇒ Object

List number of objects and total bytes stored

Parameters

  • container<~String> - Name of container to retrieve info for

Returns

  • response<~Excon::Response>:

    • headers<~Hash>:

      • ‘X-Container-Object-Count’<~String> - Count of containers

      • ‘X-Container-Bytes-Used’<~String> - Bytes used



16
17
18
19
20
21
22
23
24
# File 'lib/fog/hp/requests/storage/head_container.rb', line 16

def head_container(container)
  response = request(
    :expects  => 204,
    :method   => 'HEAD',
    :path     => Fog::HP.escape(container),
    :query    => {'format' => 'json'}
  )
  response
end

#head_containersObject

List number of containers and total bytes stored

Returns

  • response<~Excon::Response>:

    • headers<~Hash>:

      • ‘X-Account-Container-Count’<~String> - Count of containers

      • ‘X-Account-Bytes-Used’<~String> - Bytes used



13
14
15
16
17
18
19
20
21
# File 'lib/fog/hp/requests/storage/head_containers.rb', line 13

def head_containers
  response = request(
    :expects  => 204,
    :method   => 'HEAD',
    :path     => '',
    :query    => {'format' => 'json'}
  )
  response
end

#head_object(container, object) ⇒ Object

Get headers for object

Parameters

  • container<~String> - Name of container to look in

  • object<~String> - Name of object to look for



12
13
14
15
16
17
18
19
# File 'lib/fog/hp/requests/storage/head_object.rb', line 12

def head_object(container, object)
  response = request({
    :expects  => 200,
    :method   => 'HEAD',
    :path     => "#{Fog::HP.escape(container)}/#{Fog::HP.escape(object)}"
  }, false)
  response
end

#head_shared_container(shared_container_url) ⇒ Object

List number of objects and total bytes stored for a shared container

Parameters

  • shared_container_url<~String> - Url of the shared container

Returns

  • response<~Excon::Response>:

    • headers<~Hash>:

      • ‘X-Container-Object-Count’<~String> - Count of containers

      • ‘X-Container-Bytes-Used’<~String> - Bytes used



16
17
18
19
20
21
22
23
24
25
26
27
28
# File 'lib/fog/hp/requests/storage/head_shared_container.rb', line 16

def head_shared_container(shared_container_url)
  # split up the shared container url
  uri = URI.parse(shared_container_url)
  path   = uri.path

  response = shared_request(
    :expects  => 204,
    :method   => 'HEAD',
    :path     => path,
    :query    => {'format' => 'json'}
  )
  response
end

#head_shared_object(shared_object_url) ⇒ Object

Get headers for shared object

Parameters

    • shared_object_url<~String> - Url of the shared object



11
12
13
14
15
16
17
18
19
20
21
22
# File 'lib/fog/hp/requests/storage/head_shared_object.rb', line 11

def head_shared_object(shared_object_url)
  # split up the shared object url
  uri = URI.parse(shared_object_url)
  path   = uri.path

  response = shared_request({
    :expects  => 200,
    :method   => 'HEAD',
    :path     => path
  }, false)
  response
end

#put_container(name, options = {}) ⇒ Object

Create a new container

Parameters

  • name<~String> - Name for container, should be < 256 bytes and must not contain ‘/’



11
12
13
14
15
16
17
18
19
# File 'lib/fog/hp/requests/storage/put_container.rb', line 11

def put_container(name, options = {})
  response = request(
    :expects  => [201, 202],
    :headers  => options,
    :method   => 'PUT',
    :path     => Fog::HP.escape(name)
  )
  response
end

#put_object(container, object, data, options = {}, &block) ⇒ Object

Create a new object

Parameters

  • container<~String> - Name for container, should be < 256 bytes and must not contain ‘/’



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# File 'lib/fog/hp/requests/storage/put_object.rb', line 11

def put_object(container, object, data, options = {}, &block)
  data = Fog::Storage.parse_data(data)
  headers = data[:headers].merge!(options)
  if block_given?
    headers['Transfer-Encoding'] = 'chunked'
    headers.delete('Content-Length')
    return request(
      :request_block     => block,
      :expects  => 201,
      :headers  => headers,
      :method   => 'PUT',
      :path     => "#{Fog::HP.escape(container)}/#{Fog::HP.escape(object)}"
    )
  end
  if headers.has_key?('Transfer-Encoding')
    headers.delete('Content-Length')
  end
  response = request(
    :body     => data[:body],
    :expects  => 201,
    :headers  => headers,
    :method   => 'PUT',
    :path     => "#{Fog::HP.escape(container)}/#{Fog::HP.escape(object)}"
  )
  response
end

#put_shared_object(shared_container_url, object_name, data, options = {}, &block) ⇒ Object

Create a new object in a shared container

Parameters

  • shared_container_url<~String> - Shared url for the container

  • object<~String> - Name of the object

  • options<~Hash> - header options



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# File 'lib/fog/hp/requests/storage/put_shared_object.rb', line 13

def put_shared_object(shared_container_url, object_name, data, options = {}, &block)
  # split up the shared object url
  uri = URI.parse(shared_container_url)
  path   = uri.path

  data = Fog::Storage.parse_data(data)
  headers = data[:headers].merge!(options)
  if block_given?
    headers['Transfer-Encoding'] = 'chunked'
    headers.delete('Content-Length')
    return shared_request(
      :request_block     => block,
      :expects  => 201,
      :headers  => headers,
      :method   => 'PUT',
      :path     => "#{path}/#{Fog::HP.escape(object_name)}"
    )
  end
  if headers.has_key?('Transfer-Encoding')
    headers.delete('Content-Length')
  end
  response = shared_request(
    :body     => data[:body],
    :expects  => 201,
    :headers  => headers,
    :method   => 'PUT',
    :path     => "#{path}/#{Fog::HP.escape(object_name)}"
  )
  response
end

#reloadObject



285
286
287
# File 'lib/fog/hp/storage.rb', line 285

def reload
  @connection.reset
end

#request(params, parse_json = true, &block) ⇒ Object



289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
# File 'lib/fog/hp/storage.rb', line 289

def request(params, parse_json = true, &block)
  begin
    response = @connection.request(params.merge!({
      :headers  => {
        'Content-Type' => 'application/json',
        'Accept'       => 'application/json',
        'X-Auth-Token' => @auth_token
      }.merge!(params[:headers] || {}),
      :host     => @host,
      :path     => "#{@path}/#{params[:path]}",
    }), &block)
  rescue Excon::Errors::HTTPStatusError => error
    raise case error
    when Excon::Errors::NotFound
      Fog::Storage::HP::NotFound.slurp(error)
    else
      error
    end
  end
  if !response.body.empty? && parse_json && response.headers['Content-Type'] =~ %r{application/json}
    response.body = Fog::JSON.decode(response.body)
  end
  response
end

#shared_request(params, parse_json = true, &block) ⇒ Object

this request is used only for get_shared_container and get_shared_object calls



315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
# File 'lib/fog/hp/storage.rb', line 315

def shared_request(params, parse_json = true, &block)
  begin
    response = @connection.request(params.merge!({
      :headers  => {
        'Content-Type' => 'application/json',
        'Accept'       => 'application/json',
        'X-Auth-Token' => @auth_token
      }.merge!(params[:headers] || {}),
      :host     => @host,
      :path     => "#{params[:path]}",
    }), &block)
  rescue Excon::Errors::HTTPStatusError => error
    raise case error
    when Excon::Errors::NotFound
      Fog::Storage::HP::NotFound.slurp(error)
    when Excon::Errors::Forbidden
      Fog::HP::Errors::Forbidden.slurp(error)
    else
      error
    end
  end
  if !response.body.empty? && parse_json && response.headers['Content-Type'] =~ %r{application/json}
    response.body = Fog::JSON.decode(response.body)
  end
  response
end