fakes3 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in fakes3.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    fakes3 (0.1.0)
+      builder
+      thor
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    aws-s3 (0.6.2)
+      builder
+      mime-types
+      xml-simple
+    builder (2.1.2)
+    mime-types (1.16)
+    right_aws (2.0.0)
+      right_http_connection (>= 1.2.1)
+    right_http_connection (1.2.4)
+    thor (0.14.4)
+    xml-simple (1.0.12)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  aws-s3
+  builder
+  bundler (>= 1.0.0)
+  fakes3!
+  right_aws
+  thor

data/README.md

@@ -0,0 +1,39 @@
+## Introduction
+FakeS3 is a lightweight server that responds to the same calls Amazon S3 responds to.  
+It is extremely useful for testing of S3 in a sandbox environment without actually
+making calls to Amazon, which not only require network, but also cost you precious dollars.  
+
+For now there is a basic file store backend.
+
+FakeS3 doesn't support all of the S3 command set, but the basic ones like put, get,
+list, copy, and make bucket are supported.  More coming soon.
+
+## Installation
+    gem install fakes3
+
+## Running
+To run a fakes3 server, you just specify a root and a port.
+
+    fakes3 -r /mnt/fakes3_root -p 4567
+
+## Connecting to FakeS3
+
+Take a look at the test cases to see client example usage.  For now, FakeS3 is
+mainly tested with s3cmd, aws-s3 gem, and right_aws.  There are plenty more
+libraries out there, and please do mention other clients.
+
+## Running Tests
+In order to run the tests add the following line to your /etc/hosts:
+
+    127.0.0.1 s3.localhost
+
+Then start the test server using
+
+    rake test_server
+
+
+Then in another terminal window run
+
+    rake test
+
+It is a TODO to get this to be just one command

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler'
+require 'rake/testtask'
+include Rake::DSL
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.ruby_opts = ['-rubygems'] if defined? Gem
+  t.ruby_opts << '-I.'
+end
+
+task :test_server do |t|
+  system("bundle exec bin/fakes3 --port 10453 --root test_root")
+end

data/bin/fakes3

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'fakes3/cli'
+FakeS3::CLI.start

