dumbwaiter 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee61708863374cdb339fae14fb5f750f52b1a13f
-  data.tar.gz: 239abdfa0c7d8a4dc81a3575806bba5dc758e4bb
+  metadata.gz: 2b69c9d7f2e7d25bd322771b407638c70b5dccef
+  data.tar.gz: 3a5d98c4fe4ddd7e8e3f59b8be15a8e8b94c948f
 SHA512:
-  metadata.gz: 5b04376369f0d489bd1fdedcdfe5fb970782017cd4867eae437017112c53d7bc64d4df9bec2621178875e63be4e0bd706a2e723861f91f31c1164c47bcfbb6b4
-  data.tar.gz: 28eaa1dd456eb828cb7eb3988bfd077b149d901ef4a5a5f2aefec11543ce48893c8a7ca41d88d6c2af59c55afdc821e546049a534b058f0c9f12161defdf6989
+  metadata.gz: cf1781076eba107b32d03a11e278e03fb429c413ff639999f818ed99d2bee98c51d84f11871d12fd6bee13e403d3b45b50d95f53cd088e8a31ab4a8f1a4289de
+  data.tar.gz: 4cf716ba54f720ac5670c4eec82cdcbbd97a3cba26d8db3eacb208be52a9a45477cad4a3f54970f8895a7e69c70f514f715bd599c2346e6450eb61e4fa2acfca

data/README.md

