geemus-fog 0.0.0

data/lib/fog/aws/s3.rb

@@ -0,0 +1,143 @@
+module Fog
+  module AWS
+    class S3
+
+      def self.reload
+        current_directory = File.dirname(__FILE__)
+        load "#{current_directory}/../connection.rb"
+        load "#{current_directory}/../parser.rb"
+        load "#{current_directory}/../response.rb"
+
+        parsers_directory = "#{current_directory}/parsers/s3"
+        load "#{parsers_directory}/copy_object.rb"
+        load "#{parsers_directory}/get_bucket.rb"
+        load "#{parsers_directory}/get_bucket_location.rb"
+        load "#{parsers_directory}/get_request_payment.rb"
+        load "#{parsers_directory}/get_service.rb"
+
+        requests_directory = "#{current_directory}/requests/s3"
+        load "#{requests_directory}/copy_object.rb"
+        load "#{requests_directory}/delete_bucket.rb"
+        load "#{requests_directory}/delete_object.rb"
+        load "#{requests_directory}/get_bucket.rb"
+        load "#{requests_directory}/get_bucket_location.rb"
+        load "#{requests_directory}/get_object.rb"
+        load "#{requests_directory}/get_request_payment.rb"
+        load "#{requests_directory}/get_service.rb"
+        load "#{requests_directory}/head_object.rb"
+        load "#{requests_directory}/put_bucket.rb"
+        load "#{requests_directory}/put_object.rb"
+        load "#{requests_directory}/put_request_payment.rb"
+      end
+
+      if Fog.mocking?
+        attr_accessor :data
+      end
+
+      # 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'
+        @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}")
+
+        if Fog.mocking?
+          @data = { :buckets => {} }
+        end
+      end
+
+      private
+
+      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
+
+      def request(params)
+        params[:headers]['Date'] = Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+        string_to_sign =
+<<-DATA
+#{params[:method]}
+#{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 pair in amz_headers
+          canonical_amz_headers << "#{pair[0]}:#{pair[1]}\n"
+        end
+        string_to_sign << "#{canonical_amz_headers}"
+
+        canonical_resource  = "/"
+        subdomain = params[:host].split(".#{@host}").first
+        unless subdomain == @host
+          canonical_resource << "#{subdomain}/"
+        end
+        canonical_resource << "#{params[:path]}"
+        if params[:query] && !params[:query].empty?
+          canonical_resource << "?#{params[:query]}"
+        end
+        string_to_sign << "#{canonical_resource}"
+
+        hmac = @hmac.update(string_to_sign)
+        signature = Base64.encode64(hmac.digest).chomp!
+        params[:headers]['Authorization'] = "AWS #{@aws_access_key_id}:#{signature}"
+
+        response = @connection.request({
+          :body     => params[:body],
+          :expects  => params[:expects],
+          :headers  => params[:headers],
+          :host     => params[:host],
+          :method   => params[:method],
+          :parser   => params[:parser],
+          :path     => params[:path],
+          :query    => params[:query]
+        })
+
+        response
+      end
+
+    end
+  end
+end
+
+Fog::AWS::S3.reload

data/lib/fog/aws/simpledb.rb

