beanstalkify 0.0.3 → 0.0.4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    beanstalkify (0.0.3)
+    beanstalkify (0.0.4)
       aws-sdk
 
 GEM

data/README.md

@@ -24,8 +24,8 @@ Should do the following
 - Connect to aws using the credentials in `credentials.yml`
 - Publish `app-version.zip` to s3
 - Ensure that a beanstalk application called 'app' exists, and add a version called 'version', linked to the archive in that s3 bucket
-- Ensure that the environment `env` exists (with optional settings overrides in `config.yml` - see below), running the specified stack.
-- Deploy the provided version of the application into `env`
+- Ensure that the environment `app-env` exists (with optional settings overrides in `config.yml` - see below), running the specified stack.
+- Deploy the provided version of the application into `app-env`
 - Report progress. When complete report the URL where the app can be hit (note: this will be the URL of the ELB).
 
 # Settings overrides

data/bin/beanstalkify

@@ -3,6 +3,9 @@ require 'optparse'
 require 'yaml'
 Dir.glob(File.join(File.dirname(__FILE__), "../lib/beanstalkify", "*.rb")).each { |f| require f }
 
+# Flush all logging immediately so that scripts invoking beanstalkify can choose to merge the info.
+$stdout.sync = true
+
 options = {}
 OptionParser.new do |opts|
     opts.on("-k", "--keyfile [file]", "Load credentials from yaml file") do |v|
@@ -27,17 +30,18 @@ end.parse!
 
 required_params = [:credentials, :archive, :environment, :stack]
 unless (required_params - options.keys).empty?
-    puts "Example usage: beanstalkify -k credentials.yml -a AppName-version.zip -e AppName-test -s '64bit Amazon Linux running Node.js' [-c config.yml] [-o info.yml]"
+    puts "Example usage: beanstalkify -k credentials.yml -a AppName-version.zip -e Test -s '64bit Amazon Linux running Node.js' [-c config.yml] [-o info.yml]"
     exit
 end
 
 Beanstalkify::Beanstalk.configure! options[:credentials]
 
 app = Beanstalkify::Application.new(options[:stack], options[:config] || [])
-deployment = Beanstalkify::Deploy.new(options[:archive])
-environment = Beanstalkify::Environment.new(options[:environment])
+archive = Beanstalkify::Archive.new(options[:archive])
+environment = Beanstalkify::Environment.new(archive, options[:environment])
 
-deployment_info = app.deploy! deployment, environment
+deployment_info = app.deploy! archive, environment
 
 File.open(options[:outfile], 'w') { |f| f.puts deployment_info.to_yaml } if options[:outfile]
 
+raise("Deployed environment is not healthy") unless environment.healthy?

data/lib/beanstalkify/application.rb

@@ -11,24 +11,20 @@ module Beanstalkify
 
         # Deploy an archive to an environment. 
         # If the environment doesn't exist, it will be created.
-        def deploy!(deployment, env)
-            if deployment.deployed?
-                puts "#{deployment.archive.version} is already uploaded."
-            else
-                deployment.upload!
-                deployment.wait!
-            end
+        def deploy!(archive, env)
+            archive.upload(Beanstalk.api)
+            
             if env.status.empty?
-                puts "Creating stack '#{@stack}' for #{deployment.archive.name}-#{deployment.archive.version}..."
-                env.create!(deployment.archive, @stack, @config)
+                puts "Creating stack '#{@stack}' for #{archive.app_name}-#{archive.version}..."
+                env.create!(archive, @stack, @config)
                 env.wait!("Launching")
             else
-                puts "Deploying #{deployment.archive.version} to #{env.name}..."
-                env.deploy!(deployment.archive, @config)
+                puts "Deploying #{archive.version} to #{env.name}..."
+                env.deploy!(archive, @config)
                 env.wait!("Updating")
             end
             puts "Done. Visit http://#{env.url} in your browser."
-            DeploymentInfo.new env, deployment.archive
+            DeploymentInfo.new env, archive
         end
     end
 end

data/lib/beanstalkify/archive.rb

