Class: Fog::Storage::InternetArchive::Real

Inherits:
Object
  • Object
show all
Includes:
GetObjectHttpUrl, GetObjectHttpsUrl, GetObjectUrl, PutObjectUrl, Utils
Defined in:
lib/fog/internet_archive/storage.rb,
lib/fog/internet_archive/requests/storage/list_parts.rb,
lib/fog/internet_archive/requests/storage/get_object.rb,
lib/fog/internet_archive/requests/storage/get_bucket.rb,
lib/fog/internet_archive/requests/storage/put_object.rb,
lib/fog/internet_archive/requests/storage/sync_clock.rb,
lib/fog/internet_archive/requests/storage/put_bucket.rb,
lib/fog/internet_archive/requests/storage/copy_object.rb,
lib/fog/internet_archive/requests/storage/get_service.rb,
lib/fog/internet_archive/requests/storage/upload_part.rb,
lib/fog/internet_archive/requests/storage/head_object.rb,
lib/fog/internet_archive/requests/storage/delete_bucket.rb,
lib/fog/internet_archive/requests/storage/delete_object.rb,
lib/fog/internet_archive/requests/storage/put_object_url.rb,
lib/fog/internet_archive/requests/storage/get_object_acl.rb,
lib/fog/internet_archive/requests/storage/put_bucket_acl.rb,
lib/fog/internet_archive/requests/storage/get_object_url.rb,
lib/fog/internet_archive/requests/storage/put_object_acl.rb,
lib/fog/internet_archive/requests/storage/get_bucket_acl.rb,
lib/fog/internet_archive/requests/storage/put_bucket_cors.rb,
lib/fog/internet_archive/requests/storage/get_bucket_cors.rb,
lib/fog/internet_archive/requests/storage/put_bucket_policy.rb,
lib/fog/internet_archive/requests/storage/get_bucket_policy.rb,
lib/fog/internet_archive/requests/storage/put_bucket_website.rb,
lib/fog/internet_archive/requests/storage/put_bucket_logging.rb,
lib/fog/internet_archive/requests/storage/delete_bucket_cors.rb,
lib/fog/internet_archive/requests/storage/get_bucket_website.rb,
lib/fog/internet_archive/requests/storage/get_object_torrent.rb,
lib/fog/internet_archive/requests/storage/get_bucket_logging.rb,
lib/fog/internet_archive/requests/storage/get_request_payment.rb,
lib/fog/internet_archive/requests/storage/put_request_payment.rb,
lib/fog/internet_archive/requests/storage/get_object_http_url.rb,
lib/fog/internet_archive/requests/storage/get_bucket_location.rb,
lib/fog/internet_archive/requests/storage/delete_bucket_policy.rb,
lib/fog/internet_archive/requests/storage/put_bucket_lifecycle.rb,
lib/fog/internet_archive/requests/storage/get_bucket_lifecycle.rb,
lib/fog/internet_archive/requests/storage/get_object_https_url.rb,
lib/fog/internet_archive/requests/storage/delete_bucket_website.rb,
lib/fog/internet_archive/requests/storage/list_multipart_uploads.rb,
lib/fog/internet_archive/requests/storage/abort_multipart_upload.rb,
lib/fog/internet_archive/requests/storage/delete_bucket_lifecycle.rb,
lib/fog/internet_archive/requests/storage/delete_multiple_objects.rb,
lib/fog/internet_archive/requests/storage/post_object_hidden_fields.rb,
lib/fog/internet_archive/requests/storage/initiate_multipart_upload.rb,
lib/fog/internet_archive/requests/storage/complete_multipart_upload.rb

Instance Attribute Summary

Attributes included from Utils

#region

Instance Method Summary collapse

Methods included from GetObjectHttpsUrl

#get_object_https_url

Methods included from GetObjectHttpUrl

#get_object_http_url

Methods included from GetObjectUrl

#get_object_url

Methods included from PutObjectUrl

#put_object_url

Methods included from Utils

#http_url, #https_url, #url

Constructor Details

#initialize(options = {}) ⇒ Real

include Fog::InternetArchive::CredentialFetcher::ConnectionMethods Initialize connection to S3

Notes

options parameter must include values for :ia_access_key_id and :ia_secret_access_key in order to create a connection

Examples

s3 = Fog::Storage.new(
  :provider => "InternetArchive",
  :ia_access_key_id => your_ia_access_key_id,
  :ia_secret_access_key => your_ia_secret_access_key
)

Parameters

  • options<~Hash> - config arguments for connection. Defaults to {}.

Returns

  • S3 object with connection to aws.



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
# File 'lib/fog/internet_archive/storage.rb', line 242

def initialize(options={})

  setup_credentials(options)
  @connection_options     = options[:connection_options] || {}

  if @endpoint = options[:endpoint]
    endpoint = URI.parse(@endpoint)
    @host = endpoint.host
    @path = if endpoint.path.empty?
      '/'
    else
      endpoint.path
    end
    @port = endpoint.port
    @scheme = endpoint.scheme
  else
    options[:region] ||= 'us-east-1'
    @region = options[:region]
    @host = options[:host] || Fog::InternetArchive::API_DOMAIN_NAME
    @path       = options[:path]        || '/'
    @persistent = options.fetch(:persistent, false)
    @port       = options[:port]        || 80
    @scheme     = options[:scheme]      || 'http'
  end
  @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
