kumo_dockercloud 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f17aa8666415f9aca28a1bff56fd4f15008ac281
-  data.tar.gz: 69a0f07ebf17b9a59fdf426a7e567f620f862b88
+  metadata.gz: 2582ba0407f7bdd51b0a313b93e9508719ce48c0
+  data.tar.gz: 9d1e586ca6c319a3b9db096d571b772d8c026d48
 SHA512:
-  metadata.gz: c4c7cec1ea8cce00a0ac8cd85375ec7ab965c44f02fd9516f0be9e0cb4598e9fbab4bb1d4034f406c4e845f71b76f27ca20e0f371b5c39a7ef4a7b9daba90fed
-  data.tar.gz: a06f463691c216e733f47d83f16713ce85706f5befff163f97bc11d8d52689ecdd72a04271afb328446a7aa009a9870cf4186f3c632751f3641d4a597dbe986d
+  metadata.gz: c67e36f20cd1691b05d0fad87f9133a38f33d3a4a9efda200a213e318b8fe2b13a4474c54df70b5cbdcbaa4e59a103ec19f8103e8d7082dd0bf6ea8efb669e48
+  data.tar.gz: 5109665c78f88ff6af562c82d0030d37696068737474e531f2848a970b0d5f62ba59397e00dc2ac21dd81c231b6f8865067f96e00998e1eba04b36a9b616ca12

data/.rspec

@@ -1,2 +1,3 @@
+--require spec_helper
 --format documentation
 --color

data/lib/kumo_dockercloud.rb

@@ -2,4 +2,5 @@ require 'kumo_dockercloud/environment'
 require 'kumo_dockercloud/deployment'
 require 'kumo_dockercloud/stack'
 require 'kumo_dockercloud/service'
+require 'kumo_dockercloud/service_checker'
 require 'kumo_dockercloud/errors'

data/lib/kumo_dockercloud/docker_cloud_api.rb

@@ -4,7 +4,7 @@ require 'base64' # left out of DockerCloud gem
 module KumoDockerCloud
   class DockerCloudApi
     extend Forwardable
-    def_delegator :@client, :services
+    def_delegators :@client, :services, :stacks
 
     def initialize(options = {})
       options[:username] ||= ENV['DOCKERCLOUD_USER']
@@ -33,5 +33,13 @@ module KumoDockerCloud
         service.containers
       end.flatten
     end
+
+    def service_by_resource_uri(resource_uri)
+      @client.services.get_from_uri(resource_uri)
+    end
+
+    def stack_by_resource_uri(resource_uri)
+      @client.stacks.get_from_uri(resource_uri)
+    end
   end
 end

data/lib/kumo_dockercloud/environment_config.rb

@@ -47,6 +47,11 @@ module KumoDockerCloud
       end
     end
 
+    def tagged_app_image(service_name)
+      service = docker_cloud_api.service_by_stack_and_service_name(stack_name, service_name)
+      service ? service.image_name : "redbubble/#{app_name}:master"
+    end
+
     def image_tag
       image_name.split(':').last
     end

data/lib/kumo_dockercloud/service.rb

@@ -9,42 +9,31 @@ module KumoDockerCloud
       @name = service_name
     end
 
+    def self.service_by_resource_uri(resource_uri)
+      api = KumoDockerCloud::DockerCloudApi.new
+      service = api.service_by_resource_uri(resource_uri)
+      stack = api.stacks.get_from_uri(service.info[:stack])
+
+      self.new(stack.name, service.name)
+    end
+
     def deploy(version)
       update_image(version)
       redeploy
     end
 
-    def check(checks, timeout)
-      Timeout::timeout(timeout) do
-        all_tests_passed = true
-        containers.each do |container|
-          checks.each do |check|
-            unless check.call(container)
-              all_tests_passed = false
-            end
-          end
-        end
-
-        unless all_tests_passed
-          print '.'
-          sleep(5)
-          check(checks, timeout)
-        end
-
-        true
-      end
-    rescue
-      raise KumoDockerCloud::ServiceDeployError.new("One or more checks failed to pass within the timeout")
+    def linked_services
+      get_service.linked_to_service.map { |link| KumoDockerCloud::Service.service_by_resource_uri(link[:to_service]) }
     end
 
     def links
-      get_service.linked_to_service.map { |service| KumoDockerCloud::Service.new(stack_name, service[:name]) }
+      get_service.linked_to_service
     end
 
-    def set_link(service_to_link)
+    def set_link(service_to_link, link_internal_name)
       linked_service = {
         to_service: service_to_link.resource_uri,
-        name: service_to_link.name,
+        name: link_internal_name,
         from_service: resource_uri
       }
 
@@ -59,13 +48,13 @@ module KumoDockerCloud
       get_service.resource_uri
     end
 
-    private
-    attr_reader :stack_name
-
     def containers
       get_service.containers
     end
 