@@ -0,0 +1,157 @@
+module Fog
+  module AWS
+    class SimpleDB
+
+      def self.reload
+        current_directory = File.dirname(__FILE__)
+        load "#{current_directory}/../connection.rb"
+        load "#{current_directory}/../parser.rb"
+        load "#{current_directory}/../response.rb"
+
+        parsers_directory = "#{current_directory}/parsers/simpledb"
+        load "#{parsers_directory}/basic.rb"
+        load "#{parsers_directory}/domain_metadata.rb"
+        load "#{parsers_directory}/get_attributes.rb"
+        load "#{parsers_directory}/list_domains.rb"
+        load "#{parsers_directory}/select.rb"
+
+        requests_directory = "#{current_directory}/requests/simpledb"
+        load "#{requests_directory}/batch_put_attributes.rb"
+        load "#{requests_directory}/create_domain.rb"
+        load "#{requests_directory}/delete_attributes.rb"
+        load "#{requests_directory}/delete_domain.rb"
+        load "#{requests_directory}/domain_metadata.rb"
+        load "#{requests_directory}/get_attributes.rb"
+        load "#{requests_directory}/list_domains.rb"
+        load "#{requests_directory}/put_attributes.rb"
+        load "#{requests_directory}/select.rb"
+      end
+
+      # Initialize connection to SimpleDB
+      #
+      # ==== Notes
+      # options parameter must include values for :aws_access_key_id and 
+      # :aws_secret_access_key in order to create a connection
+      #
+      # ==== Examples
+      #   sdb = SimpleDB.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
+      # * SimpleDB 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::SHA256.new(@aws_secret_access_key)
+        @host       = options[:host]      || 'sdb.amazonaws.com'
+        @nil_string = options[:nil_string]|| 'nil'
+        @port       = options[:port]      || 443
+        @scheme     = options[:scheme]    || 'https'
+        @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}")
+      end
+
+      private
+
+      def encode_attributes(attributes, replace_attributes = [])
+        encoded_attributes = {}
+        if attributes
+          index = 0
+          for key in attributes.keys
+            for value in Array(attributes[key])
+              encoded_attributes["Attribute.#{index}.Name"] = key.to_s
+              if replace_attributes.include?(key)
+                encoded_attributes["Attribute.#{index}.Replace"] = 'true'
+              end
+              encoded_attributes["Attribute.#{index}.Value"] = sdb_encode(value)
+              index += 1
+            end
+          end
+        end
+        encoded_attributes
+      end
+
+      def encode_attribute_names(attributes)
+        encoded_attribute_names = {}
+        if attributes
+          index = 0
+          for attribute in attributes
+            encoded_attribute_names["AttributeName.#{index}"] = attribute.to_s
+            index += 1
+          end
+        end
+        encoded_attribute_names
+      end
+
+      def encode_batch_attributes(items, replace_attributes = Hash.new([]))
+        encoded_attributes = {}
+        if items
+          item_index = 0
+          for item_key in items.keys
+            encoded_attributes["Item.#{item_index}.ItemName"] = item_key.to_s
+            for attribute_key in items[item_key].keys
+              attribute_index = 0
+              for value in Array(items[item_key][attribute_key])
+                encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Name"] = attribute_key.to_s
+                if replace_attributes[item_key].include?(attribute_key)
+                  encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Replace"] = 'true'
+                end
+                encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Value"] = sdb_encode(value)
+                attribute_index += 1
+              end
+              item_index += 1
+            end
+          end
+        end
+        encoded_attributes
+      end
+
+      def request(params, parser)
+        params.merge!({
+          'AWSAccessKeyId' => @aws_access_key_id,
+          'SignatureMethod' => 'HmacSHA256',
+          'SignatureVersion' => '2',
+          'Timestamp' => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
+          'Version' => '2007-11-07'
+        })
+
+        body = ''
+        for key in params.keys.sort
+          unless (value = params[key]).nil?
+            body << "#{key}=#{CGI.escape(value.to_s).gsub(/\+/, '%20')}&"
+          end
+        end
+
+        string_to_sign = "POST\n#{@host}\n/\n" << body.chop
+        hmac = @hmac.update(string_to_sign)
+        body << "Signature=#{CGI.escape(Base64.encode64(hmac.digest).chomp!).gsub(/\+/, '%20')}"
+
+        response = @connection.request({
+          :body => body,
+          :expects => 200,
+          :headers => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+          :host => @host,
+          :method => 'POST',
+          :parser => parser
+        })
+
+        response
+      end
+
+      def sdb_encode(value)
+        if value.nil?
+          @nil_string
+        else
+          value.to_s
+        end
+      end
+
+    end
+  end
+end
+
+Fog::AWS::SimpleDB.reload

data/lib/fog/aws.rb