@@ -1,4 +1,4 @@
-Dumbwaiter
+Dumbwaiter [![Build Status](https://travis-ci.org/minifast/dumbwaiter.png)](https://travis-ci.org/minifast/dumbwaiter) [![Code Climate](https://codeclimate.com/github/minifast/dumbwaiter.png)](https://codeclimate.com/github/minifast/dumbwaiter)
 ==========
 
 Dumbwaiter hoists your Rails application up to OpsWorks and ratchets deployment
@@ -28,9 +28,9 @@ Deploy the "cinnamon" branch of the "syrup" application to the "Pancake" stack:
 
   `dumbwaiter deploy Pancake syrup cinnamon`
 
-Roll back the "Snowman" stack:
+Roll back the "Snowman" stack's "dandruff" application:
 
-  `dumbwaiter rollback Snowman`
+  `dumbwaiter rollback Snowman dandruff`
 
 List the deployments on the "Maniacal Checklist" stack:
 

data/lib/dumbwaiter/app.rb

@@ -0,0 +1,54 @@
+require "dumbwaiter/deployment_custom_json"
+
+class Dumbwaiter::App
+  class NotFound < Exception; end
+
+  attr_reader :stack, :opsworks_app, :opsworks
+
+  def self.all(stack, opsworks = Aws::OpsWorks.new(region: "us-east-1"))
+    opsworks.describe_apps(stack_id: stack.id).apps.map { |app| new(stack, app, opsworks) }
+  end
+
+  def self.find(stack, app_name, opsworks = Aws::OpsWorks.new(region: "us-east-1"))
+    app = all(stack, opsworks).detect { |app| app.name == app_name}
+    raise NotFound.new("No app found with name #{app_name}") if app.nil?
+    app
+  end
+
+  def initialize(stack, opsworks_app, opsworks)
+    @stack = stack
+    @opsworks_app = opsworks_app
+    @opsworks = opsworks
+  end
+
+  def name
+    opsworks_app.name
+  end
+
+  def id
+    opsworks_app.app_id
+  end
+
+  def deploy(revision = nil)
+    deployment = as_deployment("deploy", args: {migrate: ["true"]})
+    unless revision.nil?
+      custom_json = Dumbwaiter::DeploymentCustomJson.create(name, revision)
+      deployment[:custom_json] = custom_json.to_json
+    end
+    opsworks.create_deployment(deployment)
+  end
+
+  def rollback
+    opsworks.create_deployment(as_deployment("rollback"))
+  end
+
+  protected
+
+  def as_deployment(command_name, args = {})
+    {
+      app_id: id,
+      stack_id: stack.id,
+      command: {name: command_name}.merge(args),
+    }
+  end
+end

data/lib/dumbwaiter/cli.rb

@@ -1,91 +1,41 @@
 require "thor"
 require "aws-sdk-core"
 require "dumbwaiter/deployment_custom_json"
+require "dumbwaiter/stack"
 
 module Dumbwaiter
   class Cli < Thor
-    class MissingStack < Error; end
-    class MissingApp < Error; end
-
     desc "deploy STACK_NAME APP_NAME GIT_REF", "Deploy an application revision"
     def deploy(stack_name, app_name, revision)
-      stack_id = stack_id_for_name(stack_name)
-      custom_json = DeploymentCustomJson.create(app_name, revision).to_json
-      opsworks.create_deployment(
-        stack_id: stack_id,
-        app_id: app_id_for_name(stack_id, app_name),
-        command: {name: "deploy", args: {migrate: ["true"]}},
-        custom_json: custom_json
-      )
+      stack = Stack.find(stack_name)
+      app = App.find(stack, app_name)
+      app.deploy(revision)
+    rescue Dumbwaiter::Stack::NotFound, Dumbwaiter::App::NotFound => e
+      raise Thor::Error.new(e.message)
     end
 
     desc "rollback STACK_NAME APP_NAME", "Roll back an application"
     def rollback(stack_name, app_name)
-      stack_id = stack_id_for_name(stack_name)
-      opsworks.create_deployment(
-        stack_id: stack_id,
-        app_id: app_id_for_name(stack_id, app_name),
-        command: {name: "rollback"}
-      )
+      stack = Stack.find(stack_name)
+      app = App.find(stack, app_name)
+      app.rollback
+    rescue Dumbwaiter::Stack::NotFound, Dumbwaiter::App::NotFound => e
+      raise Thor::Error.new(e.message)
     end
 
     desc "list STACK_NAME", "List all the deployments for a stack"
     def list(stack_name)
-      stack_id = stack_id_for_name(stack_name)
-      app_deployments = deployments(stack_id).select do |deployment|
-        %w(rollback deploy).include?(deployment.command.name)
-      end
-
-      app_deployments.each do |deployment|
-        custom_json = DeploymentCustomJson.from_json(deployment.custom_json || "{}")
-        Kernel.puts "#{deployment.created_at} - #{deployment.command.name} - #{deployment.status} - #{custom_json.git_ref}"
-      end
-    end
-
-    no_tasks do
-      def app_id_for_name(stack_id, app_name)
-        app_id = app_ids_by_name(stack_id)[app_name]
-        raise MissingApp.new("No app named #{app_name}") unless app_id
-        app_id
-      end
-
-      def stack_id_for_name(stack_name)
-        stack_id = stack_ids_by_name[stack_name]
-        raise MissingStack.new("No stack named #{stack_name}") unless stack_id
-        stack_id
-      end
-
-      def stack_ids_by_name
-        @stack_ids_by_name ||= stacks.reduce({}) do |result, stack|
-          result[stack.name] = stack.stack_id
-          result
-        end
-      end
-
-      def app_ids_by_name(stack_id)
-        apps(stack_id).reduce({}) do |result, app|
-          result[app.name] = app.app_id
-          result
-        end
-      end
-
-      def stacks
-        @stacks ||= opsworks.describe_stacks.stacks
-      end
-
-      def apps(stack_id)
-        @apps ||= {}
-        @apps[stack_id] ||= opsworks.describe_apps(stack_id: stack_id).apps
-      end
+      stack = Stack.find(stack_name)
 
-      def deployments(stack_id)
-        @deployments ||= {}
-        @deployments[stack_id] ||= opsworks.describe_deployments(stack_id: stack_id).deployments
+      deployments = stack.deployments.select do |deployment|
+        %w(rollback deploy).include?(deployment.command_name)
       end
 
-      def opsworks
-        @opsworks ||= Aws::OpsWorks.new(region: "us-east-1")
+      deployments.each do |deployment|
+        Kernel.puts(deployment.to_log)
       end
+    rescue Dumbwaiter::Stack::NotFound => e
+      raise Thor::Error.new(e.message)
     end
   end
 end

data/lib/dumbwaiter/deployment.rb

@@ -0,0 +1,43 @@
+require "dumbwaiter/deployment_custom_json"
+
+class Dumbwaiter::Deployment
+  attr_reader :opsworks_deployment
+
+  def self.all(stack_id, opsworks = Aws::OpsWorks.new(region: "us-east-1"))
+    opsworks.describe_deployments(stack_id: stack_id).deployments.map { |d| new(d) }
+  end
+
+  def initialize(opsworks_deployment)
+    @opsworks_deployment = opsworks_deployment
+  end
+
+  def created_at
+    opsworks_deployment.created_at
+  end
+
+  def command_name
+    opsworks_deployment.command.name
+  end
+
+  def status
+    opsworks_deployment.status
+  end
+
+  def git_ref
+    deployment_custom_json.git_ref
+  end
+
+  def to_log
+    "#{created_at} - #{command_name} - #{status} - #{git_ref}"
+  end
+
+  protected
+
+  def deployment_custom_json
+    Dumbwaiter::DeploymentCustomJson.from_json(custom_json)
+  end
+
+  def custom_json
+    opsworks_deployment.custom_json || "{}"
+  end
+end

data/lib/dumbwaiter/stack.rb

@@ -0,0 +1,39 @@
+require "dumbwaiter/app"
+require "dumbwaiter/deployment"
+
+class Dumbwaiter::Stack
+  attr_reader :opsworks, :opsworks_stack
+
+  class NotFound < Exception; end
+
+  def self.all(opsworks = Aws::OpsWorks.new(region: "us-east-1"))
+    opsworks.describe_stacks.stacks.map { |stack| new(stack, opsworks) }
+  end
+
+  def self.find(stack_name, opsworks = Aws::OpsWorks.new(region: "us-east-1"))
+    stack = all(opsworks).detect { |stack| stack.name == stack_name}
+    raise NotFound.new("No stack found with name #{stack_name}") if stack.nil?
+    stack
+  end
+
+  def initialize(opsworks_stack, opsworks = Aws::OpsWorks.new(region: "us-east-1"))
+    @opsworks = opsworks
+    @opsworks_stack = opsworks_stack
+  end
+
+  def name
+    opsworks_stack.name
+  end
+
+  def id
+    opsworks_stack.stack_id
+  end
+
+  def apps
+    @apps ||= Dumbwaiter::App.all(id, opsworks)
+  end
+
+  def deployments
+    @deployments ||= Dumbwaiter::Deployment.all(id, opsworks)
+  end
+end

data/lib/dumbwaiter/version.rb

@@ -1,3 +1,3 @@
 module Dumbwaiter
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/lib/dumbwaiter/app_spec.rb

@@ -0,0 +1,71 @@
+require "spec_helper"
+
+describe Dumbwaiter::App do
+  let(:fake_stack) { double(:stack, id: "pancakes") }
+  let(:fake_app) { double(:app, name: "goose", app_id: "amazing") }
+  let(:fake_apps) { double(:apps, apps: [fake_app]) }
+  let(:fake_opsworks) { double(:opsworks, describe_apps: fake_apps) }
+
+  subject(:app) { Dumbwaiter::App.new(fake_stack, fake_app, fake_opsworks) }
+
+  its(:stack) { should == fake_stack }
+  its(:opsworks_app) { should == fake_app }
+  its(:id) { should == "amazing" }
+  its(:name) { should == "goose" }
+
+  describe "#deploy" do
+    context "when no revision is specified" do
+      it "creates a deployment" do
+        fake_opsworks.should_receive(:create_deployment) do |params|
+          params[:stack_id].should == "pancakes"
+          params[:app_id].should == "amazing"
+          params[:command].should == {name: "deploy", args: {migrate: ["true"]}}
+        end
+        app.deploy
+      end
+    end
+
+    context "when a revision is specified" do
+      it "creates a deployment with a revision" do
+        fake_opsworks.should_receive(:create_deployment) do |params|
+          params[:custom_json].should == {deploy: {"goose" => {scm: {revision: "golden"}}}}.to_json
+        end
+        app.deploy("golden")
+      end
+    end
+  end
+
+  describe "#rollback" do
+    it "creates a rollback" do
+      fake_opsworks.should_receive(:create_deployment) do |params|
+        params[:stack_id].should == "pancakes"
+        params[:app_id].should == "amazing"
+        params[:command].should == {name: "rollback"}
+      end
+      app.rollback
+    end
+  end
+
+  describe ".all" do
+    it "fetches all the apps" do
+      fake_opsworks.should_receive(:describe_apps).with(stack_id: "pancakes")
+      Dumbwaiter::App.all(fake_stack, fake_opsworks).should have(1).app
+    end
+  end
+
+  describe ".find" do
+    context "when the app exists" do
+      it "finds the app by name" do
+        Dumbwaiter::App.find(fake_stack, "goose", fake_opsworks).id.should == "amazing"
+      end
+    end
+
+    context "when the app does not exist" do
+      it "blows up" do
+        expect {
+          Dumbwaiter::App.find(fake_stack, "teeth", fake_opsworks)
+        }.to raise_error(Dumbwaiter::App::NotFound)
+      end
+    end
+  end
+end

data/spec/lib/dumbwaiter/cli_spec.rb

@@ -1,85 +1,101 @@
 require "spec_helper"
 
 describe Dumbwaiter::Cli do
-  let(:fake_stack) { double(:stack, name: "ducks", stack_id: "cool") }
-  let(:fake_stacks) { double(:stacks, stacks: [fake_stack]) }
-
-  let(:fake_app) { double(:app, name: "reifel", app_id: "wat") }
-  let(:fake_apps) { double(:apps, apps: [fake_app]) }
-
-  let(:custom_json) { {deploy: {"reifel" => {scm: {revision: "corn"}}}} }
+  let(:fake_stack) { double(:stack, name: "ducks", id: "wat") }
+  let(:fake_app) { double(:app, name: "reifel") }
 
   subject(:cli) { Dumbwaiter::Cli.new }
 
-  before { cli.opsworks.stub(describe_stacks: fake_stacks, describe_apps: fake_apps) }
+  before do
+    Dumbwaiter::Stack.stub(all: [fake_stack])
+    Dumbwaiter::App.stub(all: [fake_app])
+  end
 
   describe "#deploy" do
     context "when the stack exists" do
-      it "deploys the stack with the resolved id" do
-        cli.opsworks.should_receive(:create_deployment) do |params|
-          params[:stack_id].should == "cool"
-          params[:command].should == {name: "deploy", args: {migrate: ["true"]}}
-          params[:custom_json].should == custom_json.to_json
+      context "when the app exists" do
+        it "deploys the stack with the resolved id" do
+          fake_app.should_receive(:deploy).with("corn")
+          cli.deploy("ducks", "reifel", "corn")
+        end
+      end
+
+      context "when the app does not exist" do
+        it "blows up" do
+          expect { cli.deploy("ducks", "squirrel", "corn") }.to raise_error(Thor::Error)
         end
-        cli.deploy("ducks", "reifel", "corn")
       end
     end
 
     context "when the stack does not exist" do
-      let(:fake_stack) { double(:stack, name: "tacos", stack_id: "great") }
-
       it "blows up" do
-        expect {
-          cli.deploy("ducks", "reifel", "corn")
-        }.to raise_error(Dumbwaiter::Cli::MissingStack)
+        expect { cli.deploy("toques", "reifel", "corn") }.to raise_error(Thor::Error)
       end
     end
   end
 
   describe "#rollback" do
     context "when the stack exists" do
-      it "rolls back the stack with the resolved id" do
-        cli.opsworks.should_receive(:create_deployment) do |params|
-          params[:stack_id].should == "cool"
-          params[:app_id].should == "wat"
-          params[:command].should == {name: "rollback"}
+      context "when the app exists" do
+        it "deploys the stack with the resolved id" do
+          fake_app.should_receive(:rollback)
+          cli.rollback("ducks", "reifel")
+        end
+      end
+
+      context "when the app does not exist" do
+        it "blows up" do
+          expect { cli.rollback("ducks", "montreal") }.to raise_error(Thor::Error)
         end
-        cli.rollback("ducks", "reifel")
       end
     end
 
     context "when the stack does not exist" do
-      let(:fake_stack) { double(:stack, name: "tacos", stack_id: "great") }
-
       it "blows up" do
         expect {
-          cli.rollback("ducks", "reifel")
-        }.to raise_error(Dumbwaiter::Cli::MissingStack)
+          cli.rollback("maple syrup", "reifel")
+        }.to raise_error(Thor::Error)
       end
     end
   end
 
   describe "#list" do
-    let(:fake_command) { double(:command, name: "deploy", args: "not again!")}
-    let(:fake_deployment) { double(:deployment, stack_id: "cool", created_at: "meat", status: "meh", command: fake_command, custom_json: custom_json.to_json) }
-    let(:fake_deployments) { double(:deployments, deployments: [fake_deployment]) }
+    context "when the stack exists" do
+      before { fake_stack.stub(deployments: [fake_deployment]) }
 
-    before { cli.opsworks.stub(describe_deployments: fake_deployments) }
+      context "when the deployment is a rollback" do
+        let(:fake_deployment) { double(:deployment, command_name: "rollback", to_log: "oops!") }
 
-    context "when the stack exists" do
-      it "lists the deployments" do
-        Kernel.stub(:puts) { |string| string.should =~ /meat.+meh.+corn/ }
-        cli.list("ducks")
+        it "lists the deployment" do
+          Kernel.should_receive(:puts).with("oops!")
+          cli.list("ducks")
+        end
+      end
+
+      context "when the deployment is a deploy" do
+        let(:fake_deployment) { double(:deployment, command_name: "deploy", to_log: "whee!") }
+
+        it "lists the deployment" do
+          Kernel.should_receive(:puts).with("whee!")
+          cli.list("ducks")
+        end
+      end
+
+      context "when the deployment is something else" do
+        let(:fake_deployment) { double(:deployment, command_name: "gargle", to_log: "brblrgl") }
+
+        it "does not print anything" do
+          Kernel.should_not_receive(:puts)
+          cli.list("ducks")
+        end
       end
     end
 
     context "when the stack does not exist" do
-      let(:fake_stack) { double(:stack, name: "tacos", stack_id: "great") }
-
       it "blows up" do
         expect {
-          cli.list("ducks")
-        }.to raise_error(Dumbwaiter::Cli::MissingStack)
+          cli.list("wat")
+        }.to raise_error(Thor::Error)
       end
     end
   end

