heirloom 0.5.0rc3 → 0.5.0rc4

data/lib/heirloom/cli/{update.rb → tag.rb}

@@ -1,6 +1,6 @@
 module Heirloom
   module CLI
-    class Update
+    class Tag
 
       include Heirloom::CLI::Shared
 
@@ -11,7 +11,7 @@ module Heirloom
                               :opts   => @opts
 
         ensure_valid_options :provided => @opts,
-                             :required => [:name, :id, :attribute, :updated_value],
+                             :required => [:name, :id, :attribute, :value],
                              :config   => @config
 
         ensure_domain_exists :name => @opts[:name], :config => @config
@@ -21,9 +21,13 @@ module Heirloom
                                :config => @config
       end
       
-      def update
+      def tag
+        unless @archive.exists?
+          @logger.error "Archive does not exist"
+          exit 1
+        end
         @archive.update :attribute  => @opts[:attribute],
-                        :value      => @opts[:updated_value]
+                        :value      => @opts[:value]
       end
 
       private
@@ -33,11 +37,11 @@ module Heirloom
           version Heirloom::VERSION
           banner <<-EOS
 
-Update an archive's attribute.
+Tag an archive with an attribute and value.
 
 Usage:
 
-heirloom update -n NAME -i ID -a ATTRIBUTE_TO_UPDATE -u UPDATED_VALUE
+heirloom tag -n NAME -i ID -a ATTRIBUTE -u VALUE
 
 EOS
           opt :attribute, "Attribute to update.", :type => :string
@@ -46,10 +50,11 @@ EOS
           opt :level, "Log level [debug|info|warn|error].", :type    => :string,
                                                             :default => 'info'
           opt :name, "Name of archive.", :type => :string
-          opt :updated_value, "Updated value of attribute.", :type => :string
-          opt :aws_access_key, "AWS Access Key ID", :type => :string, 
+          opt :value, "Value of attribute.", :type  => :string,
+                                             :short => 'u'
+          opt :aws_access_key, "AWS Access Key ID", :type  => :string, 
                                                     :short => :none
-          opt :aws_secret_key, "AWS Secret Access Key", :type => :string, 
+          opt :aws_secret_key, "AWS Secret Access Key", :type  => :string, 
                                                         :short => :none
         end
       end

data/lib/heirloom/cli/{build.rb → upload.rb}

@@ -1,6 +1,6 @@
 module Heirloom
   module CLI
-    class Build
+    class Upload
 
       include Heirloom::CLI::Shared
 
@@ -12,7 +12,7 @@ module Heirloom
 
         ensure_valid_options :provided => @opts, 
                              :required => [:name, :id, :region, 
-                                           :base_prefix, :directory],
+                                           :base, :directory],
                              :config   => @config
 
         @archive = Archive.new :name   => @opts[:name],
@@ -20,33 +20,30 @@ module Heirloom
                                :config => @config
       end
 
-      def build
-        unless @archive.buckets_exist? :bucket_prefix => @opts[:base_prefix],
-                                       :regions       => @opts[:region]
-          @logger.error "Buckets do no exist in required regions."
-          exit 1
-        end
-
+      def upload
         ensure_directory :path => @opts[:directory], :config => @config
         ensure_valid_secret :secret => @opts[:secret], :config => @config
 
-        @archive.destroy if @archive.exists?
+        @archive.setup :regions       => @opts[:region],
+                       :bucket_prefix => @opts[:base]
+
+        @archive.destroy :keep_domain => true if @archive.exists?
                           
-        build = @archive.build :bucket_prefix => @opts[:base_prefix],
-                               :directory     => @opts[:directory],
-                               :exclude       => @opts[:exclude],
-                               :git           => @opts[:git],
-                               :secret        => @opts[:secret]
-
-        if build
-          @archive.upload :bucket_prefix   => @opts[:base_prefix],
-                          :regions         => @opts[:region],
-                          :public_readable => @opts[:public],
-                          :file            => build
-        else
+        build = @archive.build :base       => @opts[:base],
+                               :directory  => @opts[:directory],
+                               :exclude    => @opts[:exclude],
+                               :git        => @opts[:git],
+                               :secret     => @opts[:secret]
+
+        unless build
           @logger.error "Build failed."
           exit 1
         end
+
+        @archive.upload :bucket_prefix   => @opts[:base],
+                        :regions         => @opts[:region],
+                        :public_readable => @opts[:public],
+                        :file            => build
       end
 
       private
@@ -56,14 +53,14 @@ module Heirloom
           version Heirloom::VERSION
           banner <<-EOS
 
-Build and upload a new archive.
+Upload a directory to Heirloom.
 
 Usage:
 
