rcarvalho-happening 0.2.5.1

data/lib/happening/s3/item.rb

@@ -0,0 +1,120 @@
+require 'uri'
+require 'cgi'
+
+module Happening
+  module S3
+    class Item
+      include Utils
+    
+      REQUIRED_FIELDS = [:server]
+      VALID_HEADERS = ['Cache-Control', 'Content-Disposition', 'Content-Encoding', 'Content-Length', 'Content-MD5', 'Content-Type', 'Expect', 'Expires']
+    
+      attr_accessor :bucket, :aws_id, :options
+
+      def initialize(bucket, aws_id, options = {})
+        @options = {
+          :timeout => 10,
+          :server => 's3.amazonaws.com',
+          :protocol => 'https',
+          :aws_access_key_id => nil,
+          :aws_secret_access_key => nil,
+          :retry_count => 4,
+          :permissions => 'private',
+          :ssl => Happening::S3.ssl_options
+        }.update(symbolize_keys(options))
+        assert_valid_keys(options, :timeout, :server, :protocol, :aws_access_key_id, :aws_secret_access_key, :retry_count, :permissions, :ssl)
+        @aws_id = aws_id.to_s
+        @bucket = bucket.to_s
+      
+        validate
+      end
+    
+      def head(request_options = {}, &blk)
+        headers = needs_to_sign? ? aws.sign("HEAD", path) : {}
+        request_options[:on_success] = blk if blk
+        request_options.update(:headers => headers)
+        Happening::S3::Request.new(:head, url, {:ssl => options[:ssl]}.update(request_options)).execute
+      end
+
+      def get(request_options = {}, &blk)
+        headers = needs_to_sign? ? aws.sign("GET", path) : {}
+        request_options[:on_success] = blk if blk
+        request_options.update(:headers => headers)
+        Happening::S3::Request.new(:get, url, {:ssl => options[:ssl]}.update(request_options)).execute
+      end
+      
+      def put(data, request_options = {}, &blk)
+        headers = construct_aws_headers('PUT', request_options.delete(:headers) || {})
+        request_options[:on_success] = blk if blk
+        request_options.update(:headers => headers, :data => data)
+        Happening::S3::Request.new(:put, url, {:ssl => options[:ssl]}.update(request_options)).execute
+      end
+      
+      def delete(request_options = {}, &blk)
+        headers = needs_to_sign? ? aws.sign("DELETE", path, {'url' => path}) : {}
+        request_options[:on_success] = blk if blk
+        request_options.update(:headers => headers)
+        Happening::S3::Request.new(:delete, url, {:ssl => options[:ssl]}.update(request_options)).execute
+      end
+    
+      def url
+        URI::Generic.new(options[:protocol], nil, server, port, nil, path(!dns_bucket?), nil, nil, nil).to_s
+      end
+      
+      def server
+        dns_bucket? ? "#{bucket}.#{options[:server]}" : options[:server]
+      end
+      
+      def path(with_bucket=true)
+        with_bucket ? "/#{bucket}/#{CGI::escape(aws_id)}" : "/#{CGI::escape(aws_id)}"
+      end
+    
+    protected
+        
+      def needs_to_sign?
+        present?(options[:aws_access_key_id])
+      end
+    
+      def dns_bucket?
+        # http://docs.amazonwebservices.com/AmazonS3/2006-03-01/index.html?BucketRestrictions.html
+        return false unless (3..63) === bucket.size
+        bucket.split('.').each do |component|
+          return false unless component[/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/]
+        end
+        true
+      end
+    
+      def port
+        (options[:protocol].to_s == 'https') ? 443 : 80
+      end
+    
+      def validate
+        raise ArgumentError, "need a bucket name" unless present?(bucket)
+        raise ArgumentError, "need a AWS Key" unless present?(aws_id)
+      
+        REQUIRED_FIELDS.each do |field|
+          raise ArgumentError, "need field #{field}" unless present?(options[field])
+        end
+      
+        raise ArgumentError, "unknown protocoll #{options[:protocol]}" unless ['http', 'https'].include?(options[:protocol])
+      end
+      
+      def aws
+        @aws ||= Happening::AWS.new(options[:aws_access_key_id], options[:aws_secret_access_key])
+      end
+      
+      def construct_aws_headers(http_method, headers = {})
+        unless headers.keys.all?{|header| VALID_HEADERS.include?(header) || header.to_s.match(/\Ax-amz-/) }
+          raise ArgumentError, "invalid headers. All headers must either one of #{VALID_HEADERS} or start with 'x-amz-'" 
+        end
+        
+        permissions = options[:permissions] != 'private' ? {'x-amz-acl' => options[:permissions] } : {}
+        headers.update(permissions)
+        headers.update({'url' => path})
+        
+        headers = needs_to_sign? ? aws.sign(http_method, path, headers) : headers
+      end
+    
+    end
+  end
+end