data/spec/lib/dumbwaiter/deployment_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Dumbwaiter::Deployment do
+  let(:fake_command) { double(:command, name: "deplode") }
+  let(:custom_json) { JSON.dump(deploy: {"hockey" => {scm: {revision: "eh-buddy"}}}) }
+  let(:fake_deployment) do
+    double(:deployment,
+      created_at: "yo",
+      command: fake_command,
+      status: "badical",
+      custom_json: custom_json
+    )
+  end
+  let(:fake_deployments) { double(:deployments, deployments: [fake_deployment]) }
+  let(:fake_opsworks) { double(:opsworks, describe_deployments: fake_deployments) }
+
+  subject(:deployment) { Dumbwaiter::Deployment.new(fake_deployment) }
+
+  its(:opsworks_deployment) { should == fake_deployment }
+  its(:created_at) { should == "yo" }
+  its(:command_name) { should == "deplode" }
+  its(:status) { should == "badical" }
+  its(:git_ref) { should == "eh-buddy" }
+  its(:to_log) { should == "yo - deplode - badical - eh-buddy" }
+
+  context "when custom_json is nil" do
+    let(:fake_deployment) do
+      double(:deployment,
+        created_at: "yo",
+        command: fake_command,
+        status: "badical",
+        custom_json: nil
+      )
+    end
+
+    its(:git_ref) { should == "HEAD" }
+  end
+
+  describe ".all" do
+    it "fetches all the deployments" do
+      fake_opsworks.should_receive(:describe_deployments).with(stack_id: "pancakes")
+      Dumbwaiter::Deployment.all("pancakes", fake_opsworks).should have(1).app
+    end
+  end
+end

