raws 0.0.8 → 0.0.9

data/README.rdoc

@@ -45,13 +45,11 @@ RAWS is a Ruby library for Amazon Web Service (AWS).
   p RAWS::SDB['test_domain'].get('2')
   p RAWS::SDB['test_domain'].get('3')
   
-  RAWS::SDB['test_domain'].all.each do |a|
-    key, data = a
+  RAWS::SDB['test_domain'].all.each do |key, data|
     p [key, data]
   end
 
-  RAWS::SDB['test_domain'].all.filter('a = ?', 10).each do |a|
-    key, data = a
+  RAWS::SDB['test_domain'].all.filter('a = ?', 10).each do |key, data|
     p [key, data]
   end
   
@@ -106,3 +104,13 @@ RAWS is a Ruby library for Amazon Web Service (AWS).
   Foo.delete_domain
 
 == S3 (Amazon Simple Storage Service)
+
+  require 'rubygems'
+  require 'raws'
+  
+  RAWS.aws_access_key_id = _AWS_ACCESS_KEY_ID_
+  RAWS.aws_secret_access_key = _AWS_SECRET_ACCESS_KEY_
+
+  RAWS::S3.create_bucket('test_bucket')
+  
+  RAWS::S3['test_bucket'].delete_bucket

data/Rakefile

@@ -18,10 +18,12 @@ begin
     ) + Dir.glob("{bin,doc,lib}/**/*")
     s.require_path = "lib"
     s.has_rdoc = true
-    s.add_dependency('pauldix-typhoeus', '>=0.1.2')
+    s.add_dependency('typhoeus', '>=0.1.9')
+    s.add_dependency('ht2p',     '>=0.0.5')
     s.add_dependency('nokogiri', '>=1.3.3')
     s.add_dependency('uuidtools', '>=2.0.0')
   end
+  Jeweler::GemcutterTasks.new
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
 end

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.9

data/lib/raws/http/ht2p.rb

@@ -0,0 +1,83 @@
+require 'ht2p'
+
+module RAWS::HTTP::HT2P
+  def self.connect(uri, &block)
+    response = nil
+    begin
+      HT2P::Client.new uri do |request|
+        response = block.call(Request.new(request))
+      end
+    rescue RAWS::HTTP::Redirect => e
+      r = e.response
+      uri = r.header['location'] || r.doc['Error']['Endpoint']
+      retry
+    end
+    response
+  end
+
+  class Request < RAWS::HTTP::Request
+    def initialize(request)
+      @request, @before_send = request, nil
+    end
+
+    def method
+      @request.method
+    end
+
+    def method=(val)
+      @request.method = val
+    end
+
+    def header
+      @request.header
+    end
+
+    def before_send(&block)
+      @before_send = block
+    end
+
+    def send(body=nil, &block)
+      RAWS.logger.debug self
+      @before_send && @before_send.call(self)
+      response = Response.new(@request.send(body, &block))
+      case response.code
+      when 200...300
+        response
+      when 300...400
+        response.parse
+        raise RAWS::HTTP::Redirect.new(response)
+      else
+        response.parse
+        raise RAWS::HTTP::Error.new(response)
+      end
+    end
+  end
+
+  class Response < RAWS::HTTP::Response
+    attr_reader :body, :doc
+
+    def initialize(response)
+      @response, @body, @doc = response, nil, nil
+    end
+
+    def code
+      @response.code
+    end
+
+    def header
+      @response.header
+    end
+
+    def receive(&block)
+      if block_given?
+        @response.receive(&block)
+      else
+        @body = @response.receive
+      end
+    end
+
+    def parse(params={})
+      @doc = RAWS.xml.parse(receive, params)
+    end
+  end
+end

data/lib/raws/http/typhoeus.rb

