rubber 1.15.0 → 2.0.0.pre1

data/templates/unicorn/config/rubber/role/unicorn/unicorn.rb

@@ -0,0 +1,79 @@
+<%
+  @path = "#{Rubber.root}/config/unicorn.rb"
+%>
+worker_processes 2
+working_directory "<%= Rubber.root %>"
+
+# This loads the application in the master process before forking
+# worker processes
+# Read more about it here:
+# http://unicorn.bogomips.org/Unicorn/Configurator.html
+preload_app true
+
+timeout 30
+
+# This is where we specify the socket.
+# We will point the upstream Nginx module to this socket later on
+listen "/var/run/unicorn.sock", :backlog => 64
+
+pid "/var/run/unicorn.pid"
+
+# Set the path of the log files inside the log folder of the testapp
+stderr_path "<%= Rubber.root %>/log/unicorn.stderr.log"
+stdout_path "<%= Rubber.root %>/log/unicorn.stdout.log"
+
+before_fork do |server, worker|
+  ##
+  # When sent a USR2, Unicorn will suffix its pidfile with .oldbin and
+  # immediately start loading up a new version of itself (loaded with a new
+  # version of our app). When this new Unicorn is completely loaded
+  # it will begin spawning workers. The first worker spawned will check to
+  # see if an .oldbin pidfile exists. If so, this means we've just booted up
+  # a new Unicorn and need to tell the old one that it can now die. To do so
+  # we send it a QUIT.
+  #
+  # Using this method we get 0 downtime deploys.
+  old_pid = "/var/run/unicorn.pid.oldbin"
+  if File.exists?(old_pid) && server.pid != old_pid
+    begin
+      Process.kill("QUIT", File.read(old_pid).to_i)
+    rescue Errno::ENOENT, Errno::ESRCH
+      # someone else did our job for us
+    end
+  end
+  
+  # This option works in together with preload_app true setting
+  # What is does is prevent the master process from holding
+  # the database connection
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.connection.disconnect!
+end
+
+
+after_fork do |server, worker|
+  # Unicorn master is started as root, which is fine, but let's
+  # drop the workers to www-data:www-data
+  begin
+    uid, gid = Process.euid, Process.egid
+    user, group = '#{rubber_env.app_user}', '#{rubber_env.app_user}'
+    target_uid = Etc.getpwnam(user).uid
+    target_gid = Etc.getgrnam(group).gid
+    worker.tmp.chown(target_uid, target_gid)
+    if uid != target_uid || gid != target_gid
+      Process.initgroups(user, target_gid)
+      Process::GID.change_privilege(target_gid)
+      Process::UID.change_privilege(target_uid)
+    end
+  rescue => e
+    if RAILS_ENV == 'development'
+      STDERR.puts "couldn't change user, oh well"
+    else
+      raise e
+    end
+  end
+  
+  # Here we are establishing the connection after forking worker
+  # processes
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.establish_connection
+end

data/templates/unicorn/config/rubber/rubber-unicorn.yml

@@ -0,0 +1,5 @@
+role_dependencies:
+  unicorn: [nginx]
+roles:
+  unicorn:
+    gems: [unicorn]

data/templates/unicorn/templates.yml

@@ -0,0 +1,3 @@
+description: The unicorn rack http server module
+dependent_templates:
+  - nginx

data/test/cloud/aws_table_store_test.rb

