canistor 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bf13c7035a24763b26bd9253467f4f873636829e
-  data.tar.gz: 6480171c921991df6c108bc7be1d66e643212e53
+SHA256:
+  metadata.gz: 2bb2182118a1177fe7d53b2430b381d11aeadf3b7575b91e0c64639858eb85cf
+  data.tar.gz: 1f5fd555fabda31b4f24d622a2818e5df7f0292aa1724f9984b70adf821d67a8
 SHA512:
-  metadata.gz: 43f653334c556cf39af9ab4ccc8fa75ae4ce7aea3ace8086bc7e0ccec2404f64b90250d6166da0ba6b61a11bfe28d0599e4d506e9a3fc3167a90d3aa8120ca0a
-  data.tar.gz: 05c8d219616d24e88b69ed099830a74ddef7cb88d10bfde4ab96131aa1861aa5bac42f82a372a2b64aa058d28aa36d7cb3e9b89e12c88efee93daae3d3ed9fcb
+  metadata.gz: c5c35f8dc1732a619ed8432a924e6f3bef0e09b78ff94279dfbb6f4471538fb14785e539c265de4ce3831d9a0b3c566424c56619a38b30dc654e0824918b1f93
+  data.tar.gz: 33adf6799dc1d6643228714b20df2135a4a834935630af348928ea8aa93c10f5cd278dffa66069e7229b0b81b1e7d06cc5d501def660c718c5f2ec36dd780838

data/lib/canistor.rb

@@ -1,4 +1,203 @@
+# frozen_string_literal: true
+
 require_relative "canistor/version"
