steamcannon-s3 0.3.2

data/lib/s3/bucket.rb

@@ -0,0 +1,153 @@
+module S3
+  class Bucket
+    include Parser
+    include Proxies
+    extend Forwardable
+
+    attr_reader :name, :service
+
+    def_instance_delegators :service, :service_request
+    private_class_method :new
+
+    # Retrieves the bucket information from the server. Raises an
+    # S3::Error exception if the bucket doesn't exist or you don't
+    # have access to it, etc.
+    def retrieve
+      bucket_headers
+      self
+    end
+
+    # Returns location of the bucket, e.g. "EU"
+    def location(reload = false)
+      if reload or @location.nil?
+        @location = location_constraint
+      else
+        @location
+      end
+    end
+
+    # Compares the bucket with other bucket. Returns true if the names
+    # of the buckets are the same, and both have the same services
+    # (see Service equality)
+    def ==(other)
+      self.name == other.name and self.service == other.service
+    end
+
+    # Similar to retrieve, but catches S3::Error::NoSuchBucket
+    # exceptions and returns false instead.
+    def exists?
+      retrieve
+      true
+    rescue Error::NoSuchBucket
+      false
+    end
+
+    # Destroys given bucket. Raises an S3::Error::BucketNotEmpty
+    # exception if the bucket is not empty. You can destroy non-empty
+    # bucket passing true (to force destroy)
+    def destroy(force = false)
+      delete_bucket
+      true
+    rescue Error::BucketNotEmpty
+      if force
+        objects.destroy_all
+        retry
+      else
+        raise
+      end
+    end
+
+    # Saves the newly built bucket. Optionally you can pass location
+    # of the bucket (<tt>:eu</tt> or <tt>:us</tt>)
+    def save(location = nil)
+      create_bucket_configuration(location)
+      true
+    end
+
+    # Returns true if the name of the bucket can be used like +VHOST+
+    # name. If the bucket contains characters like underscore it can't
+    # be used as +VHOST+ (e.g. <tt>bucket_name.s3.amazonaws.com</tt>)
+    def vhost?
+      "#@name.#{HOST}" =~ /\A#{URI::REGEXP::PATTERN::HOSTNAME}\Z/
+    end
+
+    # Returns host name of the bucket according (see #vhost? method)
+    def host
+      vhost? ? "#@name.#{HOST}" : "#{HOST}"
+    end
+
+    # Returns path prefix for non +VHOST+ bucket. Path prefix is used
+    # instead of +VHOST+ name, e.g. "bucket_name/"
+    def path_prefix
+      vhost? ? "" : "#@name/"
+    end
+
+    # Returns the objects in the bucket and caches the result (see
+    # #reload method).
+    def objects
+      MethodProxy.new(self, :list_bucket, :extend => ObjectsExtension)
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class}:#{name}>"
+    end
+
+    private
+
+    attr_writer :service
+
+    def location_constraint
+      response = bucket_request(:get, :params => { :location => nil })
+      parse_location_constraint(response.body)
+    end
+
+    def list_bucket(options = {})
+      response = bucket_request(:get, :params => options)
+      objects_attributes = parse_list_bucket_result(response.body)
+      objects_attributes.map { |object_attributes| Object.send(:new, self, object_attributes) }
+    end
+
+    def bucket_headers(options = {})
+      response = bucket_request(:head, :params => options)
+    rescue Error::ResponseError => e
+      if e.response.code.to_i == 404
+        raise Error::ResponseError.exception("NoSuchBucket").new("The specified bucket does not exist.", nil)
+      else
+        raise e
+      end
+    end
+
+    def create_bucket_configuration(location = nil)
+      location = location.to_s.upcase if location
+      options = { :headers => {} }
+      if location and location != "US"
+        options[:body] = "<CreateBucketConfiguration><LocationConstraint>#{location}</LocationConstraint></CreateBucketConfiguration>"
+        options[:headers][:content_type] = "application/xml"
+      end
+      bucket_request(:put, options)
+    end
+
+    def delete_bucket
+      bucket_request(:delete)
+    end
+
+    def initialize(service, name) #:nodoc:
+      self.service = service
+      self.name = name
+    end
+
+    def name=(name)
+      raise ArgumentError.new("Invalid bucket name: #{name}") unless name_valid?(name)
+      @name = name
+    end
+
+    def bucket_request(method, options = {})
+      path = "#{path_prefix}#{options[:path]}"
+      service_request(method, options.merge(:host => host, :path => path))
+    end
+
+    def name_valid?(name)
+      name =~ /\A[a-z0-9][a-z0-9\._-]{2,254}\Z/i and name !~ /\A#{URI::REGEXP::PATTERN::IPV4ADDR}\Z/
+    end
+  end
+end