+    private
+    attr_reader :stack_name
+
     def update_image(version)
       docker_cloud_api.services.update(uuid, image: "#{image_name}:#{version}")
     rescue RestClient::InternalServerError

data/lib/kumo_dockercloud/service_checker.rb

@@ -0,0 +1,35 @@
+module KumoDockerCloud
+  class ServiceChecker
+    attr_reader :checks, :timeout, :quiet_time
+
+    def initialize(checks = [], timeout = 300, quiet_time = 5)
+      @checks = checks
+      @timeout = timeout
+      @quiet_time = quiet_time
+    end
+
+    def verify(service)
+      Timeout::timeout(timeout) do
+
+        while any_check_failing?(service)
+          print '.'
+          sleep(quiet_time)
+        end
+
+      end
+    rescue Timeout::Error
+      raise KumoDockerCloud::ServiceDeployError.new("One or more checks failed to pass within the timeout")
+    end
+
+    private
+
+    def any_check_failing?(service)
+      checks.each do |check|
+        service.containers.each do |container|
+          return true unless check.call(container)
+        end
+      end
+      false
+    end
+  end
+end

data/lib/kumo_dockercloud/stack.rb

@@ -9,35 +9,37 @@ module KumoDockerCloud
       @options = options
     end
 
-    def deploy(service_name, version, checks = nil, check_timeout = 300)
+    def deploy(service_name, version, checker = ServiceChecker.new)
       validate_params(service_name, 'Service name')
       validate_params(version, 'Version')
 
       service = Service.new(stack_name, service_name)
       service.deploy(version)
-      service.check(checks, check_timeout) if checks
+      checker.verify(service)
     end
 
     def deploy_blue_green(options)
       service_names = options[:service_names]
       version = options[:version]
-      checks = options[:checks]
-      check_timeout = options[:check_timeout]
+      checker = options[:checker] || ServiceChecker.new
       switching_service_name = options[:switching_service_name]
 
       validate_params(version, "Version")
       validate_params(service_names, "Service names")
       validate_params(switching_service_name, "Switching service name")
 
-      services = service_names.map { |service_name| Service.new(stack_name, service_name) }
-
       switching_service = Service.new(stack_name, switching_service_name)
-      green_service = switching_service.links.find { |linked_service| services.find { |service| service.name == linked_service.name } }
-      blue_service = services.find { |service| service.name != green_service.name }
+      link = switching_service.links.find { |link| service_names.include?(Service.service_by_resource_uri(link[:to_service]).name) }
+      active_service = Service.service_by_resource_uri(link[:to_service])
+
+      inactive_service_name = service_names.find { |name| name != active_service.name }
+      inactive_service = Service.new(stack_name, inactive_service_name)
+
+      inactive_service.deploy(version)
+      checker.verify(inactive_service)
 
-      deploy(blue_service.name, version, checks, check_timeout)
-      switching_service.set_link(blue_service)
-      green_service.stop
+      switching_service.set_link(inactive_service, link[:name])
+      active_service.stop
     end
 
     private

data/lib/kumo_dockercloud/version.rb

@@ -1,3 +1,3 @@
 module KumoDockerCloud
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'
 end

data/spec/kumo_dockercloud/docker_cloud_api_spec.rb

@@ -1,4 +1,3 @@
-require 'kumo_dockercloud/docker_cloud_api'
 require 'webmock/rspec'
 
 describe KumoDockerCloud::DockerCloudApi do
@@ -160,6 +159,52 @@ describe KumoDockerCloud::DockerCloudApi do
     end
   end
 
+  context '#service_by_resource_uri' do
+    let(:resource_uri) { "look_at_me_im_a_resource_id" }
+    let(:service_name) { 'batman' }
+    let(:service) { double(DockerCloud::Service, name: service_name) }
+    let(:services_mock) { double(DockerCloud::StackAPI, get_from_uri: service ) }
+
+    subject { api.service_by_resource_uri(resource_uri) }
+
+    before do
+      allow_any_instance_of(::DockerCloud::Client).to receive(:services).and_return(services_mock)
+    end
+
+    context 'when the service exists' do
+      it { should == service }
+    end
+
+    context 'when there is no service' do
+      let(:services_mock) { double(DockerCloud::ServiceAPI, get_from_uri: nil ) }
+
+      it { should be_nil }
+    end
+  end
+
+  context '#stack_by_resource_uri' do
+    let(:resource_uri) { "look_at_me_im_a_resource_id" }
+    let(:stack_name) { 'batman' }
+    let(:stack) { double(DockerCloud::Stack, name: stack_name) }
+    let(:stacks_mock) { double(DockerCloud::StackAPI, get_from_uri: stack ) }
+
+    subject { api.stack_by_resource_uri(resource_uri) }
+
+    before do
+      allow_any_instance_of(::DockerCloud::Client).to receive(:stacks).and_return(stacks_mock)
+    end
+
+    context 'when the stack exists' do
+      it { should == stack }
+    end
+
+    context 'when there is no service' do
+      let(:stacks_mock) { double(DockerCloud::StackAPI, get_from_uri: nil ) }
+
+      it { should be_nil }
+    end
+  end
+
   context 'forwarded methods' do
     describe '#services' do
       let(:client) { instance_double(DockerCloud::Client) }