@@ -0,0 +1,92 @@
+require 'typhoeus'
+require 'stringio'
+
+class RAWS::HTTP::Typhoeus
+  def self.connect(uri, &block)
+    response = nil
+    begin
+      response = block.call(Request.new(uri))
+    rescue RAWS::HTTP::Redirect => e
+      r = e.response
+      uri = r.header['location'] || r.doc['Error']['Endpoint']
+      retry
+    end
+    response
+  end
+
+  class Request < RAWS::HTTP::Request
+    attr_reader :header
+    attr_accessor :uri, :method
+
+    def initialize(uri)
+      @uri, @header, @method, @before_send = uri, {}, :get , nil
+    end
+
+    def before_send(&block)
+      @before_send = block
+    end
+
+    def send(body=nil, &block)
+      RAWS.logger.debug self
+      @before_send && @before_send.call(self)
+      response = Response.new(
+        ::Typhoeus::Request.__send__(
+          @method.downcase.to_sym,
+          @uri,
+          :headers => @header,
+          :body => if block_given?
+            # TODO エラーにした方が。。。　
+            io = StringIO.new
+            block.call(io)
+            if io.size > 0
+              io.rewind
+              io.read
+            end
+          else
+            body
+          end
+        )
+      )
+      case response.code
+      when 200...300
+        response
+      when 300...400
+        response.parse
+        raise RAWS::HTTP::Redirect.new(response)
+      else
+        response.parse
+        raise RAWS::HTTP::Error.new(response)
+      end
+    end
+  end
+
+  class Response < RAWS::HTTP::Response
+    attr_reader :body, :doc
+
+    def initialize(response)
+      @response, @body, @doc = response, nil, nil
+      @header = @response.headers.split("\r\n").inject({}) do |ret, val|
+        if md = /(.+?):\s*(.*)/.match(val)
+          ret[md[1].downcase] = md[2]
+        end
+        ret
+      end
+    end
+
+    def code
+      @response.code
+    end
+
+    def receive(&block)
+      if block_given?
+        block.call(StringIO.new(@response.body)) # TODO エラーにした方が。。。
+      else
+        @body = @response.body
+      end
+    end
+
+    def parse(params={})
+      @doc = RAWS.xml.parse(receive, params)
+    end
+  end
+end

data/lib/raws/http.rb

@@ -0,0 +1,25 @@
+module RAWS
+  module HTTP
+    class Redirect < Exception
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+    end
+
+    class Error < StandardError
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+    end
+
+    class Request; end
+    class Response; end
+
+    autoload :Typhoeus, 'raws/http/typhoeus'
+    autoload :HT2P, 'raws/http/ht2p'
+  end
+end

data/lib/raws/s3/adapter.rb

@@ -1,5 +1,3 @@
-require 'digest/md5'
-
 class RAWS::S3::Adapter
   module Adapter20060301
     URI_PARAMS = {
@@ -9,113 +7,227 @@ class RAWS::S3::Adapter
       :query  => {}
     }
 
-    def build_uri(params={})
-      "#{params[:scheme]}://#{
-        if params[:bucket]
-          "#{params[:bucket]}.#{params[:host]}"
+    def parse_params(params)
+      params = URI_PARAMS.merge(params)
+
+      path = if bucket = params[:bucket]
+        if bucket.include?('.')
+          params.delete :bucket
+          params[:path] = "/#{bucket}#{params[:path]}"
         else
-          params[:host]
+          "/#{bucket}#{params[:path]}"
         end
-      }#{params[:path]}#{
-        if params[:query].empty?
-          ''
-        else
-          '?' << a[:query].map do |key, val|
-            val ? "#{RAWS.escape(key)}=#{RAWS.escape(val)}" : RAWS.escape(key)
-          end.sort.join(';')
+      else
+        params[:path]
+      end
+
+      unless params[:query].empty?
+        params[:path] += '?' << params[:query].map do |key, val|
+          val ? "#{RAWS.escape(key)}=#{RAWS.escape(val)}" : RAWS.escape(key)
+        end.sort.join(';')
+
+        params[:query].each do |key, val|
+          unless val
+            path << "?#{key}"
+            break
+          end
         end
-      }"
+      end
+
+      [
+        "#{params[:scheme]}://#{
+          if params[:bucket]
+            "#{params[:bucket]}.#{params[:host]}"
+          else
+            params[:host]
+          end
+        }#{params[:path]}",
+        path
+      ]
     end