+require_relative "canistor/storage"
+require_relative "canistor/authorization"
+require_relative "canistor/subject"
+require_relative "canistor/error_handler"
+require_relative "canistor/handler"
+require_relative "canistor/plugin"
+
+require "thread"
+
+# Replacement for the HTTP handler in the AWS SDK that mocks all interaction
+# with S3 just above the HTTP level.
+#
+# The mock implementation is turned on by removing the NetHttp handlers that
+# comes with the library by the Canistor handler.
+#
+#   Aws::S3::Client.remove_plugin(Seahorse::Client::Plugins::NetHttp)
+#   Aws::S3::Client.add_plugin(Canistor::Plugin)
+#
+# The Canistor instance then needs to be configured with buckets and
+# credentials to be useful. It can be configured using either the
+# config method on the instance or by specifying the buckets one by one.
+#
+# In the example below Canistor will have two accounts and three buckets. It
+# also specifies which accounts can access the buckets.
+#
+#   Canistor.config(
+#     logger: Rails.logger,
+#     credentials: {
+#       'global' => {
+#         access_key_id: 'AKIAIXXXXXXXXXXXXXX1',
+#         secret_access_key: 'phRL+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx1'
+#       },
+#       'accounting' => {
+#         access_key_id: 'AKIAIXXXXXXXXXXXXXX2',
+#         secret_access_key: 'phRL+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx2'
+#       }
+#     },
+#     buckets: {
+#       'us-east-1' => {
+#         'com-procore-production-images' => ['global'],
+#         'com-procore-production-books' => ['global', 'accounting']
+#       },
+#       'eu-central-1' => {
+#         'com-procore-production-sales' => ['global']
+#       }
+#     }
+#   )
+#
+# Canistor implements basic interaction with buckets and objects. It also
+# verifies authentication information. It does not implement control lists so
+# all accounts have full access to the buckets and objects.
+#
+# The mock can simulate a number of failures. These are triggered by setting
+# the operation which needs to fail on the mock. For more information see
+# [Canistor.fail].
+#
+# In most cases you should configure the suite to clear the mock before running 
+# each example with [Canistor.clear].
+module Canistor
+  class << self
+    attr_accessor :logger
+    attr_accessor :store
+    attr_reader :credentials
+    attr_reader :fail
+    attr_reader :fail_mutex
+  end
+
+  @store = {}
+  @buckets = {}
+  @credentials = Set.new
+  @fail_mutex = Mutex.new
+
+  def self.find_credentials(authorization)
+    if authorization.access_key_id
+      credentials.each do |attributes|
+        if authorization.access_key_id == attributes[:access_key_id]
+          return Aws::Credentials.new(
+            attributes[:access_key_id],
+            attributes[:secret_access_key]
+          )
+        end
+      end
+    end
+    nil
+  end
+
+  def self.credentials=(accounts)
+    accounts.each do |attributes|
+      unless attributes.keys.map(&:to_s) == %w(access_key_id secret_access_key)
+        raise(
+          ArgumentError,
+          "Credentials need to specify access_key_id and secret_access_key, " \
+          "got: `#{attributes.keys.inspect}'"
+        )
+      end
+    end
+    credentials.merge(accounts)
+  end
+
+  def self.buckets=(buckets)
+    buckets.each do |region, attributes|
+      attributes.each do |bucket, access_key_ids|
+        bucket = create_bucket(region, bucket)
+        bucket.allow_access_to(access_key_ids)
+        bucket
+      end
+    end
+  end
+
+  # Configures a bucket in the mock implementation. Use #allow_access_to on
+  # the Container object returned by this method to configure who may access
+  # the bucket.
+  def self.create_bucket(region, bucket_name)
+    store[region] ||= {}
+    store[region][bucket_name] = Canistor::Storage::Bucket.new(
+      region: region,
+      name: bucket_name
+    )
+  end
+
+  def self.config(config)
+    config.each do |section, attributes|
+      public_send("#{section}=", attributes)
+    end
+  end
+
+  SUPPORTED_FAILURES = [
+    :internal_server_error,
+    :reset_connection,
+    :fatal,
+    :store
+  ]
+
+  # The mock can simulate a number of failures. These are triggered by setting
+  # the way we expect it to fail. Note that the AWS-SDK already helps you
+  # to recover from certain errors like :reset_connection. If you want these
+  # kinds of error to trigger a failure you have to call #fail more than then
+  # configured retry count.
+  #
+  #   Canistor.fail(:reset_connection)
+  #   Canistor.fail(
+  #     :reset_connection,
+  #     :reset_connection,
+  #     :reset_connection,
+  #     :reset_connection
+  #   )
+  #
+  #  * reset_connection: Signals the library to handle a connection error
+  #    (retryable)
+  #  * internal_server_error: Returns a 500 internal server error (retryable)
+  #  * fatal: Signals the library to handle a fatal error (fatal)
+  #
+  # A less common problem is when S3 reports a successful write but fails to
+  # store the file. This means the PUT to the bucket will be successful, but
+  # GET and HEAD on the object fail, because it's not there.
+  #
+  #   Canistor.fail(:store)
+  def self.fail(*operations)
+    unsupported = operations - SUPPORTED_FAILURES
+    unless unsupported.empty?
+      raise(
+        ArgumentError,
+        "Requested unsupported failure: `#{unsupported.inspect}', supported: " \
+        "#{SUPPORTED_FAILURES.inspect}."
+      )
+    end
+    fail_mutex.synchronize do
+      @fail.concat(operations)
+    end
+  end
+
+  # Returns true when Canistor should fail the operation and false otherwise.
+  def self.fail?(operation)
+    @fail.include?(operation)
+  end
+
+  # Executes the block when the operation is in the failure queue and removes
+  # one instance of the operation.
+  def self.take_fail(operation, &block)
+    fail_mutex.synchronize do
+      if index = @fail.index(operation)
+        block.call
+        @fail.delete_at(index)
+      end
+    end
+  end
+
+  # Clears the state of the mock. Leaves all the credentials and buckets but
+  # removes all objects and mocked responses.
+  def self.clear
+    @fail = []
+    @store.each do |region, buckets|
+      buckets.each do |bucket_name, bucket|
+        bucket.clear
+      end
+    end
+  end
 
-class Canistor
-end
+  clear
+end

data/lib/canistor/authorization.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Canistor
+  class Authorization
+    attr_reader :protocol
+    attr_reader :region
+    attr_reader :access_key_id
+    attr_reader :signature
+    attr_reader :date
+
+    def initialize(authorization)
+      @protocol, params = authorization.split(' ', 2)
+      params.split(', ').inject({}) do |unpacked, part|
+        name, values = part.split('=')
+        case name
+        when 'Credential'
+          self.credential = values.split('/')
+        when 'Signature'
+          self.signature = values
+        end
+        unpacked
+      end
+    end
+
+    def valid_signature?(request, credentials)
+      return false if signature.to_s.strip == ''
+      signer = Aws::Sigv4::Signer.new(
+        service: 's3',
+        region: region,
+        credentials_provider: credentials,
+        uri_escape_path: false,
+        unsigned_headers: ['content-length', 'x-amzn-trace-id']
+      )
+      signed_request = signer.sign_request(
+        http_method: request.http_method,
+        url: request.endpoint.to_s,
+        headers: request.headers.to_hash,
+        body: request.body
+      )
+      signature == signer.send(
+        :signature,
+        credentials.secret_access_key,
+        date,
+        signed_request.string_to_sign
+      )
+    end
+
+    private
+
+    def signature=(signature)
+      @signature = signature
+    end
+
+    def credential=(credential)
+      @access_key_id, @date, @region = credential[0, 3]
+    end
+  end
+end

