fakes3testing2 1.2.0

data/lib/fakes3/file_store.rb

@@ -0,0 +1,320 @@
+require 'fileutils'
+require 'time'
+require 'fakes3/s3_object'
+require 'fakes3/bucket'
+require 'fakes3/rate_limitable_file'
+require 'digest/md5'
+require 'yaml'
+
+module FakeS3
+  class FileStore
+    FAKE_S3_METADATA_DIR = ".fakes3_metadataFFF"
+
+    # S3 clients with overly strict date parsing fails to parse ISO 8601 dates
+    # without any sub second precision (e.g. jets3t v0.7.2), and the examples
+    # given in the official AWS S3 documentation specify three (3) decimals for
+    # sub second precision.
+    SUBSECOND_PRECISION = 3
+
+    def initialize(root, quiet_mode)
+      @root = root
+      @buckets = []
+      @bucket_hash = {}
+      @quiet_mode = quiet_mode
+      Dir[File.join(root,"*")].each do |bucket|
+        bucket_name = File.basename(bucket)
+        bucket_obj = Bucket.new(bucket_name,Time.now,[])
+        @buckets << bucket_obj
+        @bucket_hash[bucket_name] = bucket_obj
+      end
+    end
+
+    # Pass a rate limit in bytes per second
+    def rate_limit=(rate_limit)
+      if rate_limit.is_a?(String)
+        if rate_limit =~ /^(\d+)$/
+          RateLimitableFile.rate_limit = rate_limit.to_i
+        elsif rate_limit =~ /^(.*)K$/
+          RateLimitableFile.rate_limit = $1.to_f * 1000
+        elsif rate_limit =~ /^(.*)M$/
+          RateLimitableFile.rate_limit = $1.to_f * 1000000
+        elsif rate_limit =~ /^(.*)G$/
+          RateLimitableFile.rate_limit = $1.to_f * 1000000000
+        else
+          raise "Invalid Rate Limit Format: Valid values include (1000,10K,1.1M)"
+        end
+      else
+        RateLimitableFile.rate_limit = nil
+      end
+    end
+
+    def buckets
+      @buckets
+    end
+
+    def get_bucket_folder(bucket)
+      File.join(@root, bucket.name)
+    end
+
+    def get_bucket(bucket)
+      @bucket_hash[bucket]
+    end
+
+    def create_bucket(bucket)
+      FileUtils.mkdir_p(File.join(@root, bucket))
+      bucket_obj = Bucket.new(bucket, Time.now, [])
+      if !@bucket_hash[bucket]
+        @buckets << bucket_obj
+        @bucket_hash[bucket] = bucket_obj
+      end
+      bucket_obj
+    end
+
+    def delete_bucket(bucket_name)
+      bucket = get_bucket(bucket_name)
+      raise NoSuchBucket if !bucket
+      raise BucketNotEmpty if bucket.objects.count > 0
+      FileUtils.rm_r(get_bucket_folder(bucket))
+      @bucket_hash.delete(bucket_name)
+    end
+
+    def get_object(bucket, object_name, request)
+      begin
+        real_obj = S3Object.new
+        obj_root = File.join(@root,bucket,object_name,FAKE_S3_METADATA_DIR)
+        metadata = File.open(File.join(obj_root, "metadata")) { |file| YAML::load(file) }
+        real_obj.name = object_name
+        real_obj.md5 = metadata[:md5]
+        real_obj.content_type = request.query['response-content-type'] ||
+          metadata.fetch(:content_type) { "application/octet-stream" }
+        real_obj.content_disposition = request.query['response-content-disposition'] ||
+          metadata[:content_disposition]
+        real_obj.content_encoding = metadata.fetch(:content_encoding) # if metadata.fetch(:content_encoding)
+        real_obj.io = RateLimitableFile.open(File.join(obj_root, "content"), 'rb')
+        real_obj.size = metadata.fetch(:size) { 0 }
+        real_obj.creation_date = File.ctime(obj_root).utc.iso8601(SUBSECOND_PRECISION)
+        real_obj.modified_date = metadata.fetch(:modified_date) do
+          File.mtime(File.join(obj_root, "content")).utc.iso8601(SUBSECOND_PRECISION)
+        end
+        real_obj.custom_metadata = metadata.fetch(:custom_metadata) { {} }
+        return real_obj
+      rescue
+        unless @quiet_mode
+          puts $!
+          $!.backtrace.each { |line| puts line }
+        end
+        return nil
+      end
+    end
+
+    def object_metadata(bucket, object)
+    end
+
+    def copy_object(src_bucket_name, src_name, dst_bucket_name, dst_name, request)
+      src_root = File.join(@root,src_bucket_name,src_name,FAKE_S3_METADATA_DIR)
+      src_metadata_filename = File.join(src_root, "metadata")
+      src_metadata = YAML.load(File.open(src_metadata_filename, 'rb').read)
+      src_content_filename = File.join(src_root, "content")
+
+      dst_filename= File.join(@root,dst_bucket_name,dst_name)
+      FileUtils.mkdir_p(dst_filename)
+
+      metadata_dir = File.join(dst_filename,FAKE_S3_METADATA_DIR)
+      FileUtils.mkdir_p(metadata_dir)
+
+      content = File.join(metadata_dir, "content")
+      metadata = File.join(metadata_dir, "metadata")
+
+      if src_bucket_name != dst_bucket_name || src_name != dst_name
+        File.open(content, 'wb') do |f|
+          File.open(src_content_filename, 'rb') do |input|
+            f << input.read
+          end
+        end
+
+        File.open(metadata,'w') do |f|
+          File.open(src_metadata_filename,'r') do |input|
+            f << input.read
+          end
+        end
+      end
+
+      metadata_directive = request.header["x-amz-metadata-directive"].first
+      if metadata_directive == "REPLACE"
+        metadata_struct = create_metadata(content, request)
+        File.open(metadata,'w') do |f|
+          f << YAML::dump(metadata_struct)
+        end
+      end
+
+      src_bucket = get_bucket(src_bucket_name) || create_bucket(src_bucket_name)
+      dst_bucket = get_bucket(dst_bucket_name) || create_bucket(dst_bucket_name)
+
+      obj = S3Object.new
+      obj.name = dst_name
+      obj.md5 = src_metadata[:md5]
+      obj.content_type = src_metadata[:content_type]
+      obj.content_disposition = src_metadata[:content_disposition]
+      obj.content_encoding = src_metadata[:content_encoding] # if src_metadata[:content_encoding]
+      obj.size = src_metadata[:size]
+      obj.modified_date = src_metadata[:modified_date]
+
+      src_bucket.find(src_name)
+      dst_bucket.add(obj)
+      return obj
+    end
+
+    def store_object(bucket, object_name, request)
+      filedata = ""
+
+      # TODO put a tmpfile here first and mv it over at the end
+      content_type = request.content_type || ""
+
+      match = content_type.match(/^multipart\/form-data; boundary=(.+)/)
+      boundary = match[1] if match
+      if boundary
+        boundary = WEBrick::HTTPUtils::dequote(boundary)
+        form_data = WEBrick::HTTPUtils::parse_form_data(request.body, boundary)
+
+        if form_data['file'] == nil || form_data['file'] == ""
+          raise WEBrick::HTTPStatus::BadRequest
+        end
+
+        filedata = form_data['file']
+      else
+        request.body { |chunk| filedata << chunk }
+      end
+
+      do_store_object(bucket, object_name, filedata, request)
+    end
+
+    def do_store_object(bucket, object_name, filedata, request)
+      begin
+        filename = File.join(@root, bucket.name, object_name)
+        FileUtils.mkdir_p(filename)
+
+        metadata_dir = File.join(filename, FAKE_S3_METADATA_DIR)
+        FileUtils.mkdir_p(metadata_dir)
+
+        content = File.join(filename, FAKE_S3_METADATA_DIR, "content")
+        metadata = File.join(filename, FAKE_S3_METADATA_DIR, "metadata")
+
+        File.open(content,'wb') { |f| f << filedata }
+
+        metadata_struct = create_metadata(content, request)
+        File.open(metadata,'w') do |f|
+          f << YAML::dump(metadata_struct)
+        end
+
+        obj = S3Object.new
+        obj.name = object_name
+        obj.md5 = metadata_struct[:md5]
+        obj.content_type = metadata_struct[:content_type]
+        obj.content_disposition = metadata_struct[:content_disposition]
+        obj.content_encoding = metadata_struct[:content_encoding] # if metadata_struct[:content_encoding]
+        obj.size = metadata_struct[:size]
+        obj.modified_date = metadata_struct[:modified_date]
+
+        bucket.add(obj)
+        return obj
+      rescue
+        unless @quiet_mode
+          puts $!
+          $!.backtrace.each { |line| puts line }
+        end
+        return nil
+      end
+    end
+
+    def combine_object_parts(bucket, upload_id, object_name, parts, request)
+      upload_path   = File.join(@root, bucket.name)
+      base_path     = File.join(upload_path, "#{upload_id}_#{object_name}")
+
+      complete_file = ""
+      chunk         = ""
+      part_paths    = []
+
+      parts.sort_by { |part| part[:number] }.each do |part|
+        part_path    = "#{base_path}_part#{part[:number]}"
+        content_path = File.join(part_path, FAKE_S3_METADATA_DIR, 'content')
+
+        File.open(content_path, 'rb') { |f| chunk = f.read }
+        etag = Digest::MD5.hexdigest(chunk)
+
+        raise new Error "invalid file chunk" unless part[:etag] == etag
+        complete_file << chunk
+        part_paths    << part_path
+      end
+
+      object = do_store_object(bucket, object_name, complete_file, request)
+
+      # clean up parts
+      part_paths.each do |path|
+        FileUtils.remove_dir(path)
+      end
+
+      object
+    end
+
+    def delete_object(bucket,object_name,request)
+      begin
+        filename = File.join(@root,bucket.name,object_name)
+        FileUtils.rm_rf(filename)
+        object = bucket.find(object_name)
+        bucket.remove(object)
+      rescue
+        puts $!
+        $!.backtrace.each { |line| puts line }
+        return nil
+      end
+    end
+
+    def delete_objects(bucket, objects, request)
+      begin
+        filenames = []
+        objects.each do |object_name|
+          filenames << File.join(@root,bucket.name,object_name)
+          object = bucket.find(object_name)
+          bucket.remove(object)
+        end
+
+        FileUtils.rm_rf(filenames)
+      rescue
+        puts $!
+        $!.backtrace.each { |line| puts line }
+        return nil
+      end
+    end
+
+    # TODO: abstract getting meta data from request.
+    def create_metadata(content, request)
+      metadata = {}
+      metadata[:md5] = Digest::MD5.file(content).hexdigest
+      metadata[:content_type] = request.header["content-type"].first
+      if request.header['content-disposition']
+        metadata[:content_disposition] = request.header['content-disposition'].first
+      end
+      content_encoding = request.header["content-encoding"].first
+      metadata[:content_encoding] = content_encoding
+      #if content_encoding
+      #  metadata[:content_encoding] = content_encoding
+      #end
+      metadata[:size] = File.size(content)
+      metadata[:modified_date] = File.mtime(content).utc.iso8601(SUBSECOND_PRECISION)
+      metadata[:amazon_metadata] = {}
+      metadata[:custom_metadata] = {}
+
+      # Add custom metadata from the request header
+      request.header.each do |key, value|
+        match = /^x-amz-([^-]+)-(.*)$/.match(key)
+        next unless match
+        if match[1].eql?('meta') && (match_key = match[2])
+          metadata[:custom_metadata][match_key] = value.join(', ')
+          next
+        end
+        metadata[:amazon_metadata][key.gsub(/^x-amz-/, '')] = value.join(', ')
+      end
+      return metadata
+    end
+  end
+end

