kumo_dockercloud 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30cba0c29df6e2bd9db7bae50838fc0bf317c2fa
-  data.tar.gz: e5b9bf55b8ff0cf329e6537099db2ea54840d383
+  metadata.gz: 8c1c50a0d06325de8c9767de8b5e85a4d09dd56d
+  data.tar.gz: b94cfc7050e86e202425c77f8e7bc492db9b5a9b
 SHA512:
-  metadata.gz: 926d693084ea08c039a9fcd643fc388399d771e73b9d221d0f4ac6a82734382dbf1090c025b1b7809e4056c514fa9810c0e4d2ad240ceabf53de7ee29dc78a41
-  data.tar.gz: db132f216e112a0a15cf6cec3563bc340f63f2cd065b0177d1a2a19bf5d127556270c93f81981cbb4e96ecca1e82c4170611357e460b634197a371299460d40f
+  metadata.gz: 317f70cb98f1dfc376cbd258a7a7a55ae6c64cba9b9f0a15e50d146d0c1f12f154f64caecb6c38193cea049aed18be586ec6e2ef0f8a9b46a8be18458d8d26eb
+  data.tar.gz: fc7f5ea565530532030617f44306afe62aa4da2cee3bbb369c2d882a4d076fda5b1bf1e3810544ed8b308ca3f085daab6b9c99f6265b4cb005037300858f94e5

data/lib/kumo_dockercloud.rb

@@ -1,3 +1,5 @@
 require 'kumo_dockercloud/environment'
 require 'kumo_dockercloud/deployment'
 require 'kumo_dockercloud/stack'
+require 'kumo_dockercloud/service'
+require 'kumo_dockercloud/errors'

data/lib/kumo_dockercloud/deployment.rb

@@ -35,11 +35,20 @@ module KumoDockerCloud
       StateValidator.new(service_state_provider).wait_for_state('Running', 240)
     end
 
+    def wait_for_exit_state
+      exit_state_provider = lambda {
+        service = docker_cloud_api.services.get(service_uuid)
+        { name: service.name, exit_code: service.containers.first.exit_code }
+      }
+
+      StateValidator.new(exit_state_provider).wait_for_exit_state(240)
+    end
+
     private
 
-    def service_uuid
+    def service_uuid(service_name)
       @service_uuid ||= begin
-        services = docker_cloud_api.services_by_stack_name(stack_name)
+        services = docker_cloud_api.service_by_stack_and_service_name(stack_name, service_name)
         services.first.uuid
       end
     end
@@ -120,7 +129,7 @@ module KumoDockerCloud
         raise e
       else
         retry
-      end 
+      end
     end
   end
 end

data/lib/kumo_dockercloud/docker_cloud_api.rb

@@ -9,7 +9,8 @@ module KumoDockerCloud
     def initialize(options = {})
       options[:username] ||= ENV['DOCKERCLOUD_USER']
       options[:api_key] ||= ENV['DOCKERCLOUD_APIKEY']
-      @client = options[:client] || ::DockerCloud::Client.new(options[:username], options[:api_key])
+
+      @client = options[:client] || ::DockerCloud::Client.new(options.fetch(:username), options.fetch(:api_key))
     end
 
     def stack_by_name(name)
@@ -22,6 +23,11 @@ module KumoDockerCloud
       stack.services
     end
 
+    def service_by_stack_and_service_name(stack_name, service_name)
+      services = services_by_stack_name(stack_name)
+      services.find { |s| s.name == service_name }
+    end
+
     def containers_by_stack_name(stack_name)
       services_by_stack_name(stack_name).collect do |service|
         service.containers

data/lib/kumo_dockercloud/environment.rb

@@ -8,6 +8,7 @@ require_relative 'state_validator'
 require_relative 'environment_config'
 require_relative 'stack_file'
 
+#TODO refactor this to use the new checker inside Service
 module KumoDockerCloud
   class Environment
     extend ::Forwardable

data/lib/kumo_dockercloud/errors.rb

@@ -0,0 +1,4 @@
+module KumoDockerCloud
+  class Error < RuntimeError; end
+  class ServiceDeployError < RuntimeError; end
+end

data/lib/kumo_dockercloud/service.rb

@@ -0,0 +1,73 @@
+require 'timeout'
+
+module KumoDockerCloud
+  class Service
+    def initialize(stack_name, service_name)
+      @stack_name = stack_name
+      @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")
+    end
+
+    private
+    attr_reader :stack_name, :name
+
+    def containers
+      service_api.containers
+    end
+
+    def update_image(version)
+      docker_cloud_api.services.update(uuid, image: "#{image_name}:#{version}")
+    rescue RestClient::InternalServerError
+      raise KumoDockerCloud::ServiceDeployError.new("Something went wrong during service update on Docker Cloud's end")
+    end
+
+    def redeploy
+      docker_cloud_api.services.redeploy(uuid)
+    rescue RestClient::InternalServerError
+      raise KumoDockerCloud::ServiceDeployError.new("Something went wrong during service update on Docker Cloud's end")
+    end
+
+    def docker_cloud_api
+      @docker_cloud_api ||= KumoDockerCloud::DockerCloudApi.new
+    end
+
+    def service_api
+      docker_cloud_api.service_by_stack_and_service_name(stack_name, name)
+    end
+
+    def uuid
+      service_api.uuid
+    end
+
+    def image_name
+      service_api.image_name.split(':').first
+    end
+  end
+end