data/spec/kumo_dockercloud/environment_config_spec.rb

@@ -1,12 +1,11 @@
-require 'kumo_dockercloud/environment_config'
-require 'kumo_dockercloud/docker_cloud_api'
-
 describe KumoDockerCloud::EnvironmentConfig do
   let(:env_name) { 'test' }
+  let(:app_name) { "app-foo" }
   let(:config_path) { File.join(__dir__, '../fixtures/config') }
-  subject(:instance) { described_class.new(app_name: 'application-stack-name', env_name: env_name, config_path: config_path) }
+  subject(:instance) { described_class.new(app_name: app_name, env_name: env_name, config_path: config_path) }
 
   let(:docker_cloud_api) { instance_double('KumoDockerCloud::DockerCloudApi') }
+  before { allow(KumoDockerCloud::DockerCloudApi).to receive(:new).and_return docker_cloud_api }
 
   describe '#get_binding' do
     let(:services_for_stack) { [] }
@@ -22,87 +21,108 @@ describe KumoDockerCloud::EnvironmentConfig do
         expect(subject).to eq env_name
       end
     end
+  end
 
-    describe '#plain_text_secrets' do
-      context 'with no encrypted secrets' do
-        let(:secrets_data) do
-          {
-            'testkey'  => 'someval',
-            'moretest' => 'otherval'
-          }
-        end
+  describe '#plain_text_secrets' do
+    subject { instance.plain_text_secrets }
 
-        let(:string) { 'plain_text_secrets' }
+    context 'with no encrypted secrets' do
+      let(:secrets_data) do
+        {
+          'testkey'  => 'someval',
+          'moretest' => 'otherval'
+        }
+      end
 
-        it do
-          expect(subject).to eq secrets_data
-        end
+      it do
+        expect(subject).to eq secrets_data
       end
+    end
 
-      context 'with some encrypted secrets' do
-        let(:env_name) { 'test_encrypted' }
-        let(:plain_value) { 'otherval' }
+    context 'with some encrypted secrets' do
+      let(:env_name) { 'test_encrypted' }
+      let(:plain_value) { 'otherval' }
 
-        let(:kms) { double('KumoKi::KMS') }
+      let(:kms) { double('KumoKi::KMS') }
 
-        let(:plain_data) do
-          {
-            'testkey' => 'someval',
-            'enctest' => plain_value
-          }
-        end
+      let(:plain_data) do
+        {
+          'testkey' => 'someval',
+          'enctest' => plain_value
+        }
+      end
 
-        let(:string) { 'plain_text_secrets' }
+      before do
+        allow(KumoKi::KMS).to receive(:new).and_return(kms)
+        allow(kms).to receive(:decrypt).with('ZW5jcnlwdGVkIGJpbmFyeSBkYXRh').and_return(plain_value)
+      end
 
-        before do
-          allow(KumoKi::KMS).to receive(:new).and_return(kms)
-          allow(kms).to receive(:decrypt).with('ZW5jcnlwdGVkIGJpbmFyeSBkYXRh').and_return(plain_value)
-        end
+      it do
+        expect(subject).to eq plain_data
+      end
+    end
+  end
 
-        it do
-          expect(subject).to eq plain_data
-        end
+  describe "#tagged_app_image" do
+    subject { instance.tagged_app_image(service_name) }
+
+    let(:service_name) { "app-foo-service-a" }
+
+    before { expect(docker_cloud_api).to receive(:service_by_stack_and_service_name).with(instance.stack_name, service_name).and_return(service) }
+
+    context "no service present in stack" do
+      let(:service) { nil }
+
+      it "returns the master application image" do
+        expect(subject).to eq("redbubble/#{app_name}:master")
       end
     end
 
-    context 'with API mocked' do
-      before do
-        allow(KumoDockerCloud::DockerCloudApi).to receive(:new).and_return docker_cloud_api
-        allow(docker_cloud_api).to receive(:services_by_stack_name).with("application-stack-name-#{env_name}").and_return(services_for_stack)
+    context "service present in stack" do
+      let(:service) { instance_double(DockerCloud::Service, image_name: current_image_name) }
+      let(:current_image_name) { "redbubble/#{app_name}:14" }
+
+      it "returns the current service image" do
+        expect(subject).to eq(current_image_name)
       end
+    end
 
-      describe '#image_name' do
-        let(:string) { 'image_name' }
+  end
 