@@ -1,23 +1,53 @@
+require 'aws-sdk'
 
 module Beanstalkify
-    class Archive
-        attr_accessor :path
-
-        def initialize(path)
-            @path = path
-        end
-
-        def name
-            f = filename
-            f[0..f.rindex('-')-1]
-        end
-
-        def version
-            File.basename(@path, '.*').split('-')[-1]
-        end
+  class Archive
+    attr_reader :app_name, :version
+    
+    def initialize(filename)
+      @filename = filename
+      @archive_name = File.basename(@filename)
+      @app_name, hyphen, @version = File.basename(filename, '.*').rpartition("-")
+    end
 
-        def filename
-            File.basename(@path)
-        end
+    def upload(beanstalk_api, s3_client=AWS::S3.new.client)
+      if already_uploaded?(beanstalk_api)
+        return puts "#{version} is already uploaded."
+      end
+      bucket = beanstalk_api.create_storage_location.data[:s3_bucket]
+      upload_to_s3(s3_client, bucket)
+      make_application_version_available_to_beanstalk(beanstalk_api, bucket)
+    end
+    
+    private
+  
+    def upload_to_s3(s3_client, bucket)
+      puts "Uploading #{@archive_name} to bucket #{bucket}..."
+      s3_client.put_object(
+        bucket_name: bucket, 
+        key: @archive_name,
+        data: File.open(@filename)
+      )
+    end
+    
+    def make_application_version_available_to_beanstalk(beanstalk_api, bucket)
+      puts "Making version #{version} of #{app_name} available to Beanstalk..."
+      beanstalk_api.create_application_version(
+        application_name: app_name, 
+        version_label: version,
+        source_bundle: {
+          s3_bucket: bucket,
+          s3_key: @archive_name
+        },
+        auto_create_application: true
+      )
+    end
+    
+    def already_uploaded?(beanstalk_api)
+      beanstalk_api.describe_application_versions(
+        application_name: app_name,
+        version_labels: [version]
+      ).data[:application_versions].count > 0
     end
+  end
 end

data/lib/beanstalkify/deployment_info.rb

@@ -6,7 +6,7 @@ module Beanstalkify
     
     def to_yaml
       {
-        'app_name'    => @archive.name,
+        'app_name'    => @archive.app_name,
         'app_version' => @archive.version,
         'env_name'    => @environment.name,
         'env_url'     => @environment.url

data/lib/beanstalkify/environment.rb

@@ -4,8 +4,8 @@ module Beanstalkify
     class Environment
         attr_accessor :name
 
-        def initialize(name)
-            @name = name
+        def initialize(archive, name)
+            @name = [archive.app_name, name].join("-")
             @beanstalk = Beanstalk.api
         end
 
@@ -20,12 +20,12 @@ module Beanstalkify
             })
         end
 
-        # Assuming the app has already been uploaded, 
+        # Assuming the archive has already been uploaded, 
         # create a new environment with the app deployed onto the provided stack.
