heirloom 0.2.0 → 0.3.0.rc1

data/lib/heirloom/cli.rb

@@ -1,5 +1,6 @@
 require 'trollop'
 
+require 'heirloom/cli/authorize'
 require 'heirloom/cli/build'
 require 'heirloom/cli/list'
 require 'heirloom/cli/show'
@@ -7,6 +8,8 @@ require 'heirloom/cli/update'
 require 'heirloom/cli/download'
 require 'heirloom/cli/destroy'
 
+require 'heirloom/cli/shared'
+
 module Heirloom
   module CLI
     def self.start
@@ -19,15 +22,19 @@ module Heirloom
         CLI::Show.new.show
       when 'build'
         CLI::Build.new.build
+      when 'authorize'
+        CLI::Authorize.new.authorize
       when 'update'
         CLI::Update.new.update
       when 'download'
         CLI::Download.new.download
       when 'destroy', 'delete'
         CLI::Destroy.new.destroy
+      when '-v'
+        puts Heirloom::VERSION
       else
-        puts "Unkown command: '#{cmd}'."
-        puts "heirloom [list|show|build|update|download|destroy] OPTIONS"
+        puts "Unkown command: '#{cmd}'." unless cmd == '-h'
+        puts "heirloom [list|show|build|authorize|update|download|destroy] OPTIONS"
         puts "Append -h for help on specific command."
       end
     end

data/lib/heirloom/config.rb

@@ -1,9 +1,7 @@
 module Heirloom
   class Config
 
-    attr_accessor :access_key, :secret_key, :regions, 
-                  :primary_region, :bucket_prefix, :authorized_aws_accounts,
-                  :logger, :simpledb
+    attr_accessor :access_key, :secret_key, :primary_region, :logger
 
     def initialize(args = {})
       @config = args[:config]
@@ -13,17 +11,13 @@ module Heirloom
 
     def load_config_file
       config_file = "#{ENV['HOME']}/.heirloom.yml"
-      c = @config ? @config : YAML::load( File.open( config_file ) )
+      config = @config ? @config : YAML::load(File.open(config_file))
 
-      aws = c['aws']
+      aws = config['aws']
 
       self.access_key = aws['access_key']
       self.secret_key = aws['secret_key']
-      self.regions = aws['regions']
-      self.bucket_prefix = aws['bucket_prefix']
-      self.authorized_aws_accounts = aws['authorized_aws_accounts']
-      self.simpledb = aws['simpledb'] ||= true
-      self.primary_region = regions ? regions.first : 'us-west-1'
+      self.primary_region = aws['primary_region'] ||= 'us-west-1'
     end
 
   end

data/lib/heirloom/directory/git_directory.rb

@@ -13,8 +13,8 @@ module Heirloom
     end
 
     def commit(sha = nil)
-      r = Repo.new path
-      sha ? r.commits(sha).first : r.commits.first
+      repo = Repo.new path
+      sha ? repo.commits(sha).first : repo.commits.first
     end
 
   end

data/lib/heirloom/logger.rb

@@ -1,44 +1,32 @@
 module Heirloom
   class HeirloomLogger
     
-    def initialize(args = {})
-      @logger = args[:logger] ||= Logger.new(STDOUT)
-      @log_level = args[:log_level] ||= 'info'
+    require 'forwardable'
 
-      unless args[:logger]
-        @logger.datetime_format = "%Y-%m-%d %H:%M:%S"
-        @logger.formatter = proc do |severity, datetime, progname, msg|
-            "#{datetime}: #{msg}\n"
-        end
-      end
+    extend Forwardable
 
-      case @log_level.downcase
-      when 'info'
-        @logger.level = Logger::INFO
-      when 'debug'
-        @logger.level = Logger::DEBUG
-      when 'warn'
-        @logger.level = Logger::WARN
-      when 'error'
-        @logger.level = Logger::ERROR
-      end
-      @logger
-    end
+    def_delegators :@logger, :debug, :error, :info, :warn
 
-    def debug(msg)
-      @logger.debug msg
+    def initialize(args = {})
+      @log_level = args[:log_level] ||= 'info'
+      @logger    = args[:logger] ||= new_logger(args)
     end
 
-    def info(msg)
-      @logger.info msg
-    end
+    private
 
-    def error(msg)
-      @logger.error msg
+    def new_logger(args)
+      Logger.new(STDOUT).tap do |l|
+        l.datetime_format = '%Y-%m-%dT%H:%M:%S%z'
+        l.formatter = proc do |severity, datetime, progname, msg|
+          "#{datetime} #{severity} : #{msg}\n"
+        end
+        l.level = logger_level
+      end
     end
 