data/lib/s3/buckets_extension.rb

@@ -0,0 +1,27 @@
+module S3
+  module BucketsExtension
+    # Builds new bucket with given name
+    def build(name)
+      Bucket.send(:new, proxy_owner, name)
+    end
+
+    # Finds the bucket with given name
+    def find_first(name)
+      bucket = build(name)
+      bucket.retrieve
+    end
+    alias :find :find_first
+
+    # Find all buckets in the service
+    def find_all
+      proxy_target
+    end
+
+    # Destroy all buckets in the service. Doesn't destroy non-empty
+    # buckets by default, pass true to force destroy (USE WITH
+    # CARE!).
+    def destroy_all(force = false)
+      proxy_target.each { |bucket| bucket.destroy(force) }
+    end
+  end
+end

data/lib/s3/connection.rb

@@ -0,0 +1,224 @@
+module S3
+
+  # Class responsible for handling connections to amazon hosts
+  class Connection
+    include Parser
+
+    attr_accessor :access_key_id, :secret_access_key, :use_ssl, :timeout, :debug, :proxy
+    alias :use_ssl? :use_ssl
+
+    # Creates new connection object.
+    #
+    # ==== Options
+    # * <tt>:access_key_id</tt> - Access key id (REQUIRED)
+    # * <tt>:secret_access_key</tt> - Secret access key (REQUIRED)
+    # * <tt>:use_ssl</tt> - Use https or http protocol (false by
+    #   default)
+    # * <tt>:debug</tt> - Display debug information on the STDOUT
+    #   (false by default)
+    # * <tt>:timeout</tt> - Timeout to use by the Net::HTTP object
+    #   (60 by default)
+    # * <tt>:proxy</tt> - Hash for Net::HTTP Proxy settings
+    # { :host => "proxy.mydomain.com", :port => "80, :user => "user_a", :password => "secret" }
+    def initialize(options = {})
+      @access_key_id = options.fetch(:access_key_id)
+      @secret_access_key = options.fetch(:secret_access_key)
+      @use_ssl = options.fetch(:use_ssl, false)
+      @debug = options.fetch(:debug, false)
+      @timeout = options.fetch(:timeout, 60)
+      @proxy = options.fetch(:proxy, nil)
+    end
+
+    # Makes request with given HTTP method, sets missing parameters,
+    # adds signature to request header and returns response object
+    # (Net::HTTPResponse)
+    #
+    # ==== Parameters
+    # * <tt>method</tt> - HTTP Method symbol, can be <tt>:get</tt>,
+    #   <tt>:put</tt>, <tt>:delete</tt>
+    #
+    # ==== Options:
+    # * <tt>:host</tt> - Hostname to connecto to, defaults
+    #   to <tt>s3.amazonaws.com</tt>
+    # * <tt>:path</tt> - path to send request to (REQUIRED)
+    # * <tt>:body</tt> - Request body, only meaningful for
+    #   <tt>:put</tt> request
+    # * <tt>:params</tt> - Parameters to add to query string for
+    #   request, can be String or Hash
+    # * <tt>:headers</tt> - Hash of headers fields to add to request
+    #   header
+    #
+    # ==== Returns
+    # Net::HTTPResponse object -- response from the server
+    def request(method, options)
+      host = options.fetch(:host, HOST)
+      path = options.fetch(:path)
+      body = options.fetch(:body, "")
+      params = options.fetch(:params, {})
+      headers = options.fetch(:headers, {})
+
+      if params
+        params = params.is_a?(String) ? params : self.class.parse_params(params)
+        path << "?#{params}"
+      end
+
+      path = URI.escape(path)
+      request = request_class(method).new(path)
+
+      headers = self.class.parse_headers(headers)
+      headers.each do |key, value|
+        request[key] = value
+      end
+
+      request.body = body
+
+      send_request(host, request)
+    end
+
+    # Helper function to parser parameters and create single string of
+    # params added to questy string
+    #
+    # ==== Parameters
+    # * <tt>params</tt> - Hash of parameters
+    #
+    # ==== Returns
+    # String -- containing all parameters joined in one params string,
+    # i.e. <tt>param1=val&param2&param3=0</tt>
+    def self.parse_params(params)
+      interesting_keys = [:max_keys, :prefix, :marker, :delimiter, :location]
+
+      result = []
+      params.each do |key, value|
+        if interesting_keys.include?(key)
+          parsed_key = key.to_s.gsub("_", "-")
+          case value
+          when nil
+            result << parsed_key
+          else
+            result << "#{parsed_key}=#{value}"
+          end
+        end
+      end
+      result.join("&")
+    end
+
+    # Helper function to change headers from symbols, to in correct
+    # form (i.e. with '-' instead of '_')
+    #
+    # ==== Parameters
+    # * <tt>headers</tt> - Hash of pairs <tt>headername => value</tt>,
+    #   where value can be Range (for Range header) or any other value
+    #   which can be translated to string
+    #
+    # ==== Returns
+    # Hash of headers translated from symbol to string, containing
+    # only interesting headers
+    def self.parse_headers(headers)
+      interesting_keys = [:content_type, :x_amz_acl, :x_amz_storage_class, :range,
+                          :if_modified_since, :if_unmodified_since,
+                          :if_match, :if_none_match,
+                          :content_disposition, :content_encoding,
+                          :x_amz_copy_source, :x_amz_metadata_directive,
+                          :x_amz_copy_source_if_match,
+                          :x_amz_copy_source_if_none_match,
+                          :x_amz_copy_source_if_unmodified_since,
+                          :x_amz_copy_source_if_modified_since]
+
+      parsed_headers = {}
+      if headers
+        headers.each do |key, value|
+          if interesting_keys.include?(key)
+            parsed_key = key.to_s.gsub("_", "-")
+            parsed_value = value
+            case value
+            when Range
+              parsed_value = "bytes=#{value.first}-#{value.last}"
+            end
+            parsed_headers[parsed_key] = parsed_value
+          end
+        end
+      end
+      parsed_headers
+    end
+
+    private
+
+    def request_class(method)
+      case method
+      when :get
+        request_class = Net::HTTP::Get
+      when :head
+        request_class = Net::HTTP::Head
+      when :put
+        request_class = Net::HTTP::Put
+      when :delete
+        request_class = Net::HTTP::Delete
+      end
+    end
+
+    def port
+      use_ssl ? 443 : 80
+    end
+
+    def proxy_settings
+      @proxy.values_at(:host, :port, :user, :password) unless @proxy.nil? || @proxy.empty?
+    end
+
+    def http(host)
+      http = Net::HTTP.new(host, port, *proxy_settings)
+      http.set_debug_output(STDOUT) if @debug
+      http.use_ssl = @use_ssl
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @use_ssl
+      http.read_timeout = @timeout if @timeout
+      http
+    end
+
+    def send_request(host, request, skip_authorization = false)
+      response = http(host).start do |http|
+        host = http.address
+
+        request['Date'] ||= Time.now.httpdate
+
+        if request.body
+          request["Content-Type"] ||= "application/octet-stream"
+          request["Content-MD5"] = Base64.encode64(Digest::MD5.digest(request.body)).chomp unless request.body.empty?
+        end
+
+        unless skip_authorization
+          request["Authorization"] = Signature.generate(:host => host,
+                                                        :request => request,
+                                                        :access_key_id => access_key_id,
+                                                        :secret_access_key => secret_access_key)
+        end
+
+        http.request(request)
+      end
+
+      if response.code.to_i == 307
+        if response.body
+          doc = Document.new response.body
+          send_request(doc.elements['Error'].elements['Endpoint'].text, request, true)
+        end
+      else
+        handle_response(response)
+      end
+    end
+
+    def handle_response(response)
+      case response.code.to_i
+      when 200...300
+        response
+      when 300...600
+        if response.body.nil? || response.body.empty?
+          raise Error::ResponseError.new(nil, response)
+        else
+          code, message = parse_error(response.body)
+          raise Error::ResponseError.exception(code).new(message, response)
+        end
+      else
+        raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
+      end
+      response
+    end
+  end
+end