-        context 'when there is a service for the given stack' do
-          let(:image_name) { 'redbubble/application-stack-name:1234' }
-          let(:services_for_stack) { [ double(DockerCloud::Service, image_name: image_name) ] }
+  context 'with API mocked' do
+    before { allow(docker_cloud_api).to receive(:services_by_stack_name).with("#{app_name}-#{env_name}").and_return(services_for_stack) }
 
-          it 'uses the pre-exisiting image name' do
-            expect(subject).to eq image_name
-          end
-        end
+    describe '#image_name' do
+      subject { instance.image_name }
 
-        context 'when there is no service for the given stack' do
-          let(:services_for_stack) { [] }
+      context 'when there is a service for the given stack' do
+        let(:image_name) { 'redbubble/application-stack-name:1234' }
+        let(:services_for_stack) { [ double(DockerCloud::Service, image_name: image_name) ] }
 
-          it { expect(subject).to eq 'redbubble/application-stack-name:master' }
+        it 'uses the pre-exisiting image name' do
+          expect(subject).to eq image_name
         end
       end
 
-      describe '#image_tag' do
-        let(:services_for_stack) { [ double(DockerCloud::Service, image_name: image_name)] }
+      context 'when there is no service for the given stack' do
+        let(:services_for_stack) { [] }
 
-        subject { instance.image_tag }
+        it { expect(subject).to eq "redbubble/#{app_name}:master" }
+      end
+    end
 
-        context "when the image name is 'redbubble/assete-wala:latest'" do
-          let(:image_name) { 'redbubble/application-stack-name:latest' }
-          it { expect(subject).to eq 'latest' }
-        end
-        context "when the image name is 'some-registry/mything:9999'" do
-          let(:image_name) { 'some-registry/mything:9999' }
-          it { expect(subject).to eq '9999' }
-        end
+    describe '#image_tag' do
+      let(:services_for_stack) { [ double(DockerCloud::Service, image_name: image_name)] }
+
+      subject { instance.image_tag }
+
+      context "when the image name is 'redbubble/assete-wala:latest'" do
+        let(:image_name) { 'redbubble/application-stack-name:latest' }
+        it { expect(subject).to eq 'latest' }
+      end
+      context "when the image name is 'some-registry/mything:9999'" do
+        let(:image_name) { 'some-registry/mything:9999' }
+        it { expect(subject).to eq '9999' }
       end
     end
   end

data/spec/kumo_dockercloud/environment_spec.rb

@@ -1,6 +1,3 @@
-require 'kumo_dockercloud/environment'
-require 'kumo_dockercloud/environment_config'
-
 describe KumoDockerCloud::Environment do
   let(:env_vars) { {app_name => {'KEY' => 'VALUE'}} }
   let(:app_name) { 'application-stack-name' }

data/spec/kumo_dockercloud/service_checker_spec.rb

@@ -0,0 +1,67 @@
+describe KumoDockerCloud::ServiceChecker do
+  describe ".initialize" do
+    context "defaults" do
+      subject { described_class.new }
+
+      it "has no checks" do
+        expect(subject.checks).to be_empty
+      end
+
+      it "has a timeout of 300 seconds" do
+        expect(subject.timeout).to eq(300)
+      end
+
+      it "has a quiet_time of 5 seconds" do
+        expect(subject.timeout).to eq(300)
+      end
+    end
+  end
+
+  describe '#verify' do
+    let(:happy_check) { lambda { |container| expect(container).to eq(container); true } }
+    let(:sad_check) { lambda { |container| expect(container).to eq(container); false } }
+    let(:container) { double(:my_container) }
+    let(:checks) {[happy_check]}
+    let(:timeout) { 5 }
+
+    let(:containers) { [container, container] }
+
+    let(:service) { instance_double(KumoDockerCloud::Service, containers: containers) }
+
+    subject { described_class.new(checks, timeout, 1).verify(service) }
+
+    context "all checks successful" do
+      it "runs without incident" do
+        subject
+      end
+
+      context "no checks" do
+        let(:checks) { [] }
+
+        it "runs without retrieving containers" do
+          expect(service).not_to receive(:containers)
+          subject
+        end
+      end
+    end
+
+    context "timing out check" do
+      let(:timeout) { 2 }
+      let(:checks) { [sad_check] }
+
+      it "raises an error" do
+        expect { subject }.to raise_error(KumoDockerCloud::ServiceDeployError, "One or more checks failed to pass within the timeout")
+      end
+    end
+
+    context "second time is the charm" do
+      let(:mutating_state) { [] }
+      let(:mutating_check) { lambda { |container| mutating_state << 1; mutating_state.size > 1 } }
+      let(:checks) { [mutating_check] }
+
+      it "runs without incident" do
+        subject
+      end
+    end
+  end
+end

data/spec/kumo_dockercloud/service_spec.rb

