qoobaa-s3 0.0.3

data/lib/s3/roxy/proxy.rb

@@ -0,0 +1,72 @@
+# Copyright (c) 2008 Ryan Daigle
+
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+module S3
+  module Roxy
+    # The very simple proxy class that provides a basic pass-through
+    # mechanism between the proxy owner and the proxy target.
+    class Proxy
+
+      alias :proxy_instance_eval :instance_eval
+      alias :proxy_extend :extend
+
+      # Make sure the proxy is as dumb as it can be.
+      # Blatanly taken from Jim Wierich's BlankSlate post:
+      # http://onestepback.org/index.cgi/Tech/Ruby/BlankSlate.rdoc
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^proxy_|^object_id)/ }
+
+      def initialize(owner, options, args, &block)
+        @owner = owner
+        @target = options[:to]
+        @args = args
+
+        # Adorn with user-provided proxy methods
+        [options[:extend]].flatten.each { |ext| proxy_extend(ext) } if options[:extend]
+        proxy_instance_eval &block if block_given?
+      end
+
+      def proxy_owner
+        @owner
+      end
+
+      def proxy_target
+        if @target.is_a?(Proc)
+          @target.call(@owner)
+        elsif @target.is_a?(UnboundMethod)
+          bound_method = @target.bind(proxy_owner)
+          bound_method.arity == 0 ? bound_method.call : bound_method.call(*@args)
+        else
+          @target
+        end
+      end
+
+      # def inspect
+      #   "#<S3::Roxy::Proxy:0x#{object_id.to_s(16)}>"
+      # end
+
+      # Delegate all method calls we don't know about to target object
+      def method_missing(sym, *args, &block)
+        proxy_target.__send__(sym, *args, &block)
+      end
+    end
+  end
+end

data/lib/s3/service.rb

@@ -0,0 +1,106 @@
+module S3
+  class Service
+    extend Roxy::Moxie
+
+    attr_reader :access_key_id, :secret_access_key, :use_ssl
+
+    def ==(other)
+      self.access_key_id == other.access_key_id and self.secret_access_key == other.secret_access_key
+    end
+
+    def initialize(options)
+      @access_key_id = options[:access_key_id] or raise ArgumentError.new("No access key id given")
+      @secret_access_key = options[:secret_access_key] or raise ArgumentError.new("No secret access key given")
+      @use_ssl = options[:use_ssl]
+      @timeout = options[:timeout]
+      @debug = options[:debug]
+    end
+
+    def buckets(reload = false)
+      if reload or @buckets.nil?
+        response = service_request(:get)
+        @buckets = parse_buckets(response.body)
+      else
+        @buckets
+      end
+    end
+
+    def protocol
+      use_ssl ? "https://" : "http://"
+    end
+
+    def port
+      use_ssl ? 443 : 80
+    end
+
+    proxy :buckets do
+      def build(name)
+        Bucket.new(proxy_owner, name)
+      end
+
+      def find_first(name)
+        bucket = build(name)
+        bucket.retrieve
+      end
+      alias :find :find_first
+
+      def find_all
+        proxy_target
+      end
+
+      def reload
+        proxy_owner.buckets(true)
+      end
+
+      def destroy_all(force = false)
+        proxy_target.each do |bucket|
+          begin
+            bucket.destroy
+          rescue Error::BucketNotEmpty
+            if force
+              bucket.objects.destroy_all
+              retry
+            else
+              raise
+            end
+          end
+        end
+      end
+    end
+
+    def inspect
+      "#<#{self.class}:#@access_key_id>"
+    end
+
+    private
+
+    def service_request(method, options = {})
+      connection.request(method, options.merge(:path => "/#{options[:path]}"))
+    end
+
+    def connection
+      if @connection.nil?
+        @connection = Connection.new
+        @connection.access_key_id = @access_key_id
+        @connection.secret_access_key = @secret_access_key
+        @connection.use_ssl = @use_ssl
+        @connection.timeout = @timeout
+        @connection.debug = @debug
+      end
+      @connection
+    end
+
+    def parse_buckets(xml_body)
+      xml = XmlSimple.xml_in(xml_body)
+      buckets = xml["Buckets"].first["Bucket"]
+      if buckets
+        buckets_names = buckets.map { |bucket| bucket["Name"].first }
+        buckets_names.map do |bucket_name|
+          Bucket.new(self, bucket_name)
+        end
+      else
+        []
+      end
+    end
+  end
+end