data/lib/canistor/error_handler.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Canistor
+  class ErrorHandler
+    attr_reader :context
+    attr_reader :request_id
+    attr_reader :host_id
+
+    def initialize(context)
+      @context = context
+      @request_id = SecureRandom.hex(8).upcase
+      @host_id = Base64.strict_encode64(SecureRandom.hex(16))
+    end
+
+    def request
+      context.http_request
+    end
+
+    def response
+      context.http_response
+    end
+
+    def serve_invalid_access_key(authorization)
+      serve_error(403, Nokogiri::XML::Builder.new do |xml|
+        xml.Error do
+          xml.Code 'InvalidAccessKeyId'
+          xml.Message 'The AWS Access Key Id you provided does not exist in our records.'
+          xml.AWSAccessKeyId authorization.access_key_id
+          xml.RequestId request_id
+          xml.HostId host_id
+        end
+      end.to_xml)
+    end
+
+    def serve_signature_does_not_match(authorization)
+      serve_error(403, Nokogiri::XML::Builder.new do |xml|
+        xml.Error do
+          xml.Code 'SignatureDoesNotMatch'
+          xml.Message 'The request signature we calculated does not match the signature you provided. Check your key and signing method.'
+          xml.AWSAccessKeyId authorization.access_key_id
+          xml.SignatureProvided authorization.signature
+          xml.RequestId request_id
+          xml.HostId host_id
+        end
+      end.to_xml)
+    end
+
+    def serve_no_such_bucket(subject)
+      serve_error(404, Nokogiri::XML::Builder.new do |xml|
+        xml.Error do
+          xml.Code 'NoSuchBucket'
+          xml.Message 'The specified bucket does not exist'
+          xml.BucketName subject.bucket
+          xml.RequestId request_id
+          xml.HostId host_id
+        end
+      end.to_xml)
+    end
+
+    def serve_no_such_key(subject)
+      serve_error(404, Nokogiri::XML::Builder.new do |xml|
+        xml.Error do
+          xml.Code 'NoSuchKey'
+          xml.Message 'The specified key does not exist.'
+          xml.Key subject.key
+          xml.RequestId request_id
+          xml.HostId host_id
+        end
+      end.to_xml)
+    end
+
+    def serve_access_denied(subject)
+      serve_error(403, Nokogiri::XML::Builder.new do |xml|
+        xml.Error do
+          xml.Code 'AccessDenied'
+          xml.Message 'Access Denied'
+          xml.RequestId request_id
+          xml.HostId host_id
+        end
+      end.to_xml)
+    end
+
+    def serve_internal_error
+      serve_error(500, Nokogiri::XML::Builder.new do |xml|
+        xml.Error do
+          xml.Code 'InternalError'
+          xml.Message 'We encountered an internal error. Please try again.'
+          xml.RequestId request_id
+          xml.HostId host_id
+        end
+      end.to_xml)
+    end
+
+    def serve_error(status_code, body)
+      response.signal_headers(
+        status_code,
+        'data' => Time.now.httpdate,
+        'x-amz-request-id' => request_id
+      )
+      unless request.http_method == 'HEAD'
+        response.signal_data(body)
+      end
+    end
+
+    def trigger_reset_connection
+      response.signal_error(Seahorse::Client::NetworkingError.new(
+        Errno::ECONNRESET.new, 'Remote host reset the connection request.'
+      ))
+    end
+
+    def trigger_fatal_error
+      response.signal_error(RuntimeError.new("Fatal error."))
+    end
+
+    def self.serve_invalid_access_key(context, authorization)
+      new(context).serve_invalid_access_key(authorization)
+    end
+
+    def self.serve_signature_does_not_match(context, authorization)
+      new(context).serve_signature_does_not_match(authorization)
+    end
+
+    def self.serve_no_such_bucket(context, subject)
+      new(context).serve_no_such_bucket(subject)
+    end
+
+    def self.serve_no_such_key(context, subject)
+      new(context).serve_no_such_key(subject)
+    end
+
+    def self.access_denied(context, subject)
+      new(context).access_denied(subject)
+    end
+
+    def self.serve_internal_error(context)
+      new(context).serve_internal_error
+    end
+
+    def self.trigger_reset_connection(context)
+      new(context).trigger_reset_connection
+    end
+
+    def self.trigger_fatal_error(context)
+      new(context).trigger_fatal_error
+    end
+  end
+end