-    def info(msg)
-      @logger.info msg
+    def logger_level
+      Logger.const_get @log_level.upcase
     end
+
   end
 end

data/lib/heirloom/version.rb

@@ -1,3 +1,3 @@
 module Heirloom
-  VERSION = "0.2.0"
+  VERSION = "0.3.0.rc1"
 end

data/script/ci_setup

@@ -2,13 +2,13 @@
 
 # Source RVM profile and set ruby / gemset
 . /etc/profile
-rvm use "1.9.3-p125@heirloom" --create
+
+# Exit with error if any command returns non zero
+set -e
 
 # Bundle gems
+rvm use "1.9.3-p125@heirloom" --create
 bundle
 
-# Create blank deployment config
-touch $HOME/.heirloom.yml
-
 # Run spec tests
 rspec spec

data/spec/acl/s3_spec.rb

@@ -5,8 +5,6 @@ describe Heirloom do
     @config_mock = double 'config'
     @logger_mock = double 'logger'
     @config_mock.should_receive(:logger).and_return(@logger_mock)
-    @config_mock.should_receive(:authorized_aws_accounts).
-                 and_return ['acct1@test.com', 'acct2@test.com']
 
     @s3 = Heirloom::ACL::S3.new :config  => @config_mock,
                                 :region  => 'us-west-1'
@@ -37,7 +35,8 @@ describe Heirloom do
 
     @s3.allow_read_access_from_accounts :bucket     => 'bucket', 
                                         :key_name   => 'key',
-                                        :key_folder => 'key-folder'
+                                        :key_folder => 'key-folder',
+                                        :accounts   => ['acct1@test.com', 'acct2@test.com']
   end
 
 end

data/spec/{heirloom → archive}/authorizer_spec.rb

@@ -11,12 +11,10 @@ describe Heirloom do
                                              :id     => '123'
     end
 
-    it "should authorize access to an acl across all regions" do
+    it "should authorize access to an archive in all regions" do
       reader = double
       s3_acl = double
       @logger_mock.should_receive(:info).exactly(2).times
-      @config_mock.should_receive(:regions).
-                   and_return(['us-west-1', 'us-west-2'])
       @authorizer.should_receive(:reader).exactly(2).times.
                   and_return(reader)
       reader.should_receive(:get_bucket).exactly(2).times.
@@ -27,8 +25,10 @@ describe Heirloom do
              exactly(2).times.
              with(:key_name   => '123',
                   :key_folder => 'tim',
-                  :bucket     => 'the-bucket')
-      @authorizer.authorize
+                  :bucket     => 'the-bucket',
+                  :accounts   => ["acct1", "acct2"])
+      @authorizer.authorize :accounts => ['acct1', 'acct2'],
+                            :regions  => ['us-west-1', 'us-west-2']
     end
 
 end

data/spec/{heirloom → archive}/destroyer_spec.rb

@@ -14,7 +14,6 @@ describe Heirloom do
     it "should destroy the given archive" do
       @logger_mock.should_receive(:info).
                    with "Destroying tim - 123"
-      @config_mock.should_receive(:regions).and_return ['us-west-1']
       reader_mock = mock 'archive reader'
       @destroyer.should_receive(:reader).and_return reader_mock
       bucket_mock = mock 'bucket'
@@ -39,7 +38,7 @@ describe Heirloom do
       sdb_mock.should_receive(:delete).with 'tim', '123'
       @logger_mock.should_receive(:info).
                    with "Destroy complete."
-      @destroyer.destroy
+      @destroyer.destroy :regions => ['us-west-1']
     end
 
 end

data/spec/{heirloom → archive}/reader_spec.rb

@@ -16,7 +16,7 @@ describe Heirloom do
   it "should show the item record" do
     @sdb_mock.should_receive(:select).
              with("select * from tim where itemName() = '123'").
-             and_return( { '123' => { 'value' => 'details' } } )
+             and_return( { '123' => { 'value' => [ 'details' ] } } )
     @reader.show.should == { 'value' => 'details' }
   end
 
@@ -30,7 +30,7 @@ describe Heirloom do
   it "should return true if the record exists" do
     @sdb_mock.should_receive(:select).
               with("select * from tim where itemName() = '123'").
-              and_return( { '123' => { 'value' => 'details' } } )
+              and_return( { '123' => { 'value' => [ 'details' ] } } )
     @logger_mock.should_receive(:debug).exactly(1).times
     @reader.exists?.should == true
   end