data/lib/s3/signature.rb

@@ -0,0 +1,120 @@
+module S3
+  class Signature
+
+    # Required options: host, request, access_key_id, secret_access_key
+    def self.generate(options)
+      request = options[:request]
+      host = options[:host]
+      access_key_id = options[:access_key_id]
+      secret_access_key = options[:secret_access_key]
+
+      http_verb = request.method
+      content_md5 = request["content-md5"] || ""
+      content_type = request["content-type"] || ""
+      date = request["x-amz-date"].nil? ? request["date"] : ""
+      canonicalized_resource = canonicalized_resource(host, request)
+      canonicalized_amz_headers = canonicalized_amz_headers(request)
+
+      string_to_sign = ""
+      string_to_sign << http_verb
+      string_to_sign << "\n"
+      string_to_sign << content_md5
+      string_to_sign << "\n"
+      string_to_sign << content_type
+      string_to_sign << "\n"
+      string_to_sign << date
+      string_to_sign << "\n"
+      string_to_sign << canonicalized_amz_headers
+      string_to_sign << canonicalized_resource
+
+      digest = OpenSSL::Digest::Digest.new('sha1')
+      hmac = OpenSSL::HMAC.digest(digest, secret_access_key, string_to_sign)
+      base64 = Base64.encode64(hmac)
+      signature = base64.chomp
+
+      "AWS #{access_key_id}:#{signature}"
+    end
+
+    private
+
+    def self.canonicalized_amz_headers(request)
+      headers = []
+
+      # 1. Convert each HTTP header name to lower-case. For example,
+      # 'X-Amz-Date' becomes 'x-amz-date'.
+      request.each { |key, value| headers << [key.downcase, value] if key =~ /\Ax-amz-/io }
+      #=> [["c", 0], ["a", 1], ["a", 2], ["b", 3]]
+
+      # 2. Sort the collection of headers lexicographically by header
+      # name.
+      headers.sort!
+      #=> [["a", 1], ["a", 2], ["b", 3], ["c", 0]]
+
+      # 3. Combine header fields with the same name into one
+      # "header-name:comma-separated-value-list" pair as prescribed by
+      # RFC 2616, section 4.2, without any white-space between
+      # values. For example, the two metadata headers
+      # 'x-amz-meta-username: fred' and 'x-amz-meta-username: barney'
+      # would be combined into the single header 'x-amz-meta-username:
+      # fred,barney'.
+      groupped_headers = headers.group_by { |i| i.first }
+      #=> {"a"=>[["a", 1], ["a", 2]], "b"=>[["b", 3]], "c"=>[["c", 0]]}
+      combined_headers = groupped_headers.map do |key, value|
+        values = value.map { |e| e.last }
+        [key, values.join(",")]
+      end
+      #=> [["a", "1,2"], ["b", "3"], ["c", "0"]]
+
+      # 4. "Un-fold" long headers that span multiple lines (as allowed
+      # by RFC 2616, section 4.2) by replacing the folding white-space
+      # (including new-line) by a single space.
+      unfolded_headers = combined_headers.map do |header|
+        key = header.first
+        value = header.last
+        value.gsub!(/\s+/, " ")
+        [key, value]
+      end
+
+      # 5. Trim any white-space around the colon in the header. For
+      # example, the header 'x-amz-meta-username: fred,barney' would
+      # become 'x-amz-meta-username:fred,barney'
+      joined_headers = unfolded_headers.map do |header|
+        key = header.first.strip
+        value = header.last.strip
+        "#{key}:#{value}"
+      end
+
+      # 6. Finally, append a new-line (U+000A) to each canonicalized
+      # header in the resulting list. Construct the
+      # CanonicalizedResource element by concatenating all headers in
+      # this list into a single string.
+      joined_headers << "" unless joined_headers.empty?
+      joined_headers.join("\n")
+    end
+
+    def self.canonicalized_resource(host, request)
+      # 1. Start with the empty string ("").
+      string = ""
+
+      # 2. If the request specifies a bucket using the HTTP Host
+      # header (virtual hosted-style), append the bucket name preceded
+      # by a "/" (e.g., "/bucketname"). For path-style requests and
+      # requests that don't address a bucket, do nothing. For more
+      # information on virtual hosted-style requests, see Virtual
+      # Hosting of Buckets.
+      bucket_name = host.sub(/\.?s3\.amazonaws\.com\Z/, "")
+      string << "/#{bucket_name}" unless bucket_name.empty?
+
+      # 3. Append the path part of the un-decoded HTTP Request-URI,
+      # up-to but not including the query string.
+      uri = URI.parse(request.path)
+      string << uri.path
+
+      # 4. If the request addresses a sub-resource, like ?location,
+      # ?acl, or ?torrent, append the sub-resource including question
+      # mark.
+      string << "?#{$1}" if uri.query =~ /&?(acl|torrent|logging|location)(?:&|=|\Z)/
+      string
+    end
+  end
+end