+    private :parse_params
 
-    def sign(http_verb, content, type, date, path)
-      "#{RAWS.aws_access_key_id}:#{
+    def sign(request, path)
+      request.header['authorization'] = "AWS #{RAWS.aws_access_key_id}:#{
         [
           ::OpenSSL::HMAC.digest(
             ::OpenSSL::Digest::SHA1.new,
             RAWS.aws_secret_access_key,
-            [
-              http_verb,
-              content ? Digest::MD5.hexdigest(content) : '',
-              type,
-              date,
-              path
-            ].join("\n")
+            (
+              [
+                request.method,
+                request.header['content-md5'],
+                request.header['content-type'],
+                request.header['x-amz-date'] ? '' : request.header['date'],
+              ] + request.header.select do |key, val|
+                /^x-amz-/.match(key)
+              end.sort.map do |key, val|
+                "#{key}:#{val}"
+              end + [
+                path
+              ]
+            ).join("\n")
           )
         ].pack('m').strip
       }"
     end
+    private :sign
 
-    def fetch(http_verb, _uri={}, options={}, content=nil, type='')
-      date = Time.now.httpdate
-      uri = URI_PARAMS.merge(_uri)
-      r = RAWS.__send__(
-        http_verb.downcase.to_sym,
-        build_uri(uri),
-        :headers => {
-          'Date' => date,
-          'Authorization' => "AWS #{
-            sign(http_verb, content, type, date, uri[:path])
-          }"
-        }
-      )
-      data = RAWS.parse(Nokogiri::XML.parse(r.body), options)
-      if 200 <= r.code && r.code <= 299
-        data
-      else
-        raise RAWS::Error.new(r, data)
+    def connect(method, params={}, &block)
+      uri, path = parse_params params
+      RAWS::S3.http.connect(uri) do |request|
+        request.method = method
+        request.header['date'] = Time.now.httpdate
+        request.before_send do |_request|
+          sign _request, path
+        end
+        block.call request
       end
     end
 
     def get_service
-      fetch('GET', {}, :multiple => 'Bucket')
+      connect 'GET' do |request|
+        response = request.send
+        response.parse :multiple => ['Bucket']
+        response
+      end
     end
 
-    def put_bucket(bucket_name)
-      fetch('PUT', :path => "/#{bucket_name}")
+    def put_bucket(bucket_name, location=nil, header={})
+      connect 'PUT', :bucket => bucket_name do |request|
+        request.header.merge! header
+        response = request.send(
+          if location
+            "<CreateBucketConfiguration>"
+              "<LocationConstraint>#{
+                location
+              }</LocationConstraint>"
+            "</CreateBucketConfiguration>"
+          end
+        )
+        response.receive
+        response
+      end
     end
 
-    def put_request_payment(bucket_name)
-      fetch(
-        'PUT',
-        {
-          :bucket => bucket_name,
-          :query  => {'requestPayment' => nil}
-        }
-      )
+    def put_request_payment(bucket_name, requester)
+      connect(
+        'PUT', 
+        :bucket => bucket_name,
+        :query  => {'requestPayment' => nil}
+      ) do |request|
+        response = request.send\
+          '<RequestPaymentConfiguration'
+            ' xmlns="http://s3.amazonaws.com/doc/2006-03-01/">'
+            "<Payer>#{requester}</Payer>"
+          '</RequestPaymentConfiguration>'
+        response.receive
+        response
+      end
     end
 
     def get_bucket(bucket_name, params={})
-      fetch(
-        'GET',
-        {
-          :bucket => bucket_name,
-          :query  => params
-        }
-      )
+      connect(
+        'GET', 
+        :bucket => bucket_name,
+        :query  => params
+      ) do |request|
+        response = request.send
+        response.parse :multiple => ['Contents']
+        response
+      end
     end
 
     def get_request_payment(bucket_name)
-      fetch(
-        'GET',
-        {
-          :bucket => bucket_name,
-          :query  => {'requestPayment' => nil}
-        }
-      )
+      connect(
+        'GET', 
+        :bucket => bucket_name,
+        :query  => {'requestPayment' => nil}
+      ) do |request|
+        response = request.send
+        response.parse
+        response
+      end
     end
 
     def get_bucket_location(bucket_name)
