Class: RightAws::S3Interface

Inherits:
RightAwsBase show all
Includes:
RightAwsBaseInterface
Defined in:
lib/s3/right_s3_interface.rb

Defined Under Namespace

Classes: S3AclParser, S3BucketLocationParser, S3HttpResponseBodyParser, S3HttpResponseHeadParser, S3HttpResponseParser, S3ImprovedListBucketParser, S3ListAllMyBucketsParser, S3ListBucketParser, S3TrueParser

Constant Summary collapse

USE_100_CONTINUE_PUT_SIZE = 
1_000_000
DEFAULT_HOST = 
's3.amazonaws.com'
DEFAULT_PORT = 
443
DEFAULT_PROTOCOL = 
'https'
REQUEST_TTL = 
30
DEFAULT_EXPIRES_AFTER =

One day’s worth of seconds

1 * 24 * 60 * 60
AMAZON_HEADER_PREFIX = 
'x-amz-'
AMAZON_METADATA_PREFIX = 
'x-amz-meta-'
@@bench = 
AwsBenchmarkingBlock.new

Constants inherited from RightAwsBase

RightAwsBase::AMAZON_PROBLEMS

Instance Attribute Summary

Attributes included from RightAwsBaseInterface

#aws_access_key_id, #cache, #connection, #last_errors, #last_request, #last_request_id, #last_response, #logger, #params

Class Method Summary collapse

Instance Method Summary collapse

Methods included from RightAwsBaseInterface

#cache_hits?, caching, caching=, #caching?, #init, #multi_thread, #on_exception, #request_info_impl, #update_cache

Methods inherited from RightAwsBase

amazon_problems, amazon_problems=

Constructor Details

#initialize(aws_access_key_id = nil, aws_secret_access_key = nil, params = {}) ⇒ S3Interface

Creates new RightS3 instance.

s3 = RightAws::S3Interface.new('1E3GDYEOGFJPIT7XXXXXX','hgTHt68JY07JKUY08ftHYtERkjgtfERn57XXXXXX', {:multi_thread => true, :logger => Logger.new('/tmp/x.log')}) #=> #<RightS3:0xb7b3c27c>

Params is a hash:

{:server       => 's3.amazonaws.com'   # Amazon service host: 's3.amazonaws.com'(default)
 :port         => 443                  # Amazon service port: 80 or 443(default)
 :protocol     => 'https'              # Amazon service protocol: 'http' or 'https'(default)
 :multi_thread => true|false           # Multi-threaded (connection per each thread): true or false(default)
 :logger       => Logger Object}       # Logger instance: logs to STDOUT if omitted }



61
62
63
64
65
66
67
68
69
 
# File 'lib/s3/right_s3_interface.rb', line 61

def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
  init({ :name             => 'S3', 
         :default_host     => ENV['S3_URL'] ? URI.parse(ENV['S3_URL']).host   : DEFAULT_HOST, 
         :default_port     => ENV['S3_URL'] ? URI.parse(ENV['S3_URL']).port   : DEFAULT_PORT, 
         :default_protocol => ENV['S3_URL'] ? URI.parse(ENV['S3_URL']).scheme : DEFAULT_PROTOCOL }, 
       aws_access_key_id     || ENV['AWS_ACCESS_KEY_ID'], 
       aws_secret_access_key || ENV['AWS_SECRET_ACCESS_KEY'], 
       params)
end

Class Method Details

.bench_s3 ⇒ Object 



44
45
46
 
# File 'lib/s3/right_s3_interface.rb', line 44

def self.bench_s3
  @@bench.service
end

.bench_xml ⇒ Object 



41
42
43
 
# File 'lib/s3/right_s3_interface.rb', line 41

def self.bench_xml
  @@bench.xml
end

Instance Method Details

#bucket_location(bucket, headers = {}) ⇒ Object

Retrieve bucket location

s3.create_bucket('my-awesome-bucket-us')        #=> true
puts s3.bucket_location('my-awesome-bucket-us') #=> '' (Amazon's default value assumed)

s3.create_bucket('my-awesome-bucket-eu', :location => :eu) #=> true
puts s3.bucket_location('my-awesome-bucket-eu')            #=> 'EU'



206
207
208
209
210
211
 
# File 'lib/s3/right_s3_interface.rb', line 206

def bucket_location(bucket, headers={})
  req_hash = generate_rest_request('GET', headers.merge(:url=>"#{bucket}?location"))
  request_info(req_hash, S3BucketLocationParser.new)
