rcarvalho-uber-s3 0.2.4

data/README.md

@@ -0,0 +1,153 @@
+# Uber-S3
+
+A simple, but very fast, S3 client for Ruby supporting
+synchronous (net-http) and asynchronous (em+fibers) io.
+
+
+## Examples
+
+```ruby
+require 'uber-s3'
+
+##########################################################################
+# Connecting to S3
+# adapter can be :net_http or :em_http_fibered
+s3 = UberS3.new({
+  :access_key         => 'abc',
+  :secret_access_key  => 'def',
+  :bucket             => 'funbucket',
+  :adapter            => :em_http_fibered
+})
+
+
+
+##########################################################################
+# Saving objects
+s3.store('/test.txt', 'Look ma no hands')
+s3.store('test2.txt', 'Hey hey', :access => :public_read)
+
+o = s3.object('/test.txt')
+o.value = 'Look ma no hands'
+o.save
+
+# or..
+
+o = UberS3::Object.new(s3.bucket, '/test.txt', 'heyo')
+o.save # => true
+
+
+
+##########################################################################
+# Reading objects
+s3['/test.txt'].class       # => UberS3::Object
+s3['/test.txt'].value       # => 'heyo'
+s3.get('/test.txt').value   # => 'heyo'
+
+s3.exists?('/anotherone')   # => false
+
+
+
+##########################################################################
+# Object access control
+
+o.access = :private
+o.access = :public_read
+# etc.
+
+# Valid options:
+# :private, :public_read, :public_read_write, :authenticated_read
+
+# See http://docs.amazonwebservices.com/AmazonS3/2006-03-01/dev/index.html?RESTAccessPolicy.html
+# NOTE: default object access level is :private
+
+
+
+##########################################################################
+# Deleting objects
+o.delete # => true
+
+
+##########################################################################
+# Save optional parameters
+# See http://docs.amazonwebservices.com/AmazonS3/latest/API/index.html?RESTObjectPUT.html
+
+options = { :access => :public_read, :content_type => 'text/plain' }
+o = UberS3::Object.new(client.bucket, '/test.txt', 'heyo', options)
+o.save
+
+# or..
+
+o = s3.object('/test.txt')
+o.value = 'Look ma no hands'
+o.access = :public_read
+o.content_type = 'text/plain'
+o.save
+
+# List of parameter methods:
+# :access               -- Object access control
+# :cache_control        -- http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9
+# :content_disposition  -- http://www.w3.org/Protocols/rfc2616/rfc2616-sec19.html#sec19.5.1
+# :content_encoding     -- http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.11
+# :content_md5          -- End-to-end integrity check
+# :content_type         -- http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.17
+# :expires              -- Number of milliseconds before expiration
+# :storage_class        -- Amazon S3's storage levels (redundancy for price)
+
+
+##########################################################################
+# Iterating objects in a bucket
+s3.objects('/path').each {|obj| puts obj } 
+
+```
+
+## Ruby version notes
+
+* Tested on MRI 1.9.2, MRI 1.9.3 (net_http / em_http_fibered adapters)
+* Tested on JRuby 1.7-dev in 1.9 mode (net_http)
+* Ruby 1.8.7 works for net/http clients, em_http_fibered adapter requires fibers
+
+## Other notes
+
+* If Nokogiri is available, it will be automatically used instead of REXML
+
+## TODO
+
+* Refactor UberS3::Object class, consider putting the operations/headers into separate classes
+* Better exception handling and reporting
+* Query string authentication -- neat feature for providing temporary public access to a private object
+* Object versioning support
+
+## Benchmarks
+
+Benchmarks were run with a speedy MBP on a 10Mbit connection
+
+### Saving lots of 1KB files
+
+<pre>
+                                                       user     system      total        real
+saving 100x1024 byte objects (net-http)            0.160000   0.080000   0.240000 ( 26.128499)
+saving 100x1024 byte objects (em-http-fibered)     0.080000   0.030000   0.110000 (  0.917334)
+</pre>
+
+### Saving lots of 500KB files
+
+<pre>
+                                                       user     system      total        real
+saving 100x512000 byte objects (net-http)          0.190000   0.740000   0.930000 ( 91.559123)
+saving 100x512000 byte objects (em-http-fibered)   0.230000   0.700000   0.930000 ( 45.119033)
+</pre>
+
+### Conclusion
+
+Yea... async adapter dominates. The 100x1KB files were 29x faster to upload, and the 100x500KB files were only 2x faster, but that is because my upload bandwidth was tapped.
+
+
+## S3 API Docs
+
+- S3 REST API: http://docs.amazonwebservices.com/AmazonS3/latest/API/
+- S3 Request Authorization: http://docs.amazonwebservices.com/AmazonS3/latest/dev/RESTAuthentication.html
+
+
+## License
+
+MIT License - Copyright (c) 2012 Nulayer Inc.