data/s3.gemspec

@@ -0,0 +1,65 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{s3}
+  s.version = "0.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jakub Kuźma", "Mirosław Boruta"]
+  s.date = %q{2009-07-03}
+  s.default_executable = %q{s3cmd.rb}
+  s.email = %q{qoobaa@gmail.com}
+  s.executables = ["s3cmd.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "bin/s3cmd.rb",
+     "lib/s3.rb",
+     "lib/s3/bucket.rb",
+     "lib/s3/connection.rb",
+     "lib/s3/exceptions.rb",
+     "lib/s3/object.rb",
+     "lib/s3/roxy/moxie.rb",
+     "lib/s3/roxy/proxy.rb",
+     "lib/s3/service.rb",
+     "lib/s3/signature.rb",
+     "s3.gemspec",
+     "test/bucket_test.rb",
+     "test/connection_test.rb",
+     "test/s3_test.rb",
+     "test/service_test.rb",
+     "test/signature_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/qoobaa/s3}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Library for accessing S3 objects and buckets, with command line tool}
+  s.test_files = [
+    "test/s3_test.rb",
+     "test/bucket_test.rb",
+     "test/service_test.rb",
+     "test/signature_test.rb",
+     "test/connection_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/bucket_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class BucketTest < Test::Unit::TestCase
+# TODO fix or remove
+#  def test_parse_name_without_bucket
+#    host, prefix = S3::Bucket.parse_name("", "s3.amazonaws.com")
+#    assert_equal "s3.amazonaws.com", host
+#    assert_equal "", prefix
+#  end
+#
+#  def test_parse_name_with_vhost_name
+#    host, prefix = S3::Bucket.parse_name("data.synergypeople.net", "s3.amazonaws.com")
+#    assert_equal "data.synergypeople.net.s3.amazonaws.com", host
+#    assert_equal "", prefix
+#  end
+#
+#  def test_parse_name_with_path_based_name
+#    host, prefix = S3::Bucket.parse_name("synergypeople_net", "s3.amazonaws.com")
+#    assert_equal "s3.amazonaws.com", host
+#    assert_equal "/synergypeople_net", prefix
+#  end
+end

data/test/connection_test.rb

@@ -0,0 +1,164 @@
+require 'test_helper'
+
+class ConnectionTest < Test::Unit::TestCase
+  def setup
+    @connection = S3::Connection.new(
+      :access_key_id =>  "12345678901234567890",
+      :secret_access_key =>  "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDF"
+    )
+    @http_request = Net::HTTP.new("")
+    @response_ok = Net::HTTPOK.new("1.1", "200", "OK")
+    @response_not_found = Net::HTTPNotFound.new("1.1", "404", "Not Found")
+    stub(@connection).http { @http_request }
+    stub(@http_request).start { @response_ok }
+  end
+
+  def test_handle_response_not_modify_response_when_ok
+    assert_nothing_raised do
+      response = @connection.request(
+        :get,
+        :host => "s3.amazonaws.com",
+        :path => "/"
+      )
+      assert_equal @response_ok, response
+    end
+  end
+
+  def test_handle_response_throws_exception_when_not_ok
+    response_body = <<-EOFakeBody
+    <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+    <SomeResult xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">
+      <Code>NoSuchBucket</Code>
+      <Message>The specified bucket does not exist</Message>
+    </SomeResult>
+    EOFakeBody
+    stub(@http_request).start { @response_not_found }
+    stub(@response_not_found).body { response_body }
+
+    assert_raise S3::Error::NoSuchBucket do
+      response = @connection.request(
+        :get,
+        :host => "data.example.com.s3.amazonaws.com",
+        :path => "/"
+      )
+    end
+  end
+
+  def test_handle_response_throws_standard_exception_when_not_ok
+    stub(@http_request).start { @response_not_found }
+    stub(@response_not_found).body { nil }
+    assert_raise S3::Error::ResponseError do
+      response = @connection.request(
+        :get,
+        :host => "data.example.com.s3.amazonaws.com",
+        :path => "/"
+      )
+    end
+
+    stub(@response_not_found).body { "" }
+    assert_raise S3::Error::ResponseError do
+      response = @connection.request(
+        :get,
+        :host => "data.example.com.s3.amazonaws.com",
+        :path => "/"
+      )
+    end
+  end
+
+  def test_parse_params_empty
+    expected = ""
+    actual = S3::Connection.parse_params({})
+    assert_equal expected, actual
+  end
+
+  def test_parse_params_only_interesting_params
+    expected = ""
+    actual = S3::Connection.parse_params(:param1 => "1", :maxkeys => "2")
+    assert_equal expected, actual
+  end
+
+  def test_parse_params_remove_underscore
+    expected = "max-keys=100"
+    actual = S3::Connection.parse_params(:max_keys => 100)
+    assert_equal expected, actual
+  end
+
+  def test_parse_params_with_and_without_values
+    expected = "max-keys=100&prefix"
+    actual = S3::Connection.parse_params(:max_keys => 100, :prefix => nil)
+    assert_equal expected, actual
+  end
+
+  def test_headers_headers_empty
+    expected = {}
+    actual = S3::Connection.parse_headers({})
+    assert_equal expected, actual
+  end
+
+  def test_parse_headers_only_interesting_headers
+    expected = {}
+    actual = S3::Connection.parse_headers(
+      :accept => "text/*, text/html, text/html;level=1, */*",
+      :accept_charset => "iso-8859-2, unicode-1-1;q=0.8"
+    )
+    assert_equal expected, actual
+  end
+
+  def test_parse_headers_remove_underscore
+    expected = {
+      "content-type" => nil,
+      "x-amz-acl" => nil,
+      "if-modified-since" => nil,
+      "if-unmodified-since" => nil,
+      "if-match" => nil,
+      "if-none-match" => nil,
+      "content-disposition" => nil,
+      "content-encoding" => nil
+    }
+    actual = S3::Connection.parse_headers(
+      :content_type => nil,
+      :x_amz_acl => nil,
+      :if_modified_since => nil,
+      :if_unmodified_since => nil,
+      :if_match => nil,
+      :if_none_match => nil,
+      :content_disposition => nil,
+      :content_encoding => nil
+    )
+    assert_equal expected, actual
+  end
+
+  def test_parse_headers_with_values
+    expected = {
+      "content-type" => "text/html",
+      "x-amz-acl" => "public-read",
+      "if-modified-since" => "today",
+      "if-unmodified-since" => "tomorrow",
+      "if-match" => "1234",
+      "if-none-match" => "1243",
+      "content-disposition" => "inline",
+      "content-encoding" => "gzip"
+    }
+    actual = S3::Connection.parse_headers(
+      :content_type => "text/html",
+      :x_amz_acl => "public-read",
+      :if_modified_since => "today",
+      :if_unmodified_since => "tomorrow",
+      :if_match => "1234",
+      :if_none_match => "1243",
+      :content_disposition => "inline",
+      :content_encoding => "gzip"
+    )
+    assert_equal expected, actual
+  end
+
+  def test_parse_headers_with_range
+    expected = {
+      "range" => "bytes=0-100"
+    }
+    actual = S3::Connection.parse_headers(
+      :range => 0..100
+    )
+    assert_equal expected, actual
+  end
+end