@@ -50,10 +50,10 @@ describe Heirloom do
               with("select * from tim where itemName() = '123'").
               and_return( { '123' => 
                             { 'us-west-1-s3-url' => 
-                              ['s3://the-url/the-buck/the-key'] 
+                              [ 's3://the-bucket/the-buck/the-key' ]  
                             }
                           } )
-    @reader.get_bucket(:region => 'us-west-1').should == 'the-url'
+    @reader.get_bucket(:region => 'us-west-1').should == 'the-bucket'
   end
 
   it "should return nil if the bucket does not exist" do
@@ -87,4 +87,20 @@ describe Heirloom do
     @reader.get_key(:region => 'us-west-1').should == nil
   end
 
+  it "should return the regions the archive has been uploaded to" do
+    @sdb_mock.should_receive(:select).
+              exactly(1).times.
+              with("select * from tim where itemName() = '123'").
+              and_return( { '123' => 
+                            { 'us-west-1-s3-url' => 
+                              ['s3://the-url-us-west-1/the-bucket/the-key'],
+                              'build_by' => 
+                              ['user'], 
+                              'us-east-1-s3-url' => 
+                              ['s3://the-url-us-east-1/the-bucket/the-key'] 
+                            }
+                          } )
+    @reader.regions.should == ['us-west-1', 'us-east-1']
+  end
+
 end

data/spec/archive/updater_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Heirloom do
+
+  before do
+    @config_mock = double 'config'
+    @logger_mock = double 'logger'
+    @config_mock.should_receive(:logger).and_return(@logger_mock)
+    @updater = Heirloom::Updater.new :config => @config_mock,
+                                     :name   => 'tim',
+                                     :id     => '123'
+  end
+
+  it "should test an attribute is updated" do
+    sdb_mock = mock 'sdb mock'
+    @logger_mock.should_receive(:info)
+    Heirloom::AWS::SimpleDB.should_receive(:new).
+                            with(:config => @config_mock).
+                            and_return sdb_mock
+    sdb_mock.should_receive(:put_attributes).
+             with('tim', '123', { 'attr' => 'val' }, { :replace => 'attr' })
+    @updater.update :attribute => 'attr',
+                    :value     => 'val'
+  end
+
+end

data/spec/archive/uploader_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Heirloom do
+
+  before do
+    @config_mock = double 'config'
+    @logger_mock = double 'logger'
+    @config_mock.should_receive(:logger).and_return(@logger_mock)
+    @uploader = Heirloom::Uploader.new :config => @config_mock,
+                                       :name   => 'tim',
+                                       :id     => '123'
+  end
+
+  it "should upload a new archive" do
+    s3_mock = mock 's3'
+    Heirloom::Uploader::S3.should_receive(:new).
+                           with(:config => @config_mock,
+                                :logger => @logger_mock,
+                                :region => 'us-west-1').
+                           and_return s3_mock
+    s3_mock.should_receive(:upload_file).
+            with(:bucket          => 'prefix-us-west-1',
+                 :file            => '/tmp/file',
+                 :id              => '123',
+                 :key_folder      => 'tim',
+                 :key_name        => "123.tar.gz",
+                 :name            => 'tim',
+                 :public_readable => true)
+    s3_mock.should_receive(:add_endpoint_attributes).
+            with(:bucket => 'prefix-us-west-1',
+                 :id     => '123',
+                 :name   => 'tim')
+    @logger_mock.should_receive(:info)
+    @uploader.upload :file            => '/tmp/file',
+                     :bucket_prefix   => 'prefix',
+                     :regions         => ['us-west-1'],
+                     :public_readable => true
+  end
+
+end

data/spec/{heirloom → archive}/verifier_spec.rb

@@ -12,7 +12,6 @@ describe Heirloom do
   end
 
   it "should return false if a bucket does not exist" do
-    @config_mock.should_receive(:regions).and_return ['us-west-1']
     Heirloom::AWS::S3.should_receive(:new).
                       with(:config => @config_mock,
                            :region => 'us-west-1').
@@ -20,19 +19,20 @@ describe Heirloom do
     @s3_mock.should_receive(:get_bucket).with('bucket123-us-west-1').
              and_return nil
     @logger_mock.should_receive(:debug)
-    @verifier.buckets_exist?(:bucket_prefix => 'bucket123').should == false
+    @verifier.buckets_exist?(:bucket_prefix => 'bucket123',
+                             :regions       => ['us-west-1']).should be_false
   end
 
   it "should true if all buckets exist" do