data/lib/uber-s3.rb

@@ -0,0 +1,45 @@
+require 'cgi'
+require 'time'
+require 'openssl'
+require 'forwardable'
+require 'base64'
+require 'digest/md5'
+require 'zlib'
+require 'stringio'
+require 'mime/types'
+
+class UberS3
+  extend Forwardable
+  
+  attr_reader :connection
+  attr_accessor :bucket, :options
+  def_delegators :@bucket, :store, :set, :object, :get, :head, :[], :exists?, :objects
+  
+  def initialize(options={})
+    self.options = options
+    self.bucket  = options[:bucket]
+  end
+
+  def inspect
+    "#<UberS3 client v#{UberS3::VERSION}>"
+  end
+
+  def connection
+    Thread.current['[uber-s3]:connection'] ||= Connection.open(self, options)
+  end
+  
+  def bucket=(bucket)
+    @bucket = bucket.is_a?(String) ? Bucket.new(self, bucket) : bucket
+  end
+end
+
+require 'uber-s3/version'
+require 'uber-s3/error'
+require 'uber-s3/response'
+require 'uber-s3/connection'
+require 'uber-s3/authorization'
+require 'uber-s3/operation'
+require 'uber-s3/bucket'
+require 'uber-s3/object'
+
+require 'uber-s3/util/xml_document'

data/lib/uber-s3/authorization.rb

@@ -0,0 +1,29 @@
+class UberS3
+  module Authorization
+    
+    def sign(client, verb, path, headers={})
+      req_verb                  = verb.to_s.upcase
+      req_content_md5           = headers['Content-MD5']
+      req_content_type          = headers['Content-Type']
+      req_date                  = headers['Date']
+      req_canonical_resource    = "/#{client.bucket}/#{path}".split('?').first
+      req_canonical_amz_headers = ''
+
+      headers.keys.sort.select {|k| k =~ /^x-amz-/ }.each do |amz_key|
+        req_canonical_amz_headers << amz_key+':'+headers[amz_key]+"\n"
+      end
+
+      canonical_string_to_sign = "#{req_verb}\n"+
+                                 "#{req_content_md5}\n"+
+                                 "#{req_content_type}\n"+
+                                 "#{req_date}\n"+
+                                 "#{req_canonical_amz_headers}"+
+                                 "#{req_canonical_resource}"
+      
+      digest = OpenSSL::Digest::Digest.new('sha1')
+      [OpenSSL::HMAC.digest(digest, client.connection.secret_access_key, canonical_string_to_sign)].pack("m").strip
+    end
+    
+    extend self    
+  end
+end

data/lib/uber-s3/bucket.rb