end

Instance Method Details

#abort_multipart_upload(bucket_name, object_name, upload_id) ⇒ Object

Abort a multipart upload



14
15
16
17
18
19
20
21
22
23
# File 'lib/fog/internet_archive/requests/storage/abort_multipart_upload.rb', line 14

def abort_multipart_upload(bucket_name, object_name, upload_id)
  request({
    :expects    => 204,
    :headers    => {},
    :host       => "#{bucket_name}.#{@host}",
    :method     => 'DELETE',
    :path       => CGI.escape(object_name),
    :query      => {'uploadId' => upload_id}
  })
end

#complete_multipart_upload(bucket_name, object_name, upload_id, parts) ⇒ Excon::Response

Complete a multipart upload



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# File 'lib/fog/internet_archive/requests/storage/complete_multipart_upload.rb', line 23

def complete_multipart_upload(bucket_name, object_name, upload_id, parts)
  data = "<CompleteMultipartUpload>"
  parts.each_with_index do |part, index|
    data << "<Part>"
    data << "<PartNumber>#{index + 1}</PartNumber>"
    data << "<ETag>#{part}</ETag>"
    data << "</Part>"
  end
  data << "</CompleteMultipartUpload>"
  request({
    :body       => data,
    :expects    => 200,
    :headers    => { 'Content-Length' => data.length },
    :host       => "#{bucket_name}.#{@host}",
    :method     => 'POST',
    :parser     => Fog::Parsers::Storage::InternetArchive::CompleteMultipartUpload.new,
    :path       => CGI.escape(object_name),
    :query      => {'uploadId' => upload_id}
  })
end

#copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, options = {}) ⇒ Excon::Response

Copy an object from one S3 bucket to another

Options Hash (options):

  • x-amz-metadata-directive (String)

    Specifies whether to copy metadata from source or replace with data in request. Must be in ['COPY', 'REPLACE']

  • x-amz-copy_source-if-match (String)

    Copies object if its etag matches this value

  • x-amz-copy_source-if-modified_since (Time)

    Copies object it it has been modified since this time

  • x-amz-copy_source-if-none-match (String)

    Copies object if its etag does not match this value

  • x-amz-copy_source-if-unmodified-since (Time)

    Copies object it it has not been modified since this time

  • x-amz-storage-class (String)

    Default is 'STANDARD', set to 'REDUCED_REDUNDANCY' for non-critical, reproducable data

See Also:



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

def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, options = {})
  headers = { 'x-amz-copy-source' => "/#{source_bucket_name}/#{CGI.escape(source_object_name)}" }.merge!(options)
  request({
    :expects  => 200,
    :headers  => headers,
    :host     => "#{target_bucket_name}.#{@host}",
    :method   => 'PUT',
    :parser   => Fog::Parsers::Storage::InternetArchive::CopyObject.new,
    :path     => CGI.escape(target_object_name)
  })
end

#delete_bucket(bucket_name) ⇒ Excon::Response

Delete an S3 bucket



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

def delete_bucket(bucket_name)
  request({
    :expects  => 204,
    :headers  => {},
    :host     => "#{bucket_name}.#{@host}",
    :method   => 'DELETE'
  })
end

#delete_bucket_cors(bucket_name) ⇒ Excon::Response

Deletes the cors configuration information set for the bucket.



14
15
16
17
18
19
20
21
22
# File 'lib/fog/internet_archive/requests/storage/delete_bucket_cors.rb', line 14

def delete_bucket_cors(bucket_name)
  request({
    :expects  => 204,
    :headers  => {},
    :host     => "#{bucket_name}.#{@host}",
    :method   => 'DELETE',
    :query    => {'cors' => nil}
  })
end

#delete_bucket_lifecycle(bucket_name) ⇒ Excon::Response

Delete lifecycle configuration for a bucket



14
15
16
17
18
19
20
21
22
# File 'lib/fog/internet_archive/requests/storage/delete_bucket_lifecycle.rb', line 14

def delete_bucket_lifecycle(bucket_name)
  request({
            :expects  => 204,
            :headers  => {},
            :host     => "#{bucket_name}.#{@host}",
            :method   => 'DELETE',
            :query    => {'lifecycle' => nil}
          })
end

#delete_bucket_policy(bucket_name) ⇒ Excon::Response

Delete policy for a bucket



14
15
16
17
18
19
20
21
22
# File 'lib/fog/internet_archive/requests/storage/delete_bucket_policy.rb', line 14

def delete_bucket_policy(bucket_name)
  request({
    :expects  => 204,
    :headers  => {},
    :host     => "#{bucket_name}.#{@host}",
    :method   => 'DELETE',
    :query    => {'policy' => nil}
  })
end

#delete_bucket_website(bucket_name) ⇒ Excon::Response

Delete website configuration for a bucket



14
15
16
17
18
19
20
21
22
# File 'lib/fog/internet_archive/requests/storage/delete_bucket_website.rb', line 14