data/lib/kumo_dockercloud/stack.rb

@@ -8,39 +8,20 @@ module KumoDockerCloud
       @options = options
     end
 
-    def deploy(version)
-      update_image(version)
-      redeploy
-      validate_deployment(version)
-    end
-
-    private
-
-    def update_image(version)
-      docker_cloud_api.services.update(service_uuid, image: "redbubble/#{app_name}:#{version}")
-    end
+    def deploy(service_name, version, checks = nil, check_timeout = 300)
+      validate_params(service_name, 'Service name')
+      validate_params(version, 'Version')
 
-    def redeploy
-      docker_cloud_api.services.redeploy(service_uuid)
+      service = Service.new(stack_name, service_name)
+      service.deploy(version)
+      service.check(checks, check_timeout) if checks
     end
 
-    def validate_deployment(version)
-      deployment = Deployment.new(stack_name, version)
-      deployment.app_name = app_name
-      deployment.contactable = options[:contactable]
-      deployment.validate
-    end
-
-    def service_uuid
-      @service_uuid ||= begin
-        services = docker_cloud_api.services_by_stack_name(stack_name)
-        services.first.uuid
-      end
-    end
+    private
 
-    def docker_cloud_api
-      @docker_cloud_api ||= KumoDockerCloud::DockerCloudApi.new
+    def validate_params(param_value, param_name)
+      raise KumoDockerCloud::Error.new("#{param_name} cannot be nil") unless param_value
+      raise KumoDockerCloud::Error.new("#{param_name} cannot be empty") if param_value.empty?
     end
-
   end
 end

data/lib/kumo_dockercloud/state_validator.rb

@@ -37,6 +37,35 @@ module KumoDockerCloud
       end
     end
 
+    def wait_for_exit_state(time_limit)
+      start_time = Time.now
+
+      while Time.now.to_i - start_time.to_i < time_limit
+        @stateful = state_provider.call
+
+        print "."
+
+        unless current_exit_code.nil?
+          break
+        end
+
+        sleep(1)
+      end
+
+      print "\n"
+
+      if current_exit_code.nil?
+        puts "#{@stateful[:name]} deployment timed out after #{time_limit} seconds"
+        raise TimeoutError.new
+      end
+
+      if current_exit_code != 0
+        error_message = "#{@stateful[:name]} deployment failed with exit code #{current_exit_code}"
+        puts error_message
+        raise error_message
+      end
+    end
+
     private
 
     def current_state
@@ -44,6 +73,11 @@ module KumoDockerCloud
       @stateful.fetch(:state, 'an unknown state')
     end
 
+    def current_exit_code
+      return 'an unknown state' if @stateful.nil?
+      @stateful.fetch(:exit_code, nil)
+    end
+
   end
 
 end

data/lib/kumo_dockercloud/version.rb

@@ -1,3 +1,3 @@
 module KumoDockerCloud
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/spec/kumo_dockercloud/service_spec.rb

@@ -0,0 +1,72 @@
+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_api) { double(:services_api, uuid: service_uuid, image_name: service_image, containers: []) }
+  let(:docker_cloud_api) { instance_double(KumoDockerCloud::DockerCloudApi, services: docker_cloud_service_api)}
+
+  subject { described_class.new('stack_name', 'service_name') }
+
+  before do
+    allow(KumoDockerCloud::DockerCloudApi).to receive(:new).and_return(docker_cloud_api)
+
+    allow(docker_cloud_api).to receive(:service_by_stack_and_service_name).with('stack_name', 'service_name').and_return(docker_cloud_service_api)
+  end
+
+  describe '#deploy' do
+    it 'runs the actual update and redeploy methods' do
+      expect(docker_cloud_service_api).to receive(:update).with(service_uuid, { image: service_image })
+      expect(docker_cloud_service_api).to receive(:redeploy).with(service_uuid)
+      subject.deploy('version')
+    end
+
+    it 'raises an appropriate exception when there is an error during image update' do
+      expect(docker_cloud_service_api).to receive(:update).and_raise(RestClient::InternalServerError)
+      expect { subject.deploy('version') }.to raise_error(KumoDockerCloud::ServiceDeployError, "Something went wrong during service update on Docker Cloud's end")
+    end
+
+    it 'raises an appropriate exception when there is an error during redployment' do
+      allow(docker_cloud_service_api).to receive(:update).with(service_uuid, { image: service_image })
+      expect(docker_cloud_service_api).to receive(:redeploy).and_raise(RestClient::InternalServerError)
+      expect { subject.deploy('version') }.to raise_error(KumoDockerCloud::ServiceDeployError, "Something went wrong during service update on Docker Cloud's end")
+    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
+    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] }
+
+    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_api).to receive(:containers).and_return(containers)
+    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 '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")
+    end
+  end
+end