data/lib/s3/exceptions.rb

@@ -0,0 +1,110 @@
+module S3
+  module Error
+
+    # All responses with a code between 300 and 599 that contain an
+    # <Error></Error> body are wrapped in an ErrorResponse which
+    # contains an Error object. This Error class generates a custom
+    # exception with the name of the xml Error and its message. All
+    # such runtime generated exception classes descend from
+    # ResponseError and contain the ErrorResponse object so that all
+    # code that makes a request can rescue ResponseError and get
+    # access to the ErrorResponse.
+    class ResponseError < StandardError
+      attr_reader :response
+
+      # Creates new S3::ResponseError.
+      #
+      # ==== Parameters
+      # * <tt>message</tt> - what went wrong
+      # * <tt>response</tt> - Net::HTTPResponse object or nil
+      def initialize(message, response)
+        @response = response
+        super(message)
+      end
+
+      # Factory for all other Exception classes in module, each for
+      # every error response available from AmazonAWS
+      #
+      # ==== Parameters
+      # * <tt>code</tt> - Code name of exception
+      #
+      # ==== Returns
+      # Descendant of ResponseError suitable for that exception code
+      # or ResponseError class if no class found
+      def self.exception(code)
+        S3::Error.const_get(code)
+      rescue NameError
+        ResponseError
+      end
+    end
+
+    #:stopdoc:
+
+    class AccessDenied < ResponseError; end
+    class AccountProblem < ResponseError; end
+    class AmbiguousGrantByEmailAddress < ResponseError; end
+    class BadDigest < ResponseError; end
+    class BucketAlreadyExists < ResponseError; end
+    class BucketAlreadyOwnedByYou < ResponseError; end
+    class BucketNotEmpty < ResponseError; end
+    class CredentialsNotSupported < ResponseError; end
+    class CrossLocationLoggingProhibited < ResponseError; end
+    class EntityTooSmall < ResponseError; end
+    class EntityTooLarge < ResponseError; end
+    class ExpiredToken < ResponseError; end
+    class IncompleteBody < ResponseError; end
+    class IncorrectNumberOfFilesInPostRequestPOST < ResponseError; end
+    class InlineDataTooLarge < ResponseError; end
+    class InternalError < ResponseError; end
+    class InvalidAccessKeyId < ResponseError; end
+    class InvalidAddressingHeader < ResponseError; end
+    class InvalidArgument < ResponseError; end
+    class InvalidBucketName < ResponseError; end
+    class InvalidDigest < ResponseError; end
+    class InvalidLocationConstraint < ResponseError; end
+    class InvalidPayer < ResponseError; end
+    class InvalidPolicyDocument < ResponseError; end
+    class InvalidRange < ResponseError; end
+    class InvalidSecurity < ResponseError; end
+    class InvalidSOAPRequest < ResponseError; end
+    class InvalidStorageClass < ResponseError; end
+    class InvalidTargetBucketForLogging < ResponseError; end
+    class InvalidToken < ResponseError; end
+    class InvalidURI < ResponseError; end
+    class KeyTooLong < ResponseError; end
+    class MalformedACLError < ResponseError; end
+    class MalformedACLError < ResponseError; end
+    class MalformedPOSTRequest < ResponseError; end
+    class MalformedXML < ResponseError; end
+    class MaxMessageLengthExceeded < ResponseError; end
+    class MaxPostPreDataLengthExceededErrorYour < ResponseError; end
+    class MetadataTooLarge < ResponseError; end
+    class MethodNotAllowed < ResponseError; end
+    class MissingAttachment < ResponseError; end
+    class MissingContentLength < ResponseError; end
+    class MissingRequestBodyError < ResponseError; end
+    class MissingSecurityElement < ResponseError; end
+    class MissingSecurityHeader < ResponseError; end
+    class NoLoggingStatusForKey < ResponseError; end
+    class NoSuchBucket < ResponseError; end
+    class NoSuchKey < ResponseError; end
+    class NotImplemented < ResponseError; end
+    class NotSignedUp < ResponseError; end
+    class OperationAborted < ResponseError; end
+    class PermanentRedirect < ResponseError; end
+    class PreconditionFailed < ResponseError; end
+    class Redirect < ResponseError; end
+    class RequestIsNotMultiPartContent < ResponseError; end
+    class RequestTimeout < ResponseError; end
+    class RequestTimeTooSkewed < ResponseError; end
+    class RequestTorrentOfBucketError < ResponseError; end
+    class SignatureDoesNotMatch < ResponseError; end
+    class SlowDown < ResponseError; end
+    class TemporaryRedirect < ResponseError; end
+    class TokenRefreshRequired < ResponseError; end
+    class TooManyBuckets < ResponseError; end
+    class UnexpectedContent < ResponseError; end
+    class UnresolvableGrantByEmailAddress < ResponseError; end
+    class UserKeyMustBeSpecified < ResponseError; end
+  end
+end