data/lib/fakes3/rate_limitable_file.rb

@@ -0,0 +1,21 @@
+module FakeS3
+  class RateLimitableFile < File
+    @@rate_limit = nil
+    # Specify a rate limit in bytes per second
+    def self.rate_limit
+      @@rate_limit
+    end
+
+    def self.rate_limit=(rate_limit)
+      @@rate_limit = rate_limit
+    end
+
+    def read(args)
+      if @@rate_limit
+        time_to_sleep = args / @@rate_limit
+        sleep(time_to_sleep)
+      end
+      return super(args)
+    end
+  end
+end

data/lib/fakes3/s3_object.rb

@@ -0,0 +1,19 @@
+module FakeS3
+  class S3Object
+    include Comparable
+    attr_accessor :name,:size,:creation_date,:modified_date,:md5,:io,:content_type,:content_disposition,:content_encoding,:custom_metadata
+
+    def hash
+      @name.hash
+    end
+
+    def eql?(object)
+      object.is_a?(self.class) ? (@name == object.name) : false
+    end
+
+    # Sort by the object's name
+    def <=>(object)
+      object.is_a?(self.class) ? (@name <=> object.name) : nil
+    end
+  end
+end

data/lib/fakes3/server.rb

@@ -0,0 +1,597 @@
+require 'time'
+require 'webrick'
+require 'webrick/https'
+require 'openssl'
+require 'securerandom'
+require 'cgi'
+require 'fakes3/util'
+require 'fakes3/file_store'
+require 'fakes3/xml_adapter'
+require 'fakes3/xml_parser'
+require 'fakes3/bucket_query'
+require 'fakes3/unsupported_operation'
+require 'fakes3/errors'
+require 'ipaddr'
+
+module FakeS3
+  class Request
+    CREATE_BUCKET = "CREATE_BUCKET"
+    LIST_BUCKETS = "LIST_BUCKETS"
+    LS_BUCKET = "LS_BUCKET"
+    HEAD = "HEAD"
+    STORE = "STORE"
+    COPY = "COPY"
+    GET = "GET"
+    GET_ACL = "GET_ACL"
+    SET_ACL = "SET_ACL"
+    MOVE = "MOVE"
+    DELETE_OBJECT = "DELETE_OBJECT"
+    DELETE_BUCKET = "DELETE_BUCKET"
+    DELETE_OBJECTS = "DELETE_OBJECTS"
+
+    attr_accessor :bucket, :object, :type, :src_bucket,
+                  :src_object, :method, :webrick_request,
+                  :path, :is_path_style, :query, :http_verb
+
+    def inspect
+      puts "-----Inspect FakeS3 Request"
+      puts "Type: #{@type}"
+      puts "Is Path Style: #{@is_path_style}"
+      puts "Request Method: #{@method}"
+      puts "Bucket: #{@bucket}"
+      puts "Object: #{@object}"
+      puts "Src Bucket: #{@src_bucket}"
+      puts "Src Object: #{@src_object}"
+      puts "Query: #{@query}"
+      puts "-----Done"
+    end
+  end
+
+  def self.logger
+    @@logger ||= defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+  end
+
+  def self.logger=(logger)
+    @@logger = logger
+  end
+
+  class Servlet < WEBrick::HTTPServlet::AbstractServlet
+    def initialize(server,store,hostname)
+      super(server)
+      @store = store
+      @hostname = hostname
+      @port = server.config[:Port]
+      @root_hostnames = [hostname,'localhost','s3.amazonaws.com','s3.localhost']
+    end
+
+    def validate_request(request)
+      req = request.webrick_request
+      return if req.nil?
+      return if not req.header.has_key?('expect')
+      req.continue if req.header['expect'].first=='100-continue'
+    end
+
+    def do_GET(request, response)
+      s_req = normalize_request(request)
+
+      case s_req.type
+      when 'LIST_BUCKETS'
+        response.status = 200
+        response['Content-Type'] = 'application/xml'
+        buckets = @store.buckets
+        response.body = XmlAdapter.buckets(buckets)
+      when 'LS_BUCKET'
+        bucket_obj = @store.get_bucket(s_req.bucket)
+        if bucket_obj
+          response.status = 200
+          response['Content-Type'] = "application/xml"
+          query = {
+            :marker => s_req.query["marker"] ? s_req.query["marker"].to_s : nil,
+            :prefix => s_req.query["prefix"] ? s_req.query["prefix"].to_s : nil,
+            :max_keys => s_req.query["max-keys"] ? s_req.query["max-keys"].to_i : nil,
+            :delimiter => s_req.query["delimiter"] ? s_req.query["delimiter"].to_s : nil
+          }
+          bq = bucket_obj.query_for_range(query)
+          response.body = XmlAdapter.bucket_query(bq)
+        else
+          response.status = 404
+          response.body = XmlAdapter.error_no_such_bucket(s_req.bucket)
+          response['Content-Type'] = "application/xml"
+        end
+      when 'GET_ACL'
+        response.status = 200
+        response.body = XmlAdapter.acl
+        response['Content-Type'] = 'application/xml'
+      when 'GET'
+        real_obj = @store.get_object(s_req.bucket, s_req.object, request)
+        if !real_obj
+          response.status = 404
+          response.body = XmlAdapter.error_no_such_key(s_req.object)
+          response['Content-Type'] = "application/xml"
+          return
+        end
+
+        if_none_match = request["If-None-Match"]
+        if if_none_match == "\"#{real_obj.md5}\"" or if_none_match == "*"
+          response.status = 304
+          return
+        end
+
+        if_modified_since = request["If-Modified-Since"]
+        if if_modified_since
+          time = Time.httpdate(if_modified_since)
+          if time >= Time.iso8601(real_obj.modified_date)
+            response.status = 304
+            return
+          end
+        end
+
+        response.status = 200
+        response['Content-Type'] = real_obj.content_type
+
+        if real_obj.content_encoding
+          response.header['X-Content-Encoding'] = real_obj.content_encoding
+          response.header['Content-Encoding'] = real_obj.content_encoding
+        end
+
+        response['Content-Disposition'] = real_obj.content_disposition if real_obj.content_disposition
+        stat = File::Stat.new(real_obj.io.path)
+
+        response['Last-Modified'] = Time.iso8601(real_obj.modified_date).httpdate
+        response.header['ETag'] = "\"#{real_obj.md5}\""
+        response['Accept-Ranges'] = "bytes"
+        response['Last-Ranges'] = "bytes"
+        response['Access-Control-Allow-Origin'] = '*'
+
+        real_obj.custom_metadata.each do |header, value|
+          response.header['x-amz-meta-' + header] = value
+        end
+
+        content_length = stat.size
+
+        # Added Range Query support
+        range = request.header["range"].first
+        if range
+          response.status = 206
+          if range =~ /bytes=(\d*)-(\d*)/
+            start = $1.to_i
+            finish = $2.to_i
+            finish_str = ""
+            if finish == 0
+              finish = content_length - 1
+              finish_str = "#{finish}"
+            else
+              finish_str = finish.to_s
+            end
+
+            bytes_to_read = finish - start + 1
+            response['Content-Range'] = "bytes #{start}-#{finish_str}/#{content_length}"
+            real_obj.io.pos = start
+            response.body = real_obj.io.read(bytes_to_read)
+            return
+          end
+        end
+        response['Content-Length'] = File::Stat.new(real_obj.io.path).size
+        response['Content-Disposition'] = 'attachment'
+        if s_req.http_verb == 'HEAD'
+          response.body = ""
+	        real_obj.io.close
+        else
+          response.body = real_obj.io
+        end
+      end
+    end
+
+    def do_PUT(request, response)
+      s_req = normalize_request(request)
+      query = CGI::parse(request.request_uri.query || "")
+
+      return do_multipartPUT(request, response) if query['uploadId'].first
+
+      response.status = 200
+      response.body = ""
+      response['Content-Type'] = "text/xml"
+      response['Access-Control-Allow-Origin'] = '*'
+
+      case s_req.type
+      when Request::COPY
+        object = @store.copy_object(s_req.src_bucket, s_req.src_object, s_req.bucket, s_req.object, request)
+        response.body = XmlAdapter.copy_object_result(object)
+      when Request::STORE
+        bucket_obj = @store.get_bucket(s_req.bucket)
+        if !bucket_obj
+          # Lazily create a bucket.  TODO fix this to return the proper error
+          bucket_obj = @store.create_bucket(s_req.bucket)
+        end
+
+        real_obj = @store.store_object(bucket_obj, s_req.object, s_req.webrick_request)
+        response.header['ETag'] = "\"#{real_obj.md5}\""
+      when Request::CREATE_BUCKET
+        @store.create_bucket(s_req.bucket)
+      end
+    end
+
+    def do_multipartPUT(request, response)
+      s_req = normalize_request(request)
+      query = CGI::parse(request.request_uri.query)
+
+      part_number   = query['partNumber'].first
+      upload_id     = query['uploadId'].first
+      part_name     = "#{upload_id}_#{s_req.object}_part#{part_number}"
+
+      # store the part
+      if s_req.type == Request::COPY
+        real_obj = @store.copy_object(
+          s_req.src_bucket, s_req.src_object,
+          s_req.bucket    , part_name,
+          request
+        )
+
+        response['Content-Type'] = "text/xml"
+        response.body = XmlAdapter.copy_object_result real_obj
+      else
+        bucket_obj  = @store.get_bucket(s_req.bucket)
+        if !bucket_obj
+          bucket_obj = @store.create_bucket(s_req.bucket)
+        end
+        real_obj    = @store.store_object(
+          bucket_obj, part_name,
+          request
+        )
+
+        response.body   = ""
+        response.header['ETag']  = "\"#{real_obj.md5}\""
+      end
+
+      response['Access-Control-Allow-Origin']   = '*'
+      response['Access-Control-Allow-Headers']  = 'Authorization, Content-Length'
+      response['Access-Control-Expose-Headers'] = 'ETag'
+
+      response.status = 200
+    end
+
+    def do_POST(request,response)
+      if request.query_string === 'delete'
+        return do_DELETE(request, response)
+      end
+
+      s_req = normalize_request(request)
+      key   = request.query['key']
+      query = CGI::parse(request.request_uri.query || "")
+
+      if query.has_key?('uploads')
+        upload_id = SecureRandom.hex
+
+        response.body = <<-eos.strip
+          <?xml version="1.0" encoding="UTF-8"?>
+          <InitiateMultipartUploadResult>
+            <Bucket>#{ s_req.bucket }</Bucket>
+            <Key>#{ key }</Key>
+            <UploadId>#{ upload_id }</UploadId>
+          </InitiateMultipartUploadResult>
+        eos
+      elsif query.has_key?('uploadId')
+        upload_id  = query['uploadId'].first
+        bucket_obj = @store.get_bucket(s_req.bucket)
+        real_obj   = @store.combine_object_parts(
+          bucket_obj,
+          upload_id,
+          s_req.object,
+          parse_complete_multipart_upload(request),
+          request
+        )
+
+        response.body = XmlAdapter.complete_multipart_result real_obj
+      elsif request.content_type =~ /^multipart\/form-data; boundary=(.+)/
+        key = request.query['key']
+
+        success_action_redirect = request.query['success_action_redirect']
+        success_action_status   = request.query['success_action_status']
+
+        filename = 'default'
+        filename = $1 if request.body =~ /filename="(.*)"/
+        key      = key.gsub('${filename}', filename)
+
+        bucket_obj = @store.get_bucket(s_req.bucket) || @store.create_bucket(s_req.bucket)
+        real_obj   = @store.store_object(bucket_obj, key, s_req.webrick_request)
+
+        response['Etag'] = "\"#{real_obj.md5}\""
+
+        if success_action_redirect
+          object_params = [ [ :bucket, s_req.bucket ], [ :key, key ] ]
+          location_uri = URI.parse(success_action_redirect)
+          original_location_params = URI.decode_www_form(String(location_uri.query))
+          location_uri.query = URI.encode_www_form(original_location_params + object_params)
+
+          response.status      = 303
+          response.body        = ""
+          response['Location'] = location_uri.to_s
+        else
+          response.status = success_action_status || 204
+          if response.status == "201"
+
+            FakeS3.logger.debug '##### here is the request.body: '
+            FakeS3.logger.debug request.body
+            FakeS3.logger.debug '##### request.body ^^^'
+            str = request.inspect
+            port = str[str.index('@port')+6..str[str.index('@port')..str.length].index(',')+str.index('@port')-1]
+            host = str[str.index('@host')+7..str[str.index('@host')..str.length].index(',')+str.index('@host')-2]
+            response.body = <<-eos.strip
+              <?xml version="1.0" encoding="UTF-8"?>
+              <PostResponse>
+                <Location>http://#{host}:#{port}/#{s_req.bucket}/#{key}</Location>
+                <Bucket>#{s_req.bucket}</Bucket>
+                <Key>#{key}</Key>
+                <ETag>#{response['Etag']}</ETag>
+              </PostResponse>
+            eos
+          end
+
+        end
+      else
+        raise WEBrick::HTTPStatus::BadRequest
+      end
+
+      response['Content-Type']                  = 'text/xml'
+      response['Access-Control-Allow-Origin']   = '*'
+      response['Access-Control-Allow-Headers']  = 'Authorization, Content-Length'
+      response['Access-Control-Expose-Headers'] = 'ETag'
+    end
+
+    def do_DELETE(request, response)
+      s_req = normalize_request(request)
+
+      case s_req.type
+      when Request::DELETE_OBJECTS
+        bucket_obj = @store.get_bucket(s_req.bucket)
+        keys = XmlParser.delete_objects(s_req.webrick_request)
+        @store.delete_objects(bucket_obj,keys,s_req.webrick_request)
+      when Request::DELETE_OBJECT
+        bucket_obj = @store.get_bucket(s_req.bucket)
+        @store.delete_object(bucket_obj,s_req.object,s_req.webrick_request)
+      when Request::DELETE_BUCKET
+        @store.delete_bucket(s_req.bucket)
+      end
+
+      response.status = 204
+      response.body = ""
+    end
+
+    def do_OPTIONS(request, response)
+      super
+      response['Access-Control-Allow-Origin']   = '*'
+      response['Access-Control-Allow-Methods']  = 'PUT, POST, HEAD, GET, OPTIONS'
+      response['Access-Control-Allow-Headers']  = 'Accept, Content-Type, Authorization, Content-Length, ETag, X-CSRF-Token, Content-Disposition'
+      response['Access-Control-Expose-Headers'] = 'ETag'
+    end
+
+    private
+
+    def normalize_delete(webrick_req, s_req)
+      path = webrick_req.path
+      path_len = path.size
+      query = webrick_req.query
+      if path == "/" and s_req.is_path_style
+        # Probably do a 404 here
+      else
+        if s_req.is_path_style
+          elems = path[1,path_len].split("/")
+          s_req.bucket = elems[0]
+        else
+          elems = path.split("/")
+        end
+
+        if elems.size == 0
+          raise UnsupportedOperation
+        elsif elems.size == 1
+          s_req.type = webrick_req.query_string == 'delete' ? Request::DELETE_OBJECTS : Request::DELETE_BUCKET
+          s_req.query = query
+          s_req.webrick_request = webrick_req
+        else
+          s_req.type = Request::DELETE_OBJECT
+          object = elems[1,elems.size].join('/')
+          s_req.object = object
+        end
+      end
+    end
+
+    def normalize_get(webrick_req, s_req)
+      path = webrick_req.path
+      path_len = path.size
+      query = webrick_req.query
+      if path == "/" and s_req.is_path_style
+        s_req.type = Request::LIST_BUCKETS
+      else
+        if s_req.is_path_style
+          elems = path[1,path_len].split("/")
+          s_req.bucket = elems[0]
+        else
+          elems = path.split("/")
+        end
+
+        if elems.size < 2
+          s_req.type = Request::LS_BUCKET
+          s_req.query = query
+        else
+          if query["acl"] == ""
+            s_req.type = Request::GET_ACL
+          else
+            s_req.type = Request::GET
+          end
+          object = elems[1,elems.size].join('/')
+          s_req.object = object
+        end
+      end
+    end
+
+    def normalize_put(webrick_req, s_req)
+      path = webrick_req.path
+      path_len = path.size
+      if path == "/"
+        if s_req.bucket
+          s_req.type = Request::CREATE_BUCKET
+        end
+      else
+        if s_req.is_path_style
+          elems = path[1,path_len].split("/")
+          s_req.bucket = elems[0]
+          if elems.size == 1
+            s_req.type = Request::CREATE_BUCKET
+          else
+            if webrick_req.request_line =~ /\?acl/
+              s_req.type = Request::SET_ACL
+            else
+              s_req.type = Request::STORE
+            end
+            s_req.object = elems[1,elems.size].join('/')
+          end
+        else
+          if webrick_req.request_line =~ /\?acl/
+            s_req.type = Request::SET_ACL
+          else
+            s_req.type = Request::STORE
+          end
+          s_req.object = webrick_req.path[1..-1]
+        end
+      end
+
+      # TODO: also parse the x-amz-copy-source-range:bytes=first-last header
+      # for multipart copy
+      copy_source = webrick_req.header["x-amz-copy-source"]
+      if copy_source and copy_source.size == 1
+        src_elems   = copy_source.first.split("/")
+        root_offset = src_elems[0] == "" ? 1 : 0
+        s_req.src_bucket = src_elems[root_offset]
+        s_req.src_object = src_elems[1 + root_offset,src_elems.size].join("/")
+        s_req.type = Request::COPY
+      end
+
+      s_req.webrick_request = webrick_req
+    end
+
+    def normalize_post(webrick_req,s_req)
+      path = webrick_req.path
+      path_len = path.size
+
+      s_req.path = webrick_req.query['key']
+      s_req.webrick_request = webrick_req
+
+      if s_req.is_path_style
+        elems = path[1, path_len].split("/")
+        s_req.bucket = elems[0]
+        s_req.object = elems[1..-1].join('/') if elems.size >= 2
+      else
+        s_req.object = path[1..-1]
+      end
+    end
+
+    # This method takes a webrick request and generates a normalized FakeS3 request
+    def normalize_request(webrick_req)
+      host_header= webrick_req["Host"]
+      host = host_header.split(':')[0]
+
+      s_req = Request.new
+      s_req.path = webrick_req.path
+      s_req.is_path_style = true
+
+      if !@root_hostnames.include?(host) && !(IPAddr.new(host) rescue nil)
+        s_req.bucket = host.split(".")[0]
+        s_req.is_path_style = false
+      end
+
+      s_req.http_verb = webrick_req.request_method
+
+      case webrick_req.request_method
+      when 'PUT'
+        normalize_put(webrick_req,s_req)
+      when 'GET','HEAD'
+        normalize_get(webrick_req,s_req)
+      when 'DELETE'
+        normalize_delete(webrick_req,s_req)
+      when 'POST'
+        if webrick_req.query_string != 'delete'
+          normalize_post(webrick_req,s_req)
+        else
+          normalize_delete(webrick_req,s_req)
+        end
+      else
+        raise "Unknown Request"
+      end
+
+      validate_request(s_req)
+
+      return s_req
+    end
+
+    def parse_complete_multipart_upload(request)
+      parts_xml   = ""
+      request.body { |chunk| parts_xml << chunk }
+
+      # TODO: improve parsing xml
+      parts_xml = parts_xml.scan(/<Part>.*?<\/Part>/m)
+
+      parts_xml.collect do |xml|
+        {
+          number: xml[/<PartNumber>(\d+)<\/PartNumber>/, 1].to_i,
+          etag:   FakeS3::Util.strip_before_and_after(xml[/\<ETag\>(.+)<\/ETag>/, 1], '"')
+        }
+      end
+    end
+
+    def dump_request(request)
+      puts "----------Dump Request-------------"
+      puts request.request_method
+      puts request.path
+      request.each do |k,v|
+        puts "#{k}:#{v}"
+      end
+      puts "----------End Dump -------------"
+    end
+  end
+
+
+  class Server
+    def initialize(address, port, store, hostname, ssl_cert_path, ssl_key_path, extra_options={})
+      @address = address
+      @port = port
+      @store = store
+      @hostname = hostname
+      @ssl_cert_path = ssl_cert_path
+      @ssl_key_path = ssl_key_path
+      webrick_config = {
+        :BindAddress => @address,
+        :Port => @port
+      }
+      if !@ssl_cert_path.to_s.empty?
+        webrick_config.merge!(
+          {
+            :SSLEnable => true,
+            :SSLCertificate => OpenSSL::X509::Certificate.new(File.read(@ssl_cert_path)),
+            :SSLPrivateKey => OpenSSL::PKey::RSA.new(File.read(@ssl_key_path))
+          }
+        )
+      end
+
+      if extra_options[:quiet]
+        webrick_config.merge!(
+          :Logger => WEBrick::Log.new("/dev/null"),
+          :AccessLog => []
+        )
+      end
+
+      @server = WEBrick::HTTPServer.new(webrick_config)
+    end
+
+    def serve
+      @server.mount "/", Servlet, @store, @hostname
+      shutdown = proc { @server.shutdown }
+      trap "INT", &shutdown
+      trap "TERM", &shutdown
+      @server.start
+    end
+
+    def shutdown
+      @server.shutdown
+    end
+  end
+end