-heirloom build -n NAME -i ID -b BASE_PREFIX -r REGION1 -r REGION2 -d DIRECTORY_TO_BUILD
+heirloom upload -n NAME -i ID -b BASE -r REGION1 -r REGION2 -d DIRECTORY_TO_UPLOAD
 
 EOS
-          opt :base_prefix, "Base bucket prefix which will be combined with region. \
+          opt :base, "Base prefix which will be combined with region. \
 For example: -b 'test' -r 'us-west-1'  will expect bucket 'test-us-west-1' \
 to be present", :type => :string
           opt :directory, "Source directory of build.", :type  => :string

data/lib/heirloom/directory/directory.rb

@@ -19,8 +19,8 @@ module Heirloom
       @local_build = Tempfile.new('archive.tar.gz').path
 
       @logger.info "Building Heirloom '#{@local_build}' from '#{@path}'."
-      @logger.info "Excluding #{@exclude.to_s}."
-      @logger.info "Adding #{files_to_pack}."
+      @logger.debug "Excluding #{@exclude.to_s}."
+      @logger.debug "Adding #{files_to_pack}."
 
       return build_archive unless @secret
 

data/lib/heirloom/uploader/s3.rb

@@ -44,10 +44,10 @@ module Heirloom
         @logger.info "Adding attribute #{s3_endpoint}."
 
         sdb.put_attributes domain, id, { "#{@region}-http-url" => http_endpoint }
-        @logger.info "Adding attribute #{http_endpoint}."
+        @logger.debug "Adding attribute #{http_endpoint}."
 
         sdb.put_attributes domain, id, { "#{@region}-https-url" => https_endpoint }
-        @logger.info "Adding attribute #{https_endpoint}."
+        @logger.debug "Adding attribute #{https_endpoint}."
       end
 
       private

data/lib/heirloom/version.rb

@@ -1,3 +1,3 @@
 module Heirloom
-  VERSION = "0.5.0rc3"
+  VERSION = "0.5.0rc4"
 end

data/spec/archive/authorizer_spec.rb

@@ -5,6 +5,7 @@ describe Heirloom do
     before do
       @config_mock = double('config')
       @logger_mock = double('logger')
+      @logger_mock.stub :info => true, :debug => true
       @config_mock.should_receive(:logger).and_return(@logger_mock)
       @authorizer = Heirloom::Authorizer.new :config => @config_mock,
                                              :name   => 'tim',
@@ -14,7 +15,7 @@ describe Heirloom 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
+      accounts = [ "test@a.com", "a@test.com", "test@test.co", "test@test.co.uk" ]
       @authorizer.should_receive(:reader).exactly(2).times.
                   and_return(reader)
       reader.should_receive(:get_bucket).exactly(2).times.
@@ -26,9 +27,18 @@ describe Heirloom do
              with(:key_name   => '123',
                   :key_folder => 'tim',
                   :bucket     => 'the-bucket',
-                  :accounts   => ["acct1", "acct2"])
-      @authorizer.authorize :accounts => ['acct1', 'acct2'],
-                            :regions  => ['us-west-1', 'us-west-2']
+                  :accounts   => accounts)
+      @authorizer.authorize(:accounts => accounts,
+                            :regions  => ['us-west-1', 'us-west-2']).
+                  should be_true
     end
 
+    it "should exit when an account is not an email" do
+      @logger_mock.should_receive(:error)
+      @authorizer.authorize(:accounts => ['good@good.com', 'bad@blah'],
+                            :regions  => ['us-west-1', 'us-west-2']).
+                  should be_false
+    end
+
+
 end

data/spec/archive/builder_spec.rb

@@ -6,9 +6,6 @@ describe Heirloom::Builder do
     @logger_stub   = stub :debug => 'true', :info => 'true', :warn => 'true'
     @config_mock.stub(:logger).and_return(@logger_stub)
     @simpledb_mock = double 'simple db'
-    Heirloom::AWS::SimpleDB.should_receive(:new).with(:config => @config_mock).
-                            and_return(@simpledb_mock)
-    @simpledb_mock.should_receive(:create_domain).with 'heirloom_tim'
     @builder       = Heirloom::Builder.new :config => @config_mock,
                                            :name   => 'tim',
                                            :id     => '123'
@@ -16,8 +13,7 @@ describe Heirloom::Builder do
 
   describe 'build' do
     context 'when successful' do
-      context 'with a git directory' do
-        before do
+      before do
           @author_stub    = stub :name => 'weaver'
           @directory_stub = stub :build_artifact_from_directory => '/tmp/build_dir',
                                  :local_build                   => '/var/tmp/file.tar.gz'