data/lib/canistor/handler.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'cgi'
+require 'uri/http'
+require 'digest/sha1'
+require 'base64'
+require 'nokogiri'
+require 'singleton'
+require 'securerandom'
+
+module Canistor
+  # AWS-SDK compatible handler to mock S3 interaction.
+  class Handler < Seahorse::Client::Handler
+    # @param [RequestContext] context
+    # @return [Response]
+    def call(context)
+      log(context.config, context.http_request)
+      handle(
+        context,
+        Canistor::Authorization.new(context.http_request.headers['Authorization']),
+        Canistor::Subject.new(context.http_request.endpoint)
+      )
+      Seahorse::Client::Response.new(context: context)
+    end
+
+    private
+
+    # Mocks interaction with S3 using the library request context, authorization
+    # from headers, and subject based on the request URI.
+    #
+    # When a bucket can be found the request will be forwarded to the
+    # Canistor::Store::Bucket object for futher handling.
+    #
+    # Stubbed error reponses and error conditions are handled by rendering the
+    # correct responses or raising an exception.
+    def handle(context, authorization, subject)
+      Canistor.take_fail(:fatal) do
+        return Canistor::ErrorHandler.trigger_fatal_error(context)
+      end
+      Canistor.take_fail(:reset_connection) do
+        return Canistor::ErrorHandler.trigger_reset_connection(context)
+      end
+      Canistor.take_fail(:internal_server_error) do
+        return Canistor::ErrorHandler.serve_internal_error(context)
+      end
+      if credentials = Canistor.find_credentials(authorization)
+        if authorization.valid_signature?(context.http_request, credentials)
+          if bucket = Canistor.store.dig(subject.region, subject.bucket)
+            method = context.http_request.http_method.to_s.downcase
+            bucket.send(
+              method,
+              context,
+              authorization.access_key_id,
+              subject
+            )
+          else
+            Canistor::ErrorHandler.serve_no_such_bucket(context, subject)
+          end
+        else
+          Canistor::ErrorHandler.serve_signature_does_not_match(
+            context,
+            authorization
+          )
+        end
+      else
+        Canistor::ErrorHandler.serve_invalid_access_key(context, authorization)
+      end
+
+      context.http_response.signal_done
+    end
+
+    def log(config, request)
+      headers = request.headers.to_hash.slice('content-length', 'content-type')
+      params = CGI::parse(request.endpoint.query.to_s)
+      Canistor.logger.debug(
+        '[Canistor::S3] ' + config.region + ' ' + request.http_method + ' ' +
+        request.endpoint.path.to_s +
+        (headers.empty? ? '' : ' ' + headers.inspect) +
+        (params.empty? ? '' : ' ' + params.inspect)
+      ) if Canistor.logger
+    end
+  end
+end

data/lib/canistor/plugin.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Canistor
+  class Plugin < Seahorse::Client::Plugin
+    option(:http_proxy, default: nil, doc_type: String, docstring: '')
+    option(:http_open_timeout, default: 15, doc_type: Integer, docstring: '')
+    option(:http_read_timeout, default: 60, doc_type: Integer, docstring: '')
+    option(:http_idle_timeout, default: 5, doc_type: Integer, docstring: '')
+    option(:http_continue_timeout, default: 1, doc_type: Integer, docstring: '')
+    option(:http_wire_trace, default: false, doc_type: 'Boolean', docstring: '')
+    option(:ssl_verify_peer, default: true, doc_type: 'Boolean', docstring: '')
+    option(:ssl_ca_bundle, default: nil, doc_type: String, docstring: '')
+    option(:ssl_ca_directory, default: nil, doc_type: String, docstring: '')
+    option(:ssl_ca_store, default: nil, doc_type: String, docstring: '')
+    option(:logger) # for backwards compat
+    handler(Canistor::Handler, step: :send)
+  end
+end