@@ -1,12 +1,10 @@
-require 'spec_helper'
-require 'httpi'
-
 describe KumoDockerCloud::Service do
   let(:service_image) { "repository/docker_image_name:version" }
   let(:service_uuid) { "i_am_a_unique_snowflower" }
   let(:docker_cloud_service) { double(:service, uuid: service_uuid, image_name: service_image, containers: [], resource_uri: "api/v1/#{service_uuid}")}
   let(:docker_cloud_services_api) { double(:services_api) }
-  let(:docker_cloud_api) { instance_double(KumoDockerCloud::DockerCloudApi, services: docker_cloud_services_api)}
+  let(:docker_cloud_stacks_api) { instance_double(DockerCloud::StackAPI, :stack_api) }
+  let(:docker_cloud_api) { instance_double(KumoDockerCloud::DockerCloudApi, services: docker_cloud_services_api, stacks: docker_cloud_stacks_api)}
 
   subject { described_class.new('stack_name', 'service_name') }
 
@@ -35,100 +33,69 @@ describe KumoDockerCloud::Service do
     end
   end
 
-  describe '#check' do
-    let(:http_lib) { double('http_lib') }
-    let(:container_status_check) { lambda { |container| container.state == 'Running' } }
-    let(:endpoint_check) do
-      lambda do |container|
-        url = "#{container.container_ports.first[:endpoint_uri]}/site_status"
-        response = http_lib.get(url)
-        response == 200
-      end
+  describe "#linked_services" do
+    let(:linked_service_uuid) { "i_am_the_db" }
+    let(:linked_service_resource_uri) { "/api/app/v1/service/#{linked_service_uuid}" }
+    let(:linked_service_internal_name) { "db" }
+    let(:linked_service_name) { "db-1" }
+    let(:stack_resource_uri) { "stack_resource_uri" }
+    let(:linked_service) { double(:linked_service, uuid: linked_service_uuid, resource_uri: linked_service_resource_uri, info: { stack: stack_resource_uri}, name: linked_service_name) }
+    let(:linked_to_service) do
+      {
+        from_service: service_uuid,
+        name: linked_service_internal_name,
+        to_service: linked_service_resource_uri
+      }
     end
-    let(:checks) {[container_status_check, endpoint_check]}
-    let(:check_timeout) { 300 }
-    let(:whale1) { double(:whale1, container_ports: [{endpoint_uri: "http://whale1.test"}], reload: nil) }
-    let(:whale2) { double(:whale2, state: "Running", container_ports: [{endpoint_uri: "http://whale2.test"}], reload: nil)}
-    let(:containers) { [whale1, whale2] }
+    let(:stack) { double(:docker_cloud_stack, name: "my-stack", resource_uri: stack_resource_uri)}
 
     before do
-      allow(http_lib).to receive(:get).with("http://whale1.test/site_status").and_return(200)
-      allow(http_lib).to receive(:get).with("http://whale2.test/site_status").and_return("timeout", "timeout", 200)
-      allow(whale1).to receive(:state).and_return("Starting", "Running")
-      allow(docker_cloud_service).to receive(:containers).and_return(containers)
+      allow(docker_cloud_service).to receive(:linked_to_service).and_return([linked_to_service])
     end
 
-    it 'resolves to true if all the checks eventually pass' do
-      allow(subject).to receive(:sleep).and_return(nil)
-      expect(subject.check(checks, check_timeout)).to eq(true)
-    end
+    it "returns a list of KumoDockerCloud::Service object that are linked to from this service" do
+      allow(docker_cloud_api).to receive(:service_by_resource_uri).with(linked_service_resource_uri).and_return(linked_service)
+      allow(docker_cloud_stacks_api).to receive(:get_from_uri).with(stack_resource_uri).and_return(stack)
+      allow(docker_cloud_api).to receive(:service_by_stack_and_service_name).with(stack.name, linked_service_name).and_return(linked_service)
 
+      links = subject.linked_services
+      expect(links.first).to have_attributes(resource_uri: linked_service_resource_uri)
+      expect(links.size).to eq(1)
+    end
 
-    it 'raises an error if any check fails to pass within the timeout period' do
-      short_timeout = 2
-      allow(whale1).to receive(:state).and_return("Starting")
-      expect { subject.check(checks, short_timeout) }.to raise_error(KumoDockerCloud::ServiceDeployError, "One or more checks failed to pass within the timeout")
+    it "returns an empty array if there are no links" do
+      allow(docker_cloud_service).to receive(:linked_to_service).and_return([])
+      expect(subject.linked_services).to eq([])
     end
+  end
 