@@ -32,6 +28,14 @@ describe Heirloom::Builder do
                                  with(:path => 'path_to_build').
                                  and_return @git_dir_mock
           @builder.should_receive(:create_artifact_record)
+      end
+
+      context 'with a git directory' do
+
+        before do
+          Heirloom::AWS::SimpleDB.should_receive(:new).
+                                  with(:config => @config_mock).
+                                  and_return(@simpledb_mock)
         end
 
         it "should build an archive" do
@@ -66,6 +70,9 @@ describe Heirloom::Builder do
                          :git       => 'true').should == '/var/tmp/file.tar.gz'
         end
 
+      end
+
+      context "without git dir" do
         it "should build an archive and log a warning if the git sha is not found" do
           @logger_stub.should_receive(:warn).with "Could not load Git sha '123' in 'path_to_build'."
           @git_dir_mock.should_receive(:commit).

data/spec/archive/destroyer_spec.rb

@@ -11,33 +11,43 @@ describe Heirloom do
                                            :id     => '123'
     end
 
-    it "should destroy the given archive" do
+    before do
       @logger_mock.stub :info => true
-      reader_mock = mock 'archive reader'
-      @destroyer.should_receive(:reader).and_return reader_mock
-      bucket_mock = mock 'bucket'
-      reader_mock.should_receive(:get_bucket).
+      @reader_mock = mock 'archive reader'
+      @destroyer.stub :reader => @reader_mock
+      @reader_mock.should_receive(:get_bucket).
                   with(:region => 'us-west-1').
                   and_return 'bucket-us-west-1'
 
 
-      s3_destroyer_mock = mock 's3 destroyer'
+      @s3_destroyer_mock = mock 's3 destroyer'
       Heirloom::Destroyer::S3.should_receive(:new).
                               with(:config => @config_mock,
                                    :region => 'us-west-1').
-                              and_return s3_destroyer_mock
-      s3_destroyer_mock.should_receive(:destroy_file).
+                              and_return @s3_destroyer_mock
+      @s3_destroyer_mock.should_receive(:destroy_file).
                         with :key_name   => '123.tar.gz',
                              :key_folder => 'tim',
                              :bucket     => 'bucket-us-west-1'
-      sdb_mock = mock 'sdb'
-      @destroyer.stub :sdb => sdb_mock
-      sdb_mock.should_receive(:delete).with 'heirloom_tim', '123'
+      @sdb_mock = mock 'sdb'
+      @destroyer.stub :sdb => @sdb_mock
+      @sdb_mock.should_receive(:delete).with 'heirloom_tim', '123'
+    end
+
+    it "should destroy the given archive" do
       Kernel.should_receive(:sleep).with 3
-      sdb_mock.should_receive(:domain_empty?).with('heirloom_tim').
+      @sdb_mock.should_receive(:domain_empty?).with('heirloom_tim').
                and_return true
-      sdb_mock.should_receive(:delete_domain).with('heirloom_tim')
-      @destroyer.destroy :regions => ['us-west-1']
+      @sdb_mock.should_receive(:delete_domain).with('heirloom_tim')
+      @destroyer.destroy :regions => ['us-west-1'],
+                         :keep_domain => false
+    end
+
+    it "should destroy the given archive but keep the sbd domain" do
+      @sdb_mock.should_receive(:domain_empty?).exactly(0).times
+      @sdb_mock.should_receive(:delete_domain).exactly(0).times
+      @destroyer.destroy :regions     => ['us-west-1'],
+                         :keep_domain => true
     end
 
 end

data/spec/archive/setup_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Heirloom do
+
+  before do
+    @logger_stub = stub 'logger', :debug => true, :info => true
+    @config_mock = mock 'config'
+    @config_mock.stub :logger => @logger_stub
+    @verifier_mock = mock 'verifier'
+    Heirloom::Verifier.should_receive(:new).
+                       with(:config => @config_mock,
+                            :name   => 'archive').
+                       and_return @verifier_mock
+    @setuper = Heirloom::Setuper.new :config => @config_mock,
+                                     :name   => 'archive'
+  end
+
+  context "creating domains" do
+    before do
+      @verifier_mock.stub :bucket_exists? => true
+    end
+
+    it "should create the domain if it does not exist" do
+      @sdb_mock = mock 'sdb'
+      Heirloom::AWS::SimpleDB.should_receive(:new).
+                              with(:config => @config_mock).
+                              and_return @sdb_mock
+      @verifier_mock.stub :domain_exists? => false
+      @sdb_mock.should_receive(:create_domain).with 'heirloom_archive'
+      @setuper.setup :regions       => ['us-west-1'],
+                     :bucket_prefix => 'base'
+                     
+    end
+
+    it "should not create the domain if alrady exists" do
+      @verifier_mock.stub :domain_exists? => true
+      @setuper.setup :regions       => ['us-west-1'],
+                     :bucket_prefix => 'base'
+    end
+  end
+
+  context "creating buckets" do
+    before do
+      @verifier_mock.stub :domain_exists? => true
+    end
+
+    it "should create required buckets that don't exist" do
+      @verifier_mock.should_receive(:bucket_exists?).
+                     with(:region => "us-west-1", :bucket_prefix => "base").
+                     and_return true
+      @verifier_mock.should_receive(:bucket_exists?).
+                     with(:region => "us-east-1", :bucket_prefix => "base").
+                     and_return false
+      @s3_mock = mock 's3'
+      Heirloom::AWS::S3.should_receive(:new).
+                        with(:config => @config_mock,
+                             :region => 'us-east-1').
+                        and_return @s3_mock
+      @s3_mock.should_receive(:put_bucket).
+               with 'base-us-east-1', 'us-east-1'
+      @setuper.setup :regions       => ['us-west-1', 'us-east-1'],
+                     :bucket_prefix => 'base'
+    end
+  end
+
+end