-    @config_mock.should_receive(:regions).and_return ['us-west-2']
     Heirloom::AWS::S3.should_receive(:new).
                       with(:config => @config_mock,
-                           :region => 'us-west-2').
+                           :region => 'us-west-1').
                       and_return @s3_mock
-    @s3_mock.should_receive(:get_bucket).with('bucket123-us-west-2').
+    @s3_mock.should_receive(:get_bucket).with('bucket123-us-west-1').
              and_return 'an s3 bucket'
     @logger_mock.should_receive(:debug)
-    @verifier.buckets_exist?(:bucket_prefix => 'bucket123').should == true
+    @verifier.buckets_exist?(:bucket_prefix => 'bucket123',
+                             :regions       => ['us-west-1']).should be_true
   end
 
 end

data/spec/archive_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+describe Heirloom do
+
+  before do
+      @config_mock = mock 'config'
+      @logger_mock = mock 'logger'
+      Heirloom::Config.should_receive(:new).and_return @config_mock
+      @archive = Heirloom::Archive.new :logger => @logger_mock,
+                                       :name   => 'chef',
+                                       :id     => '123'
+  end
+
+
+  context "test public methods" do
+
+    it "should call build with given args" do
+      mock = double('Mock')
+      Heirloom::Builder.should_receive(:new).
+                        with(:config => @config_mock,
+                             :name   => 'chef',
+                             :id     => '123').
+                        and_return mock
+      mock.should_receive(:build).with('args')
+      @archive.build('args')
+    end
+
+    it "should call download method with given args" do
+      mock = double('Mock')
+      Heirloom::Downloader.should_receive(:new).
+                           with(:config => @config_mock,
+                                :name   => 'chef',
+                                :id     => '123').
+                           and_return mock
+      mock.should_receive(:download).with('args')
+      @archive.download('args')
+    end
+
+    it "should call update archive method with given args" do
+      mock = double('Mock')
+      Heirloom::Updater.should_receive(:new).
+                        with(:config => @config_mock,
+                             :name   => 'chef',
+                             :id     => '123').
+                        and_return mock
+      mock.should_receive(:update).with('args')
+      @archive.update('args')
+    end
+
+    it "should call upload archive method with given args" do
+      mock = double('Mock')
+      reader_mock = double('reader mock')
+      Heirloom::Reader.should_receive(:new).
+                          with(:config => @config_mock,
+                               :name   => 'chef',
+                               :id     => '123').
+                          and_return reader_mock
+      reader_mock.should_receive(:regions).and_return ['us-west-1', 'us-west-2']
+      Heirloom::Uploader.should_receive(:new).
+                         with(:config => @config_mock,
+                              :name   => 'chef',
+                              :id     => '123').
+                         and_return mock
+      mock.should_receive(:upload).with('arg' => 'val', :regions => ['us-west-1', 'us-west-2'])
+      @archive.upload('arg' => 'val')
+    end
+
+    it "should call authorize method" do
+      mock = double('Mock')
+      reader_mock = double('reader mock')
+      Heirloom::Reader.should_receive(:new).
+                          with(:config => @config_mock,
+                               :name   => 'chef',
+                               :id     => '123').
+                          and_return reader_mock
+      reader_mock.should_receive(:regions).and_return ['us-west-1', 'us-west-2']
+      Heirloom::Authorizer.should_receive(:new).
+                           with(:config => @config_mock,
+                                :name   => 'chef',
+                                :id     => '123').
+                           and_return mock
+      mock.should_receive(:authorize).with :regions  => ['us-west-1', 'us-west-2'],
+                                           :accounts => ['acct1', 'acct2']
+      @archive.authorize ['acct1', 'acct2']
+    end
+
+    it "should call archive exists method and return true if archive exists" do
+      mock = double('Mock')
+      Heirloom::Reader.should_receive(:new).
+                       with(:config => @config_mock,
+                                 :name   => 'chef',
+                                 :id     => '123').
+                            and_return mock
+      mock.should_receive(:exists?).and_return true
+      @archive.exists?.should be_true
+    end
+
+    it "should call archive exists method and return fasle if archive doesnt exists" do
+      mock = double('Mock')
+      Heirloom::Reader.should_receive(:new).
+                       with(:config => @config_mock,
+                            :name   => 'chef',
+                            :id     => '123').
+                       and_return mock
+      mock.should_receive(:exists?).and_return false
+      @archive.exists?.should be_false
+    end
+
+    it "should call show method" do
+      mock = double('Mock')
+      Heirloom::Reader.should_receive(:new).
+                       with(:config => @config_mock,
+                            :name   => 'chef',
+                            :id     => '123').
+                       and_return mock
+      mock.should_receive(:show)
+      @archive.show
+    end
+
+    it "should call list method" do
+      mock = double('Mock')
+      Heirloom::Lister.should_receive(:new).
+                       with(:config => @config_mock,
+                            :name   => 'chef').
+                       and_return mock
+      mock.should_receive(:list)
+      @archive.list
+    end
+
+    it "should call cleanup method" do
+      mock = double('Mock')
+      Heirloom::Builder.should_receive(:new).
+                        with(:config => @config_mock,
+                             :name   => 'chef',
+                             :id     => '123').
+                        and_return mock
+      mock.should_receive(:cleanup)
+      @archive.cleanup
+    end
+
+    it "should return true if the required buckets exist" do
+      mock = double('Mock')
+      Heirloom::Verifier.should_receive(:new).
+                         with(:config => @config_mock,
+                              :name   => 'chef').
+                         and_return mock
+      mock.should_receive(:buckets_exist?).
+           with(:bucket_prefix => 'test-123').and_return true
+      @archive.buckets_exist?(:bucket_prefix => 'test-123').
+               should be_true
+    end
+
+    it "should return false if the required buckets don't exist" do
+      mock = double('Mock')
+      Heirloom::Verifier.should_receive(:new).
+                         with(:config => @config_mock,
+                              :name   => 'chef').
+                         and_return mock
+      mock.should_receive(:buckets_exist?).
+           with(:bucket_prefix => 'test-123').and_return false
+      @archive.buckets_exist?(:bucket_prefix => 'test-123').
+               should be_false
+    end
+
+    it "should call the destroy method" do
+      destroyer_mock = double('destroyer mock')
+      reader_mock = double('reader mock')
+      Heirloom::Reader.should_receive(:new).
+                          with(:config => @config_mock,
+                               :name   => 'chef',
+                               :id     => '123').
+                          and_return reader_mock
+      reader_mock.should_receive(:regions).and_return ['us-west-1', 'us-west-2']
+      Heirloom::Destroyer.should_receive(:new).
+                          with(:config  => @config_mock,
+                               :name    => 'chef',
+                               :id      => '123').
+                          and_return destroyer_mock
+      destroyer_mock.should_receive(:destroy).
+                     with(:regions => ['us-west-1', 'us-west-2'])
+      @archive.destroy
+    end
+
+    it "should call the regions method for an archive" do
+      mock = double('Mock')
+      Heirloom::Reader.should_receive(:new).
+                          with(:config => @config_mock,
+                               :name   => 'chef',
+                               :id     => '123').
+                          and_return mock
+      mock.should_receive(:regions)
+      @archive.regions
+    end
+  end
+end