-    describe "#links" do
-      let(:linked_service_uuid) { "i_am_the_db" }
-      let(:linked_service_name) { "db" }
-      let(:linked_to_service) do
-        {
-          from_service: service_uuid,
-          name: linked_service_name,
-          to_service: linked_service_uuid
-        }
-      end
-
-      before do
-        allow(docker_cloud_service).to receive(:linked_to_service).and_return([linked_to_service])
-      end
-
-      it "returns a list of KumoDockerCloud::Service object that are linked to from this service" do
-        links = subject.links
-        expect(links.first).to have_attributes(name: linked_service_name)
-        expect(links.size).to eq(1)
-      end
-
-      it "returns an empty array if there are no links" do
-        allow(docker_cloud_service).to receive(:linked_to_service).and_return([])
-        expect(subject.links).to eq([])
-      end
+  describe "#set_link" do
+    let(:linked_service_uuid) { "i_am_the_db" }
+    let(:linked_service_name) { "db-1" }
+
+    let(:linked_service_internal_name) { "db" }
+    let(:linked_to_service) do
+      {
+        to_service: "api/v1/#{linked_service_uuid}",
+        name: linked_service_internal_name,
+        from_service: "api/v1/#{service_uuid}"
+      }
     end
 
-    describe "#set_link" do
-      let(:linked_service_uuid) { "i_am_the_db" }
-      let(:linked_service_name) { "db" }
-      let(:linked_to_service) do
-        {
-          to_service: "api/v1/#{linked_service_uuid}",
-          name: linked_service_name,
-          from_service: "api/v1/#{service_uuid}"
-        }
-      end
-      let(:linked_service) { KumoDockerCloud::Service.new('stack_name', linked_service_name) }
-      let(:this_service) { double(:this_service, uuid: service_uuid, resource_uri: "api/v1/#{service_uuid}") }
-      let(:linked_service) { double(:linked_service, uuid: linked_service_uuid, resource_uri: "api/v1/#{linked_service_uuid}", name: linked_service_name) }
-
-      before do
-        allow(docker_cloud_api).to receive(:service_by_stack_and_service_name).with('stack_name', 'service_name').and_return(this_service)
-        allow(docker_cloud_api).to receive(:service_by_stack_and_service_name).with('stack_name', linked_service_name).and_return(linked_service)
-      end
-
-      it "updates the link attribute" do
-        expect(docker_cloud_services_api).to receive(:update).with(service_uuid, { linked_to_service: [linked_to_service] })
-
-        subject.set_link(linked_service)
-      end
+    let(:this_service) { double(:this_service, uuid: service_uuid, resource_uri: "api/v1/#{service_uuid}") }
+    let(:linked_service) { double(:linked_service, uuid: linked_service_uuid, resource_uri: "api/v1/#{linked_service_uuid}", name: linked_service_name) }
+
+    it "updates the link attribute" do
+      expect(docker_cloud_services_api).to receive(:update).with(service_uuid, { linked_to_service: [linked_to_service] })
+      subject.set_link(linked_service, linked_service_internal_name)
     end
+  end
 
-    describe "#stop" do
-      it "sends a request to stop the service" do
-        expect(docker_cloud_services_api).to receive(:stop).with(service_uuid)
+  describe "#stop" do
+    it "sends a request to stop the service" do
+      expect(docker_cloud_services_api).to receive(:stop).with(service_uuid)
 
-        subject.stop
-      end
+      subject.stop
     end
   end
 end

data/spec/kumo_dockercloud/stack_file_spec.rb

@@ -1,6 +1,3 @@
-require_relative '../../lib/kumo_dockercloud/environment_config'
-require_relative '../../lib/kumo_dockercloud/stack_file'
-
 describe KumoDockerCloud::StackFile do
 
   let(:app_name) { 'application-stack-name' }

data/spec/kumo_dockercloud/stack_spec.rb

@@ -1,141 +1,140 @@
-require 'spec_helper'
-
 describe KumoDockerCloud::Stack do
-  let(:service_api) { instance_double(DockerCloud::ServiceAPI) }
-  let(:uuid) { 'foo' }
-  let(:service_name) { 'test_service' }
+  let(:stack) { described_class.new(app_name, environment_name) }
   let(:app_name) { 'test_app' }
   let(:environment_name) { 'environment' }
-  let(:app_version) { '1' }
-  let(:client) { instance_double(DockerCloud::Client, stacks: stacks, services: service_api) }
-  let(:stacks) { double('stacks', all: [stack]) }
-  let(:stack_name) { "#{app_name}-#{environment_name}" }
-  let(:stack) { instance_double(DockerCloud::Stack, name: stack_name) }
-  let(:service) { instance_double(KumoDockerCloud::Service, uuid: uuid) }
-  let(:check_timeout) { 300 }
-
-  before do
-    allow(::DockerCloud::Client).to receive(:new).and_return(client)
-    allow(KumoDockerCloud::Service).to receive(:new).with(stack_name, service_name).and_return(service)
-    allow(service).to receive(:deploy).with("test_version")
-  end
+  let(:stack_name) { stack.stack_name }
 
   describe '#deploy' do