@@ -0,0 +1,127 @@
+require 'rubygems'
+require 'base64'
+require 'cgi'
+require 'digest/md5'
+require 'hmac-sha1'
+require 'hmac-sha2'
+require 'mime/types'
+
+module Fog
+  module AWS
+
+    def self.reload
+      current_directory = File.dirname(__FILE__)
+      load "#{current_directory}/aws/ec2.rb"
+      Fog::AWS::EC2.reload
+      load "#{current_directory}/aws/simpledb.rb"
+      Fog::AWS::SimpleDB.reload
+      load "#{current_directory}/aws/s3.rb"
+      Fog::AWS::S3.reload
+    end
+
+    if Fog.mocking?
+      srand(Time.now.to_i)
+
+      class Mock
+
+        def self.etag
+          hex(32)
+        end
+
+        def self.key_fingerprint
+          fingerprint = []
+          20.times do
+            fingerprint << hex(2)
+          end
+          fingerprint.join(':')
+        end
+
+        def self.instance_id
+        end
+
+        def self.ip_address
+          ip = []
+          4.times do
+            ip << numbers(rand(3) + 1).to_i.to_s # remove leading 0
+          end
+          ip.join('.')
+        end
+
+        def self.key_material
+          key_material = ['-----BEGIN RSA PRIVATE KEY-----']
+          20.times do
+            key_material << base64(76)
+          end
+          key_material << base64(67) + '='
+          key_material << '-----END RSA PRIVATE KEY-----'
+          key_material.join("\n")
+        end
+
+        def self.owner_id
+          numbers(12)
+        end
+
+        def self.request_id
+          request_id = []
+          request_id << hex(8)
+          3.times do
+            request_id << hex(4)
+          end
+          request_id << hex(12)
+          request_id.join('-')
+        end
+
+        def self.snapshot_id
+          "snap-#{hex(8)}"
+        end
+
+        def self.volume_id
+          "vol-#{hex(8)}"
+        end
+
+        private
+
+        def self.random_selection(characters, length)
+          selection = ''
+          length.times do
+            position = rand(characters.length)
+            selection << characters[position..position]
+          end
+          selection
+        end
+
+        def self.letters(length)
+          random_selection(
+            'abcdefghijklmnopqrstuvwxyz',
+            length
+          )
+        end
+
+        def self.numbers(length)
+          random_selection(
+            '0123456789',
+            length
+          )
+        end
+
+        def self.hex(length)
+          random_selection(
+            '0123456789abcdef',
+            length
+          )
+        end
+
+        def self.base64(length)
+          random_selection(
+            "ABCDEFGHIJKLMNOP QRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+            length
+          )
+        end
+
+      end
+    end
+
+  end
+end
+
+Fog::AWS.reload

data/lib/fog/connection.rb