@@ -0,0 +1,100 @@
+class UberS3
+  class Bucket
+    attr_accessor :s3, :name
+    
+    def initialize(s3, name)
+      self.s3   = s3
+      self.name = name
+    end
+
+    def to_s
+      name.to_s
+    end
+    
+    def connection
+      s3.connection
+    end
+
+    def store(key, value, options={})
+      Object.new(self, key, value, options).save
+    end
+    alias_method :set, :store
+
+    def object(key)
+      Object.new(self, key)
+    end
+    alias_method :[], :object
+
+    def get(key)
+      object(key).fetch
+    end
+
+    def head(key)
+      object(key).head
+    end
+
+    def exists?(key)
+      object(key).exists?
+    end
+    
+    def objects(key, options={})
+      ObjectList.new(self, key, options)
+    end
+    
+    
+    class ObjectList
+      include Enumerable
+      
+      attr_accessor :bucket, :key, :options, :objects
+      
+      def initialize(bucket, key, options={})
+        self.bucket   = bucket
+        self.key      = key.gsub(/^\//, '')
+        self.options  = options
+        self.objects  = []
+      end
+      
+      def fetch(marker=nil)
+        @objects = []
+
+        default_max_keys = 500
+        response = bucket.connection.get("/?prefix=#{CGI.escape(key)}&marker=#{marker}&max-keys=#{default_max_keys}")        
+
+        @objects = parse_contents(response.body)
+      end
+      
+      def parse_contents(xml)
+        objects = []
+        doc = Util::XmlDocument.new(xml)
+        
+        # TODO: can use more error checking on the xml stuff
+        
+        @is_truncated = doc.xpath('//ListBucketResult/IsTruncated').first.text == "true"
+        contents = doc.xpath('//ListBucketResult/Contents')
+        
+        contents.each do |content|
+          h = {}
+          content.elements.each {|el| h[el.name] = el.text }
+          objects << ::UberS3::Object.new(bucket, h['Key'], nil, { :size => h['Size'].to_i })
+        end if contents.any?
+
+        objects
+      end
+      
+      def each(&block)
+        loop do
+          marker = objects.last.key rescue nil
+          fetch(marker)
+          
+          objects.each {|obj| block.call(obj) }
+          break if @is_truncated == false
+        end
+      end
+      
+      def to_a
+        fetch
+      end
+    end
+    
+  end
+end

data/lib/uber-s3/connection.rb

@@ -0,0 +1,72 @@
+class UberS3
+  module Connection
+    
+    def self.open(s3, options={})
+      adapter = options.delete(:adapter) || :net_http      
+      
+      begin
+        require "uber-s3/connection/#{adapter}"
+        klass = instance_eval(adapter.to_s.split('_').map {|x| x.capitalize}.join(""))
+      rescue LoadError
+        raise "Cannot load #{adapter} adapter class"
+      end
+      
+      klass.new(s3, options)
+    end
+    
+    
+    class Adapter
+    
+      attr_accessor :s3, :http, :uri, :access_key, :secret_access_key, :defaults
+    
+      def initialize(s3, options={})
+        self.s3                 = s3
+        self.http               = nil
+        self.uri                = nil
+        self.access_key         = options[:access_key]
+        self.secret_access_key  = options[:secret_access_key]
+        self.defaults           = options[:defaults] || {}
+      end
+    
+      [:get, :post, :put, :delete, :head].each do |verb|
+        define_method(verb) do |*args|
+          path, headers, body = args
+          path = path.gsub(/^\//, '')
+          headers ||= {}
+
+          # Default headers
+          headers['Date'] = Time.now.httpdate if !headers.keys.include?('Date')
+          headers['User-Agent'] ||= "UberS3 v#{UberS3::VERSION}"
+          headers['Connection'] ||= 'keep-alive'
+          
+          if body
+            headers['Content-Length'] ||= body.bytesize.to_s
+          end
+          
+          # Authorize the request          
+          signature = Authorization.sign(s3, verb, path, headers)
+          headers['Authorization'] = "AWS #{access_key}:#{signature}"
+          
+          # Make the request
+          url = "http://#{s3.bucket}.s3.amazonaws.com/#{path}"
+          request(verb, url, headers, body)
+        end
+      end
+
+      def uri=(uri)
+        # Reset the http connection if the host/port change
+        if !@uri.nil? && !(uri.host == @uri.host && uri.port == @uri.port)
+          self.http = nil
+        end
+
+        @uri = uri
+      end
+
+      def request(verb, url, headers={}, body=nil)
+        raise "Abstract method"
+      end
+
+    end
+    
+  end  
+end

data/lib/uber-s3/connection/em_http.rb

@@ -0,0 +1,12 @@
+require 'eventmachine'
+require 'em-http'
+
+module UberS3::Connection
+  class EmHttp < Adapter
+    
+    # NOTE: this will be very difficult to support
+    # with our interface.. will need lots of work.
+    # We may only want to support async with fibers.
+    
+  end
+end

data/lib/uber-s3/connection/em_http_fibered.rb

@@ -0,0 +1,26 @@
+require 'eventmachine'
+require 'em-http'
+require 'em-synchrony'
+require 'em-synchrony/em-http'
+
+module UberS3::Connection
+  class EmHttpFibered < Adapter
+    
+    def request(verb, url, headers={}, body=nil)
+      params = {}
+      params[:head] = headers
+      params[:body] = body if body
+      # params[:keepalive] = true if persistent # causing issues ...?
+        
+      r = EM::HttpRequest.new(url).send(verb, params)
+
+      UberS3::Response.new({
+        :status => r.response_header.status,
+        :header => r.response_header,
+        :body   => r.response,
+        :raw    => r
+      })
+    end
+    
+  end
+end

data/lib/uber-s3/connection/net_http.rb

@@ -0,0 +1,62 @@
+require 'net/http'
+
+module UberS3::Connection
+  class NetHttp < Adapter
+    
+    def request(verb, url, headers={}, body=nil)
+      if verb == :get
+        # Support fetching compressed data
+        headers['Accept-Encoding'] = 'gzip, deflate'
+      end
+      
+      self.uri = URI.parse(url)
+
+      # Init and open a HTTP connection
+      http_connect! if http.nil? || !http.started?
+
+      req_klass = instance_eval("Net::HTTP::"+verb.to_s.capitalize)
+      req = req_klass.new(uri.to_s, headers)
+
+      req.body = body if !body.nil? && !body.empty?
+
+      # Make HTTP request
+      retries = 2
+      begin
+        r = http.request(req)
+      rescue EOFError, Errno::EPIPE
+        # Something happened to our connection, lets try this again
+        http_connect!
+        retries -= 1
+        retry if retries >= 0
+      end
+
+      # Auto-decode any gzipped objects
+      if verb == :get && r.header['Content-Encoding'] == 'gzip'
+        gz = Zlib::GzipReader.new(StringIO.new(r.body))
+        response_body = gz.read
+      else
+        response_body = r.body
+      end
+      
+      UberS3::Response.new({
+        :status => r.code.to_i,
+        :header => r.header.to_hash,
+        :body   => response_body,
+        :raw    => r
+      })
+    end
+
+    private
+
+      def http_connect!
+        self.http = Net::HTTP.new(uri.host, uri.port)
+        http.start
+
+        if Socket.const_defined?(:TCP_NODELAY)
+          socket = http.instance_variable_get(:@socket)
+          socket.io.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
+        end
+      end
+    
+  end
+end

data/lib/uber-s3/error.rb

@@ -0,0 +1,89 @@
+class UberS3
+  
+  module Error
+  
+    class Standard < StandardError
+      def initialize(key, message)
+        super("#{key}: #{message}")
+      end
+    end
+  
+    class Unknown < StandardError; end
+    
+    class AccessDenied < Standard; end
+    class AccountProblem < Standard; end
+    class AmbiguousGrantByEmailAddress < Standard; end
+    class BadDigest < Standard; end
+    class BucketAlreadyExists < Standard; end
+    class BucketAlreadyOwnedByYou < Standard; end
+    class BucketNotEmpty < Standard; end
+    class CredentialsNotSupported < Standard; end
+    class CrossLocationLoggingProhibited < Standard; end
+    class EntityTooSmall < Standard; end
+    class EntityTooLarge < Standard; end
+    class ExpiredToken < Standard; end
+    class IllegalVersioningConfigurationException < Standard; end
+    class IncompleteBody < Standard; end
+    class IncorrectNumberOfFilesInPostRequest < Standard; end
+    class InlineDataTooLarge < Standard; end
+    class InternalError < Standard; end
+    class InvalidAccessKeyId < Standard; end
+    class InvalidAddressingHeader < Standard; end
+    class InvalidArgument < Standard; end
+    class InvalidBucketName < Standard; end
+    class InvalidDigest < Standard; end
+    class InvalidLocationConstraint < Standard; end
+    class InvalidPart < Standard; end
+    class InvalidPartOrder < Standard; end
+    class InvalidPayer < Standard; end
+    class InvalidPolicyDocument < Standard; end
+    class InvalidRange < Standard; end
+    class InvalidRequest < Standard; end
+    class InvalidSecurity < Standard; end
+    class InvalidSOAPRequest < Standard; end
+    class InvalidStorageClass < Standard; end
+    class InvalidTargetBucketForLogging < Standard; end
+    class InvalidToken < Standard; end
+    class InvalidURI < Standard; end
+    class KeyTooLong < Standard; end
+    class MalformedACLError < Standard; end
+    class MalformedPOSTRequest < Standard; end
+    class MalformedXML < Standard; end
+    class MaxMessageLengthExceeded < Standard; end
+    class MaxPostPreDataLengthExceededError < Standard; end
+    class MetadataTooLarge < Standard; end
+    class MethodNotAllowed < Standard; end
+    class MissingAttachment < Standard; end
+    class MissingContentLength < Standard; end
+    class MissingRequestBodyError < Standard; end
+    class MissingSecurityElement < Standard; end
+    class MissingSecurityHeader < Standard; end
+    class NoLoggingStatusForKey < Standard; end
+    class NoSuchBucket < Standard; end
+    class NoSuchKey < Standard; end
+    class NoSuchUpload < Standard; end
+    class NoSuchVersion < Standard; end
+    class NotImplemented < Standard; end
+    class NotSignedUp < Standard; end
+    class NotSuchBucketPolicy < Standard; end
+    class OperationAborted < Standard; end
+    class PermanentRedirect < Standard; end
+    class PreconditionFailed < Standard; end
+    class Redirect < Standard; end
+    class RequestIsNotMultiPartContent < Standard; end
+    class RequestTimeout < Standard; end
+    class RequestTimeTooSkewed < Standard; end
+    class RequestTorrentOfBucketError < Standard; end
+    class SignatureDoesNotMatch < Standard; end
+    class ServiceUnavailable < Standard; end
+    class SlowDown < Standard; end
+    class TemporaryRedirect < Standard; end
+    class TokenRefreshRequired < Standard; end
+    class TooManyBuckets < Standard; end
+    class UnexpectedContent < Standard; end
+    class UnresolvableGrantByEmailAddress < Standard; end
+    class UserKeyMustBeSpecified < Standard; end
+
+  end
+
+end

data/lib/uber-s3/object.rb

@@ -0,0 +1,147 @@
+class UberS3
+  class Object
+    include Operation::Object::AccessPolicy
+    include Operation::Object::ContentDisposition
+    include Operation::Object::ContentEncoding
+    include Operation::Object::ContentMd5
+    include Operation::Object::ContentType
+    include Operation::Object::HttpCache
+    include Operation::Object::Meta
+    include Operation::Object::StorageClass
+
+    attr_accessor :bucket, :key, :response, :value, :size, :error
+    
+    def initialize(bucket, key, value=nil, options={})
+      self.bucket        = bucket
+      self.key           = key
+      self.value         = value
+      
+      # Init current state
+      infer_content_type!
+      
+      # Call operation methods based on options passed
+      bucket.connection.defaults.merge(options).each {|k,v| self.send((k.to_s+'=').to_sym, v) }
+    end
+    
+    def to_s
+      "#<#{self.class} @key=\"#{self.key}\">"
+    end
+    
+    def exists?
+      # TODO.. refactor this as if we've already called head
+      # on the object, there is no need to do it again..
+      # perhaps move some things into class methods?
+      bucket.connection.head(key).status == 200
+    end
+
+    def head
+      self.response = bucket.connection.head(key)
+      
+      parse_response_header!
+      self
+    end
+    
+    def fetch
+      self.response = bucket.connection.get(key)
+      self.value = response.body
+
+      parse_response_header!
+      self
+    end
+    
+    def save
+      headers = {}
+      
+      # Encode data if necessary
+      gzip_content!
+      
+      # Standard pass through values
+      headers['Content-Disposition']  = content_disposition
+      headers['Content-Encoding']     = content_encoding
+      headers['Content-Length']       = size.to_s
+      headers['Content-Type']         = content_type
+      headers['Cache-Control']        = cache_control
+      headers['Expires']              = expires
+      headers['Pragma']               = pragma
+
+      headers.each {|k,v| headers.delete(k) if v.nil? || v.empty? }
+
+      # Content MD5 integrity check
+      if !content_md5.nil?
+        self.content_md5 = Digest::MD5.hexdigest(value) if content_md5 == true
+
+        # We expect a md5 hex digest here
+        md5_digest = content_md5.unpack('a2'*16).collect {|i| i.hex.chr }.join
+        headers['Content-MD5'] = Base64.encode64(md5_digest).strip
+      end
+
+      # ACL
+      if !access.nil?
+        headers['x-amz-acl'] = access.to_s.gsub('_', '-')
+      end
+      
+      # Storage class
+      if !storage_class.nil?
+        headers['x-amz-storage-class'] = storage_class.to_s.upcase
+      end
+
+      # Meta
+      if !meta.nil? && !meta.empty?
+        meta.each {|k,v| headers["x-amz-meta-#{k}"] = v.to_s }
+      end
+      
+      # Let's do it
+      response = bucket.connection.put(key, headers, value)
+      
+      # Update error state
+      self.error = response.error
+      
+      # Test for success....
+      response.status == 200      
+    end
+    
+    def delete
+      bucket.connection.delete(key).status == 204
+    end
+    
+    def value
+      fetch if !@value
+      @value
+    end
+    
+    def persisted?
+      # TODO
+    end
+    
+    def url
+      # TODO
+    end
+    
+    def key=(key)
+      @key = key.gsub(/^\//,'')
+    end
+    
+    def value=(value)
+      self.size = value.to_s.bytesize
+      @value = value
+    end
+    
+    # TODO..
+    # Add callback support so Operations can hook into that ... cleaner. ie. on_save { ... }
+    
+    private
+
+      def parse_response_header!
+        # Meta..
+        self.meta ||= {}
+        response.header.keys.sort.select {|k| k =~ /^x.amz.meta./i }.each do |amz_key|
+
+          # TODO.. value is an array.. meaning a meta attribute can have multiple values
+          meta[amz_key.gsub(/^x.amz.meta./i, '')] = [response.header[amz_key]].flatten.first
+
+          # TODO.. em-http adapters return headers that look like X_AMZ_META_ .. very annoying.
+        end
+      end
+
+  end
+end

data/lib/uber-s3/operation.rb

@@ -0,0 +1,7 @@
+class UberS3
+  module Operation
+  end
+end
+
+# Load object operation modules
+Dir[File.dirname(__FILE__) + '/operation/object/*.rb'].each {|f| require f }

data/lib/uber-s3/operation/object/access_policy.rb

@@ -0,0 +1,29 @@
+module UberS3::Operation::Object
+  module AccessPolicy
+    
+    def self.included(base)
+      base.send :extend,  ClassMethods
+      base.send :include, InstanceMethods
+      
+      base.instance_eval do
+        attr_accessor :access
+      end
+    end
+
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+      def access=(access)
+        valid_values = [:private, :public_read, :public_read_write, :authenticated_read]
+
+        if valid_values.include?(access)
+          @access = access
+        else
+          raise "Invalid access value"
+        end
+      end
+    end
+    
+  end
+end

data/lib/uber-s3/operation/object/content_disposition.rb

@@ -0,0 +1,20 @@
+module UberS3::Operation::Object
+  module ContentDisposition
+    
+    def self.included(base)
+      base.send :extend,  ClassMethods
+      base.send :include, InstanceMethods
+      
+      base.instance_eval do
+        attr_accessor :content_disposition
+      end
+    end
+
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+    end
+    
+  end
+end

data/lib/uber-s3/operation/object/content_encoding.rb

@@ -0,0 +1,64 @@
+module UberS3::Operation::Object
+  module ContentEncoding
+    
+    def self.included(base)
+      base.send :extend,  ClassMethods
+      base.send :include, InstanceMethods
+      
+      base.instance_eval do
+        attr_accessor :gzip, :content_encoding
+      end
+    end
+
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+      
+      # Default mime-types to be auto-gzipped if gzip == :web
+      WEB_GZIP_TYPES = ['text/html', 'text/plain', 'text/css', 'application/json',
+                        'application/javascript', 'application/x-javascript',
+                        'text/xml', 'application/xml', 'application/xml+rss']
+      
+      private
+      
+        def gzip_content!
+          return if gzip.nil?
+          
+          if gzip == true
+            encode = true
+          elsif gzip == :web && WEB_GZIP_TYPES.include?(content_type)
+            encode = true
+          elsif gzip.is_a?(String) && gzip == content_type
+            encode = true
+          elsif gzip.is_a?(Array) && gzip.include?(content_type)
+            encode = true
+          else
+            encode = false
+          end
+          
+          if encode
+            self.value = gzip_encoder(value)
+            self.content_encoding = 'gzip'
+          end
+        end
+      
+        def gzip_encoder(data)
+          begin
+            gz_stream = StringIO.new
+            gz = Zlib::GzipWriter.new(gz_stream)
+            gz.write(value)
+            gz.close
+
+            gz_stream.string
+          rescue => ex
+            # TODO ...
+            $stderr.puts "Gzip failed: #{ex.message}"
+            raise ex
+          end
+        end
+      
+    end
+    
+  end
+end

data/lib/uber-s3/operation/object/content_md5.rb

@@ -0,0 +1,21 @@
+module UberS3::Operation::Object
+  module ContentMd5
+    
+    def self.included(base)
+      base.send :extend,  ClassMethods
+      base.send :include, InstanceMethods
+      
+      base.instance_eval do
+        attr_accessor :content_md5
+      end
+    end
+
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+      # TODO.. move stuff from object.rb to here... need callback / chaining stuff...
+    end
+    
+  end
+end

data/lib/uber-s3/operation/object/content_type.rb

@@ -0,0 +1,31 @@
+module UberS3::Operation::Object
+  module ContentType
+    
+    def self.included(base)
+      base.send :extend,  ClassMethods
+      base.send :include, InstanceMethods
+      
+      base.instance_eval do
+        # attr_accessor :content_type
+      end
+    end
+
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+      
+      def infer_content_type!
+        mime_type = MIME::Types.type_for(key).first
+
+        self.content_type ||= mime_type.content_type if mime_type
+        self.content_type ||= 'binary/octet-stream'
+      end
+      
+      def content_type=(x);     @content_type = x;          end
+      def content_type;         @content_type;              end
+      
+    end
+    
+  end
+end

data/lib/uber-s3/operation/object/http_cache.rb

@@ -0,0 +1,67 @@
+module UberS3::Operation::Object
+  module HttpCache
+    
+    def self.included(base)
+      # TODO: .. strange behaviour.. can't override these methods in below modules.
+      # requires some metaprogramming debugging
+      # base.instance_eval do
+      #   attr_accessor :cache_control, :expires, :pragma, :ttl
+      # end
+      
+      base.send :extend,  ClassMethods
+      base.send :include, InstanceMethods   
+    end
+
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+      
+      # TODO: shouldn't need this junk... see above comment
+      def cache_control=(x);    @cache_control = x;         end
+      def cache_control;        @cache_control;             end
+      
+      def expires=(x);          @expires = x;               end
+      def expires;              @expires;                   end
+      
+      def pragma=(x);           @pragma = x;                end
+      def pragma;               @pragma;                    end
+      
+      def ttl=(x);              @ttl = x;                   end
+      def ttl;                  @ttl;                       end
+      
+      #----
+      
+      # Helper method that will set the max-age for cache-control
+      def ttl=(val)
+        (@ttl = val).tap { infer_cache_control! }
+      end
+      
+      # TODO... there are some edge cases here.. ie. someone sets their own self.content_type ...
+      def infer_cache_control!
+        return if ttl.nil? || content_type.nil?
+        
+        if ttl.is_a?(Hash)
+          mime_types = ttl.keys
+          match = mime_types.find {|pattern| !(content_type =~ /#{pattern}/i).nil? }
+          self.cache_control = "public,max-age=#{ttl[match]}" if match
+        else
+          self.cache_control = "public,max-age=#{ttl}"
+        end
+      end
+
+      
+      # Expires can take a time or string
+      def expires=(val)
+        if val.is_a?(String)
+          self.expires = val
+        elsif val.is_a?(Time)
+          # RFC 1123 format 
+          self.expires = val.strftime("%a, %d %b %Y %H:%I:%S %Z")
+        end
+      end
+      
+    end
+        
+  end
+end

data/lib/uber-s3/operation/object/meta.rb

@@ -0,0 +1,20 @@
+module UberS3::Operation::Object
+  module Meta
+    
+    def self.included(base)
+      base.send :extend,  ClassMethods
+      base.send :include, InstanceMethods
+      
+      base.instance_eval do
+        attr_accessor :meta
+      end
+    end
+
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+    end
+    
+  end
+end

data/lib/uber-s3/operation/object/storage_class.rb

@@ -0,0 +1,29 @@
+module UberS3::Operation::Object
+  module StorageClass
+    
+    def self.included(base)
+      base.send :extend,  ClassMethods
+      base.send :include, InstanceMethods
+      
+      base.instance_eval do
+        attr_accessor :storage_class
+      end
+    end
+
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+      def storage_class=(storage_class)
+        valid_values = [:standard, :reduced_redundancy]
+
+        if valid_values.include?(storage_class)
+          @storage_class = storage_class
+        else
+          raise "Invalid storage_class value"
+        end
+      end
+    end
+    
+  end
+end

data/lib/uber-s3/response.rb

@@ -0,0 +1,49 @@
+class UberS3  
+  class Response
+    
+    attr_accessor :status, :header, :body, :raw, :error_key, :error_message
+    
+    def initialize(options={})
+      if !([:status, :header, :body, :raw] - options.keys).empty?
+        raise "Expecting keys :status, :header, :body and :raw"
+      end
+      
+      self.status = options[:status]
+      self.header = options[:header]
+      self.body   = options[:body]
+      self.raw    = options[:raw]
+      
+      success?
+    end
+    
+    # TODO: can/should we normalize the keys..? downcase.. etc.?
+    # def header=(header)
+    # end
+    
+    def success?
+      return if status < 400 || body.to_s.empty?
+      
+      # Errors are XML
+      doc = Util::XmlDocument.new(body)
+      
+      self.error_key      = doc.xpath('//Error/Code').first.text
+      self.error_message  = doc.xpath('//Error/Message').first.text
+      
+      error_klass = instance_eval("Error::#{error_key}") rescue nil
+      
+      if error_klass.nil?
+        raise Error::Unknown, "HTTP Response: #{status}, Body: #{body}"
+      else
+        raise error_klass.new(error_key, error_message)
+      end
+    end
+    
+    def error
+      if !error_key.nil?
+        "#{error_key}: #{error_message}"
+      end
+    end
+    
+        
+  end
+end

data/lib/uber-s3/util/xml_document.rb

@@ -0,0 +1,48 @@
+begin
+  require 'nokogiri'
+rescue LoadError
+  require 'rexml/document'
+end
+
+module UberS3::Util
+  class XmlDocument
+    
+    def initialize(xml)
+      if defined?(Nokogiri)
+        @parser = NokogiriParser.new(xml)
+      else
+        @parser = RexmlParser.new(xml)
+      end
+    end
+    
+    def method_missing(sym, *args, &block)
+      @parser.send sym, *args, &block
+    end
+        
+    class RexmlParser
+      attr_accessor :doc
+      
+      def initialize(xml)
+        self.doc = REXML::Document.new(xml)
+      end
+      
+      def xpath(path)
+        REXML::XPath.match(doc.root, path)
+      end
+    end
+    
+    class NokogiriParser
+      attr_accessor :doc
+      
+      def initialize(xml)
+        self.doc = Nokogiri::XML(xml)
+        doc.remove_namespaces!
+      end
+      
+      def xpath(path)
+        doc.xpath(path).to_a
+      end
+    end
+    
+  end
+end

data/lib/uber-s3/version.rb

@@ -0,0 +1,3 @@
+class UberS3
+  VERSION = '0.2.4'
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: rcarvalho-uber-s3
+version: !ruby/object:Gem::Version
+  version: 0.2.4
+  prerelease: 
+platform: ruby
+authors:
+- Peter Kieltyka
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-20 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: &2156690680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2156690680
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2156690300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156690300
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2156689740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :development
+  prerelease: false
+  version_requirements: *2156689740
+description: A simple & very fast S3 client supporting sync / async HTTP adapters
+email:
+- peter@nulayer.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/uber-s3/authorization.rb
+- lib/uber-s3/bucket.rb
+- lib/uber-s3/connection/em_http.rb
+- lib/uber-s3/connection/em_http_fibered.rb
+- lib/uber-s3/connection/net_http.rb
+- lib/uber-s3/connection.rb
+- lib/uber-s3/error.rb
+- lib/uber-s3/object.rb
+- lib/uber-s3/operation/object/access_policy.rb
+- lib/uber-s3/operation/object/content_disposition.rb
+- lib/uber-s3/operation/object/content_encoding.rb
+- lib/uber-s3/operation/object/content_md5.rb
+- lib/uber-s3/operation/object/content_type.rb
+- lib/uber-s3/operation/object/http_cache.rb
+- lib/uber-s3/operation/object/meta.rb
+- lib/uber-s3/operation/object/storage_class.rb
+- lib/uber-s3/operation.rb
+- lib/uber-s3/response.rb
+- lib/uber-s3/util/xml_document.rb
+- lib/uber-s3/version.rb
+- lib/uber-s3.rb
+homepage: http://github.com/nulayer/uber-s3
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: A simple & very fast S3 client supporting sync / async HTTP adapters
+test_files: []