kumo_dockercloud 3.1.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad2671be63f6abc977f2bf30685ced335589bb12
-  data.tar.gz: 635f266c6dd92c1efc4c3c42a0c21277cf066463
+  metadata.gz: d56a26a559069438a8dffe96f6197a43ff784a88
+  data.tar.gz: b8b55150263ca7259d21524b8bd759c412561122
 SHA512:
-  metadata.gz: 890aefc823c9e726e6a17358fc191d4f37cf8d9dd78ed5505eb4f78edea10522fde7140731d299258cf866941a8434217b4ee198d5275d41a35b6074bda7d2d0
-  data.tar.gz: 85f752619dd42387da47cba37d53e0fdb7a4198499b32a0e98f17c4680a55359ecb4f04fbca08e9828d0c3b5778aaf47b59f16bbfbc228a6c12d85b6237375f1
+  metadata.gz: 36456d19ed2a73171023e65d5ed7e09de4a71d4c23d1e305a4c57c73dd488c5f43963289550f88648657dd0354e0c6184d725ed55df064694927f349e30073a7
+  data.tar.gz: 65858ebe4cabbd00d82b18e281c978cc1e2e5016925f4056a610a703844fc94b36669615bff7a8e1fe7edcc0448d9ef6945314c60a0bdbb042ac4af5ba4bbd2d

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in kumo_dockercloud.gemspec
 gemspec
+
+group :development do
+  gem 'pry'
+end

data/lib/kumo_dockercloud/console_jockey.rb

@@ -19,6 +19,12 @@ module KumoDockerCloud
       $stdout.flush
     end
 
+    def self.write_char(char)
+      print char
+
+      $stdout.flush
+    end
+
     def self.get_confirmation(timeout=30)
       begin
         status = Timeout::timeout(timeout) {

data/lib/kumo_dockercloud/service_check.rb

@@ -0,0 +1,14 @@
+module KumoDockerCloud
+  class ServiceCheck
+    attr_reader :error_message
+
+    def initialize(lambda, error_message)
+      @error_message = error_message
+      @lambda = lambda
+    end
+
+    def call(container)
+      @lambda.call(container)
+    end
+  end
+end

data/lib/kumo_dockercloud/service_checker.rb

@@ -1,3 +1,5 @@
+require_relative 'console_jockey'
+
 module KumoDockerCloud
   class ServiceChecker
     attr_reader :checks, :timeout, :quiet_time
@@ -12,24 +14,35 @@ module KumoDockerCloud
       Timeout::timeout(timeout) do
 
         while any_check_failing?(service)
-          print '.'
+          ConsoleJockey.write_char '.'
           sleep(quiet_time)
         end
 
       end
     rescue Timeout::Error
-      raise KumoDockerCloud::ServiceDeployError.new("One or more checks failed to pass within the timeout")
+      if @error_messages.length > 0
+        raise KumoDockerCloud::ServiceDeployError.new("One or more checks failed to pass within the timeout.#{@error_messages.join}")
+      else
+        raise KumoDockerCloud::ServiceDeployError.new("One or more checks failed to pass within the timeout. I'd show you what went wrong but the checks were lambdas so I can't. Maybe you should update your usage to the new ServiceCheck object instead of lambdas?")
+      end
     end
 
     private
 
     def any_check_failing?(service)
+      failed = false
+      @error_messages = []
       checks.each do |check|
         service.containers.each do |container|
-          return true unless check.call(container)
+          unless check.call(container)
+            failed = true
+          end
+        end
+        if failed && check.respond_to?(:error_message)
+          @error_messages << ( "\nMessage: #{check.error_message} | Service Name: #{service.name}" )
         end
       end
-      false
+      failed
     end
   end
 end

data/lib/kumo_dockercloud/stack_checker.rb

@@ -1,8 +1,8 @@
 module KumoDockerCloud
   class StackChecker
-    def initialize(specific_checks = {}, common_check = nil, timeout = 300)
+    def initialize(specific_checks = {}, default_check = nil, timeout = 300)
       @checks = specific_checks
-      @default_check = common_check
+      @default_check = default_check
       @timeout = timeout
     end
 
@@ -28,7 +28,7 @@ module KumoDockerCloud
     private
 
     def default_check
-      @default_check ||= [lambda { |container| container.state == 'Running' }]
+      @default_check ||= [ServiceCheck.new(lambda { |container| container.state == 'Running' }, "Service is not running")]
     end
   end
 end

data/lib/kumo_dockercloud/version.rb

@@ -1,3 +1,3 @@
 module KumoDockerCloud
-  VERSION = '3.1.1'
+  VERSION = '3.2.0'
 end

data/lib/kumo_dockercloud.rb

@@ -4,5 +4,6 @@ require 'kumo_dockercloud/stack'
 require 'kumo_dockercloud/stack_checker'
 require 'kumo_dockercloud/service'
 require 'kumo_dockercloud/service_checker'
+require 'kumo_dockercloud/service_check'
 require 'kumo_dockercloud/errors'
 require 'kumo_dockercloud/console_jockey'

data/spec/kumo_dockercloud/service_checker_spec.rb

@@ -1,3 +1,5 @@
+require 'spec_helper'
+
 describe KumoDockerCloud::ServiceChecker do
   describe ".initialize" do
     context "defaults" do
@@ -18,49 +20,118 @@ describe KumoDockerCloud::ServiceChecker do
   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, name: 'service') }