-        def create!(app, stack, settings=[])
+        def create!(archive, stack, settings=[])
             @beanstalk.create_environment({
-                :application_name => app.name,
-                :version_label => app.version,
+                :application_name => archive.app_name,
+                :version_label => archive.version,
                 :environment_name => self.name,
                 :solution_stack_name => stack,
                 :option_settings => settings
@@ -33,28 +33,37 @@ module Beanstalkify
         end
 
         def status
-            envs = @beanstalk.describe_environments({
-                :environment_names => [self.name],
-                :include_deleted => false
-            }).data[:environments]
-            e = envs.first
+            e = describe_environment
             e ? e[:status] : ""
         end
 
         def url
-            envs = @beanstalk.describe_environments({
-                :environment_names => [self.name]
-            }).data[:environments]
-            e = envs.first
-            e ? e[:endpoint_url] : ""
+            e = describe_environment
+            e ? e[:cname] : ""
+        end
+        
+        def healthy?
+           e = describe_environment
+           e ? e[:health] == 'Green' : false
         end
 
         # Wait for the status to change from `old_status` to something else
         def wait!(old_status)
+            puts "Waiting for #{self.name} to finish #{old_status.downcase}..."
             while self.status == old_status
-                puts "#{self.name} is still #{old_status}..."
-                sleep 20
+                print '.'              
+                sleep 5
             end
+            puts
+        end
+        
+        private
+        
+        def describe_environment
+            @beanstalk.describe_environments({
+                :environment_names => [name],
+                :include_deleted => false
+            }).data[:environments].first
         end
     end
 end

data/lib/beanstalkify/version.rb

@@ -1,3 +1,3 @@
 module Beanstalkify
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/test/archive_spec.rb

@@ -1,26 +1,86 @@
-
 require './lib/beanstalkify/archive'
 
 describe Beanstalkify::Archive do
-  archive = nil
+  ARCHIVE_FILENAME = '/path/to/my/archive/app-name-version.zip'
+  
   before do
-    archive = Beanstalkify::Archive.new '/path/to/my/archive/app-name-version.zip'
+    @archive = Beanstalkify::Archive.new ARCHIVE_FILENAME
   end
+  
+  describe 'parsing the filename' do
+    it 'extracts the application name from the filename' do
+      @archive.app_name.should eq('app-name')
+    end
 
-  it 'should store the path' do
-    archive.path.should eq('/path/to/my/archive/app-name-version.zip')
+    it 'extracts the archive version from the filename' do
+      @archive.version.should eq('version')
+    end
   end
-
-  it 'extracts the application name from the path' do
-    archive.name.should eq('app-name')
+  
+  describe 'uploading to AWS' do
+    before(:each) do
+      @beanstalk_api = double(
+        create_storage_location: double(
+          data: {s3_bucket: 'mah bukkit'}
+        )
+      ).as_null_object
+      @s3_client = double.as_null_object
+      allow(File).to receive(:open).with(ARCHIVE_FILENAME).and_return("fake archive file contents")
+    end
+    
+    it 'knows if it has already been uploaded' do
+      when_beanstalk_describe_application_versions_returns([])
+      @archive.send(:already_uploaded?, @beanstalk_api).should be_false
+      when_beanstalk_describe_application_versions_returns(["some version or other"])
+      @archive.send(:already_uploaded?, @beanstalk_api).should be_true      
+    end
+    
+    context "when it has already been uploaded" do
+      before(:each) do
+        allow(@archive).to receive(:already_uploaded?).and_return true
+      end
+      
+      it 'does not re-upload' do
+        expect(@s3_client).to_not receive(:put_object)        
+        expect(@beanstalk_api).to_not receive(:create_application_version)
+        @archive.upload @beanstalk_api, @s3_client
+      end
+    end
+    
+    context "when it hasn't already been uploaded" do
+      before(:each) do
+        allow(@archive).to receive(:already_uploaded?).and_return false
+      end
+      
+      it 'uploads the file to S3' do
+        expect(@s3_client).to receive(:put_object).with(
+          bucket_name: 'mah bukkit', 
+          key: 'app-name-version.zip', 
+          data: "fake archive file contents"
+        )
+        @archive.upload @beanstalk_api, @s3_client
+      end
+    
+      it 'creates an available application version' do
+        expect(@beanstalk_api).to receive(:create_application_version).with(
+          application_name: "app-name", 
+          version_label: "version",
+          source_bundle: {
+            s3_bucket: "mah bukkit",
+            s3_key: "app-name-version.zip"
+          },
+          auto_create_application: true
+        )
+        @archive.upload @beanstalk_api, @s3_client
+      end
+    end
   end
-
-  it 'extracts the version from the path' do
-    archive.version.should eq('version')
-  end
-
-  it 'returns the filename of the archive' do
-    archive.filename.should eq('app-name-version.zip')
+  
+  def when_beanstalk_describe_application_versions_returns(versions)
+    expect(@beanstalk_api).to receive(:describe_application_versions).with(
+      application_name: "app-name",
+      version_labels: ["version"]
+    ).and_return(double(data: {application_versions: versions}))
   end
 end
 

data/test/environment_spec.rb

@@ -0,0 +1,40 @@
+require './lib/beanstalkify/archive'
+require './lib/beanstalkify/environment'
+
+describe Beanstalkify::Environment do
+  before do
+    allow(Beanstalkify::Beanstalk).to receive(:api).and_return @beanstalk_api = double
+    archive = Beanstalkify::Archive.new '/path/to/my/archive/app-name-version.zip'
+    @env = Beanstalkify::Environment.new archive, "Test"
+  end
+
+  it 'prepends the application name because environment names must be unique within an AWS account' do
+    @env.name.should == "app-name-Test"
+  end
+  
+  it 'exposes the Beanstalk status' do
+    when_beanstalk_describe_environments_returns(status: 'Uncertain')
+    @env.status.should == 'Uncertain'
+  end
+  
+  it 'exposes the Beanstalk CNAME URL' do
+    when_beanstalk_describe_environments_returns(cname: 'http://cname.elasticbeanstalk.com')
+    @env.url.should == 'http://cname.elasticbeanstalk.com'
+  end
+  
+  it 'is healthy when Beanstalk reports that it is green' do
+    when_beanstalk_describe_environments_returns(health: 'Red')
+    @env.should_not be_healthy
+    when_beanstalk_describe_environments_returns(health: 'Green')
+    @env.should be_healthy
+  end
+  
+  def when_beanstalk_describe_environments_returns(env_data)
+    expect(@beanstalk_api).to receive(:describe_environments).with(
+      environment_names: ["app-name-Test"],
+      include_deleted: false
+    ).and_return double(
+      data: {environments: [env_data]}
+    )
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: beanstalkify
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-09 00:00:00.000000000 Z
+date: 2013-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -62,12 +62,12 @@ files:
 - lib/beanstalkify/application.rb
 - lib/beanstalkify/archive.rb
 - lib/beanstalkify/beanstalk.rb
-- lib/beanstalkify/deploy.rb
 - lib/beanstalkify/deployment_info.rb
 - lib/beanstalkify/environment.rb
 - lib/beanstalkify/version.rb
 - test/archive_spec.rb
 - test/deployment_info_spec.rb
+- test/environment_spec.rb
 homepage: https://github.com/pranavraja/beanstalkify
 licenses:
 - MIT
@@ -81,12 +81,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -4062555010533808231
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -4062555010533808231
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -96,3 +102,4 @@ summary: Beanstalk automation for dummies
 test_files:
 - test/archive_spec.rb
 - test/deployment_info_spec.rb
+- test/environment_spec.rb

data/lib/beanstalkify/deploy.rb

@@ -1,49 +0,0 @@
-require 'beanstalkify/archive'
-require 'beanstalkify/beanstalk'
-require 'aws-sdk'
-
-module Beanstalkify
-    class Deploy
-        attr_accessor :beanstalk, :archive
-
-        def initialize(path)
-            @archive = Archive.new(path)
-            @beanstalk = Beanstalk.api
-        end
-
-        def bucket
-            @beanstalk.create_storage_location.data[:s3_bucket]
-        end
-
-        def upload!
-            client = AWS::S3.new.client
-            bucket = self.bucket
-            puts "Uploading #{@archive.filename} to bucket #{bucket}..."
-            client.put_object({ :bucket_name => bucket, :key => @archive.filename, :data => File.open(@archive.path) })
-            puts "Creating #{@archive.name} - #{@archive.version} in beanstalk"
-            @beanstalk.create_application_version({ 
-                :application_name => @archive.name, 
-                :version_label => @archive.version,
-                :source_bundle => {
-                    :s3_bucket => bucket,
-                    :s3_key => @archive.filename
-                },
-                :auto_create_application => true
-            })
-        end
-
-        def deployed?
-            @beanstalk.describe_application_versions({
-                :application_name => @archive.name,
-                :version_labels => [@archive.version]
-            }).data[:application_versions].count > 0
-        end
-
-        def wait!
-            while not self.deployed?
-                puts "Waiting for #{@archive.version} to be available..."
-                sleep 10
-            end
-        end
-    end
-end