-    subject { described_class.new(app_name, environment_name) }
+    let(:service_name) { 'test_service' }
+    let(:version) { '1' }
+    let(:checker) { instance_double(KumoDockerCloud::ServiceChecker, verify: nil) }
+    let(:service) { instance_double(KumoDockerCloud::Service) }
 
-    it 'complains if passed a nil service name' do
-      expect { subject.deploy(nil, 1) }.to raise_error(KumoDockerCloud::Error, 'Service name cannot be nil')
+    before do
+      allow(KumoDockerCloud::Service).to receive(:new).with(stack_name, service_name).and_return(service)
+      allow(service).to receive(:deploy).with(version)
     end
 
-    it 'complains if passed an empty service name' do
-      expect { subject.deploy("", 1) }.to raise_error(KumoDockerCloud::Error, 'Service name cannot be empty')
-    end
+    subject { stack.deploy(service_name, version) }
 
-    it 'complains if passed a nil version' do
-      expect { subject.deploy("test_service", nil) }.to raise_error(KumoDockerCloud::Error, 'Version cannot be nil')
+    it 'deploys the version of my service' do
+      expect(service).to receive(:deploy).with(version)
+      subject
     end
 
-    it 'complains if passed an empty version' do
-      expect { subject.deploy("test_service", "") }.to raise_error(KumoDockerCloud::Error, 'Version cannot be empty')
-    end
+    context "validation" do
+      context "nil name" do
+        let(:service_name) { nil }
 
-    it 'deploys the version of my service' do
-      expect(service).to receive(:deploy).with("test_version")
-      subject.deploy('test_service', 'test_version')
-    end
+        it "complains" do
+          expect { subject }.to raise_error(KumoDockerCloud::Error, 'Service name cannot be nil')
+        end
+      end
 
-    it 'passes any checks to the checker' do
-      checks = ["check1", "check2"]
-      allow(service).to receive(:deploy).with("test_version")
-      expect(service).to receive(:check).with(checks, check_timeout)
-      subject.deploy('test_service', 'test_version', checks)
-    end
+      context "empty name" do
+        let(:service_name) { "" }
+
+        it "complains" do
+          expect { subject }.to raise_error(KumoDockerCloud::Error, 'Service name cannot be empty')
+        end
+      end
 
-    it 'passes any specific timeout to the checker' do
-      checks = ["check1", "check2"]
-      shortened_timeout = 10
-      allow(service).to receive(:deploy).with("test_version")
-      expect(service).to receive(:check).with(checks, shortened_timeout)
-      subject.deploy('test_service', 'test_version', checks, shortened_timeout)
+      context "nil version" do
+        let(:version) { nil }
+
+        it "complains" do
+          expect { subject }.to raise_error(KumoDockerCloud::Error, 'Version cannot be nil')
+        end
+      end
+
+      context "empty version" do
+        let(:version) { "" }
+
+        it "complains" do
+          expect { subject }.to raise_error(KumoDockerCloud::Error, 'Version cannot be empty')
+        end
+      end
     end
 
+    context "with a checker supplied" do
+      subject { stack.deploy(service_name, version, checker) }
+
+      it 'uses the supplied service checker' do
+        expect(checker).to receive(:verify).with(service)
+        subject
+      end
+    end
   end
 
   describe '#deploy_blue_green' do
-    let(:service_a_uuid) { 'service_a_uuid' }
-    let(:service_a) { instance_double(KumoDockerCloud::Service, :service_a, uuid: uuid, name: "service-a") }
-    let(:service_b_uuid) { 'service_b_uuid' }
-    let(:service_b) { instance_double(KumoDockerCloud::Service, :service_b, uuid: uuid, name: "service-b") }
-    let(:nginx) { instance_double(KumoDockerCloud::Service, uuid: "nginx_uuid") }
-    let(:version) { "1" }
-    let(:deployment_checks) { [] }
-    let(:links) { [service_a] }
-    let(:check_timeout) { 120 }
+    let(:service_name) { 'test_service' }
+    let(:version) { '1' }
+    let(:checker) { instance_double(KumoDockerCloud::ServiceChecker, verify: nil) }
+
+    let(:active_service) { instance_double(KumoDockerCloud::Service, :active_service, name: "service-a", stop: nil) }
+    let(:inactive_service) { instance_double(KumoDockerCloud::Service, :inactive_service, name: "service-b", deploy: nil) }
+    let(:service_link) { { name: switching_service_internal_link_name, to_service: linked_service_uri} }
+    let(:linked_service_uri) { "active_uri" }
+    let(:switching_service) { instance_double(KumoDockerCloud::Service, links: [service_link], set_link: nil) }
+    let(:switching_service_internal_link_name) { "app" }
     let(:deploy_options) do
       {
-        service_names: ["service-a", "service-b"],
+        service_names: [active_service.name, inactive_service.name],
         version: version,
-        checks: deployment_checks,
-        check_timeout: check_timeout,
-        switching_service_name: "nginx"
+        checker: checker,
+        switching_service_name: "switcher"
       }
     end
 
     subject { described_class.new(app_name, environment_name).deploy_blue_green(deploy_options) }
 
     before do