def delete_bucket_website(bucket_name)
  request({
    :expects  => 204,
    :headers  => {},
    :host     => "#{bucket_name}.#{@host}",
    :method   => 'DELETE',
    :query    => {'website' => nil}
  })
end

#delete_multiple_objects(bucket_name, object_names, options = {}) ⇒ Excon::Response

Note:

For versioned deletes, options should include a version_ids hash, which maps from filename to an array of versions. The semantics are that for each (object_name, version) tuple, the caller must insert the object_name and an associated version (if desired), so for n versions, the object must be inserted n times.

Delete multiple objects from S3



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
# File 'lib/fog/internet_archive/requests/storage/delete_multiple_objects.rb', line 33

def delete_multiple_objects(bucket_name, object_names, options = {})
  data = "<Delete>"
  data << "<Quiet>true</Quiet>" if options.delete(:quiet)
  object_names.each do |object_name|
    data << "<Object>"
    data << "<Key>#{CGI.escapeHTML(object_name)}</Key>"
    data << "</Object>"
  end
  data << "</Delete>"

  headers = options
  headers['Content-Length'] = data.length
  headers['Content-MD5'] = Base64.encode64(Digest::MD5.digest(data)).
                           gsub("\n", '')

  request({
    :body       => data,
    :expects    => 200,
    :headers    => headers,
    :host       => "#{bucket_name}.#{@host}",
    :method     => 'POST',
    :parser     => Fog::Parsers::Storage::InternetArchive::DeleteMultipleObjects.new,
    :query      => {'delete' => nil}
  })
end

#delete_object(bucket_name, object_name, options = {}) ⇒ Excon::Response

Delete an object from S3



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

def delete_object(bucket_name, object_name, options = {})
  path = CGI.escape(object_name)

  headers = options
  request({
    :expects    => 204,
    :headers    => headers,
    :host       => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method     => 'DELETE',
    :path       => path
  })
end

#get_bucket(bucket_name, options = {}) ⇒ Excon::Response

List information about objects in an S3 bucket

Options Hash (options):

  • delimiter (String)

    causes keys with the same string between the prefix value and the first occurence of delimiter to be rolled up

  • marker (String)

    limits object keys to only those that appear lexicographically after its value.

  • max-keys (Integer)

    limits number of object keys returned

  • prefix (String)

    limits object keys to those beginning with its value.

See Also:



39
40
41
42
43
44
45
46
47
48
49
50
51
52
# File 'lib/fog/internet_archive/requests/storage/get_bucket.rb', line 39

def get_bucket(bucket_name, options = {})
  unless bucket_name
    raise ArgumentError.new('bucket_name is required')
  end
  request({
    :expects  => 200,
    :headers  => {},
    :host     => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method   => 'GET',
    :parser   => Fog::Parsers::Storage::InternetArchive::GetBucket.new,
    :query    => options
  })
end

#get_bucket_acl(bucket_name) ⇒ Excon::Response

Get access control list for an S3 bucket



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

def get_bucket_acl(bucket_name)
  unless bucket_name
    raise ArgumentError.new('bucket_name is required')
  end
  request({
    :expects    => 200,
    :headers    => {},
    :host       => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method     => 'GET',
    :parser     => Fog::Parsers::Storage::InternetArchive::AccessControlList.new,
    :query      => {'acl' => nil}
  })
end

#get_bucket_cors(bucket_name) ⇒ Excon::Response

Gets the CORS configuration for an S3 bucket



24
25
26
27
28
29
30
31
32
33
34
35
36
37
# File 'lib/fog/internet_archive/requests/storage/get_bucket_cors.rb', line 24

def get_bucket_cors(bucket_name)
  unless bucket_name
    raise ArgumentError.new('bucket_name is required')
  end
  request({
    :expects    => 200,
    :headers    => {},
    :host       => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method     => 'GET',
    :parser     => Fog::Parsers::Storage::InternetArchive::CorsConfiguration.new,
    :query      => {'cors' => nil}
  })
end

#get_bucket_lifecycle(bucket_name) ⇒ Excon::Response

Get bucket lifecycle configuration



21
22
23
24
25
26
27
28
29
30
31
# File 'lib/fog/internet_archive/requests/storage/get_bucket_lifecycle.rb', line 21

def get_bucket_lifecycle(bucket_name)
  request({
            :expects  => 200,
            :headers  => {},
            :host     => "#{bucket_name}.#{@host}",
            :idempotent => true,
            :method   => 'GET',
            :parser   => Fog::Parsers::Storage::InternetArchive::GetBucketLifecycle.new,
            :query    => {'lifecycle' => nil}
          })
end

#get_bucket_location(bucket_name) ⇒ Excon::Response

Get location constraint for an S3 bucket



17
18
19
20
21
22
23
24
25
26
27
# File 'lib/fog/internet_archive/requests/storage/get_bucket_location.rb', line 17

def get_bucket_location(bucket_name)
  request({
    :expects  => 200,
    :headers  => {},
    :host     => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method   => 'GET',
    :parser   => Fog::Parsers::Storage::InternetArchive::GetBucketLocation.new,
    :query    => {'location' => nil}
  })
end

#get_bucket_logging(bucket_name) ⇒ Excon::Response

Get logging status for an S3 bucket



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