data/fakes3.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "fakes3/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fakes3"
+  s.version     = FakeS3::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Curtis Spencer"]
+  s.email       = ["thorin@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{FakeS3 is a server that simulates S3 commands so you can test your S3 functionality in your projects}
+  s.description = %q{Use FakeS3 to test basic S3 functionality without actually connecting to S3}
+
+  s.rubyforge_project = "fakes3"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "aws-s3"
+  s.add_development_dependency "right_aws"
+  #s.add_development_dependency "aws-sdk"
+  #s.add_development_dependency "ruby-debug19"
+  s.add_dependency "thor"
+  s.add_dependency "builder"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/fakes3.rb

@@ -0,0 +1,3 @@
+require 'fakes3/version'
+require 'fakes3/file_store'
+require 'fakes3/server'

data/lib/fakes3/bucket.rb

@@ -0,0 +1,18 @@
+require 'builder'
+require 'fakes3/s3_object'
+
+module FakeS3
+  class Bucket
+    attr_accessor :name,:creation_date,:objects
+
+    def initialize(name,creation_date,objects)
+      @name = name
+      @creation_date = creation_date
+      @objects = []
+      objects.each do |obj|
+        @objects << obj
+      end
+    end
+
+  end
+end

data/lib/fakes3/cli.rb

@@ -0,0 +1,59 @@
+require 'thor'
+require 'fakes3/server'
+require 'fakes3/version'
+
+module FakeS3
+  class CLI < Thor
+    default_task("server")
+
+    desc "server", "Run a server on a particular hostname"
+    method_option :root, :type => :string, :aliases => '-r', :required => true
+    method_option :port, :type => :numeric, :aliases => '-p', :required => true
+    method_option :hostname, :type => :string, :aliases => '-h', :desc => "The root name of the host.  Defaults to s3.amazonaws.com."
+    method_option :limit, :aliases => '-l', :type => :string, :desc => 'Rate limit for serving (ie. 50K, 1.0M)'
+    def server
+      store = nil
+      if options[:root]
+        root = File.expand_path(options[:root])
+        store = FileStore.new(root)
+      end
+
+      if store.nil?
+        puts "You must specify a root to use a file store (the current default)"
+        exit(-1)
+      end
+
+      hostname = 's3.amazonaws.com'
+      if options[:hostname]
+        hostname = options[:hostname]
+        # In case the user has put a port on the hostname
+        if hostname =~ /:(\d+)/
+          hostname = hostname.split(":")[0]
+        end
+      end
+
+      if options[:limit]
+        begin
+          store.rate_limit = options[:limit]
+        rescue
+          puts $!.message
+          exit(-1)
+        end
+      end
+
+      puts "Loading FakeS3 with #{root} on port #{options[:port]} with hostname #{hostname}"
+      server = FakeS3::Server.new(options[:port],store,hostname)
+      server.serve
+    end
+
+    desc "version", "Report the current fakes3 version"
+    def version
+      puts <<"EOF"
+======================
+FakeS3 #{FakeS3::VERSION}
+
+Copyright 2012, Curtis Spencer (@jubos)
+EOF
+    end
+  end
+end

data/lib/fakes3/file_store.rb

@@ -0,0 +1,153 @@
+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
+    SHUCK_METADATA_DIR = ".fakes3_metadataFFF"
+
+    def initialize(root)
+      @root = root
+      @buckets = []
+      @bucket_hash = {}
+      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(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
+    end
+
+    def get_object(bucket,object, request)
+      begin
+        real_obj = S3Object.new
+        obj_root = File.join(@root,bucket,object,SHUCK_METADATA_DIR)
+        metadata = YAML.parse(File.open(File.join(obj_root,"metadata"),'rb').read)
+        real_obj.name = object
+        real_obj.md5 = metadata[:md5].value
+        real_obj.content_type = metadata[:content_type] ? metadata[:content_type].value : "application/octet-stream"
+        #real_obj.io = File.open(File.join(obj_root,"content"),'rb')
+        real_obj.io = RateLimitableFile.open(File.join(obj_root,"content"),'rb')
+        return real_obj
+      rescue
+        puts $!
+        return nil
+      end
+    end
+
+    def object_metadata(bucket,object)
+    end
+
+    def copy_object(src_bucket,src_object,dst_bucket,dst_object)
+      src_root = File.join(@root,src_bucket,src_object,SHUCK_METADATA_DIR)
+      src_obj = S3Object.new
+      src_metadata_filename = File.join(src_root,"metadata")
+      src_metadata = YAML.parse(File.open(src_metadata_filename,'rb').read)
+      src_content_filename = File.join(src_root,"content")
+
+      dst_filename= File.join(@root,dst_bucket,dst_object)
+      FileUtils.mkdir_p(dst_filename)
+
+      metadata_dir = File.join(dst_filename,SHUCK_METADATA_DIR)
+      FileUtils.mkdir_p(metadata_dir)
+
+      content = File.join(metadata_dir,"content")
+      metadata = File.join(metadata_dir,"metadata")
+
+      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
+
+      obj = S3Object.new
+      obj.md5 = src_metadata[:md5]
+      obj.content_type = src_metadata[:content_type]
+      return obj
+    end
+
+    def store_object(bucket,object,request)
+      begin
+        filename = File.join(@root,bucket,object)
+        FileUtils.mkdir_p(filename)
+
+        metadata_dir = File.join(filename,SHUCK_METADATA_DIR)
+        FileUtils.mkdir_p(metadata_dir)
+
+        content = File.join(filename,SHUCK_METADATA_DIR,"content")
+        metadata = File.join(filename,SHUCK_METADATA_DIR,"metadata")
+
+        md5 = Digest::MD5.new
+
+        File.open(content,'wb') do |f|
+          request.body do |chunk|
+            f << chunk
+            md5 << chunk
+          end
+        end
+
+        metadata_struct = {}
+        metadata_struct[:md5] = md5.hexdigest
+        metadata_struct[:content_type] = request.header["content-type"].first
+
+        File.open(metadata,'w') do |f|
+          f << YAML::dump(metadata_struct)
+        end
+        obj = S3Object.new
+        obj.md5 = metadata_struct[:md5]
+        obj.content_type = metadata_struct[:content_type]
+        return obj
+      rescue
+        puts $!
+        $!.backtrace.each { |line| puts line }
+        return nil
+      end
+    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,5 @@
+module FakeS3
+  class S3Object
+    attr_accessor :name,:size,:creation_date,:md5,:io,:content_type
+  end
+end

data/lib/fakes3/server.rb

@@ -0,0 +1,264 @@
+require 'webrick'
+require 'fakes3/file_store'
+require 'fakes3/xml_adapter'
+
+module FakeS3
+  class Request
+    CREATE_BUCKET = "CREATE_BUCKET"
+    LIST_BUCKETS = "LIST_BUCKETS"
+    LS_BUCKET = "LS_BUCKET"
+    STORE = "STORE"
+    COPY = "COPY"
+    GET = "GET"
+    GET_ACL = "GET_ACL"
+    SET_ACL = "SET_ACL"
+    MOVE = "MOVE"
+    DELETE = "DELETE"
+
+    attr_accessor :bucket,:object,:type,:src_bucket,:src_object,:method,:webrick_request,:path,:is_path_style
+
+    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 "-----Done"
+    end
+  end
+
+  class Servlet < WEBrick::HTTPServlet::AbstractServlet
+    def initialize(server,store,hostname)
+      super(server)
+      @store = store
+      @hostname = hostname
+      @root_hostnames = [hostname,'localhost','s3.amazonaws.com','s3.localhost']
+    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.body = XmlAdapter.bucket(bucket_obj)
+          response['Content-Type'] = "application/xml"
+        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 = ""
+          return
+        end
+
+        response.status = 200
+        response['Content-Type'] = real_obj.content_type
+        content_length = File::Stat.new(real_obj.io.path).size
+        response['Etag'] = real_obj.md5
+        response['Accept-Ranges'] = "bytes"
+
+        # Added Range Query support
+        if range = request.header["range"].first
+          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.body = real_obj.io
+      end
+    end
+
+    def do_PUT(request,response)
+      s_req = normalize_request(request)
+
+
+      case s_req.type
+      when Request::COPY
+        @store.copy_object(s_req.src_bucket,s_req.src_object,s_req.bucket,s_req.object)
+      when Request::STORE
+        real_obj = @store.store_object(s_req.bucket,s_req.object,s_req.webrick_request)
+        response['Etag'] = real_obj.md5
+      when Request::CREATE_BUCKET
+        @store.create_bucket(s_req.bucket)
+      end
+
+      response.status = 200
+      response.body = ""
+      response['Content-Type'] = "text/xml"
+    end
+
+    def do_POST(request,response)
+      p request
+    end
+
+    def do_DELETE(request,response)
+      p request
+    end
+
+    private
+
+    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 == 0
+          # List buckets
+          s_req.type = Request::LIST_BUCKETS
+        elsif elems.size == 1
+          s_req.type = Request::LS_BUCKET
+        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
+        end
+      end
+
+      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
+
+    # 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)
+        s_req.bucket = host.split(".")[0]
+        s_req.is_path_style = false
+      end
+
+      case webrick_req.request_method
+      when 'PUT'
+        normalize_put(webrick_req,s_req)
+      when 'GET'
+        normalize_get(webrick_req,s_req)
+      else
+        raise "Unknown Request"
+      end
+
+      return s_req
+    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(port,store,hostname)
+      @port = port
+      @store = store
+      @hostname = hostname
+    end
+
+    def serve
+      @server = WEBrick::HTTPServer.new(:Port => @port)
+      @server.mount "/", Servlet, @store,@hostname
+      trap "INT" do @server.shutdown end
+      @server.start
+    end
+
+    def shutdown
+      @server.shutdown
+    end
+  end
+end

data/lib/fakes3/version.rb

@@ -0,0 +1,3 @@
+module FakeS3
+  VERSION = "0.1.0"
+end

data/lib/fakes3/xml_adapter.rb

@@ -0,0 +1,98 @@
+require 'builder'
+require 'time'
+
+module FakeS3
+  class XmlAdapter
+    def self.buckets(bucket_objects)
+      output = ""
+      xml = Builder::XmlMarkup.new(:target => output)
+      xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+      xml.ListAllMyBucketsResult(:xmlns => "http://s3.amazonaws.com/doc/2006-03-01/") { |lam|
+        lam.Owner { |owner|
+          owner.ID("123")
+          owner.DisplayName("FakeS3")
+        }
+        lam.Buckets { |buckets|
+          bucket_objects.each do |bucket|
+            buckets.Bucket do |b|
+              b.Name(bucket.name)
+              b.CreationDate(bucket.creation_date.strftime("%Y-%m-%dT%H:%M:%S.000Z"))
+            end
+          end
+        }
+      }
+      output
+    end
+
+    # <?xml version="1.0" encoding="UTF-8"?>
+    #<Error>
+    #  <Code>NoSuchKey</Code>
+    #  <Message>The resource you requested does not exist</Message>
+    #  <Resource>/mybucket/myfoto.jpg</Resource> 
+    #  <RequestId>4442587FB7D0A2F9</RequestId>
+    #</Error> 
+    def self.error_no_such_bucket(name)
+      output = ""
+      xml = Builder::XmlMarkup.new(:target => output)
+      xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+      xml.Error { |err|
+        err.Code("NoSuchBucket")
+        err.Message("The resource you requested does not exist")
+        err.Resource(name)
+        err.RequestId(1)
+      }
+      output
+    end
+
+    def self.error_no_such_key(name)
+      output = ""
+      xml = Builder::XmlMarkup.new(:target => output)
+      xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+      xml.Error { |err|
+        err.Code("NoSuchKey")
+        err.Message("The specified key does not exist")
+        err.Key(name)
+        err.RequestId(1)
+        err.HostId(2)
+      }
+      output
+    end
+
+    def self.bucket(bucket)
+      output = ""
+      xml = Builder::XmlMarkup.new(:target => output)
+      xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+      xml.ListBucketResult(:xmlns => "http://s3.amazonaws.com/doc/2006-03-01/") { |lbr|
+        lbr.Name(bucket.name)
+        lbr.Prefix
+        lbr.Marker
+        lbr.MaxKeys("1000")
+        lbr.IsTruncated("false")
+      }
+      output
+    end
+
+    # ACL xml
+    def self.acl(object = nil)
+      output = ""
+      xml = Builder::XmlMarkup.new(:target => output)
+      xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+      xml.AccessControlPolicy(:xmlns => "http://s3.amazonaws.com/doc/2006-03-01/") { |acp|
+        acp.Owner do |owner|
+          owner.ID("abc")
+          owner.DisplayName("You")
+        end
+        acp.AccessControlList do |acl|
+          acl.Grant do |grant|
+            grant.Grantee("xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance", "xsi:type" => "CanonicalUser") do |grantee|
+              grantee.ID("abc")
+              grantee.DisplayName("You")
+            end
+            grant.Permission("FULL_CONTROL")
+          end
+        end
+      }
+      output
+    end
+  end
+end

data/test/local_s3_cfg

@@ -0,0 +1,34 @@
+[default]
+access_key = abc
+acl_public = False
+bucket_location = US
+cloudfront_host = cloudfront.amazonaws.com
+cloudfront_resource = /2008-06-30/distribution
+default_mime_type = binary/octet-stream
+delete_removed = False
+dry_run = False
+encoding = UTF-8
+encrypt = False
+force = False
+get_continue = False
+gpg_command = None
+gpg_decrypt = %(gpg_command)s -d --verbose --no-use-agent --batch --yes --passphrase-fd %(passphrase_fd)s -o %(output_file)s %(input_file)s
+gpg_encrypt = %(gpg_command)s -c --verbose --no-use-agent --batch --yes --passphrase-fd %(passphrase_fd)s -o %(output_file)s %(input_file)s
+gpg_passphrase = 
+guess_mime_type = True
+host_base = localhost:10453
+host_bucket = %(bucket)s.localhost:10453
+human_readable_sizes = False
+list_md5 = False
+preserve_attrs = True
+progress_meter = True
+proxy_host = 
+proxy_port = 0
+recursive = False
+recv_chunk = 4096
+secret_key = def
+send_chunk = 4096
+simpledb_host = sdb.amazonaws.com
+skip_existing = False
+use_https = False
+verbosity = WARNING

data/test/right_aws_commands_test.rb

@@ -0,0 +1,63 @@
+require 'test/test_helper'
+require 'fileutils'
+require 'fakes3/server'
+require 'right_aws'
+
+class RightAWSCommandsTest < Test::Unit::TestCase
+
+  def setup
+    @s3 = RightAws::S3Interface.new('1E3GDYEOGFJPIT7XXXXXX','hgTHt68JY07JKUY08ftHYtERkjgtfERn57XXXXXX',
+                                    {:multi_thread => false, :server => 'localhost',
+                                      :port => 10453, :protocol => 'http',:logger => Logger.new("/dev/null") })
+  end
+
+  def teardown
+  end
+
+  def test_create_bucket
+    bucket = @s3.create_bucket("s3media")
+    assert_not_nil bucket
+  end
+
+  def test_store
+    @s3.put("s3media","helloworld","Hello World Man!")
+    obj = @s3.get("s3media","helloworld")
+    assert_equal "Hello World Man!",obj[:object]
+
+    obj = @s3.get("s3media","helloworld", )
+  end
+
+  def test_large_store
+    @s3.put("s3media","helloworld","Hello World Man!")
+    buffer = ""
+    500000.times do
+      buffer << "#{(rand * 100).to_i}"
+    end
+
+    buf_len = buffer.length
+    @s3.put("s3media","big",buffer)
+
+    output = ""
+    @s3.get("s3media","big") do |chunk|
+      output << chunk
+    end
+    assert_equal buf_len,output.size
+  end
+
+  def test_multi_directory
+    @s3.put("s3media","dir/right/123.txt","recursive")
+    output = ""
+    obj = @s3.get("s3media","dir/right/123.txt") do |chunk|
+      output << chunk
+    end
+    assert_equal "recursive", output
+  end
+
+  def test_intra_bucket_copy
+    @s3.put("s3media","original.txt","Hello World")
+    @s3.copy("s3media","original.txt","s3media","copy.txt")
+    obj = @s3.get("s3media","copy.txt")
+    assert_equal "Hello World",obj[:object]
+  end
+
+end

data/test/s3_commands_test.rb

@@ -0,0 +1,69 @@
+require 'test/test_helper'
+require 'fileutils'
+require 'fakes3/server'
+require 'aws/s3'
+
+class S3CommandsTest < Test::Unit::TestCase
+  include AWS::S3
+
+  def setup
+    AWS::S3::Base.establish_connection!(:access_key_id => "123", :secret_access_key => "abc", :server => "localhost", :port => "10453" )
+  end
+
+  def teardown
+    AWS::S3::Base.disconnect!
+  end
+
+  def test_create_bucket
+    bucket = Bucket.create("mybucket")
+    assert_not_nil bucket
+  end
+
+  def test_store
+    bucket = Bucket.create("mybucket")
+    S3Object.store("hello","world","mybucket")
+
+    output = ""
+    obj = S3Object.stream("hello","mybucket") do |chunk|
+      output << chunk
+    end
+    assert_equal "world", output
+  end
+
+  def test_large_store
+    bucket = Bucket.create("mybucket")
+    buffer = ""
+    500000.times do
+      buffer << "#{(rand * 100).to_i}"
+    end
+
+    buf_len = buffer.length
+    S3Object.store("big",buffer,"mybucket")
+
+    output = ""
+    S3Object.stream("big","mybucket") do |chunk|
+      output << chunk
+    end
+    assert_equal buf_len,output.size
+  end
+
+  def test_multi_directory
+    bucket = Bucket.create("mybucket")
+    S3Object.store("dir/myfile/123.txt","recursive","mybucket")
+
+    output = ""
+    obj = S3Object.stream("dir/myfile/123.txt","mybucket") do |chunk|
+      output << chunk
+    end
+    assert_equal "recursive", output
+  end
+
+  def test_find_nil_bucket
+    begin
+      bucket = Bucket.find("unknown")
+      assert_fail "Bucket.find didn't throw an exception"
+    rescue
+      assert_equal AWS::S3::NoSuchBucket,$!.class
+    end
+  end
+end

data/test/s3cmd_test.rb

@@ -0,0 +1,55 @@
+require 'test/test_helper'
+require 'fileutils'
+require 'fakes3/server'
+
+# You need to have s3cmd installed to use this
+class S3CmdTest < Test::Unit::TestCase
+
+  def setup
+    config = File.expand_path(File.join(File.dirname(__FILE__),'local_s3_cfg'))
+    @s3cmd = "s3cmd --config #{config}"
+  end
+
+  def teardown
+  end
+
+  def test_create_bucket
+    `#{@s3cmd} mb s3://s3cmd_bucket`
+    output = `#{@s3cmd} ls`
+    assert_match(/s3cmd_bucket/,output)
+  end
+
+  def test_store
+    File.open(__FILE__,'rb') do |input|
+      File.open("/tmp/fakes3_upload",'wb') do |output|
+        output << input.read
+      end
+    end
+    output = `#{@s3cmd} put /tmp/fakes3_upload s3://s3cmd_bucket/upload`
+    assert_match(/stored/,output)
+
+    FileUtils.rm("/tmp/fakes3_upload")
+  end
+
+  def test_acl
+    File.open(__FILE__,'rb') do |input|
+      File.open("/tmp/fakes3_acl_upload",'wb') do |output|
+        output << input.read
+      end
+    end
+    output = `#{@s3cmd} put /tmp/fakes3_acl_upload s3://s3cmd_bucket/acl_upload`
+    assert_match(/stored/,output)
+
+    output = `#{@s3cmd} --force setacl -P s3://s3cmd_bucket/acl_upload`
+  end
+
+  def test_large_store
+  end
+
+  def test_multi_directory
+  end
+
+  def test_intra_bucket_copy
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+require 'bundler/setup'
+
+testdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift testdir unless $LOAD_PATH.include?(testdir)
+
+libdir = File.dirname(File.dirname(__FILE__)) + '/lib'
+$LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification 
+name: fakes3
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Curtis Spencer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-13 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: aws-s3
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: right_aws
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+description: Use FakeS3 to test basic S3 functionality without actually connecting to S3
+email: 
+- thorin@gmail.com
+executables: 
+- fakes3
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/fakes3
+- fakes3.gemspec
+- lib/fakes3.rb
+- lib/fakes3/bucket.rb
+- lib/fakes3/cli.rb
+- lib/fakes3/file_store.rb
+- lib/fakes3/rate_limitable_file.rb
+- lib/fakes3/s3_object.rb
+- lib/fakes3/server.rb
+- lib/fakes3/version.rb
+- lib/fakes3/xml_adapter.rb
+- test/local_s3_cfg
+- test/right_aws_commands_test.rb
+- test/s3_commands_test.rb
+- test/s3cmd_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: fakes3
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: FakeS3 is a server that simulates S3 commands so you can test your S3 functionality in your projects
+test_files: 
+- test/local_s3_cfg
+- test/right_aws_commands_test.rb
+- test/s3_commands_test.rb
+- test/s3cmd_test.rb
+- test/test_helper.rb