data/spec/lib/dumbwaiter/stack_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Dumbwaiter::Stack do
+  let(:fake_stack) { double(:stack, name: "ducks", stack_id: "cool") }
+  let(:fake_stacks) { double(:stacks, stacks: [fake_stack]) }
+  let(:fake_opsworks) { double(:opsworks, describe_stacks: fake_stacks) }
+  let(:fake_app) { double(:app) }
+  let(:fake_deployment) { double(:deployment) }
+
+  subject(:stack) { Dumbwaiter::Stack.new(fake_stack) }
+
+  before do
+    Dumbwaiter::App.stub(all: [fake_app])
+    Dumbwaiter::Deployment.stub(all: [fake_deployment])
+  end
+
+  its(:opsworks_stack) { should == fake_stack }
+  its(:id) { should == "cool" }
+  its(:name) { should == "ducks" }
+
+  its(:apps) { should == [fake_app] }
+  its(:deployments) { should == [fake_deployment] }
+
+  describe ".all" do
+    it "fetches all the stacks" do
+      Dumbwaiter::Stack.all(fake_opsworks).should have(1).stack
+    end
+  end
+
+  describe ".find" do
+    context "when the stack exists" do
+      it "finds the stack by name" do
+        Dumbwaiter::Stack.find("ducks", fake_opsworks).id.should == "cool"
+      end
+    end
+
+    context "when the stack does not exist" do
+      it "blows up" do
+        expect {
+          Dumbwaiter::Stack.find("teeth", fake_opsworks)
+        }.to raise_error(Dumbwaiter::Stack::NotFound)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dumbwaiter
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Doc Ritezel
@@ -114,12 +114,18 @@ files:
 - bin/dumbwaiter
 - dumbwaiter.gemspec
 - lib/dumbwaiter.rb
+- lib/dumbwaiter/app.rb
 - lib/dumbwaiter/cli.rb
+- lib/dumbwaiter/deployment.rb
 - lib/dumbwaiter/deployment_custom_json.rb
+- lib/dumbwaiter/stack.rb
 - lib/dumbwaiter/version.rb
 - script/ci.sh
+- spec/lib/dumbwaiter/app_spec.rb
 - spec/lib/dumbwaiter/cli_spec.rb
 - spec/lib/dumbwaiter/deployment_custom_json_spec.rb
+- spec/lib/dumbwaiter/deployment_spec.rb
+- spec/lib/dumbwaiter/stack_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/minifast/dumbwaiter
 licenses:
@@ -146,6 +152,9 @@ signing_key:
 specification_version: 4
 summary: Monitor, deploy and maintain your Opsworks application stacks
 test_files:
+- spec/lib/dumbwaiter/app_spec.rb
 - spec/lib/dumbwaiter/cli_spec.rb
 - spec/lib/dumbwaiter/deployment_custom_json_spec.rb
+- spec/lib/dumbwaiter/deployment_spec.rb
+- spec/lib/dumbwaiter/stack_spec.rb
 - spec/spec_helper.rb