@@ -0,0 +1,172 @@
+require File.expand_path(File.join(__FILE__, '../..', 'test_helper'))
+require 'rubber/cloud/aws_table_store'
+
+class AwsTableStoreTest < Test::Unit::TestCase
+
+  context "aws table store" do
+
+    setup do
+      @provider = ::Fog::AWS::SimpleDB.new(:aws_access_key_id => 'XXX',
+                                           :aws_secret_access_key => 'YYY')
+      @table = 'mytable'
+      @provider.create_domain(@table)
+      @table_store = Rubber::Cloud::AwsTableStore.new(@provider, @table)
+    end
+
+    should "require a table" do
+      
+      assert_raise do
+        Rubber::Cloud::AwsTableStore.new(@provider, nil)
+      end
+
+      assert_raise do
+        Rubber::Cloud::AwsTableStore.new(@provider, "")
+      end
+      
+      assert Rubber::Cloud::AwsTableStore.new(@provider, @table)
+    end
+    
+    context "ensure_table" do
+      
+      should "created table if not there" do
+        assert_raises { @provider.domain_metadata('sometable') }
+        @table_store = Rubber::Cloud::AwsTableStore.new(@provider, 'sometable')
+        assert @provider.domain_metadata('sometable')
+      end
+      
+      should "still work if table already exists" do
+        @provider.create_domain('sometable')
+        assert @provider.domain_metadata('sometable')
+        @table_store = Rubber::Cloud::AwsTableStore.new(@provider, 'sometable')
+        assert @provider.domain_metadata('sometable')
+      end
+      
+    end
+    
+    context 'encode and decode' do
+      
+      setup do
+        @data = [123, "foo", {'foo' => 'bar'}, ["foo", "bar"]]
+      end
+      
+      should 'roundtrip' do
+        @data.each do |d|
+          assert_equal d, @table_store.decode(@table_store.encode(d))
+        end
+      end
+
+      should 'decode_attributes' do
+        d = {'"foo"' => ['["bar"]']}  
+        assert_equal({'"foo"' => "bar"}, @table_store.decode_attributes(d))
+      end
+      
+    end
+    
+    context 'put' do
+      
+      should 'put data' do
+        @table_store.put('mykey', {'foo' => 'bar'})
+        assert_equal({'foo' => ['["bar"]']},
+                     @provider.get_attributes(@table, 'mykey',
+                                              'AttributeName' => ['foo']).body['Attributes'])
+      end
+      
+      should 'overwrite data' do
+        @table_store.put('mykey', {'foo' => 'bar'})
+        @table_store.put('mykey', {'foo' => 'baz'})
+        assert_equal({'foo' => ['["baz"]']},
+                     @provider.get_attributes(@table, 'mykey',
+                                              'AttributeName' => ['foo']).body['Attributes'])
+      end
+      
+    end
+    
+    context 'get' do
+      
+      should 'get data' do
+        @table_store.put('mykey', {'foo' => 'bar', 'baz' => 2})
+        assert_equal({'foo' => 'bar', 'baz' => 2}, @table_store.get('mykey'))
+        assert_equal({'foo' => 'bar', 'baz' => 2}, @table_store.get('mykey', ['foo', 'baz']))
+        assert_equal({'baz' => 2}, @table_store.get('mykey', ['baz']))
+      end
+      
+    end
+    
+    context 'delete' do
+      
+      should 'delete data' do
+        @table_store.put('mykey', {'foo' => 'bar', 'baz' => 2})
+        @table_store.delete('mykey')
+        assert_equal({}, @table_store.get('mykey'))
+      end
+      
+      should 'delete partial data' do
+        @table_store.put('mykey', {'foo' => 'bar', 'baz' => 2})
+        @table_store.delete('mykey', ['foo'])
+        assert_equal({'baz' => 2}, @table_store.get('mykey'))
+      end
+      
+    end
+    
+    # no fog mocks for select, so use mocha
+    context 'find' do
+      
+      should 'find all with no params' do
+        response = mock('fog response') do
+          expects(:body).twice().returns({'Items' => {}})
+        end
+        
+        @provider.expects(:select).with("select * from `#{@table}` limit 200", {}).returns(response)
+        assert_equal({}, @table_store.find())
+      end
+      
+      should 'find with key' do
+        response = mock('fog response') do
+          expects(:body).twice().returns({'Items' => {}})
+        end
+        
+        @provider.expects(:select).with("select * from `#{@table}` where ItemName = 'foo' limit 200", {}).returns(response)
+        assert_equal({}, @table_store.find('foo'))
+      end
+      
+      should 'find with attributes' do
+        response = mock('fog response') do
+          expects(:body).twice().returns({'Items' => {}})
+        end
+        
+        @provider.expects(:select).with("select foo, bar from `#{@table}` limit 200", {}).returns(response)
+        assert_equal({}, @table_store.find(nil, ['foo', 'bar']))
+      end
+      
+      should 'find with limit' do
+        response = mock('fog response') do
+          expects(:body).twice().returns({'Items' => {}})
+        end
+        
+        @provider.expects(:select).with("select * from `#{@table}` limit 5", {}).returns(response)
+        assert_equal({}, @table_store.find(nil, nil, :limit => 5))
+      end
+      
+      should 'find with offset' do
+        response = mock('fog response') do
+          expects(:body).twice().returns({'Items' => {}})
+        end
+        
+        @provider.expects(:select).with("select * from `#{@table}` limit 200", {'NextToken' => 'blah'}).returns(response)
+        assert_equal({}, @table_store.find(nil, nil, :offset => 'blah'))
+      end
+      
+      should 'add next_offset' do
+        response = mock('fog response') do
+          expects(:body).twice().returns({'Items' => {}, 'NextToken' => 'blah'})
+        end
+        
+        @provider.stubs(:select).returns(response)
+        resp = @table_store.find()
+        assert_equal 'blah', resp.next_offset
+      end
+      
+    end
+    
+  end
+end