def get_bucket_logging(bucket_name)
  unless bucket_name
    raise ArgumentError.new('bucket_name is required')
  end
  request({
    :expects    => 200,
    :headers    => {},
    :host       => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method     => 'GET',
    :parser     => Fog::Parsers::Storage::InternetArchive::GetBucketLogging.new,
    :query      => {'logging' => nil}
  })
end

#get_bucket_policy(bucket_name) ⇒ Excon::Response

Get bucket policy for an S3 bucket



14
15
16
17
18
19
20
21
22
23
24
25
26
27
# File 'lib/fog/internet_archive/requests/storage/get_bucket_policy.rb', line 14

def get_bucket_policy(bucket_name)
  unless bucket_name
    raise ArgumentError.new('bucket_name is required')
  end
  response = request({
    :expects    => 200,
    :headers    => {},
    :host       => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method     => 'GET',
    :query      => {'policy' => nil}
  })
  response.body = Fog::JSON.decode(response.body) unless response.body.nil?
end

#get_bucket_website(bucket_name) ⇒ Excon::Response

Get website configuration for an S3 bucket



21
22
23
24
25
26
27
28
29
30
31
32
33
34
# File 'lib/fog/internet_archive/requests/storage/get_bucket_website.rb', line 21

def get_bucket_website(bucket_name)
  unless bucket_name
    raise ArgumentError.new('bucket_name is required')
  end
  request({
    :expects    => 200,
    :headers    => {},
    :host       => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method     => 'GET',
    :parser     => Fog::Parsers::Storage::InternetArchive::GetBucketWebsite.new,
    :query      => {'website' => nil}
  })
end

#get_object(bucket_name, object_name, options = {}, &block) ⇒ Excon::Response

Get an object from S3

Options Hash (options):

  • If-Match (String)

    Returns object only if its etag matches this value, otherwise returns 412 (Precondition Failed).

  • If-Modified-Since (Time)

    Returns object only if it has been modified since this time, otherwise returns 304 (Not Modified).

  • If-None-Match (String)

    Returns object only if its etag differs from this value, otherwise returns 304 (Not Modified)

  • If-Unmodified-Since (Time)

    Returns object only if it has not been modified since this time, otherwise returns 412 (Precodition Failed).

  • Range (String)

    Range of object to download

See Also:



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# File 'lib/fog/internet_archive/requests/storage/get_object.rb', line 26

def get_object(bucket_name, object_name, options = {}, &block)
  unless bucket_name
    raise ArgumentError.new('bucket_name is required')
  end
  unless object_name
    raise ArgumentError.new('object_name is required')
  end

  params = { :headers => {} }
  params[:headers].merge!(options)
  if options['If-Modified-Since']
    params[:headers]['If-Modified-Since'] = Fog::Time.at(options['If-Modified-Since'].to_i).to_date_header
  end
  if options['If-Unmodified-Since']
    params[:headers]['If-Unmodified-Since'] = Fog::Time.at(options['If-Unmodified-Since'].to_i).to_date_header
  end

  if block_given?
    params[:response_block] = Proc.new
  end

  request(params.merge!({
    :expects  => [ 200, 206 ],
    :host     => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method   => 'GET',
    :path     => CGI.escape(object_name),
  }))
end

#get_object_acl(bucket_name, object_name, options = {}) ⇒ Excon::Response

Get access control list for an S3 object



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# File 'lib/fog/internet_archive/requests/storage/get_object_acl.rb', line 30

def get_object_acl(bucket_name, object_name, options = {})
  unless bucket_name
    raise ArgumentError.new('bucket_name is required')
  end
  unless object_name
    raise ArgumentError.new('object_name is required')
  end
  query = {'acl' => nil}
  request({
    :expects    => 200,
    :headers    => {},
    :host       => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method     => 'GET',
    :parser     => Fog::Parsers::Storage::InternetArchive::AccessControlList.new,
    :path       => CGI.escape(object_name),
    :query      => query
  })
end

#get_object_torrent(bucket_name, object_name) ⇒ Excon::Response

Get torrent for an S3 object



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# File 'lib/fog/internet_archive/requests/storage/get_object_torrent.rb', line 25

def get_object_torrent(bucket_name, object_name)
  unless bucket_name
    raise ArgumentError.new('bucket_name is required')
  end
  unless object_name
    raise ArgumentError.new('object_name is required')
  end
  request({
    :expects    => 200,
    :headers    => {},
    :host       => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method     => 'GET',
    :path       => CGI.escape(object_name),
    :query      => {'torrent' => nil}
  })
end

#get_request_payment(bucket_name) ⇒ Excon::Response

Get configured payer for an S3 bucket



17
18
19
20
21
22
23
24
25
26
27
# File 'lib/fog/internet_archive/requests/storage/get_request_payment.rb', line 17

def get_request_payment(bucket_name)
  request({
    :expects  => 200,
    :headers  => {},
    :host     => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method   => 'GET',
    :parser   => Fog::Parsers::Storage::InternetArchive::GetRequestPayment.new,
    :query    => {'requestPayment' => nil}
  })
end

#get_serviceExcon::Response

List information about S3 buckets for authorized user



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