+    let(:timeout) { 0.5 }
+    let(:quiet_time) { 0.1 }
 
-    let(:service) { instance_double(KumoDockerCloud::Service, containers: containers) }
+    subject { described_class.new(checks, timeout, quiet_time).verify(service) }
+
+    before do
+      allow(KumoDockerCloud::ConsoleJockey).to receive(:write_char).and_return(nil)
+    end
 
-    subject { described_class.new(checks, timeout, 1).verify(service) }
+    context 'passing ServiceCheck objects' do
+      let(:check) { KumoDockerCloud::ServiceCheck.new(check_lambda, check_error_message) }
+      let(:check_lambda) { lambda { |_container| true } }
+      let(:check_error_message) { "" }
+      let(:checks) { [check] }
 
-    context "all checks successful" do
-      it "runs without incident" do
-        subject
+      context 'all checks successful' do
+        it 'runs without incident' do
+          subject
+        end
       end
 
-      context "no checks" do
-        let(:checks) { [] }
+      context "timing out check" do
+        let(:timeout) { 2 }
+        let(:check_lambda) { lambda { |_container| false } }
+        let(:check_error_message) { "Expected error message" }
 
-        it "runs without retrieving containers" do
-          expect(service).not_to receive(:containers)
+        it "raises an error with service detail" do
+          expect { subject }.to raise_error(KumoDockerCloud::ServiceDeployError, "One or more checks failed to pass within the timeout.\nMessage: #{check_error_message} | Service Name: #{service.name}")
+        end
+      end
+
+      context "checks that pass the second time" do
+        let(:mutating_state) { [] }
+        let(:check_lambda) { lambda { |_container| mutating_state << 1; mutating_state.size > 1 } }
+        let(:check_error_message) { "Your mutant became a zombie" }
+
+        it "runs without incident" do
           subject
         end
       end
-    end
 
