2009-05-19 06:06:49 +00:00
|
|
|
require 'rubygems'
|
|
|
|
require 'base64'
|
|
|
|
require 'cgi'
|
2009-06-07 22:42:51 +00:00
|
|
|
require 'digest/md5'
|
2009-05-19 06:06:49 +00:00
|
|
|
require 'hmac-sha1'
|
2009-06-07 22:42:51 +00:00
|
|
|
require 'mime/types'
|
2009-05-24 16:11:32 +00:00
|
|
|
require 'uri'
|
2009-05-19 06:06:49 +00:00
|
|
|
|
|
|
|
require File.dirname(__FILE__) + '/s3/parsers'
|
|
|
|
|
|
|
|
module Fog
|
|
|
|
module AWS
|
|
|
|
class S3
|
|
|
|
|
|
|
|
# Initialize connection to S3
|
|
|
|
#
|
|
|
|
# ==== Notes
|
|
|
|
# options parameter must include values for :aws_access_key_id and
|
|
|
|
# :aws_secret_access_key in order to create a connection
|
|
|
|
#
|
|
|
|
# ==== Examples
|
|
|
|
# sdb = S3.new(
|
|
|
|
# :aws_access_key_id => your_aws_access_key_id,
|
|
|
|
# :aws_secret_access_key => your_aws_secret_access_key
|
|
|
|
# )
|
|
|
|
#
|
|
|
|
# ==== Parameters
|
|
|
|
# options<~Hash>:: config arguments for connection. Defaults to {}.
|
|
|
|
#
|
|
|
|
# ==== Returns
|
|
|
|
# S3 object with connection to aws.
|
|
|
|
def initialize(options={})
|
|
|
|
@aws_access_key_id = options[:aws_access_key_id]
|
|
|
|
@aws_secret_access_key = options[:aws_secret_access_key]
|
|
|
|
@hmac = HMAC::SHA1.new(@aws_secret_access_key)
|
|
|
|
@host = options[:host] || 's3.amazonaws.com'
|
|
|
|
@port = options[:port] || 443
|
|
|
|
@scheme = options[:scheme] || 'https'
|
2009-06-11 17:25:05 +00:00
|
|
|
|
|
|
|
EventMachine::run {
|
|
|
|
@connection = EventMachine.connect(@host, @port, Fog::AWS::Connection) {|connection|
|
|
|
|
connection.scheme = @scheme
|
|
|
|
}
|
|
|
|
EventMachine.stop_event_loop
|
|
|
|
}
|
2009-05-19 06:06:49 +00:00
|
|
|
end
|
|
|
|
|
2009-06-05 23:51:17 +00:00
|
|
|
# List information about S3 buckets for authorized user
|
2009-05-19 06:06:49 +00:00
|
|
|
def get_service
|
2009-06-05 23:51:17 +00:00
|
|
|
request(
|
|
|
|
'GET',
|
2009-06-07 08:12:13 +00:00
|
|
|
url,
|
2009-06-05 23:51:17 +00:00
|
|
|
Fog::Parsers::AWS::S3::GetServiceParser.new
|
|
|
|
)
|
2009-05-19 06:06:49 +00:00
|
|
|
end
|
|
|
|
|
2009-06-05 23:51:17 +00:00
|
|
|
# Create an S3 bucket
|
|
|
|
#
|
|
|
|
# ==== Parameters
|
|
|
|
# bucket_name<~String>:: name of bucket to create
|
2009-06-07 08:12:13 +00:00
|
|
|
# options<~Hash>:: config arguments for bucket. Defaults to {}.
|
|
|
|
# :location_constraint sets the location for the bucket
|
|
|
|
def put_bucket(bucket_name, options = {})
|
|
|
|
if options[:location_constraint]
|
|
|
|
data = <<-DATA
|
|
|
|
<CreateBucketConfiguration>
|
|
|
|
<LocationConstraint>#{options[:location_constraint]}</LocationConstraint>
|
|
|
|
</CreateBucketConfiguration>
|
|
|
|
DATA
|
|
|
|
else
|
|
|
|
data = nil
|
|
|
|
end
|
2009-06-05 23:51:17 +00:00
|
|
|
request(
|
|
|
|
'PUT',
|
2009-06-07 08:12:13 +00:00
|
|
|
url(bucket_name),
|
|
|
|
Fog::Parsers::AWS::S3::BasicParser.new,
|
2009-06-07 08:37:54 +00:00
|
|
|
{},
|
2009-06-07 08:12:13 +00:00
|
|
|
data
|
2009-06-05 23:51:17 +00:00
|
|
|
)
|
2009-05-19 06:06:49 +00:00
|
|
|
end
|
2009-06-05 23:51:17 +00:00
|
|
|
|
2009-06-07 08:55:52 +00:00
|
|
|
# Change who pays for requests to an S3 bucket
|
|
|
|
#
|
|
|
|
# ==== Parameters
|
|
|
|
# bucket_name<~String>:: name of bucket to modify
|
|
|
|
# payer<~String>:: valid values are BucketOwner or Requester
|
|
|
|
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(
|
|
|
|
'PUT',
|
|
|
|
url(bucket_name),
|
|
|
|
Fog::Parsers::AWS::S3::BasicParser.new,
|
|
|
|
{},
|
|
|
|
data
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
2009-06-05 23:51:17 +00:00
|
|
|
# List information about objects in an S3 bucket
|
|
|
|
#
|
|
|
|
# ==== Parameters
|
|
|
|
# bucket_name<~String>:: name of bucket to list object keys from
|
|
|
|
# options<~Hash>:: config arguments for list. Defaults to {}.
|
2009-06-07 07:54:22 +00:00
|
|
|
# :prefix limits object keys to those beginning with its value.
|
|
|
|
# :marker limits object keys to only those that appear
|
2009-06-05 23:51:17 +00:00
|
|
|
# lexicographically after its value.
|
2009-06-07 07:54:22 +00:00
|
|
|
# :maxkeys limits number of object keys returned
|
|
|
|
# :delimiter causes keys with the same string between the prefix
|
2009-06-05 23:51:17 +00:00
|
|
|
# value and the first occurence of delimiter to be rolled up
|
|
|
|
def get_bucket(bucket_name, options = {})
|
2009-06-07 07:54:22 +00:00
|
|
|
options['max-keys'] = options.delete(:maxkeys) if options[:maxkeys]
|
2009-06-05 23:51:17 +00:00
|
|
|
query = '?'
|
|
|
|
options.each do |key, value|
|
|
|
|
query << "#{key}=#{value};"
|
|
|
|
end
|
|
|
|
query.chop!
|
|
|
|
request(
|
|
|
|
'GET',
|
2009-06-07 08:12:13 +00:00
|
|
|
url(bucket_name, query),
|
2009-06-05 23:51:17 +00:00
|
|
|
Fog::Parsers::AWS::S3::GetBucketParser.new
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
2009-06-07 08:55:52 +00:00
|
|
|
# Get configured payer for an S3 bucket
|
|
|
|
def get_request_payment(bucket_name)
|
|
|
|
request(
|
|
|
|
'GET',
|
|
|
|
url(bucket_name, '?requestpayment'),
|
|
|
|
Fog::Parsers::AWS::S3::GetRequestPayment.new
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Get location constraint for an S3 bucket
|
|
|
|
def get_location(bucket_name)
|
|
|
|
request(
|
|
|
|
'GET',
|
|
|
|
url(bucket_name, '?location'),
|
|
|
|
Fog::Parsers::AWS::S3::GetRequestPayment.new
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
2009-06-05 23:51:17 +00:00
|
|
|
# Delete an S3 bucket
|
|
|
|
#
|
|
|
|
# ==== Parameters
|
|
|
|
# bucket_name<~String>:: name of bucket to delete
|
|
|
|
def delete_bucket(bucket_name)
|
|
|
|
request(
|
|
|
|
'DELETE',
|
2009-06-07 08:12:13 +00:00
|
|
|
url(bucket_name),
|
2009-06-05 23:51:17 +00:00
|
|
|
Fog::Parsers::AWS::S3::BasicParser.new
|
|
|
|
)
|
2009-05-24 16:11:32 +00:00
|
|
|
end
|
2009-05-19 06:06:49 +00:00
|
|
|
|
2009-06-07 22:42:51 +00:00
|
|
|
# Create an object in an S3 bucket
|
|
|
|
def put_object(bucket_name, object_name, object, options = {})
|
|
|
|
file = parse_file(object)
|
|
|
|
request(
|
|
|
|
'PUT',
|
|
|
|
url(bucket_name, object_name),
|
|
|
|
Fog::Parsers::AWS::S3::BasicParser.new,
|
|
|
|
options.merge!(file[:headers]),
|
|
|
|
file[:body]
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
2009-06-07 08:37:54 +00:00
|
|
|
# Copy an object from one S3 bucket to another
|
|
|
|
def copy_object(source_bucket_name, source_object_name, destination_bucket_name, destination_object_name)
|
|
|
|
request(
|
|
|
|
'PUT',
|
|
|
|
url(destination_bucket_name, destination_object_name),
|
|
|
|
Fog::Parsers::AWS::S3::BasicParser.new,
|
|
|
|
{ 'x-amz-copy-source' => "/#{source_bucket_name}/#{source_object_name}" }
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Get an object from S3
|
|
|
|
def get_object(bucket_name, object_name)
|
|
|
|
request(
|
|
|
|
'GET',
|
|
|
|
url(bucket_name, object_name),
|
2009-06-07 22:42:51 +00:00
|
|
|
nil
|
2009-06-07 08:37:54 +00:00
|
|
|
)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Get headers for an object from S3
|
|
|
|
def head_object(bucket_name, object_name)
|
|
|
|
request(
|
|
|
|
'HEAD',
|
|
|
|
url(bucket_name, object_name),
|
|
|
|
Fog::Parsers::AWS::S3::BasicParser.new
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
|
|
|
# Delete an object from S3
|
|
|
|
def delete_object(bucket_name, object_name)
|
|
|
|
request(
|
|
|
|
'DELETE',
|
|
|
|
url(bucket_name, object_name),
|
|
|
|
Fog::Parsers::AWS::S3::BasicParser.new
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
2009-05-19 06:06:49 +00:00
|
|
|
private
|
|
|
|
|
2009-06-07 08:12:13 +00:00
|
|
|
def url(bucket_name = nil, path = nil)
|
2009-06-07 20:43:22 +00:00
|
|
|
url = "#{@scheme}://"
|
2009-06-07 08:12:13 +00:00
|
|
|
url << "#{bucket_name}." if bucket_name
|
2009-06-10 16:56:33 +00:00
|
|
|
url << "#{@host}:#{@port}/#{path}"
|
2009-06-07 08:12:13 +00:00
|
|
|
url
|
|
|
|
end
|
|
|
|
|
2009-06-07 08:37:54 +00:00
|
|
|
def canonicalize_amz_headers(headers)
|
2009-06-11 17:25:05 +00:00
|
|
|
headers = headers.select {|key,value| key.match(/^x-amz-/iu)}.sort {|x,y| x[0] <=> y[0]}.collect {|header| header.join(':')}.join("\n").downcase
|
|
|
|
headers.empty? ? nil : headers
|
2009-06-07 08:37:54 +00:00
|
|
|
end
|
|
|
|
|
2009-06-07 22:42:51 +00:00
|
|
|
def canonicalize_resource(uri)
|
2009-06-10 16:56:33 +00:00
|
|
|
resource = "/"
|
2009-06-10 17:08:39 +00:00
|
|
|
if match = uri.host.match(/(.*).s3.amazonaws.com/)
|
|
|
|
resource << "#{match[1]}/"
|
|
|
|
end
|
2009-06-07 22:42:51 +00:00
|
|
|
resource << "#{uri.path[1..-1]}" if uri.path
|
2009-06-10 16:56:33 +00:00
|
|
|
resource << "?acl" if uri.to_s.include?('?acl')
|
2009-06-07 22:42:51 +00:00
|
|
|
resource << "?location" if uri.to_s.include?('?location')
|
2009-06-10 16:56:33 +00:00
|
|
|
resource << "?torrent" if uri.to_s.include?('?torrent')
|
2009-06-07 22:42:51 +00:00
|
|
|
resource
|
|
|
|
end
|
|
|
|
|
|
|
|
def parse_file(file)
|
|
|
|
metadata = {
|
|
|
|
:body => nil,
|
|
|
|
:headers => {}
|
|
|
|
}
|
|
|
|
|
|
|
|
filename = File.basename(file.path)
|
|
|
|
unless (mime_types = MIME::Types.of(filename)).empty?
|
|
|
|
metadata[:headers]['Content-Type'] = mime_types.first.content_type
|
|
|
|
end
|
|
|
|
|
|
|
|
metadata[:body] = file.read
|
|
|
|
metadata[:headers]['Content-Length'] = metadata[:body].size.to_s
|
|
|
|
metadata[:headers]['Content-MD5'] = Base64.encode64(Digest::MD5.digest(metadata[:body])).strip
|
|
|
|
metadata
|
|
|
|
end
|
|
|
|
|
2009-06-07 08:37:54 +00:00
|
|
|
def request(method, url, parser, headers = {}, data = nil)
|
2009-05-24 16:11:32 +00:00
|
|
|
uri = URI.parse(url)
|
2009-06-07 20:43:22 +00:00
|
|
|
headers['Date'] = Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S +0000")
|
2009-05-19 06:06:49 +00:00
|
|
|
params = [
|
2009-05-21 01:49:20 +00:00
|
|
|
method,
|
2009-06-07 22:42:51 +00:00
|
|
|
content_md5 = headers['Content-MD5'] || '',
|
|
|
|
content_type = headers['Content-Type'] || '',
|
2009-05-21 01:49:20 +00:00
|
|
|
headers['Date'],
|
2009-06-07 08:37:54 +00:00
|
|
|
canonicalized_amz_headers = canonicalize_amz_headers(headers),
|
2009-06-07 22:42:51 +00:00
|
|
|
canonicalized_resource = canonicalize_resource(uri)
|
2009-05-19 06:06:49 +00:00
|
|
|
]
|
2009-06-07 20:43:22 +00:00
|
|
|
string_to_sign = params.delete_if {|value| value.nil?}.join("\n")
|
2009-05-19 06:06:49 +00:00
|
|
|
hmac = @hmac.update(string_to_sign)
|
|
|
|
signature = Base64.encode64(hmac.digest).strip
|
2009-05-21 01:49:20 +00:00
|
|
|
headers['Authorization'] = "AWS #{@aws_access_key_id}:#{signature}"
|
2009-06-05 23:51:17 +00:00
|
|
|
|
2009-05-21 01:49:20 +00:00
|
|
|
response = nil
|
|
|
|
EventMachine::run {
|
|
|
|
http = EventMachine.connect(@host, @port, Fog::AWS::Connection) {|connection|
|
2009-06-11 17:25:05 +00:00
|
|
|
connection.scheme = @scheme
|
2009-05-21 01:49:20 +00:00
|
|
|
}
|
2009-06-11 17:25:05 +00:00
|
|
|
|
|
|
|
request = Fog::AWS::Request.new(http)
|
|
|
|
request.body = data
|
|
|
|
request.headers = headers
|
|
|
|
request.method = method
|
|
|
|
request.parser = parser
|
|
|
|
request.url = url
|
|
|
|
http.send(request)
|
|
|
|
|
|
|
|
request.callback {|request| response = request.response}
|
2009-05-21 01:49:20 +00:00
|
|
|
}
|
|
|
|
response
|
2009-05-19 06:06:49 +00:00
|
|
|
end
|
2009-06-05 23:51:17 +00:00
|
|
|
|
2009-05-19 06:06:49 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|