def get_service
  request({
    :expects  => 200,
    :headers  => {},
    :host     => @host,
    :idempotent => true,
    :method   => 'GET',
    :parser   => Fog::Parsers::Storage::InternetArchive::GetService.new
  })
end

#head_object(bucket_name, object_name, options = {}) ⇒ Excon::Response

Get headers for an object from S3

Options Hash (options):

  • If-Match (String)

    Returns object only if its etag matches this value, otherwise returns 412 (Precondition Failed).

  • If-Modified-Since (Time)

    Returns object only if it has been modified since this time, otherwise returns 304 (Not Modified).

  • If-None-Match (String)

    Returns object only if its etag differs from this value, otherwise returns 304 (Not Modified)

  • If-Unmodified-Since (Time)

    Returns object only if it has not been modified since this time, otherwise returns 412 (Precodition Failed).

  • Range (String)

    Range of object to download

See Also:



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# File 'lib/fog/internet_archive/requests/storage/head_object.rb', line 26

def head_object(bucket_name, object_name, options={})
  unless bucket_name
    raise ArgumentError.new('bucket_name is required')
  end
  unless object_name
    raise ArgumentError.new('object_name is required')
  end
  headers = {}
  headers['If-Modified-Since'] = Fog::Time.at(options['If-Modified-Since'].to_i).to_date_header if options['If-Modified-Since']
  headers['If-Unmodified-Since'] = Fog::Time.at(options['If-Unmodified-Since'].to_i).to_date_header if options['If-Modified-Since']
  headers.merge!(options)
  request({
    :expects    => 200,
    :headers    => headers,
    :host       => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method     => 'HEAD',
    :path       => CGI.escape(object_name)
  })
end

#initiate_multipart_upload(bucket_name, object_name, options = {}) ⇒ Excon::Response

Initiate a multipart upload to an S3 bucket

Options Hash (options):

  • Cache-Control (String)

    Caching behaviour

  • Content-Disposition (String)

    Presentational information for the object

  • Content-Encoding (String)

    Encoding of object data

  • Content-MD5 (String)

    Base64 encoded 128-bit MD5 digest of message (defaults to Base64 encoded MD5 of object.read)

  • Content-Type (String)

    Standard MIME type describing contents (defaults to MIME::Types.of.first)

  • x-amz-acl (String)

    Permissions, must be in ['private', 'public-read', 'public-read-write', 'authenticated-read']

  • x-amz-meta-#{name} (String)

    Headers to be returned with object, note total size of request without body must be less than 8 KB.

See Also:



28
29
30
31
32
33
34
35
36
37
38
# File 'lib/fog/internet_archive/requests/storage/initiate_multipart_upload.rb', line 28

def initiate_multipart_upload(bucket_name, object_name, options = {})
  request({
    :expects    => 200,
    :headers    => options,
    :host       => "#{bucket_name}.#{@host}",
    :method     => 'POST',
    :parser     => Fog::Parsers::Storage::InternetArchive::InitiateMultipartUpload.new,
    :path       => CGI.escape(object_name),
    :query      => {'uploads' => nil}
  })
end

#list_multipart_uploads(bucket_name, options = {}) ⇒ Excon::Response

List multipart uploads for a bucket

Options Hash (options):

  • key-marker (String)

    limits parts to only those that appear lexicographically after this key.

  • max-uploads (Integer)

    limits number of uploads returned

  • upload-id-marker (String)

    limits uploads to only those that appear lexicographically after this upload id.

See Also:



38
39
40
41
42
43
44
45
46
47
48
# File 'lib/fog/internet_archive/requests/storage/list_multipart_uploads.rb', line 38

def list_multipart_uploads(bucket_name, options = {})
  request({
    :expects  => 200,
    :headers  => {},
    :host     => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method   => 'GET',
    :parser   => Fog::Parsers::Storage::InternetArchive::ListMultipartUploads.new,
    :query    => options.merge!({'uploads' => nil})
  })
end

#list_parts(bucket_name, object_name, upload_id, options = {}) ⇒ Excon::Response

List parts for a multipart upload

Options Hash (options):

  • max-parts (Integer)

    limits number of parts returned

  • part-number-marker (String)

    limits parts to only those that appear lexicographically after this part number.

See Also:



37
38
39
40
41
42
43
44
45
46
47
48
49
# File 'lib/fog/internet_archive/requests/storage/list_parts.rb', line 37

def list_parts(bucket_name, object_name, upload_id, options = {})
  options['uploadId'] = upload_id
  request({
    :expects  => 200,
    :headers  => {},
    :host     => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method   => 'GET',
    :parser   => Fog::Parsers::Storage::InternetArchive::ListParts.new,
    :path     => CGI.escape(object_name),
    :query    => options.merge!({'uploadId' => upload_id})
  })
end

#post_object_hidden_fields(options = {}) ⇒ Object

#put_bucket(bucket_name, options = {}) ⇒ Excon::Response

Create an S3 bucket

Options Hash (options):

  • config (Hash)

    arguments for bucket. Defaults to {}.

  • LocationConstraint (Symbol)

    sets the location for the bucket

  • x-amz-acl (String)

    Permissions, must be in ['private', 'public-read', 'public-read-write', 'authenticated-read']