data/lib/canistor/storage.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'base64'
+require 'nokogiri'
+require 'securerandom'
+
+require_relative "storage/bucket"
+require_relative "storage/object"

data/lib/canistor/storage/bucket.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'base64'
+require 'nokogiri'
+require 'singleton'
+require 'securerandom'
+
+module Canistor
+  module Storage
+    class Bucket
+      attr_accessor :region
+      attr_accessor :name
+
+      attr_reader :access_keys
+      attr_reader :objects
+
+      def initialize(**attributes)
+        @access_keys = Set.new
+        clear
+        attributes.each do |name, value|
+          public_send("#{name}=", value)
+        end
+      end
+
+      def [](name)
+        @objects[name]
+      end
+
+      def []=(name, value)
+        @objects[name] = value
+      end
+
+      def dig(*segments)
+        @objects.dig(*segments)
+      end
+
+      def head(context, access_key_id, subject)
+        if !access_keys.include?(access_key_id)
+          Canistor::ErrorHandler.serve_access_denied(context, subject)
+        elsif object = objects[subject.key]
+          object.head(context, subject)
+        else
+          Canistor::ErrorHandler.serve_no_such_key(context, subject)
+        end
+      end
+
+      def get(context, access_key_id, subject)
+        if !access_keys.include?(access_key_id)
+          Canistor::ErrorHandler.serve_access_denied(context, subject)
+        elsif object = objects[subject.key] 
+          object.get(context, subject)
+        else
+          Canistor::ErrorHandler.serve_no_such_key(context, subject)
+        end
+      end
+
+      def put(context, access_key_id, subject)
+        if access_keys.include?(access_key_id)
+          Canistor.take_fail(:store) { return }
+          object = find_or_build_object(subject, context)
+          self[subject.key] = object
+          object.put(context, subject)
+        else
+          Canistor::ErrorHandler.serve_access_denied(context, subject)
+        end
+      end
+
+      def delete(context, access_key_id, subject)
+        if !access_keys.include?(access_key_id)
+          Canistor::ErrorHandler.serve_access_denied(context, subject)
+        elsif object = objects[subject.key]
+          @objects.delete(object.key)
+          object.delete(context, subject)
+        else
+          Canistor::ErrorHandler.serve_no_such_key(context, subject)
+        end
+      end
+
+      def clear
+        @objects = {}
+      end
+
+      def to_s
+        @objects.values.map do |object|
+          ' * ' + object.label
+        end.join("\n")
+      end
+
+      def allow_access_to(access_key_ids)
+        access_keys.merge(access_key_ids)
+      end
+
+      def headers
+        {}
+      end
+
+      private
+
+      def find_or_build_object(subject, context)
+        objects[subject.key] || Canistor::Storage::Object.new(
+          region: subject.region,
+          bucket: subject.bucket,
+          key: subject.key
+        )
+      end
+    end
+  end
+end