data/spec/cli/shared_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+require 'heirloom/cli/shared'
+
+describe Heirloom do
+  before do 
+    @logger_mock = mock 'logger'
+  end
+
+  it "should return false if a required array is emtpy" do
+    @logger_mock.should_receive(:error)
+    Heirloom::CLI::Shared.valid_options?(:provided => { :array  => [],
+                                                        :string => 'present' },
+                                         :required => [:array, :string],
+                                         :logger   => @logger_mock).
+                          should be_false
+  end
+
+  it "should return false if a required string is nil" do
+    @logger_mock.should_receive(:error)
+    Heirloom::CLI::Shared.valid_options?(:provided => { :array  => ['present'],
+                                                        :string => nil },
+                                         :required => [:array, :string],
+                                         :logger   => @logger_mock).
+                          should be_false
+  end
+
+  it "shoudl return false if a require string is nil & array is empty" do
+    @logger_mock.should_receive(:error).exactly(2).times
+    Heirloom::CLI::Shared.valid_options?(:provided => { :array  => [],
+                                                        :string => nil },
+                                         :required => [:array, :string],
+                                         :logger   => @logger_mock).
+                          should be_false
+  end
+
+  it "shoudl return true if all options are present" do
+    @logger_mock.should_receive(:error).exactly(0).times
+    Heirloom::CLI::Shared.valid_options?(:provided => { :array  => ['present'],
+                                                        :string => 'present' },
+                                         :required => [:array, :string],
+                                         :logger   => @logger_mock).
+                          should be_true
+  end
+end