See Also:



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# File 'lib/fog/internet_archive/requests/storage/put_bucket.rb', line 17

def put_bucket(bucket_name, options = {})
  if location_constraint = options.delete('LocationConstraint')
    data =
<<-DATA
  <CreateBucketConfiguration>
    <LocationConstraint>#{location_constraint}</LocationConstraint>
  </CreateBucketConfiguration>
DATA
  else
    data = nil
  end
  request({
    :expects    => 200,
    :body       => data,
    :headers    => options,
    :idempotent => true,
    :host       => "#{bucket_name}.#{@host}",
    :method     => 'PUT'
  })
end

#put_bucket_acl(bucket_name, acl) ⇒ Object

Change access control list for an S3 bucket

  • acl [String] Permissions, must be in ['private', 'public-read', 'public-read-write', 'authenticated-read']



27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# File 'lib/fog/internet_archive/requests/storage/put_bucket_acl.rb', line 27

def put_bucket_acl(bucket_name, acl)
  data = ""
  headers = {}

  if acl.is_a?(Hash)
    data = Fog::Storage::InternetArchive.hash_to_acl(acl)
  else
    if !['private', 'public-read', 'public-read-write', 'authenticated-read'].include?(acl)
      raise Excon::Errors::BadRequest.new('invalid x-amz-acl')
    end
    headers['x-amz-acl'] = acl
  end

  headers['Content-MD5'] = Base64.encode64(Digest::MD5.digest(data)).strip
  headers['Content-Type'] = 'application/json'
  headers['Date'] = Fog::Time.now.to_date_header

  request({
    :body     => data,
    :expects  => 200,
    :headers  => headers,
    :host     => "#{bucket_name}.#{@host}",
    :method   => 'PUT',
    :query    => {'acl' => nil}
  })
end

#put_bucket_cors(bucket_name, cors) ⇒ Object

Sets the cors configuration for your bucket. If the configuration exists, Amazon S3 replaces it.



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# File 'lib/fog/internet_archive/requests/storage/put_bucket_cors.rb', line 21

def put_bucket_cors(bucket_name, cors)
  data = Fog::Storage::InternetArchive.hash_to_cors(cors)

  headers = {}
  headers['Content-MD5'] = Base64.encode64(Digest::MD5.digest(data)).strip
  headers['Content-Type'] = 'application/json'
  headers['Date'] = Fog::Time.now.to_date_header

  request({
    :body     => data,
    :expects  => 200,
    :headers  => headers,
    :host     => "#{bucket_name}.#{@host}",
    :method   => 'PUT',
    :query    => {'cors' => nil}
  })
end

#put_bucket_lifecycle(bucket_name, lifecycle) ⇒ Object

Change lifecycle configuration for an S3 bucket

  • lifecycle [Hash]:

    • Rules [Array] object expire rules

      • ID [String] Unique identifier for the rule

      • Prefix [String] Prefix identifying one or more objects to which the rule applies

      • Enabled [Boolean] if rule is currently being applied

      • Expiration [Hash] Container for the object expiration rule.

        • Days [Integer] lifetime, in days, of the objects that are subject to the rule

        • Date [Date] Indicates when the specific rule take effect. The date value must conform to the ISO 8601 format. The time is always midnight UTC.

      • Transition [Hash] Container for the transition rule that describes when objects transition to the Glacier storage class

        • Days [Integer] lifetime, in days, of the objects that are subject to the rule

        • Date [Date] Indicates when the specific rule take effect. The date value must conform to the ISO 8601 format. The time is always midnight UTC.

        • StorageClass [String] Indicates the Amazon S3 storage class to which you want the object to transition to.



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
# File 'lib/fog/internet_archive/requests/storage/put_bucket_lifecycle.rb', line 28

def put_bucket_lifecycle(bucket_name, lifecycle)
  builder = Nokogiri::XML::Builder.new do
    LifecycleConfiguration {
      lifecycle['Rules'].each do |rule|
        Rule {
          ID rule['ID']
          Prefix rule['Prefix']
          Status rule['Enabled'] ? 'Enabled' : 'Disabled'
          unless (rule['Expiration'] or rule['Transition'])
            Expiration { Days rule['Days'] }
          else
            if rule['Expiration']
              if rule['Expiration']['Days']
                Expiration { Days rule['Expiration']['Days'] }
              elsif rule['Expiration']['Date']
                Expiration { Date rule['Expiration']['Date'].is_a?(Time) ? rule['Expiration']['Date'].utc.iso8601 : Time.parse(rule['Expiration']['Date']).utc.iso8601 }
              end
            end
            if rule['Transition']
              Transition {
                if rule['Transition']['Days']
                  Days rule['Transition']['Days']
                elsif rule['Transition']['Date']
                  Date rule['Transition']['Date'].is_a?(Time) ? time.utc.iso8601 : Time.parse(time).utc.iso8601
                end
                StorageClass rule['Transition']['StorageClass'].nil? ? 'GLACIER' : rule['Transition']['StorageClass']
              }
            end
          end
        }
      end
    }
  end
  body = builder.to_xml
  body.gsub! /<([^<>]+)\/>/, '<\1></\1>'
  request({
            :body     => body,
            :expects  => 200,
            :headers  => {'Content-MD5' => Base64.encode64(Digest::MD5.digest(body)).chomp!,
              'Content-Type' => 'application/xml'},
            :host     => "#{bucket_name}.#{@host}",
            :method   => 'PUT',
            :query    => {'lifecycle' => nil}
          })