data/spec/kumo_dockercloud/stack_spec.rb

@@ -1,29 +1,63 @@
 require 'spec_helper'
 
 describe KumoDockerCloud::Stack do
+  let(:service_api) { instance_double(DockerCloud::ServiceAPI) }
+  let(:uuid) { 'foo' }
+  let(:service_name) { 'test_service' }
+  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
+
   describe '#deploy' do
-    subject { described_class.new(app_name, environment_name).deploy(app_version) }
-
-    let(:app_name) { 'test_app' }
-    let(:environment_name) { 'environment' }
-    let(:app_version) { '1' }
-    let(:uuid) { 'foo' }
-    let(:client) { instance_double(DockerCloud::Client, stacks: stacks, services: service_api) }
-    let(:service_api) { instance_double(DockerCloud::ServiceAPI) }
-    let(:stacks) { double('stacks', all: [stack]) }
-    let(:stack) { instance_double(DockerCloud::Stack, name: "#{app_name}-#{environment_name}", services: [service]) }
-    let(:service) { instance_double(DockerCloud::Service, uuid: uuid, containers: []) }
-    let(:state_validator) { instance_double(KumoDockerCloud::StateValidator, wait_for_state: nil) }
-
-    before do
-      allow(::DockerCloud::Client).to receive(:new).and_return(client)
-      allow(KumoDockerCloud::StateValidator).to receive(:new).and_return(state_validator)
+    subject { described_class.new(app_name, environment_name) }
+
+    it 'complains if passed a nil service name' do
+      expect { subject.deploy(nil, 1) }.to raise_error(KumoDockerCloud::Error, 'Service name cannot be nil')
+    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
+
+    it 'complains if passed a nil version' do
+      expect { subject.deploy("test_service", nil) }.to raise_error(KumoDockerCloud::Error, 'Version cannot be nil')
     end
 
-    it 'uses the service api to update the image and redeploy' do
-      expect(service_api).to receive(:update).with(uuid, {image: "redbubble/#{app_name}:#{app_version}"})
-      expect(service_api).to receive(:redeploy).with(uuid)
-      subject
+    it 'complains if passed an empty version' do
+      expect { subject.deploy("test_service", "") }.to raise_error(KumoDockerCloud::Error, 'Version cannot be empty')
     end
+
+    it 'deploys the version of my service' do
+      expect(service).to receive(:deploy).with("test_version")
+      subject.deploy('test_service', 'test_version')
+    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
+
+    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)
+    end
+
   end
 end

data/spec/kumo_dockercloud/state_validator_spec.rb

@@ -6,7 +6,7 @@ describe KumoDockerCloud::StateValidator do
     subject { state_validator.wait_for_state('done', 1) }
     let(:state_validator) { described_class.new(state_provider) }
     let(:state_provider) { double('state_provider', call: service) }
-    let(:service) { { state: service_state, name: 'service name' } }
+    let(:service) { {state: service_state, name: 'service name'} }
 
     context 'the right state' do
       let(:service_state) { 'done' }
@@ -26,4 +26,36 @@ describe KumoDockerCloud::StateValidator do
 
   end
 
+  describe '#wait_for_exit_state' do
+    subject { state_validator.wait_for_exit_state(1) }
+    let(:state_validator) { described_class.new(state_provider) }
+    let(:state_provider) { double('state_provider', call: service) }
+    let(:service) { {name: 'service name', exit_code: exit_code} }
+
+    context 'success' do
+      let(:exit_code) { 0 }
+
+      it 'succeeds immediately if the state is right' do
+        subject
+      end
+    end
+
+    context 'failure' do
+      let(:exit_code) { 1 }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error("service name deployment failed with exit code 1")
+      end
+    end
+
+    context 'no exit before the timeout' do
+      let(:exit_code) { nil }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error(Timeout::Error)
+      end
+    end
+
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumo_dockercloud
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Redbubble
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-05 00:00:00.000000000 Z
+date: 2016-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpi
@@ -132,6 +132,8 @@ files:
 - lib/kumo_dockercloud/docker_cloud_api.rb
 - lib/kumo_dockercloud/environment.rb
 - lib/kumo_dockercloud/environment_config.rb
+- lib/kumo_dockercloud/errors.rb
+- lib/kumo_dockercloud/service.rb
 - lib/kumo_dockercloud/stack.rb
 - lib/kumo_dockercloud/stack_file.rb
 - lib/kumo_dockercloud/state_validator.rb
@@ -147,6 +149,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_spec.rb
 - spec/kumo_dockercloud/stack_file_spec.rb
 - spec/kumo_dockercloud/stack_spec.rb
 - spec/kumo_dockercloud/state_validator_spec.rb
@@ -184,6 +187,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_spec.rb
 - spec/kumo_dockercloud/stack_file_spec.rb
 - spec/kumo_dockercloud/stack_spec.rb
 - spec/kumo_dockercloud/state_validator_spec.rb