data/lib/happening/s3/request.rb

@@ -0,0 +1,111 @@
+module Happening
+  module S3
+    class Request
+      include Utils
+      
+      VALID_HTTP_METHODS = [:head, :get, :put, :delete]
+      
+      attr_accessor :http_method, :url, :options, :response
+      
+      def initialize(http_method, url, options = {})
+        @options = {
+          :timeout => 10,
+          :retry_count => 4,
+          :headers => {},
+          :on_error => nil,
+          :on_success => nil,
+          :data => nil,
+          :ssl => {
+            :cert_chain_file => nil,
+            :verify_peer => false
+          }
+        }.update(options)
+        assert_valid_keys(options, :timeout, :on_success, :on_error, :retry_count, :headers, :data, :ssl)
+        @http_method = http_method
+        @url = url
+        
+        validate
+      end
+      
+      def execute
+        Happening::Log.debug "Request: #{http_method.to_s.upcase} #{url}"
+        @response = http_class.new(url).send(http_method, :timeout => options[:timeout], :head => options[:headers], :body => options[:data], :ssl => options[:ssl])
+
+        @response.errback { error_callback }
+        @response.callback { success_callback }
+        @response
+      end
+      
+      def http_class
+        EventMachine::HttpRequest
+      end
+      
+    protected
+    
+      def validate
+        raise ArgumentError, "#{http_method} is not a valid HTTP method that #{self.class.name} understands." unless VALID_HTTP_METHODS.include?(http_method)
+      end
+      
+      def error_callback
+        Happening::Log.error "Response error: #{http_method.to_s.upcase} #{url}: #{response.response_header.status rescue ''}"
+        if should_retry?
+          Happening::Log.info "#{http_method.to_s.upcase} #{url}: retrying after error: status #{response.response_header.status rescue ''}"
+          handle_retry
+        elsif options[:on_error].respond_to?(:call)
+          call_user_error_handler
+        else
+          raise Happening::Error.new("#{http_method.to_s.upcase} #{url}: Failed reponse! Status code was #{response.response_header.status rescue ''}")
+        end
+      end
+      
+      def success_callback
+        Happening::Log.debug "Response success: #{http_method.to_s.upcase} #{url}: #{response.response_header.status rescue ''}"
+        case response.response_header.status
+        when 0, 400, 401, 404, 403, 409, 411, 412, 416, 500, 503
+          if should_retry?
+            Happening::Log.info "#{http_method.to_s.upcase} #{url}: retrying after: status #{response.response_header.status rescue ''}"
+            handle_retry
+          else
+            Happening::Log.error "#{http_method.to_s.upcase} #{url}: Re-tried too often - giving up"
+            error_callback
+          end
+        when 300, 301, 303, 304, 307
+          Happening::Log.info "#{http_method.to_s.upcase} #{url}: being redirected_to: #{response.response_header['LOCATION'] rescue ''}"
+          handle_redirect
+        else
+          call_user_success_handler
+        end
+      end
+      
+      def call_user_success_handler
+        options[:on_success].call(response) if options[:on_success].respond_to?(:call)
+      end
+      
+      def call_user_error_handler
+        options[:on_error].call(response) if options[:on_error].respond_to?(:call)
+      end
+      
+      def should_retry?
+        options[:retry_count] > 0
+      end
+      
+      def handle_retry
+        if should_retry?
+          new_request = self.class.new(http_method, url, options.update(:retry_count => options[:retry_count] - 1 ))
+          new_request.execute
+        else
+          Happening::Log.error "#{http_method.to_s.upcase} #{url}: Re-tried too often - giving up"
+        end
+      end
+      
+      def handle_redirect
+        new_location = response.response_header['LOCATION'] rescue ''
+        raise "Could not find the location to redirect to, empty location header?" if blank?(new_location)
+
+        new_request = self.class.new(http_method, new_location, options)
+        new_request.execute
+      end
+    
+    end
+  end
+end