@@ -0,0 +1,122 @@
+require 'rubygems'
+require 'openssl'
+require 'socket'
+require 'uri'
+
+require "#{File.dirname(__FILE__)}/errors"
+require "#{File.dirname(__FILE__)}/response"
+
+unless Fog.mocking?
+
+  module Fog
+    class Connection
+
+      def initialize(url)
+        @uri = URI.parse(url)
+        @connection = TCPSocket.open(@uri.host, @uri.port)
+        if @uri.scheme == 'https'
+          @ssl_context = OpenSSL::SSL::SSLContext.new
+          @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          @connection = OpenSSL::SSL::SSLSocket.new(@connection, @ssl_context)
+          @connection.sync_close = true
+          @connection.connect
+        end
+      end
+
+      def request(params)
+        params[:path] ||= ''
+        unless params[:path][0] == '/'
+          params[:path] = '/' + params[:path].to_s
+        end
+        if params[:query] && !params[:query].empty?
+          params[:path] << "?#{params[:query]}"
+        end
+        request = "#{params[:method]} #{params[:path]} HTTP/1.1\r\n"
+        params[:headers] ||= {}
+        params[:headers]['Host'] = params[:host]
+        if params[:body]
+          params[:headers]['Content-Length'] = params[:body].length
+        end
+        for key, value in params[:headers]
+          request << "#{key}: #{value}\r\n"
+        end
+        request << "\r\n#{params[:body]}"
+        @connection.write(request)
+
+        response = Fog::Response.new
+        response.request = params
+        response.status = @connection.readline[9..11].to_i
+        while true
+          data = @connection.readline.chomp!
+          if data == ""
+            break
+          end
+          header = data.split(': ')
+          response.headers[capitalize(header[0])] = header[1]
+        end
+
+        if params[:parser]
+          body = Nokogiri::XML::SAX::PushParser.new(params[:parser])
+        else
+          body = ''
+        end
+
+        unless params[:method] == 'HEAD'
+          if response.headers['Content-Length']
+            body << @connection.read(response.headers['Content-Length'].to_i)
+          elsif response.headers['Transfer-Encoding'] == 'chunked'
+            while true
+              # 2 == "/r/n".length
+              chunk_size = @connection.readline.chomp!.to_i(16) + 2
+              chunk = @connection.read(chunk_size)
+              body << chunk[0...-2]
+              if chunk_size == 2
+                break
+              end
+            end
+          end
+        end
+
+        if params[:parser]
+          body.finish
+          response.body = params[:parser].response
+        else
+          response.body = body
+        end
+
+        if params[:expects] && params[:expects] != response.status
+          raise(Fog::Errors.status_error(params[:expects], response.status, response))
+        else
+          response
+        end
+      end
+
+      private
+
+      def capitalize(header)
+        words = header.split('-')
+        header = ''
+        for word in words
+          header << word[0..0].upcase << word[1..-1] << '-'
+        end
+        header.chop!
+      end
+
+    end
+  end
+
+else
+
+  module Fog
+    class Connection
+
+      def initialize(url)
+      end
+
+      def request(params)
+      end
+
+    end
+  end
+
+end

data/lib/fog/errors.rb