end

#put_bucket_logging(bucket_name, logging_status) ⇒ Object

Change logging status for an S3 bucket



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
# File 'lib/fog/internet_archive/requests/storage/put_bucket_logging.rb', line 24

def put_bucket_logging(bucket_name, logging_status)
  if logging_status['LoggingEnabled'].empty?
    data =
<<-DATA
<BucketLoggingStatus xmlns="http://doc.s3.amazonaws.com/2006-03-01" />
DATA
  else
    data =
<<-DATA
<BucketLoggingStatus xmlns="http://doc.s3.amazonaws.com/2006-03-01">
  <LoggingEnabled>
    <TargetBucket>#{logging_status['LoggingEnabled']['TargetBucket']}</TargetBucket>
    <TargetPrefix>#{logging_status['LoggingEnabled']['TargetBucket']}</TargetPrefix>
    <TargetGrants>
DATA

    acl['AccessControlList'].each do |grant|
      data << "      <Grant>"
      type = case grant['Grantee'].keys.sort
      when ['DisplayName', 'ID']
        'CanonicalUser'
      when ['EmailAddress']
        'AmazonCustomerByEmail'
      when ['URI']
        'Group'
      end
      data << "        <Grantee xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"#{type}\">"
      for key, value in grant['Grantee']
        data << "          <#{key}>#{value}</#{key}>"
      end
      data << "        </Grantee>"
      data << "        <Permission>#{grant['Permission']}</Permission>"
      data << "      </Grant>"
    end

    data <<
<<-DATA
    </TargetGrants>
  </LoggingEnabled>
</BucketLoggingStatus>
DATA
  end

  request({
    :body     => data,
    :expects  => 200,
    :headers  => {},
    :host     => "#{bucket_name}.#{@host}",
    :method   => 'PUT',
    :query    => {'logging' => nil}
  })
end

#put_bucket_policy(bucket_name, policy) ⇒ Object

Change bucket policy for an S3 bucket



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

def put_bucket_policy(bucket_name, policy)
  request({
    :body     => Fog::JSON.encode(policy),
    :expects  => 204,
    :headers  => {},
    :host     => "#{bucket_name}.#{@host}",
    :method   => 'PUT',
    :query    => {'policy' => nil}
  })
end

#put_bucket_website(bucket_name, suffix, options = {}) ⇒ Object

Change website configuration for an S3 bucket

Options Hash (options):

  • key (String)

    key to use for 4XX class errors

See Also:



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
# File 'lib/fog/internet_archive/requests/storage/put_bucket_website.rb', line 14

def put_bucket_website(bucket_name, suffix, options = {})
  data =
<<-DATA
<WebsiteConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
    <IndexDocument>
<Suffix>#{suffix}</Suffix>
    </IndexDocument>
DATA

  if options[:key]
    data <<
<<-DATA
<ErrorDocument>
    <Key>#{options[:key]}</Key>
</ErrorDocument>
DATA
  end

  data << '</WebsiteConfiguration>'
  request({
    :body     => data,
    :expects  => 200,
    :headers  => {},
    :host     => "#{bucket_name}.#{@host}",
    :method   => 'PUT',
    :query    => {'website' => nil}
  })
end

#put_object(bucket_name, object_name, data, options = {}) ⇒ Excon::Response

Create an object in an S3 bucket

Options Hash (options):

  • Cache-Control (String)

    Caching behaviour

  • Content-Disposition (String)

    Presentational information for the object

  • Content-Encoding (String)

    Encoding of object data

  • Content-Length (String)

    Size of object in bytes (defaults to object.read.length)

  • Content-MD5 (String)

    Base64 encoded 128-bit MD5 digest of message

  • Content-Type (String)

    Standard MIME type describing contents (defaults to MIME::Types.of.first)

  • Expires (String)

    Cache expiry

  • x-amz-acl (String)

    Permissions, must be in ['private', 'public-read', 'public-read-write', 'authenticated-read']

  • x-amz-storage-class (String)

    Default is 'STANDARD', set to 'REDUCED_REDUNDANCY' for non-critical, reproducable data

  • x-amz-meta-# (name)

    Headers to be returned with object, note total size of request without body must be less than 8 KB.

See Also:



28
29
30
31
32
33
34
35
36
37
38
39
40
# File 'lib/fog/internet_archive/requests/storage/put_object.rb', line 28

def put_object(bucket_name, object_name, data, options = {})
  data = Fog::Storage.parse_data(data)
  headers = data[:headers].merge!(options)
  request({
    :body       => data[:body],
    :expects    => 200,
    :headers    => headers,
    :host       => "#{bucket_name}.#{@host}",
    :idempotent => true,
    :method     => 'PUT',
    :path       => CGI.escape(object_name)
  })
end

#put_object_acl(bucket_name, object_name, acl, options = {}) ⇒ Object

Change access control list for an S3 object



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
# File 'lib/fog/internet_archive/requests/storage/put_object_acl.rb', line 29