-      allow(KumoDockerCloud::Service).to receive(:new)
-        .with(stack_name, "service-a")
-        .and_return(service_a)
+      allow(KumoDockerCloud::Service).to receive(:service_by_resource_uri).with(linked_service_uri).and_return(active_service)
 
       allow(KumoDockerCloud::Service).to receive(:new)
-        .with(stack_name, "service-b")
-        .and_return(service_b)
+        .with(stack_name, active_service.name)
+        .and_return(active_service)
 
       allow(KumoDockerCloud::Service).to receive(:new)
-        .with(stack_name, "nginx")
-        .and_return(nginx)
+        .with(stack_name, inactive_service.name)
+        .and_return(inactive_service)
 
-      allow(nginx).to receive(:links).and_return(links)
-      allow(nginx).to receive(:set_link).with(service_b)
-
-      allow(service_a).to receive(:stop)
-
-      allow(service_b).to receive(:deploy).with(version)
-      allow(service_b).to receive(:check).with(deployment_checks, check_timeout)
+      allow(KumoDockerCloud::Service).to receive(:new)
+        .with(stack_name, deploy_options[:switching_service_name])
+        .and_return(switching_service)
     end
 
     context 'when parameters are missing' do
-      it 'blow up when version is missing' do
+      it 'blows up when version is missing' do
         deploy_options.delete(:version)
         expect{ subject }.to raise_error(KumoDockerCloud::Error, "Version cannot be nil")
       end
 
-      it 'blow up when service_names are missing' do
+      it 'blows up when service_names are missing' do
         deploy_options.delete(:service_names)
         expect{ subject }.to raise_error(KumoDockerCloud::Error, "Service names cannot be nil")
       end
 
-      it 'blow up when switching_service_name is missing' do
+      it 'blows up when switching_service_name is missing' do
         deploy_options.delete(:switching_service_name)
         expect{ subject }.to raise_error(KumoDockerCloud::Error, "Switching service name cannot be nil")
       end
     end
 
     it 'deploys to the blue service only' do
-      expect(service_b).to receive(:deploy).with(version)
-      expect(service_b).to receive(:check).with(deployment_checks, check_timeout)
-      expect(service_a).to_not receive(:deploy)
+      expect(inactive_service).to receive(:deploy).with(version)
+      expect(checker).to receive(:verify).with(inactive_service)
+      expect(active_service).to_not receive(:deploy)
       subject
     end
 
     it 'switches over to the blue service on a successful deployment' do
-      expect(nginx).to receive(:set_link).with(service_b)
+      expect(switching_service).to receive(:set_link).with(inactive_service, switching_service_internal_link_name)
       subject
     end
 
     it 'shuts down the previously green service' do
-      expect(service_a).to receive(:stop)
+      expect(active_service).to receive(:stop)
       subject
     end
   end

data/spec/kumo_dockercloud/state_validator_spec.rb

@@ -1,6 +1,3 @@
-require 'rspec'
-require 'spec_helper'
-
 describe KumoDockerCloud::StateValidator do
   describe '#wait_for_state' do
     subject { state_validator.wait_for_state('done', 1) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumo_dockercloud
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Redbubble
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-27 00:00:00.000000000 Z
+date: 2016-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpi
@@ -134,6 +134,7 @@ files:
 - lib/kumo_dockercloud/environment_config.rb
 - lib/kumo_dockercloud/errors.rb
 - lib/kumo_dockercloud/service.rb
+- lib/kumo_dockercloud/service_checker.rb
 - lib/kumo_dockercloud/stack.rb
 - lib/kumo_dockercloud/stack_file.rb
 - lib/kumo_dockercloud/state_validator.rb
@@ -149,6 +150,7 @@ files:
 - spec/kumo_dockercloud/docker_cloud_api_spec.rb
 - spec/kumo_dockercloud/environment_config_spec.rb
 - spec/kumo_dockercloud/environment_spec.rb
+- spec/kumo_dockercloud/service_checker_spec.rb
 - spec/kumo_dockercloud/service_spec.rb
 - spec/kumo_dockercloud/stack_file_spec.rb
 - spec/kumo_dockercloud/stack_spec.rb
@@ -187,6 +189,7 @@ test_files:
 - spec/kumo_dockercloud/docker_cloud_api_spec.rb
 - spec/kumo_dockercloud/environment_config_spec.rb
 - spec/kumo_dockercloud/environment_spec.rb
+- spec/kumo_dockercloud/service_checker_spec.rb
 - spec/kumo_dockercloud/service_spec.rb
 - spec/kumo_dockercloud/stack_file_spec.rb
 - spec/kumo_dockercloud/stack_spec.rb