-    context "timing out check" do
-      let(:timeout) { 2 }
-      let(:checks) { [sad_check] }
+      context "one check failing and succeding and one check failing" do
+        let(:mutating_state) { [] }
+        let(:failed_and_passed_lambda) { lambda { |_container| mutating_state << 1; mutating_state.size > 1 } }
+        let(:failed_and_passed_error_message) { "Your mutant became a zombie" }
+        let(:failed_and_passed_check) { KumoDockerCloud::ServiceCheck.new(failed_and_passed_lambda, failed_and_passed_error_message) }
+        let(:failing_lambda) { lambda { |_container| false } }
+        let(:failing_error_message) { "You failed. Too bad." }
+        let(:failing_check) { KumoDockerCloud::ServiceCheck.new(failing_lambda, failing_error_message) }
+        let(:checks) { [failed_and_passed_check, failing_check] }
+
+        it "runs without incident" do
+          expect { subject }.to raise_error(KumoDockerCloud::ServiceDeployError, "One or more checks failed to pass within the timeout.\nMessage: #{failing_error_message} | Service Name: #{service.name}")
+        end
+      end
+
+      context 'multiple checks failing' do
+        let(:failing_lambda_a) { lambda { |_container| false } }
+        let(:failing_error_message_a) { "You failed check A. Too bad." }
+        let(:failing_check_a) { KumoDockerCloud::ServiceCheck.new(failing_lambda_a, failing_error_message_a) }
+        let(:failing_lambda_b) { lambda { |_container| false } }
+        let(:failing_error_message_b) { "You failed check B. Too bad." }
+        let(:failing_check_b) { KumoDockerCloud::ServiceCheck.new(failing_lambda_b, failing_error_message_b) }
+        let(:checks) { [failing_check_a, failing_check_b] }
+        let(:containers) { [container] }
 
-      it "raises an error" do
-        expect { subject }.to raise_error(KumoDockerCloud::ServiceDeployError, "One or more checks failed to pass within the timeout")
+        it 'includes all error messages' do
+          expect { subject }.to raise_error(KumoDockerCloud::ServiceDeployError, "One or more checks failed to pass within the timeout.\nMessage: #{failing_error_message_a} | Service Name: #{service.name}\nMessage: #{failing_error_message_b} | Service Name: #{service.name}")
+        end
       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] }
+    context 'passing lambdas' do
+      let(:happy_check) { lambda { |container| expect(container).to eq(container); true } }
+      let(:sad_check) { lambda { |container| expect(container).to eq(container); false } }
+      let(:checks) {[happy_check]}
+
+      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
 
-      it "runs without incident" do
-        subject
+      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. I'd show you what went wrong but the checks were lambdas so I can't. Maybe you should update your usage to the new ServiceCheck object instead of lambdas?")
+        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/stack_checker_spec.rb

@@ -5,8 +5,8 @@ describe KumoDockerCloud::StackChecker do
   let(:services) { [service]}
   let(:failed_services) { double(:service_api, name: 'redbubble', state: 'Stopped')}
   let(:service_checker) { instance_double(KumoDockerCloud::ServiceChecker, verify: nil)}
-  let(:default_service_check) { [double(:default_check)] }
-  let(:specific_service_check) { { "redbubble" => [double(:specific_check)] } }
+  let(:default_service_check) { instance_double(KumoDockerCloud::ServiceCheck) }
+  let(:specific_service_check) { { "redbubble" => [instance_double(KumoDockerCloud::ServiceCheck)] } }
 
   subject { described_class.new.verify(stack) }
 
@@ -33,13 +33,13 @@ describe KumoDockerCloud::StackChecker do
 
     context 'single service' do
       context 'without passing services checks' do
-        before { allow_any_instance_of(KumoDockerCloud::StackChecker).to receive(:default_check).and_return(default_service_check) }
+        before { allow(KumoDockerCloud::ServiceCheck).to receive(:new).and_return(default_service_check) }
         it 'returns true when verify successful' do
           expect(subject).to be true
         end
 
         it 'uses default check' do
-          expect(KumoDockerCloud::ServiceChecker).to receive(:new).with(default_service_check, 300)
+          expect(KumoDockerCloud::ServiceChecker).to receive(:new).with([default_service_check], 300)
           subject
         end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumo_dockercloud
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.0
 platform: ruby
 authors:
 - Redbubble
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-24 00:00:00.000000000 Z
+date: 2016-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpi
@@ -150,6 +150,7 @@ files:
 - lib/kumo_dockercloud/environment_config.rb
 - lib/kumo_dockercloud/errors.rb
 - lib/kumo_dockercloud/service.rb
+- lib/kumo_dockercloud/service_check.rb
 - lib/kumo_dockercloud/service_checker.rb
 - lib/kumo_dockercloud/stack.rb
 - lib/kumo_dockercloud/stack_checker.rb