@@ -0,0 +1,131 @@
+module Fog
+  module Errors
+    class Continue < StandardError; end # 100
+    class SwitchingProtocols < StandardError; end # 101
+    class OK < StandardError; end # 200
+    class Created < StandardError; end # 201
+    class Accepted < StandardError; end # 202
+    class NonAuthoritativeInformation < StandardError; end # 203
+    class NoContent < StandardError; end # 204
+    class ResetContent < StandardError; end # 205
+    class PartialContent < StandardError; end # 206
+    class MultipleChoices < StandardError; end # 300
+    class MovedPermanently < StandardError; end # 301
+    class Found < StandardError; end # 302
+    class SeeOther < StandardError; end # 303
+    class NotModified < StandardError; end # 304
+    class UseProxy < StandardError; end # 305
+    class TemporaryRedirect < StandardError; end # 307
+    class BadRequest < StandardError; end # 400
+    class Unauthorized < StandardError; end # 401
+    class PaymentRequired < StandardError; end # 402
+    class Forbidden < StandardError; end # 403
+    class NotFound < StandardError; end # 404
+    class MethodNotAllowed < StandardError; end # 405
+    class NotAcceptable < StandardError; end #406
+    class ProxyAuthenticationRequired < StandardError; end #407
+    class RequestTimeout < StandardError; end # 408
+    class Conflict < StandardError; end # 409
+    class Gone < StandardError; end # 410
+    class LengthRequired < StandardError; end # 411
+    class PreconditionFailed < StandardError; end # 412
+    class RequestEntityTooLarge < StandardError; end # 412
+    class RequestURITooLong < StandardError; end # 414
+    class UnsupportedMediaType < StandardError; end # 415
+    class RequestedRangeNotSatisfiable < StandardError; end # 416
+    class ExpectationFailed < StandardError; end # 417
+    class InternalServerError < StandardError; end # 500
+    class NotImplemented < StandardError; end # 501
+    class BadGateway < StandardError; end # 502
+    class ServiceUnavailable < StandardError; end # 503
+    class GatewayTimeout < StandardError; end # 504
+
+    # Messages for nicer exceptions, from rfc2616
+    def self.status_error(expected, actual, response)
+      @errors ||= { 
+        100 => Fog::Errors::Continue, 
+        101 => Fog::Errors::SwitchingProtocols,
+        200 => Fog::Errors::OK,
+        201 => Fog::Errors::Created,
+        202 => Fog::Errors::Accepted,
+        203 => Fog::Errors::NonAuthoritativeInformation,
+        204 => Fog::Errors::NoContent,
+        205 => Fog::Errors::ResetContent,
+        206 => Fog::Errors::PartialContent,
+        300 => Fog::Errors::MultipleChoices,
+        301 => Fog::Errors::MovedPermanently,
+        302 => Fog::Errors::Found,
+        303 => Fog::Errors::SeeOther,
+        304 => Fog::Errors::NotModified,
+        305 => Fog::Errors::UseProxy,
+        307 => Fog::Errors::TemporaryRedirect,
+        400 => Fog::Errors::BadRequest,
+        401 => Fog::Errors::Unauthorized,
+        402 => Fog::Errors::PaymentRequired,
+        403 => Fog::Errors::Forbidden,
+        404 => Fog::Errors::NotFound,
+        405 => Fog::Errors::MethodNotAllowed,
+        406 => Fog::Errors::NotAcceptable,
+        407 => Fog::Errors::ProxyAuthenticationRequired,
+        408 => Fog::Errors::RequestTimeout,
+        409 => Fog::Errors::Conflict,
+        410 => Fog::Errors::Gone,
+        411 => Fog::Errors::LengthRequired,
+        412 => Fog::Errors::PreconditionFailed,
+        413 => Fog::Errors::RequestEntityTooLarge,
+        414 => Fog::Errors::RequestURITooLong,
+        415 => Fog::Errors::UnsupportedMediaType,
+        416 => Fog::Errors::RequestedRangeNotSatisfiable,
+        417 => Fog::Errors::ExpectationFailed,
+        500 => Fog::Errors::InternalServerError,
+        501 => Fog::Errors::NotImplemented,
+        502 => Fog::Errors::BadGateway,
+        503 => Fog::Errors::ServiceUnavailable,
+        504 => Fog::Errors::GatewayTimeout
+      }
+      @messages ||= { 
+        100 => 'Continue', 
+        101 => 'Switching Protocols',
+        200 => 'OK',
+        201 =>'Created',
+        202 => 'Accepted',
+        203 => 'Non-Authoritative Information',
+        204 => 'No Content',
+        205 => 'Reset Content',
+        206 => 'Partial Content',
+        300 => 'Multiple Choices',
+        301 => 'Moved Permanently',
+        302 => 'Found',
+        303 => 'See Other',
+        304 => 'Not Modified',
+        305 => 'Use Proxy',
+        307 => 'Temporary Redirect',
+        400 => 'Bad Request',
+        401 => 'Unauthorized',
+        402 => 'Payment Required',
+        403 => 'Forbidden',
+        404 => 'Not Found',
+        405 => 'Method Not Allowed',
+        406 => 'Not Acceptable',
+        407 => 'Proxy Authentication Required',
+        408 => 'Request Timeout',
+        409 => 'Conflict',
+        410 => 'Gone',
+        411 => 'Length Required',
+        412 => 'Precondition Failed',
+        413 => 'Request Entity Too Large',
+        414 => 'Request-URI Too Long',
+        415 => 'Unsupported Media Type',
+        416 => 'Requested Range Not Satisfiable',
+        417 => 'Expectation Failed',
+        500 => 'Internal Server Error',
+        501 => 'Not Implemented',
+        502 => 'Bad Gateway',
+        503 => 'Service Unavailable',
+        504 => 'Gateway Timeout'
+      }
+      @errors[actual].new("Expected(#{expected} #{@messages[expected]}) <=> Actual(#{actual} #{@messages[actual]}) #{response.inspect}")
+    end
+
+  end
+end