def put_object_acl(bucket_name, object_name, acl, options = {})
  query = {'acl' => nil}
  data = ""
  headers = {}

  if acl.is_a?(Hash)
    data = Fog::Storage::InternetArchive.hash_to_acl(acl)
  else
    if !['private', 'public-read', 'public-read-write', 'authenticated-read'].include?(acl)
      raise Excon::Errors::BadRequest.new('invalid x-amz-acl')
    end
    headers['x-amz-acl'] = acl
  end

  headers['Content-MD5'] = Base64.encode64(Digest::MD5.digest(data)).strip
  headers['Content-Type'] = 'application/json'
  headers['Date'] = Fog::Time.now.to_date_header

  request({
    :body     => data,
    :expects  => 200,
    :headers  => headers,
    :host     => "#{bucket_name}.#{@host}",
    :method   => 'PUT',
    :path       => CGI.escape(object_name),
    :query    => query
  })
end

#put_request_payment(bucket_name, payer) ⇒ Object

Change who pays for requests to an S3 bucket



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

def put_request_payment(bucket_name, payer)
  data =
<<-DATA
<RequestPaymentConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
  <Payer>#{payer}</Payer>
</RequestPaymentConfiguration>
DATA
  request({
    :body     => data,
    :expects  => 200,
    :headers  => {},
    :host     => "#{bucket_name}.#{@host}",
    :method   => 'PUT',
    :query    => {'requestPayment' => nil}
  })
end

#reloadObject



269
270
271
# File 'lib/fog/internet_archive/storage.rb', line 269

def reload
  @connection.reset
end

#signature(params) ⇒ Object



273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
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
341
342
343
344
345
346
# File 'lib/fog/internet_archive/storage.rb', line 273

def signature(params)
  string_to_sign =
<<-DATA
#{params[:method].to_s.upcase}
#{params[:headers]['Content-MD5']}
#{params[:headers]['Content-Type']}
#{params[:headers]['Date']}
DATA

  amz_headers, canonical_amz_headers = {}, ''
  for key, value in params[:headers]
    if key[0..5] == 'x-amz-'
      amz_headers[key] = value
    end
  end
  amz_headers = amz_headers.sort {|x, y| x[0] <=> y[0]}
  for key, value in amz_headers
    canonical_amz_headers << "#{key}:#{value}\n"
  end
  string_to_sign << canonical_amz_headers

  subdomain = params[:host].split(".#{@host}").first
  unless subdomain =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\.(?![\.\-])|\-(?![\.])){1,61}[a-z0-9]$/
    Fog::Logger.warning("fog: the specified s3 bucket name(#{subdomain}) is not a valid dns name, which will negatively impact performance.  For details see: http://docs.amazonwebservices.com/AmazonS3/latest/dev/BucketRestrictions.html")
    params[:host] = params[:host].split("#{subdomain}.")[-1]
    if params[:path]
      params[:path] = "#{subdomain}/#{params[:path]}"
    else
      params[:path] = subdomain
    end
    subdomain = nil
  end

  canonical_resource  = @path.dup
  unless subdomain.nil? || subdomain == @host
    canonical_resource << "#{Fog::InternetArchive.escape(subdomain).downcase}/"
  end
  canonical_resource << params[:path].to_s
  canonical_resource << '?'
  for key in (params[:query] || {}).keys.sort
    if %w{
      acl
      cors
      delete
      lifecycle
      location
      logging
      notification
      partNumber
      policy
      requestPayment
      response-cache-control
      response-content-disposition
      response-content-encoding
      response-content-language
      response-content-type
      response-expires
      torrent
      uploadId
      uploads
      versionId
      versioning
      versions
      website
    }.include?(key)
      canonical_resource << "#{key}#{"=#{params[:query][key]}" unless params[:query][key].nil?}&"
    end
  end
  canonical_resource.chop!
  string_to_sign << canonical_resource

  signed_string = @hmac.sign(string_to_sign)
  Base64.encode64(signed_string).chomp!
end

#sync_clockObject

Sync clock against S3 to avoid skew errors



7
8
9
10
11
12
13
14
# File 'lib/fog/internet_archive/requests/storage/sync_clock.rb', line 7

def sync_clock
  response = begin
    get_service
  rescue Excon::Errors::HTTPStatusError => error
    error.response
  end
  Fog::Time.now = Time.parse(response.headers['Date'])
end

#upload_part(bucket_name, object_name, upload_id, part_number, data, options = {}) ⇒ Excon::Response

Upload a part for a multipart upload

Options Hash (options):

  • Content-MD5 (String)

    Base64 encoded 128-bit MD5 digest of message

See Also:



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

def upload_part(bucket_name, object_name, upload_id, part_number, data, options = {})
  data = Fog::Storage.parse_data(data)
  headers = options
  headers['Content-Length'] = data[:headers]['Content-Length']
  request({
    :body       => data[:body],
    :expects    => 200,
    :idempotent => true,
    :headers    => headers,
    :host       => "#{bucket_name}.#{@host}",
    :method     => 'PUT',
    :path       => CGI.escape(object_name),
    :query      => {'uploadId' => upload_id, 'partNumber' => part_number}
  })
end