data/lib/happening/s3.rb

@@ -0,0 +1,16 @@
+module Happening
+  module S3
+
+    def self.ssl_options
+      @_ssl_options ||= {
+        :cert_chain_file => nil,
+        :verify_peer => false
+      }
+    end
+  
+    def self.ssl_options=(val)
+      @_ssl_options = val
+    end
+
+  end
+end

data/lib/happening/utils.rb

@@ -0,0 +1,26 @@
+module Happening
+  module Utils
+    protected
+
+    def symbolize_keys(hash)
+      hash.inject({}) do |h, kv|
+        h[kv[0].to_sym] = kv[1]
+        h
+      end
+    end
+
+    def assert_valid_keys(hash, *valid_keys)
+      unknown_keys = hash.keys - [valid_keys].flatten
+      raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+    end
+
+    def present?(obj)
+      !blank?(obj)
+    end
+
+    def blank?(obj)
+      obj.respond_to?(:empty?) ? obj.empty? : !obj
+    end
+
+  end
+end

data/lib/happening.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'em-http'
+require 'openssl'
+require 'logger'
+
+unless defined?(Happening)
+  $:<<(File.expand_path(File.dirname(__FILE__) + "/lib"))
+  require File.expand_path(File.dirname(__FILE__) + '/happening/utils')
+  require File.expand_path(File.dirname(__FILE__) + '/happening/log')
+  require File.expand_path(File.dirname(__FILE__) + '/happening/aws')
+  require File.expand_path(File.dirname(__FILE__) + '/happening/s3')
+  require File.expand_path(File.dirname(__FILE__) + '/happening/s3/request')
+  require File.expand_path(File.dirname(__FILE__) + '/happening/s3/item')
+  require File.expand_path(File.dirname(__FILE__) + '/happening/s3/bucket')
+
+  module Happening
+    MAJOR = 0
+    MINOR = 2
+    PATCH = 5
+
+    VERSION = [MAJOR, MINOR, PATCH].compact.join('.')
+    class Error < RuntimeError; end
+  end
+end

data/test/aws_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class ItemTest < Test::Unit::TestCase
+  context "An Happening::AWS instance" do
+    
+    setup do
+      @aws = Happening::AWS.new('the-aws-access-key', 'the-aws-secret-key')
+    end
+    
+    context "when constructing" do
+      should "require Access Key and Secret Key" do
+        assert_raise(ArgumentError) do
+          Happening::AWS.new(nil, nil)
+        end
+        
+        assert_raise(ArgumentError) do
+          Happening::AWS.new('', '')
+        end
+        
+        assert_nothing_raised do
+          Happening::AWS.new('abc', 'abc')
+        end
+      end
+    end
+    
+    context "when signing parameters" do
+      should "return a header hash" do
+        assert_not_nil @aws.sign("GET", '/')['Authorization']
+      end
+      
+      should "include the current date" do
+        assert_not_nil @aws.sign("GET", '/')['date']
+      end
+      
+      should "keep given headers" do
+        assert_equal 'bar', @aws.sign("GET", '/', {'foo' => 'bar'})['foo']
+      end
+    end
+    
+  end
+end