data/spec/archive/verifier_spec.rb

@@ -4,35 +4,67 @@ describe Heirloom do
 
   before do
     @config_mock = double 'config'
-    @logger_mock = double 'logger'
+    @logger_stub = stub 'logger', :debug => true
     @s3_mock = double 's3_mock'
-    @config_mock.should_receive(:logger).and_return(@logger_mock)
+    @config_mock.stub :logger => @logger_stub
     @verifier = Heirloom::Verifier.new :config => @config_mock,
                                        :name   => 'heirloom-name'
   end
 
-  it "should return false if a bucket does not exist" do
-    Heirloom::AWS::S3.should_receive(:new).
-                      with(:config => @config_mock,
-                           :region => 'us-west-1').
-                      and_return @s3_mock
-    @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',
-                             :regions       => ['us-west-1']).should be_false
+  context "verifying all buckets exist" do
+    before do
+      Heirloom::AWS::S3.should_receive(:new).
+                        with(:config => @config_mock,
+                             :region => 'us-west-1').
+                        and_return @s3_mock
+      Heirloom::AWS::S3.should_receive(:new).
+                        with(:config => @config_mock,
+                             :region => 'us-east-1').
+                        and_return @s3_mock
+    end
+    it "should return false if a bucket does not exist in a region" do
+      @s3_mock.should_receive(:get_bucket).with('bucket123-us-west-1').
+               and_return nil
+      @s3_mock.should_receive(:get_bucket).with('bucket123-us-east-1').
+               and_return 'an s3 bucket'
+      @verifier.buckets_exist?(:bucket_prefix => 'bucket123',
+                               :regions       => ['us-west-1', 'us-east-1']).
+                should be_false
+    end
+
+    it "should true if all buckets exist" do
+      @s3_mock.should_receive(:get_bucket).with('bucket123-us-west-1').
+               and_return 'an s3 bucket'
+      @s3_mock.should_receive(:get_bucket).with('bucket123-us-east-1').
+               and_return 'an s3 bucket'
+      @verifier.buckets_exist?(:bucket_prefix => 'bucket123',
+                               :regions       => ['us-west-1', 'us-east-1']).
+                should be_true
+    end
   end
 
-  it "should true if all buckets exist" do
-    Heirloom::AWS::S3.should_receive(:new).
-                      with(:config => @config_mock,
-                           :region => 'us-west-1').
-                      and_return @s3_mock
-    @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',
-                             :regions       => ['us-west-1']).should be_true
+  context "verifying a single bucket exist" do
+    it "should return true if the given bucket does not exist in the region" do
+      Heirloom::AWS::S3.should_receive(:new).
+                        with(:config => @config_mock,
+                             :region => 'us-west-1').
+                        and_return @s3_mock
+      @s3_mock.should_receive(:get_bucket).with('bucket123-us-west-1').
+               and_return 'an s3 bucket'
+      @verifier.bucket_exists?(:bucket_prefix => 'bucket123',
+                               :region        => 'us-west-1').should be_true
+    end
+
+    it "should return false if the given bucket does not exist in the region" do
+      Heirloom::AWS::S3.should_receive(:new).
+                        with(:config => @config_mock,
+                             :region => 'us-west-1').
+                        and_return @s3_mock
+      @s3_mock.should_receive(:get_bucket).with('bucket123-us-west-1').
+               and_return 'an s3 bucket'
+      @verifier.bucket_exists?(:bucket_prefix => 'bucket123',
+                               :region        => 'us-west-1').should be_true
+    end
   end
 
 end