data/test/cloud/aws_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.join(__FILE__, '../..', 'test_helper'))
+require 'rubber/cloud/aws'
+require 'ostruct'
+
+class AwsTest < Test::Unit::TestCase
+
+  context "aws" do
+
+    setup do
+      env = {'access_key' => "XXX", 'secret_access_key' => "YYY", 'region' => "us-east-1"}
+      env = Rubber::Configuration::Environment::BoundEnv.new(env, nil, nil)
+      @cloud = Rubber::Cloud::Aws.new(env, nil)
+    end
+
+    should "instantiate" do
+      assert @cloud.compute_provider
+      assert @cloud.storage_provider
+    end
+
+    should "provide storage" do
+      assert @cloud.storage('mybucket')
+    end
+
+    should "provide table store" do
+      assert @cloud.table_store('somekey')
+    end
+
+    should "create instance" do
+      assert @cloud.create_instance('', '', '', '')
+    end
+
+  end
+end

data/test/cloud/fog_storage_test.rb

@@ -0,0 +1,183 @@
+require File.expand_path(File.join(__FILE__, '../..', 'test_helper'))
+require 'rubber/cloud/fog_storage'
+require 'ostruct'
+
+class FogStorageTest < Test::Unit::TestCase
+
+  context "fog storage" do
+
+    setup do
+      @provider = Fog::Storage.new(:provider => 'AWS',
+                                   :aws_access_key_id => 'XXX',
+                                   :aws_secret_access_key => 'YYY')
+      @bucket = 'mybucket'
+      @provider.put_bucket(@bucket)
+      @storage = Rubber::Cloud::FogStorage.new(@provider, @bucket)
+    end
+
+    should "require a bucket" do
+      
+      assert_raise do
+        Rubber::Cloud::FogStorage.new(@provider, nil)
+      end
+
+      assert_raise do
+        Rubber::Cloud::FogStorage.new(@provider, "")
+      end
+      
+    end
+    
+    context "ensure_bucket" do
+      
+      should "created bucket if not there" do
+        assert @provider.directories.get('somebucket').nil?
+        @storage = Rubber::Cloud::FogStorage.new(@provider, 'somebucket')
+        @storage.ensure_bucket
+        assert @provider.directories.get('somebucket')
+      end
+      
+      should "still work if bucket already exists" do
+        assert @provider.directories.create(:key => 'somebucket')
+        assert @provider.directories.get('somebucket')
+        @storage = Rubber::Cloud::FogStorage.new(@provider, 'somebucket')
+        @storage.ensure_bucket
+        assert @provider.directories.get('somebucket')
+      end
+      
+    end
+    
+    context 'storing a file' do
+      
+      should 'require a key' do
+        assert_raise do
+          @storage.store(nil, "data")
+        end
+      end
+    
+      should "store a file path" do
+        @storage.store("filename", "data")
+    
+        assert_equal("data", @provider.get_object(@bucket, 'filename').body)
+      end
+    
+      should "singlepart files under 5 mb" do
+        @provider.expects(:initiate_multipart_upload).never
+        data = 'a' * (5 * 10**6 - 1)
+    
+        @storage.store('filename', data)
+    
+        assert_equal data, @provider.get_object(@bucket, 'filename').body
+      end
+    
+      should "multipart files over 5 mb" do
+        @storage.expects(:singlepart_store).never
+        data = 'a' * (5 * 10**6 + 1)
+    
+        #FIXME: Fog mock for initiate_multipart_upload isn't implemented. Remove mocks when it is
+        @provider.expects(:initiate_multipart_upload).returns(OpenStruct.new(:body => {'UploadId' => 'fake-upload-id'}))
+        @provider.expects(:upload_part).returns(OpenStruct.new(:headers => {'ETag' => 'fake-etag'}))
+        @provider.expects(:complete_multipart_upload)
+    
+        io = Tempfile.new('s3-helper-test')
+        io.unlink
+        io.write(data)
+        io.rewind
+    
+        @storage.store('filename', io)
+    
+        #FIXME: proper assertion when Fog mock supports multipart upload
+        #assert_equal data, @provider.get_object(@bucket, 'filename').body
+    
+      end
+      
+    end
+    
+    
+    context 'fetching a file' do
+      
+      should 'require a filename' do
+        assert_raise do
+          @storage.fetch(nil)
+        end
+      end
+        
+      should "fetch a file with a path" do
+        @provider.put_object(@bucket, 'path/filename', 'some data')
+    
+        assert_equal('some data', @storage.fetch("path/filename"))
+      end
+
+      should "return nil for non-existent file" do
+        assert_nil @storage.fetch("path/filename")
+      end
+
+    end
+
+    
+    context 'fetching many files' do
+      should "fetch files without a prefix" do
+        @provider.put_object(@bucket, 'path1/file1', 'some data1')
+        @provider.put_object(@bucket, 'path2/file2', 'some data2')
+    
+        files = []
+        @storage.walk_tree do |s3_file|
+          files << s3_file
+        end
+        assert_equal 2, files.size
+        assert_equal('path1/file1', files[0].key)
+        assert_equal('some data1', files[0].body)
+        assert_equal('path2/file2', files[1].key)
+        assert_equal('some data2', files[1].body)
+      end
+    
+      should "restrict fetched files to a prefix" do
+        @provider.put_object(@bucket, 'path1/file1', 'some data1')
+        @provider.put_object(@bucket, 'path2/file2', 'some data2')
+    
+        files = []
+        @storage.walk_tree('path1') do |s3_file|
+          files << s3_file
+        end
+        assert_equal 1, files.size
+        assert_equal('path1/file1', files[0].key)
+        assert_equal('some data1', files[0].body)
+      end
+    
+    end
+    
+    should "stream a file" do
+      yielded_value = nil
+      @provider.put_object(@bucket, 'path/filename', 'my chunk')
+      
+      @storage.fetch("path/filename", {}) { |chunk| yielded_value = chunk }
+    
+      assert_equal yielded_value, 'my chunk'
+    end
+    
+    should "stream a file for non-existent key" do
+      yielded_value = 'x'
+      
+      @storage.fetch("path/filename", {}) { |chunk| yielded_value = chunk }
+    
+      assert_equal 'x', yielded_value
+    end
+    
+    context 'deleting a file' do
+      should 'require a filename' do
+        assert_raise do
+          @storage.delete(nil)
+        end
+      end
+    
+      should 'delete a file' do
+        @provider.put_object(@bucket, 'path/filename', 'some data')
+        assert_equal 1, @provider.get_bucket(@bucket).body['Contents'].size
+        assert_equal 'path/filename', @provider.get_bucket(@bucket).body['Contents'].first['Key']
+    
+        @storage.delete('path/filename')
+        assert_equal 0, @provider.get_bucket(@bucket).body['Contents'].size
+      end
+    end
+  
+  end
+end