data/lib/canistor/storage/object.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+
+module Canistor
+  module Storage
+    class Object
+      attr_accessor :region
+      attr_accessor :bucket
+      attr_accessor :key
+
+      attr_reader :data
+      attr_reader :last_modified
+
+      def initialize(**attributes)
+        @headers = {}
+        @data = ''
+        attributes.each do |name, value|
+          send("#{name}=", value)
+        end
+        @digest = nil
+      end
+
+      def size
+        data&.size
+      end
+
+      def label
+        [region, bucket, key].map(&:to_s).join(':') + ' ' + headers.inspect
+      end
+
+      def write(headers, data)
+        self.headers = headers
+        self.data = data
+      end
+
+      def digest
+        @digest ||= Digest::SHA1.hexdigest(data)
+      end
+
+      def etag
+        '"' + digest + '"'
+      end
+
+      def headers
+        @headers.merge(identity_headers).merge(
+          'date' => Time.now.httpdate,
+          'content-length' => size.to_s,
+          'last-modified' => last_modified.httpdate,
+          'server' => 'Canistor'
+        )
+      end
+
+      def identity_headers
+        {
+          'x-amz-request-id' => Base64.strict_encode64(SecureRandom.hex(16)),
+          'x-amz-id' => digest[0, 16],
+          'x-amz-id-2' => Base64.strict_encode64(digest),
+          'etag' => etag
+        }
+      end
+
+      def head(context, subject)
+        context.http_response.signal_headers(200, headers)
+      end
+
+      def get(context, subject)
+        context.http_response.signal_headers(200, headers)
+        context.http_response.signal_data(data)
+      end
+
+      def put(context, subject)
+        catch(:rendered_error) do
+          source_object = source_object(context, subject)
+          self.data = object_data(context, source_object)
+          self.headers = object_headers(context, source_object)
+          context.http_response.signal_headers(200, identity_headers)
+        end
+      end
+
+      def delete(context, subject)
+        context.http_response.signal_headers(200, {})
+      end
+
+      private
+
+      def source_object(context, subject)
+        if source = context.http_request.headers['x-amz-copy-source']
+          bucket_name, key = source.split('/', 2)
+          if bucket = Canistor.store.dig(region, bucket_name)
+            if object = bucket.dig(key)
+              object
+            else
+              Canistor::ErrorHandler.serve_no_such_key(context, subject)
+              throw :rendered_error
+            end
+          else
+            Canistor::ErrorHandler.serve_no_such_bucket(context, subject)
+            throw :rendered_error
+          end
+        end
+      end
+
+      def object_data(context, source_object)
+        if source_object
+          source_object.data
+        else
+          context.http_request.body
+        end
+      end
+
+      def object_headers(context, source_object)
+        directive = context.http_request.headers['x-amz-metadata-directive']
+        case directive
+        when 'COPY'
+          source_object.headers
+        when 'REPLACE', nil
+          context.http_request.headers
+        else
+          raise ArgumentError, "Unsupported metadata directive: `#{directive}'"
+        end
+      end
+
+      META_HEADERS = %w(
+        content-disposition
+        content-type
+      )
+
+      def headers=(headers)
+        return if headers.nil?
+        headers.each do |name, value|
+          if META_HEADERS.include?(name)
+            @headers[name] = value
+          end
+        end
+      end
+
+      def data=(data)
+        @digest = nil
+        @last_modified = Time.now
+        if data.respond_to?(:read)
+          @data = data.read
+        else
+          @data = data
+        end
+      end
+    end
+  end
+end

data/lib/canistor/subject.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Canistor
+  class Subject
+    attr_reader :uri
+
+    attr_reader :region
+    attr_reader :bucket
+    attr_reader :key
+
+    HOST_RE = /\A([^\.]+\.)?(s3\.([^\.]+)|s3-([^\.]+))/
+
+    def initialize(uri)
+      @uri = uri
+
+      host_segments = HOST_RE.match(uri.host)
+      path_segments = uri.path.split('/', 3)[1..-1] || []
+
+      @region = parse_region(host_segments)
+      @bucket = parse_bucket(host_segments, path_segments)
+      @key = path_segments.empty? ? nil : path_segments.join('/')
+    end
+
+    private
+
+    def parse_region(host_segments)
+      case host_segments[3]
+      when nil
+        host_segments[4]
+      when 'amazonaws'
+        'us-east-1'
+      else
+        host_segments[3]
+      end
+    end
+
+    def parse_bucket(host_segments, path_segments)
+      if host_segments[1]
+        host_segments[1][0..-2]
+      else
+        path_segments.shift
+      end
+    end
+  end
+end

data/lib/canistor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-class Canistor
-  VERSION = '0.1.0'
-end
+module Canistor
+  VERSION = '0.1.1'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canistor
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Manfred Stienstra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-22 00:00:00.000000000 Z
+date: 2018-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: minitest-assert_errors
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: aws-sdk-s3
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
 description: |2
     Canistor allows you to register an HTTP handler with the AWS SDK and all
     interaction with S3 buckets and objects will happen in memory instead of
@@ -64,6 +92,14 @@ extra_rdoc_files: []
 files:
 - LICENSE.txt
 - lib/canistor.rb
+- lib/canistor/authorization.rb
+- lib/canistor/error_handler.rb
+- lib/canistor/handler.rb
+- lib/canistor/plugin.rb
+- lib/canistor/storage.rb
+- lib/canistor/storage/bucket.rb
+- lib/canistor/storage/object.rb
+- lib/canistor/subject.rb
 - lib/canistor/version.rb
 homepage: https://erm.im/canistor
 licenses:
@@ -85,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Canistor is mock for Aws::S3 defined by the AWS SDK gem.