rescue
  on_exception
end

#canonical_string(method, path, headers = {}, expires = nil) ⇒ Object

Produces canonical string for signing.



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/s3/right_s3_interface.rb', line 76

def canonical_string(method, path, headers={}, expires=nil) # :nodoc:
  s3_headers = {}
  headers.each do |key, value|
    key = key.downcase
    s3_headers[key] = value.to_s.strip if key[/^#{AMAZON_HEADER_PREFIX}|^content-md5$|^content-type$|^date$/o]
  end
  s3_headers['content-type'] ||= ''
  s3_headers['content-md5']  ||= ''
  s3_headers['date']           = ''      if s3_headers.has_key? 'x-amz-date'
  s3_headers['date']           = expires if expires
    # prepare output string
  out_string = "#{method}\n"
  s3_headers.sort { |a, b| a[0] <=> b[0] }.each do |key, value|
    out_string << (key[/^#{AMAZON_HEADER_PREFIX}/o] ? "#{key}:#{value}\n" : "#{value}\n")
  end
    # ignore everything after the question mark...
  out_string << path.gsub(/\?.*$/, '')
   # ...unless there is an acl or torrent parameter
  out_string << '?acl'      if path[/[&?]acl($|&|=)/]
  out_string << '?torrent'  if path[/[&?]torrent($|&|=)/]
  out_string << '?location' if path[/[&?]location($|&|=)/]
#      out_string << '?logging'  if path[/[&?]logging($|&|=)/]  # this one is beta, no support for now
  out_string
end

#clear_bucket(bucket) ⇒ Object

Removes all keys from bucket. Returns true or an exception.

s3.clear_bucket('my_awesome_bucket') #=> true



511
512
513
514
515
516
517
518
 
# File 'lib/s3/right_s3_interface.rb', line 511

def clear_bucket(bucket)
  incrementally_list_bucket(bucket) do |results|
    results[:contents].each { |key| delete(bucket, key[:key]) }
  end
  true
rescue
  on_exception
end

#create_bucket(bucket, headers = {}) ⇒ Object

Creates new bucket. Returns true or an exception.

# create a bucket at American server
s3.create_bucket('my-awesome-bucket-us') #=> true
# create a bucket at European server
s3.create_bucket('my-awesome-bucket-eu', :location => :eu) #=> true



186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/s3/right_s3_interface.rb', line 186

def create_bucket(bucket, headers={})
  data = nil
  unless headers[:location].blank?
    data = "<CreateBucketConfiguration><LocationConstraint>#{headers[:location].to_s.upcase}</LocationConstraint></CreateBucketConfiguration>"
  end
  req_hash = generate_rest_request('PUT', headers.merge(:url=>bucket, :data => data))
  request_info(req_hash, S3TrueParser.new)
rescue Exception => e
    # if the bucket exists AWS returns an error for the location constraint interface. Drop it
  e.is_a?(RightAws::AwsError) && e.message.include?('BucketAlreadyOwnedByYou') ? true  : on_exception
end

#create_bucket_link(bucket, expires = nil, headers = {}) ⇒ Object

Generates link for ‘CreateBucket’.

s3.create_bucket_link('my_awesome_bucket') #=> url string



615
616
617
618
619
 
# File 'lib/s3/right_s3_interface.rb', line 615

def create_bucket_link(bucket, expires=nil, headers={})
  generate_link('PUT', headers.merge(:url=>bucket), expires)
rescue
  on_exception
end

#delete(bucket, key = '', headers = {}) ⇒ Object

Deletes key. Returns true or an exception.

s3.delete('my_awesome_bucket', 'log/curent/1.log') #=> true



407
408
409
410
411
412
 
# File 'lib/s3/right_s3_interface.rb', line 407

def delete(bucket, key='', headers={})
  req_hash = generate_rest_request('DELETE', headers.merge(:url=>"#{bucket}/#{CGI::escape key}"))
  request_info(req_hash, S3TrueParser.new)
rescue
  on_exception
end

#delete_bucket(bucket, headers = {}) ⇒ Object

Deletes new bucket. Bucket must be empty! Returns true or an exception.

s3.delete_bucket('my_awesome_bucket')  #=> true

See also: force_delete_bucket method



219
220
221
222
223
224
 
# File 'lib/s3/right_s3_interface.rb', line 219

def delete_bucket(bucket, headers={})
  req_hash = generate_rest_request('DELETE', headers.merge(:url=>bucket))
  request_info(req_hash, S3TrueParser.new)
rescue
  on_exception
end

#delete_bucket_link(bucket, expires = nil, headers = {}) ⇒ Object

Generates link for ‘DeleteBucket’.

s3.delete_bucket_link('my_awesome_bucket') #=> url string



625
626
627
628
629
 
# File 'lib/s3/right_s3_interface.rb', line 625

def delete_bucket_link(bucket, expires=nil,  headers={})
  generate_link('DELETE', headers.merge(:url=>bucket), expires)
rescue
  on_exception
end

#delete_folder(bucket, folder_key, separator = '/') ⇒ Object

Deletes all keys where the ‘folder_key’ may be assumed as ‘folder’ name. Returns an array of string keys that have been deleted.

s3.list_bucket('my_awesome_bucket').map{|key_data| key_data[:key]} #=> ['test','test/2/34','test/3','test1','test1/logs']
s3.delete_folder('my_awesome_bucket','test')                       #=> ['test','test/2/34','test/3']



536
537
538
539
540
541
542
543
544
545
546
547
 
# File 'lib/s3/right_s3_interface.rb', line 536

def delete_folder(bucket, folder_key, separator='/')
  folder_key.chomp!(separator)
  allkeys = []
  incrementally_list_bucket(bucket, { 'prefix' => folder_key }) do |results|
    keys = results[:contents].map{ |s3_key| s3_key[:key][/^#{folder_key}($|#{separator}.*)/] ? s3_key[:key] : nil}.compact
    keys.each{ |key| delete(bucket, key) }
    allkeys << keys
  end
  allkeys
rescue
  on_exception
end

#delete_link(bucket, key, expires = nil, headers = {}) ⇒ Object

Generates link for ‘DeleteObject’.

s3.delete_link('my_awesome_bucket',key) #=> url string



676
677
678
679
680
 
# File 'lib/s3/right_s3_interface.rb', line 676

def delete_link(bucket, key, expires=nil, headers={})
  generate_link('DELETE', headers.merge(:url=>"#{bucket}/#{CGI::escape key}"), expires)
rescue
  on_exception
end

#force_delete_bucket(bucket) ⇒ Object

Deletes all keys in bucket then deletes bucket. Returns true or an exception.

s3.force_delete_bucket('my_awesome_bucket')



524
525
526
527
528
529
 
# File 'lib/s3/right_s3_interface.rb', line 524

def force_delete_bucket(bucket)
  clear_bucket(bucket)
  delete_bucket(bucket)
rescue
  on_exception
end

#generate_link(method, headers = {}, expires = nil) ⇒ Object

Generates link for QUERY API



564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
 
# File 'lib/s3/right_s3_interface.rb', line 564

def generate_link(method, headers={}, expires=nil) #:nodoc:
  # default server to use
  server = @params[:server]
  # fix path
  path_to_sign = headers[:url]
  path_to_sign = "/#{path_to_sign}" unless path_to_sign[/^\//]
  # extract bucket name and check it's dns compartibility
  path_to_sign[%r{^/([a-z0-9._-]*)(/[^?]*)?(\?.+)?}i]
  bucket_name, key_path, params_list = $1, $2, $3
  # select request model
  if is_dns_bucket?(bucket_name)
    # add backet to a server name
    server = "#{bucket_name}.#{server}"
    # remove bucket from the path
    path = "#{key_path || '/'}#{params_list}"
    # refactor the path (add '/' before params_list if the key is empty)
    path_to_sign = "/#{bucket_name}#{path}"
  else
    path = path_to_sign
  end
   # expiration time
  expires ||= DEFAULT_EXPIRES_AFTER
  expires   = Time.now.utc.since(expires) if expires.is_a?(Fixnum) && (expires<1.year)
  expires   = expires.to_i
    # remove unset(==optional) and symbolyc keys
  headers.each{ |key, value| headers.delete(key) if (value.nil? || key.is_a?(Symbol)) }
    #generate auth strings
  auth_string = canonical_string(method, path_to_sign, headers, expires)
  signature   = CGI::escape(Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new("sha1"), @aws_secret_access_key, auth_string)).strip)
    # path building
  addon = "Signature=#{signature}&Expires=#{expires}&AWSAccessKeyId=#{@aws_access_key_id}"
  path += path[/\?/] ? "&#{addon}" : "?#{addon}"
  "#{@params[:protocol]}://#{server}:#{@params[:port]}#{path}"
rescue
  on_exception
end

#generate_rest_request(method, headers) ⇒ Object

Generates request hash for REST API. Assumes that headers is URL encoded (use CGI::escape)



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/s3/right_s3_interface.rb', line 112

def generate_rest_request(method, headers)  # :nodoc:
# default server to use
server = @params[:server]
# fix path
path_to_sign = headers[:url]
path_to_sign = "/#{path_to_sign}" unless path_to_sign[/^\//]
# extract bucket name and check it's dns compartibility
path_to_sign[%r{^/([a-z0-9._-]*)(/[^?]*)?(\?.+)?}i]
bucket_name, key_path, params_list = $1, $2, $3
# select request model
if is_dns_bucket?(bucket_name)
  # add backet to a server name
  server = "#{bucket_name}.#{server}"
  # remove bucket from the path
  path = "#{key_path || '/'}#{params_list}"
  # refactor the path (add '/' before params_list if the key is empty)
  path_to_sign = "/#{bucket_name}#{path}"
else
  path = path_to_sign
end
data = headers[:data]
  # remove unset(==optional) and symbolyc keys
headers.each{ |key, value| headers.delete(key) if (value.nil? || key.is_a?(Symbol)) }
  #
headers['content-type'] ||= ''
headers['date']           = Time.now.httpdate
  # create request
request      = "Net::HTTP::#{method.capitalize}".constantize.new(path)
request.body = data if data
  # set request headers and meta headers
headers.each      { |key, value| request[key.to_s] = value }
  #generate auth strings
auth_string = canonical_string(request.method, path_to_sign, request.to_hash)
signature   = AwsUtils::sign(@aws_secret_access_key, auth_string)
  # set other headers
request['Authorization'] = "AWS #{@aws_access_key_id}:#{signature}"
  # prepare output hash
{ :request  => request, 
  :server   => server,
  :port     => @params[:port],
  :protocol => @params[:protocol] }
end

#get(bucket, key, headers = {}, &block) ⇒ Object

Retrieves object data from Amazon. Returns a hash or an exception.

s3.get('my_awesome_bucket', 'log/curent/1.log') #=>

    {:object  => "Ola-la!", 
     :headers => {"last-modified"     => "Wed, 23 May 2007 09:08:04 GMT", 
                  "content-type"      => "", 
                  "etag"              => "\"000000000096f4ee74bc4596443ef2a4\"", 
                   "date"              => "Wed, 23 May 2007 09:08:03 GMT", 
                   "x-amz-id-2"        => "ZZZZZZZZZZZZZZZZZZZZ1HJXZoehfrS4QxcxTdNGldR7w/FVqblP50fU8cuIMLiu", 
                   "x-amz-meta-family" => "Woho556!",
                   "x-amz-request-id"  => "0000000C246D770C", 
                   "server"            => "AmazonS3", 
                   "content-length"    => "7"}}

If a block is provided, yields incrementally to the block as the response is read. For large responses, this function is ideal as the response can be ‘streamed’. The hash containing header fields is still returned. Example: foo = File.new(‘./chunder.txt’, File::CREAT|File::RDWR) rhdr = s3.get(‘aws-test’, ‘Cent5V1_7_1.img.part.00’) do |chunk|

foo.write(chunk)

end foo.close



376
377
378
379
380
381
 
# File 'lib/s3/right_s3_interface.rb', line 376

def get(bucket, key, headers={}, &block)
  req_hash = generate_rest_request('GET', headers.merge(:url=>"#{bucket}/#{CGI::escape key}"))
  request_info(req_hash, S3HttpResponseBodyParser.new, &block)
rescue
  on_exception
end

#get_acl(bucket, key = '', headers = {}) ⇒ Object

Retieves the ACL (access control policy) for a bucket or object. Returns a hash of headers and xml doc with ACL data. See: docs.amazonwebservices.com/AmazonS3/2006-03-01/RESTAccessPolicy.html.

s3.get_acl('my_awesome_bucket', 'log/curent/1.log') #=>
  {:headers => {"x-amz-id-2"=>"B3BdDMDUz+phFF2mGBH04E46ZD4Qb9HF5PoPHqDRWBv+NVGeA3TOQ3BkVvPBjgxX",
                "content-type"=>"application/xml;charset=ISO-8859-1",
                "date"=>"Wed, 23 May 2007 09:40:16 GMT",
                "x-amz-request-id"=>"B183FA7AB5FBB4DD",
                "server"=>"AmazonS3",
                "transfer-encoding"=>"chunked"},
   :object  => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<AccessControlPolicy xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\"><Owner>
                <ID>16144ab2929314cc309ffe736daa2b264357476c7fea6efb2c3347ac3ab2792a</ID><DisplayName>root</DisplayName></Owner>
                <AccessControlList><Grant><Grantee xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"CanonicalUser\"><ID>
                16144ab2929314cc309ffe736daa2b264357476c7fea6efb2c3347ac3ab2792a</ID><DisplayName>root</DisplayName></Grantee>
                <Permission>FULL_CONTROL</Permission></Grant></AccessControlList></AccessControlPolicy>" }



430
431
432
433
434
435
436
 
# File 'lib/s3/right_s3_interface.rb', line 430

def get_acl(bucket, key='', headers={})
  key = key.blank? ? '' : "/#{CGI::escape key}"
  req_hash = generate_rest_request('GET', headers.merge(:url=>"#{bucket}#{key}?acl"))
  request_info(req_hash, S3HttpResponseBodyParser.new) 
rescue
  on_exception
end

#get_acl_link(bucket, key = '', headers = {}) ⇒ Object

Generates link for ‘GetACL’.

s3.get_acl_link('my_awesome_bucket',key) #=> url string



687
688
689
690
691
 
# File 'lib/s3/right_s3_interface.rb', line 687

def get_acl_link(bucket, key='', headers={})
  return generate_link('GET', headers.merge(:url=>"#{bucket}/#{CGI::escape key}?acl"))
rescue
  on_exception
end

#get_acl_parse(bucket, key = '', headers = {}) ⇒ Object

Retieves the ACL (access control policy) for a bucket or object. Returns a hash of :grantees

s3.get_acl_parse('my_awesome_bucket', 'log/curent/1.log') #=>

{ :grantees=>
  { "16...2a"=>
    { :display_name=>"root",
      :permissions=>["FULL_CONTROL"],
      :attributes=>
       { "xsi:type"=>"CanonicalUser",
         "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance"}},
   "http://acs.amazonaws.com/groups/global/AllUsers"=>
     { :display_name=>"AllUsers",
       :permissions=>["READ"],
       :attributes=>
        { "xsi:type"=>"Group",
          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance"}}},
 :owner=>
   { :id=>"16..2a",
     :display_name=>"root"}}



460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
 
# File 'lib/s3/right_s3_interface.rb', line 460

def get_acl_parse(bucket, key='', headers={})
  key = key.blank? ? '' : "/#{CGI::escape key}"
  req_hash = generate_rest_request('GET', headers.merge(:url=>"#{bucket}#{key}?acl"))
  acl = request_info(req_hash, S3AclParser.new(:logger => @logger))
  result = {}
  result[:owner]    = acl[:owner]
  result[:grantees] = {}
  acl[:grantees].each do |grantee|
    key = grantee[:id] || grantee[:uri]
    if result[:grantees].key?(key)
      result[:grantees][key][:permissions] << grantee[:permissions]
    else
      result[:grantees][key] = 
        { :display_name => grantee[:display_name] || grantee[:uri].to_s[/[^\/]*$/],
          :permissions  => grantee[:permissions].to_a,
          :attributes   => grantee[:attributes] }
    end
  end
  result
rescue
  on_exception
end

#get_bucket_acl(bucket, headers = {}) ⇒ Object

Retieves the ACL (access control policy) for a bucket. Returns a hash of headers and xml doc with ACL data.



493
494
495
496
497
 
# File 'lib/s3/right_s3_interface.rb', line 493

def get_bucket_acl(bucket, headers={})
  return get_acl(bucket, '', headers)
rescue
  on_exception
end

#get_bucket_acl_link(bucket, headers = {}) ⇒ Object

Generates link for ‘GetBucketACL’.

s3.get_acl_link('my_awesome_bucket',key) #=> url string



707
708
709
710
711
 
# File 'lib/s3/right_s3_interface.rb', line 707

def get_bucket_acl_link(bucket, headers={})
  return get_acl_link(bucket, '', headers)
rescue
  on_exception
end

#get_link(bucket, key, expires = nil, headers = {}) ⇒ Object

Generates link for ‘GetObject’.

s3.get_link('my_awesome_bucket',key) #=> url string



656
657
658
659
660
 
# File 'lib/s3/right_s3_interface.rb', line 656

def get_link(bucket, key, expires=nil, headers={})
  generate_link('GET', headers.merge(:url=>"#{bucket}/#{CGI::escape key}"), expires)
rescue
  on_exception
end

#get_object(bucket, key, headers = {}) ⇒ Object

Retrieves object data only (headers are omitted). Returns string or an exception.

s3.get('my_awesome_bucket', 'log/curent/1.log') #=> 'Ola-la!'



553
554
555
556
557
 
# File 'lib/s3/right_s3_interface.rb', line 553

def get_object(bucket, key, headers={})
  get(bucket, key, headers)[:object]
rescue
  on_exception
end

#head(bucket, key, headers = {}) ⇒ Object

Retrieves object metadata. Returns a hash of http_response_headers.

s3.head('my_awesome_bucket', 'log/curent/1.log') #=>
  {"last-modified"     => "Wed, 23 May 2007 09:08:04 GMT", 
   "content-type"      => "", 
   "etag"              => "\"000000000096f4ee74bc4596443ef2a4\"", 
   "date"              => "Wed, 23 May 2007 09:08:03 GMT", 
   "x-amz-id-2"        => "ZZZZZZZZZZZZZZZZZZZZ1HJXZoehfrS4QxcxTdNGldR7w/FVqblP50fU8cuIMLiu", 
   "x-amz-meta-family" => "Woho556!",
   "x-amz-request-id"  => "0000000C246D770C", 
   "server"            => "AmazonS3", 
   "content-length"    => "7"}



396
397
398
399
400
401
 
# File 'lib/s3/right_s3_interface.rb', line 396

def head(bucket, key, headers={})
  req_hash = generate_rest_request('HEAD', headers.merge(:url=>"#{bucket}/#{CGI::escape key}"))
  request_info(req_hash, S3HttpResponseHeadParser.new)
rescue
  on_exception
end

#head_link(bucket, key, expires = nil, headers = {}) ⇒ Object

Generates link for ‘HeadObject’.

s3.head_link('my_awesome_bucket',key) #=> url string



666
667
668
669
670
 
# File 'lib/s3/right_s3_interface.rb', line 666

def head_link(bucket, key, expires=nil,  headers={})
  generate_link('HEAD', headers.merge(:url=>"#{bucket}/#{CGI::escape key}"), expires)
rescue
  on_exception
end

#incrementally_list_bucket(bucket, options = {}, headers = {}, &block) ⇒ Object

Incrementally list the contents of a bucket. Yields the following hash to a block:

s3.incrementally_list_bucket('my_awesome_bucket', { 'prefix'=>'t', 'marker'=>'', 'max-keys'=>5, delimiter=>'' }) yields  
 {
   :name => 'bucketname',
   :prefix => 'subfolder/',
   :marker => 'fileN.jpg',
   :max_keys => 234,
   :delimiter => '/',
   :is_truncated => true,
   :next_marker => 'fileX.jpg',
   :contents => [
     { :key => "file1",
       :last_modified => "2007-05-18T07:00:59.000Z",
       :e_tag => "000000000059075b964b07152d234b70",
       :size => 3,
       :storage_class => "STANDARD",
       :owner_id => "00000000009314cc309ffe736daa2b264357476c7fea6efb2c3347ac3ab2792a",
       :owner_display_name => "root"
     }, { :key, ...}, ... {:key, ...}
   ]
   :common_prefixes => [
     "prefix1",
     "prefix2",
     ...,
     "prefixN"
   ]
 }



277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
 
# File 'lib/s3/right_s3_interface.rb', line 277

def incrementally_list_bucket(bucket, options={}, headers={}, &block)
  internal_options = options.symbolize_keys
  begin 
    internal_bucket = bucket.dup
    internal_bucket  += '?'+internal_options.map{|k, v| "#{k.to_s}=#{CGI::escape v.to_s}"}.join('&') unless internal_options.blank?
    req_hash = generate_rest_request('GET', headers.merge(:url=>internal_bucket))
    response = request_info(req_hash, S3ImprovedListBucketParser.new(:logger => @logger))
    there_are_more_keys = response[:is_truncated]
    if(there_are_more_keys)
      if(response[:next_marker])
        internal_options[:marker] = response[:next_marker]
      else 
        internal_options[:marker] = response[:contents].last[:key]
      end
      internal_options[:'max-keys'] ? (internal_options[:'max-keys'] -= response[:contents].length) : nil 
    end
    yield response
  end while there_are_more_keys 
  true
rescue
  on_exception
end

#is_dns_bucket?(bucket_name) ⇒ Boolean

Returns:

  • (Boolean) 


101
102
103
104
105
106
107
108
 
# File 'lib/s3/right_s3_interface.rb', line 101

def is_dns_bucket?(bucket_name)
  bucket_name = bucket_name.to_s
  return nil unless (3..63) === bucket_name.size
  bucket_name.split('.').each do |component|
    return nil unless component[/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/]
  end
  true
end

#list_all_my_buckets(headers = {}) ⇒ Object

Returns an array of customer’s buckets. Each item is a hash.

s3.list_all_my_buckets #=> 
  [{:owner_id           => "00000000009314cc309ffe736daa2b264357476c7fea6efb2c3347ac3ab2792a",
    :owner_display_name => "root",
    :name               => "bucket_name",
    :creation_date      => "2007-04-19T18:47:43.000Z"}, ..., {...}]



172
173
174
175
176
177
 
# File 'lib/s3/right_s3_interface.rb', line 172

def list_all_my_buckets(headers={})
  req_hash = generate_rest_request('GET', headers.merge(:url=>''))
  request_info(req_hash, S3ListAllMyBucketsParser.new(:logger => @logger))
rescue
  on_exception
end

#list_all_my_buckets_link(expires = nil, headers = {}) ⇒ Object

Generates link for ‘ListAllMyBuckets’.

s3.list_all_my_buckets_link #=> url string



605
606
607
608
609
 
# File 'lib/s3/right_s3_interface.rb', line 605

def list_all_my_buckets_link(expires=nil, headers={})
  generate_link('GET', headers.merge(:url=>''), expires)
rescue
  on_exception
end

#list_bucket(bucket, options = {}, headers = {}) ⇒ Object

Returns an array of bucket’s keys. Each array item (key data) is a hash.

s3.list_bucket('my_awesome_bucket', { 'prefix'=>'t', 'marker'=>'', 'max-keys'=>5, delimiter=>'' }) #=>
  [{:key                => "test1",
    :last_modified      => "2007-05-18T07:00:59.000Z",
    :owner_id           => "00000000009314cc309ffe736daa2b264357476c7fea6efb2c3347ac3ab2792a",
    :owner_display_name => "root",
    :e_tag              => "000000000059075b964b07152d234b70",
    :storage_class      => "STANDARD",
    :size               => 3,
    :service=> {'is_truncated' => false,
                'prefix'       => "t",
                'marker'       => "",
                'name'         => "my_awesome_bucket",
                'max-keys'     => "5"}, ..., {...}]



242
243
244
245
246
247
248
 
# File 'lib/s3/right_s3_interface.rb', line 242

def list_bucket(bucket, options={}, headers={})
  bucket  += '?'+options.map{|k, v| "#{k.to_s}=#{CGI::escape v.to_s}"}.join('&') unless options.blank?
  req_hash = generate_rest_request('GET', headers.merge(:url=>bucket))
  request_info(req_hash, S3ListBucketParser.new(:logger => @logger))
rescue
  on_exception
end

#list_bucket_link(bucket, options = nil, expires = nil, headers = {}) ⇒ Object

Generates link for ‘ListBucket’.

s3.list_bucket_link('my_awesome_bucket') #=> url string



635
636
637
638
639
640
 
# File 'lib/s3/right_s3_interface.rb', line 635

def list_bucket_link(bucket, options=nil, expires=nil, headers={})
  bucket += '?' + options.map{|k, v| "#{k.to_s}=#{CGI::escape v.to_s}"}.join('&') unless options.blank?
  generate_link('GET', headers.merge(:url=>bucket), expires)
rescue
  on_exception
end

#put(bucket, key, data = nil, headers = {}) ⇒ Object

Saves object to Amazon. Returns true or an exception. Any header starting with AMAZON_METADATA_PREFIX is considered user metadata. It will be stored with the object and returned when you retrieve the object. The total size of the HTTP request, not including the body, must be less than 4 KB.

s3.put('my_awesome_bucket', 'log/current/1.log', 'Ola-la!', 'x-amz-meta-family'=>'Woho556!') #=> true

This method is capable of ‘streaming’ uploads; that is, it can upload data from a file or other IO object without first reading all the data into memory. This is most useful for large PUTs - it is difficult to read a 2 GB file entirely into memory before sending it to S3. To stream an upload, pass an object that responds to ‘read’ (like the read method of IO) and to either ‘lstat’ or ‘size’. For files, this means streaming is enabled by simply making the call:

s3.put(bucket_name, 'S3keyname.forthisfile',  File.open('localfilename.dat'))

If the IO object you wish to stream from responds to the read method but doesn’t implement lstat or size, you can extend the object dynamically to implement these methods, or define your own class which defines these methods. Be sure that your class returns ‘nil’ from read() after having read ‘size’ bytes. Otherwise S3 will drop the socket after ‘Content-Length’ bytes have been uploaded, and HttpConnection will interpret this as an error.

This method now supports very large PUTs, where very large is > 2 GB.

For Win32 users: Files and IO objects should be opened in binary mode. If a text mode IO object is passed to PUT, it will be converted to binary mode.



333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
 
# File 'lib/s3/right_s3_interface.rb', line 333

def put(bucket, key, data=nil, headers={})
  # On Windows, if someone opens a file in text mode, we must reset it so
  # to binary mode for streaming to work properly
  if(data.respond_to?(:binmode))
    data.binmode
  end
  if (data.respond_to?(:lstat) && data.lstat.size >= USE_100_CONTINUE_PUT_SIZE) ||
     (data.respond_to?(:size)  && data.size       >= USE_100_CONTINUE_PUT_SIZE)
    headers['expect'] = '100-continue'
  end
  req_hash = generate_rest_request('PUT', headers.merge(:url=>"#{bucket}/#{CGI::escape key}", :data=>data))
  request_info(req_hash, S3TrueParser.new)
rescue
  on_exception
end

#put_acl(bucket, key, acl_xml_doc, headers = {}) ⇒ Object

Sets the ACL on a bucket or object.



484
485
486
487
488
489
490
 
# File 'lib/s3/right_s3_interface.rb', line 484

def put_acl(bucket, key, acl_xml_doc, headers={})
  key = key.blank? ? '' : "/#{CGI::escape key}"
  req_hash = generate_rest_request('PUT', headers.merge(:url=>"#{bucket}#{key}?acl", :data=>acl_xml_doc))
  request_info(req_hash, S3HttpResponseBodyParser.new)
rescue
  on_exception
end

#put_acl_link(bucket, key = '', headers = {}) ⇒ Object

Generates link for ‘PutACL’.

s3.put_acl_link('my_awesome_bucket',key) #=> url string



697
698
699
700
701
 
# File 'lib/s3/right_s3_interface.rb', line 697

def put_acl_link(bucket, key='', headers={})
  return generate_link('PUT', headers.merge(:url=>"#{bucket}/#{CGI::escape key}?acl"))
rescue
  on_exception
end

#put_bucket_acl(bucket, acl_xml_doc, headers = {}) ⇒ Object

Sets the ACL on a bucket only.



500
501
502
503
504
 
# File 'lib/s3/right_s3_interface.rb', line 500

def put_bucket_acl(bucket, acl_xml_doc, headers={})
  return put_acl(bucket, '', acl_xml_doc, headers)
rescue
  on_exception
end

#put_bucket_acl_link(bucket, acl_xml_doc, headers = {}) ⇒ Object

Generates link for ‘PutBucketACL’.

s3.put_acl_link('my_awesome_bucket',key) #=> url string



717
718
719
720
721
 
# File 'lib/s3/right_s3_interface.rb', line 717

def put_bucket_acl_link(bucket, acl_xml_doc, headers={})
  return put_acl_link(bucket, '', acl_xml_doc, headers)
rescue
  on_exception
end

#put_link(bucket, key, data = nil, expires = nil, headers = {}) ⇒ Object

Generates link for ‘PutObject’.

s3.put_link('my_awesome_bucket',key, object) #=> url string



646
647
648
649
650
 
# File 'lib/s3/right_s3_interface.rb', line 646

def put_link(bucket, key, data=nil, expires=nil, headers={})
  generate_link('PUT', headers.merge(:url=>"#{bucket}/#{CGI::escape key}", :data=>data), expires)
rescue
  on_exception
end

#request_info(request, parser, &block) ⇒ Object

Sends request to Amazon and parses the response. Raises AwsError if any banana happened.



157
158
159
160
161
 
# File 'lib/s3/right_s3_interface.rb', line 157

def request_info(request, parser, &block) # :nodoc:
  thread = @params[:multi_thread] ? Thread.current : Thread.main
  thread[:s3_connection] ||= Rightscale::HttpConnection.new(:exception => RightAws::AwsError, :logger => @logger)
  request_info_impl(thread[:s3_connection], @@bench, request, parser, &block)
end