Class: Fog::Rackspace::Files

Inherits:
Object
  • Object
show all
Defined in:
lib/fog/rackspace/files.rb,
lib/fog/rackspace/requests/files/put_object.rb,
lib/fog/rackspace/requests/files/delete_object.rb,
lib/fog/rackspace/requests/files/get_container.rb,
lib/fog/rackspace/requests/files/put_container.rb,
lib/fog/rackspace/requests/files/get_containers.rb,
lib/fog/rackspace/requests/files/head_container.rb,
lib/fog/rackspace/requests/files/head_containers.rb,
lib/fog/rackspace/requests/files/delete_container.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Files

Returns a new instance of Files.



16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/fog/rackspace/files.rb', line 16

def initialize(options={})
  credentials = Fog::Rackspace.authenticate(options)
  @auth_token = credentials['X-Auth-Token']
  cdn_uri = URI.parse(credentials['X-CDN-Management-Url'])
  @cdn_host   = cdn_uri.host
  @cdn_path   = cdn_uri.path
  @cdn_port   = cdn_uri.port
  @cdn_scheme = cdn_uri.scheme
  storage_uri = URI.parse(credentials['X-Storage-Url'])
  @storage_host   = storage_uri.host
  @storage_path   = storage_uri.path
  @storage_port   = storage_uri.port
  @storage_scheme = storage_uri.scheme
end

Class Method Details

.reload ⇒ Object 



5
6
7
8
9
10
11
12
13
14
 
# File 'lib/fog/rackspace/files.rb', line 5

def self.reload
  load "fog/rackspace/requests/files/delete_container.rb"
  load "fog/rackspace/requests/files/delete_object.rb"
  load "fog/rackspace/requests/files/get_container.rb"
  load "fog/rackspace/requests/files/get_containers.rb"
  load "fog/rackspace/requests/files/head_container.rb"
  load "fog/rackspace/requests/files/head_containers.rb"
  load "fog/rackspace/requests/files/put_container.rb"
  load "fog/rackspace/requests/files/put_object.rb"
end

Instance Method Details

#cdn_request(params) ⇒ Object 



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/fog/rackspace/files.rb', line 52

def cdn_request(params)
  @cdn_connection = Fog::Connection.new("#{@cdn_scheme}://#{@cdn_host}:#{@cdn_port}")
  response = @cdn_connection.request({
    :body     => params[:body],
    :expects  => params[:expects],
    :headers  => {
      'Content-Type' => 'application/json',
      'X-Auth-Token' => @auth_token
    }.merge!(params[:headers] || {}),
    :host     => @cdn_host,
    :method   => params[:method],
    :path     => "#{@cdn_path}/#{params[:path]}",
    :query    => params[:query]
  })
  unless response.body.empty?
    response.body = JSON.parse(response.body)
  end
  response
end

#delete_container(name) ⇒ Object

Delete an existing container

Parameters

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



12
13
14
15
16
17
18
19
 
# File 'lib/fog/rackspace/requests/files/delete_container.rb', line 12

def delete_container(name)
  response = storage_request(
    :expects  => 204,
    :method   => 'DELETE',
    :path     => CGI.escape(name)
  )
  response
end

#delete_object(container, object) ⇒ Object

Delete an existing container

Parameters

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

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



13
14
15
16
17
18
19
20
 
# File 'lib/fog/rackspace/requests/files/delete_object.rb', line 13

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

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

List number of containers 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>:

      • 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/rackspace/requests/files/get_container.rb', line 29

def get_container(container, options = {})
  query = ''
  for key, value in options.merge!({ 'format' => 'json' })
    query << "#{key}=#{value}&"
  end
  query.chop!
  response = storage_request(
    :expects  => 200,
    :method   => 'GET',
    :path     => container,
    :query    => query
  )
  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



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/fog/rackspace/requests/files/get_containers.rb', line 21

def get_containers(options = {})
  options = { 'format' => 'json' }.merge!(options)
  query = ''
  for key, value in options
    query << "#{key}=#{CGI.escape(value)}&"
  end
  query.chop!
  response = storage_request(
    :expects  => [200, 204],
    :method   => 'GET',
    :path     => '',
    :query    => query
  )
  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



17
18
19
20
21
22
23
24
25
 
# File 'lib/fog/rackspace/requests/files/head_container.rb', line 17

def head_container(container)
  response = storage_request(
    :expects  => 204,
    :method   => 'HEAD',
    :path     => container,
    :query    => 'format=json'
  )
  response
end

#head_containers ⇒ Object

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



14
15
16
17
18
19
20
21
22
 
# File 'lib/fog/rackspace/requests/files/head_containers.rb', line 14

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

#parse_data(data) ⇒ Object 



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/fog/rackspace/files.rb', line 31

def parse_data(data)
  metadata = {
    :body => nil,
    :headers => {}
  }

  if data.is_a?(String)
    metadata[:body] = data
    metadata[:headers]['Content-Length'] = metadata[:body].size.to_s
  else
    filename = File.basename(data.path)
    unless (mime_types = MIME::Types.of(filename)).empty?
      metadata[:headers]['Content-Type'] = mime_types.first.content_type
    end
    metadata[:body] = data.read
    metadata[:headers]['Content-Length'] = File.size(data.path).to_s
  end
  # metadata[:headers]['Content-MD5'] = Base64.encode64(Digest::MD5.digest(metadata[:body])).strip
  metadata
end

#put_container(name) ⇒ Object

Create a new container

Parameters

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



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

def put_container(name)
  response = storage_request(
    :expects  => [201, 202],
    :method   => 'PUT',
    :path     => CGI.escape(name)
  )
  response
end

#put_object(container, object, data) ⇒ Object

Create a new object

Parameters

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



12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/fog/rackspace/requests/files/put_object.rb', line 12

def put_object(container, object, data)
  data = parse_data(data)
  response = storage_request(
    :body     => data[:body],
    :expects  => 201,
    :headers  => data[:headers],
    :method   => 'PUT',
    :path     => "#{CGI.escape(container)}/#{CGI.escape(object)}"
  )
  response
end

#storage_request(params) ⇒ Object 



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/fog/rackspace/files.rb', line 72

def storage_request(params)
  @storage_connection = Fog::Connection.new("#{@storage_scheme}://#{@storage_host}:#{@storage_port}")
  response = @storage_connection.request({
    :body     => params[:body],
    :expects  => params[:expects],
    :headers  => {
      'Content-Type' => 'application/json',
      'X-Auth-Token' => @auth_token
    }.merge!(params[:headers] || {}),
    :host     => @storage_host,
    :method   => params[:method],
    :path     => "#{@storage_path}/#{params[:path]}",
    :query    => params[:query]
  })
  unless response.body.empty?
    response.body = JSON.parse(response.body)
  end
  response
end