-      fetch(
-        'GET',
-        {
-          :bucket => bucket_name,
-          :query  => {'location' => nil}
-        }
-      )
+      connect(
+        'GET', 
+        :bucket => bucket_name,
+        :query  => {'location' => nil}
+      ) do |request|
+        response = request.send
+        response.parse
+        response
+      end
     end
 
     def delete_bucket(bucket_name)
-      fetch('DELETE', :path => "/#{bucket_name}")
+      connect 'DELETE', :bucket => bucket_name do |request|
+        request.send
+      end
+    end
+
+    def put_object(bucket_name, name, header, &block)
+      connect(
+        'PUT',
+        :bucket => bucket_name,
+        :path   => '/' << name
+      ) do |request|
+        request.header.merge!(header)
+        response = request.send(&block)
+        response.receive
+        response
+      end
+    end
+
+    def copy_object(src_bucket, src_name, dest_bucket, dest_name, header={})
+      connect(
+        'PUT',
+        :bucket => dest_bucket,
+        :path   => '/' << dest_name
+      ) do |request|
+        request.header.merge! header
+        request.header['x-amz-copy-source'] = "/#{src_bucket}/#{src_name}"
+        request.send
+      end
+    end
+
+    def get_object(bucket_name, name=nil, header={}, &block)
+      connect(
+        'GET',
+        :bucket => bucket_name,
+        :path   => "/#{name}"
+      ) do |request|
+        request.header.merge! header
+        response = request.send
+        response.receive(&block)
+        response
+      end
+    end
+
+    def head_object(bucket_name, name)
+      connect(
+        'HEAD',
+        :bucket => bucket_name,
+        :path   => '/' << name
+      ) do |request|
+        response = request.send
+        response.receive
+        response
+      end
+    end
+
+    def delete_object(bucket_name, name)
+      connect(
+        'DELETE',
+        :bucket => bucket_name,
+        :path   => '/' << name
+      ) do |request|
+        response = request.send
+        response.receive
+        response
+      end
     end
   end
 

data/lib/raws/s3/model.rb

@@ -0,0 +1,71 @@
+module RAWS::S3::Model
+  module ClassMethods
+    attr_accessor :bucket_name
+
+    def create_bucket
+      RAWS::S3.create_bucket(self.bucket_name)
+    end
+
+    def delete_bucket(force=nil)
+      RAWS::S3.delete_bucket(self.bucket_name, force)
+    end
+  end
+
+  module InstanceMethods
+    def after_initialize; end
+    def before_delete; end
+    def after_delete; end
+    def before_save; end
+    def after_save; end
+    def before_update; end
+    def after_update; end
+    def before_insert; end
+    def after_insert; end
+  end
+
+  def self.included(mod)
+    mod.class_eval do
+      include InstanceMethods
+      extend ClassMethods
+    end
+  end
+
+  class Metadata < Hash
+    X_AMZ_META = 'x-amz-meta-'
+
+    def initialize(object)
+      super()
+      @object = object
+      decode(@object.header)
+    end
+
+    def decode(header)
+      header.select do |key, val|
+        key.match(/^#{X_AMZ_META}/)
+      end.each do |key, val|
+        self[key.sub(X_AMZ_META, '')] = begin
+          a = val.split(',').map do |val|
+            RAWS.unescape(val)
+          end
+          1 < a.size ? a : a.first
+        end
+      end
+    end
+
+    def encode
+      self.inject({}) do |ret, (key, val)|
+        key = X_AMZ_META + key
+
+        if val.is_a? Array
+          ret[key] = val.map do |v|
+            RAWS.escape(v.strip)
+          end.join(',')
+        else
+          ret[key] = RAWS.escape(val.strip)
+        end
+
+        ret
+      end
+    end
+  end
+end

data/lib/raws/s3/s3object.rb

@@ -0,0 +1,3 @@
+class RAWS::S3::S3Object
+  include ::RAWS::S3::Model
+end