kumo_dockercloud 3.0.0 → 3.1.0

data/README.md

@@ -1,6 +1,6 @@
 # KumoDockerCloud [![Build status](https://badge.buildkite.com/e9ebd06f4732bbb2a914228ac8816a2bbbeaf8bf0444ea00b4.svg)](https://buildkite.com/redbubble/kumo-docker-cloud)
 
-This is the Redbubble wrapper around creating environments in docker cloud.  It is built into our rbdevltools container and can then be used during `apply-env` and `deploy` tasks. 
+This is the Redbubble wrapper around creating environments in docker cloud.  It is built into our rbdevltools container and can then be used during `apply-env` and `deploy` tasks.
 
 ## Installation
 
@@ -8,26 +8,97 @@ This is installed into the rbdevtools container.
 
 ## Usage
 
-Apply env example
+### Apply env example
+
+By default apply-env will check that all services within the stack are running:
+
 ```ruby
   KumoDockerCloud::Environment.new(
     name: environment_name,
     env_vars: env_vars,
     app_name: 'your-app-here',
     config_path: File.join('/app', 'config'),
-    stack_template_path: File.join('/app', 'docker-cloud, 'stack.yml.erb')
-  ).apply
+    stack_template_path: File.join('/app', 'docker-cloud', 'stack.yml.erb')
+  ).apply()
+```
+
+This is not desirable for stacks with services that are not permanently running.
+
+#### StackChecker
+
+For these situations you can pass in a stack checker object which maps services to a custom set of checks as follows:
+
+```ruby
+  require 'kumo_dockercloud'
+
+   custom_checks = {
+    'transitory_service' => [
+      lambda { |container| container.state == 'Stopped' },
+      lambda { |container| container.exit_code == 0 }
+    ]
+  }
+
+  stack_checker = KumoDockerCloud::StackChecker.new(custom_checks)
+
+  KumoDockerCloud::Environment.new(
+    name: environment_name,
+    env_vars: env_vars,
+    app_name: 'your-app-here',
+    config_path: File.join('/app', 'env', 'config'),
+    stack_template_path: File.join('/app', 'env', 'docker-cloud', 'stack.yml.erb'),
+    timeout: 600
+  ).apply(stack_checker)
+```
+
+The `StackChecker` will execute default checks for all services in your stack which are not listed
+in the custom checks. The default check is that the service is running. You can override this by
+passing in your own set of default checks as follows:
+
+```ruby
+  default_checks = [
+    lambda { |container| container.state == 'Awesome' },
+    lambda { |container| container.logs.contain? 'Ready' }
+  ]
+
+  stack_checker = KumoDockerCloud::StackChecker.new(custom_checks, default_checks, 120)
 ```
 
-Deploy example
+The third parameter in the line above is the timeout, by default is 300 seconds.
+
+### Deploy example
+
+The deploy method will deploy your docker image to a service within an existing stack
+(i.e. you've created the `Environment` as above):
+
 ```ruby
 begin
-  KumoDockerCloud::Stack.new(app_name, env_name).deploy(version)
+  KumoDockerCloud::Stack.new(app_name, env_name).deploy(service_name, version)
 rescue KumoDockerCloud::Deployment::DeploymentError, TimeoutError
   exit 1
 end
 ```
 
+The `version` is your Docker Hub tag on an image name that matches what is in your
+Docker Cloud stackfile.
+
+#### ServiceChecker
+
+By default deploy will not run any checks on the services that you deploy. You can override
+this by passing in a service checker:
+
+```ruby
+  custom_service_checks = [
+   lambda { |container| container.state == 'Stopped' },
+   lambda { |container| container.exit_code == 0 }
+ ]
+
+  service_checker = KumoDockerCloud::ServiceChecker.new(custom_service_checks, 120)
+
+  KumoDockerCloud::Stack.new(app_name, env_name).deploy(service_name, version, service_checker)
+
+```
+As for the `StackChecker`, the third parameter is a timeout which defaults to 300 seconds.
+
 ## Testing changes
 
 Changes to the gem can be manually tested end to end in a project that uses the gem (i.e. http-wala).

data/kumo_dockercloud.gemspec

@@ -26,4 +26,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.4'
   spec.add_development_dependency 'webmock', '~> 1.22'
+  spec.add_development_dependency 'rubocop', '~> 0.40'
 end

data/lib/kumo_dockercloud.rb

@@ -1,6 +1,7 @@
 require 'kumo_dockercloud/environment'
 require 'kumo_dockercloud/deployment'
 require 'kumo_dockercloud/stack'
+require 'kumo_dockercloud/stack_checker'
 require 'kumo_dockercloud/service'
 require 'kumo_dockercloud/service_checker'
 require 'kumo_dockercloud/errors'

data/lib/kumo_dockercloud/environment.rb

@@ -8,8 +8,8 @@ require_relative 'docker_cloud_api'
 require_relative 'environment_config'
 require_relative 'stack_file'
 require_relative 'state_validator'
+require_relative 'stack_checker'
 
-#TODO refactor this to use the new checker inside Service
 module KumoDockerCloud
   class Environment
     extend ::Forwardable
@@ -22,13 +22,13 @@ module KumoDockerCloud
       @timeout = params.fetch(:timeout, 120)
       @confirmation_timeout = params.fetch(:confirmation_timeout, 30)
 
-      app_name = params.fetch(:app_name)
-      @config = EnvironmentConfig.new(app_name: app_name, env_name: @env_name, config_path: params.fetch(:config_path))
+      @app_name = params.fetch(:app_name)
+      @config = EnvironmentConfig.new(app_name: @app_name, env_name: @env_name, config_path: params.fetch(:config_path))
     end
 
-    def apply
+    def apply(stack_checker = StackChecker.new)
       if @config.image_tag == 'latest'
-        puts 'WARNING: Deploying latest. The deployed container version may arbitrarily change'
+        ConsoleJockey.write_line 'WARNING: Deploying latest. The deployed container version may arbitrarily change'
       end
 
       stack_file = write_stack_config_file(configure_stack(stack_template))
@@ -37,7 +37,13 @@ module KumoDockerCloud
 
       run_command("docker-cloud stack redeploy #{stack_name}")
 
-      wait_for_running(@timeout)
+      stack = Stack.new(@app_name, @env_name)
+
+      begin
+        stack_checker.verify(stack)
+      rescue StackCheckError
+        raise EnvironmentApplyError.new("The stack is not in the expected state.")
+      end
     end
 
     def destroy
@@ -52,33 +58,6 @@ module KumoDockerCloud
       StackFile.create_from_template(stack_template, @config, @env_vars)
     end
 
-    def wait_for_running(timeout)
-      StateValidator.new(stack_state_provider).wait_for_state('Redeploying', timeout)
-      StateValidator.new(stack_state_provider).wait_for_state(expected_state, timeout)
-      StateValidator.new(service_state_provider).wait_for_state('Running', timeout)
-    end
-
-    def expected_state
-      env_name == 'production' ? 'Partly running' : 'Running'
-    end
-
-    def stack_state_provider
-      docker_cloud_api = DockerCloudApi.new
-      lambda {
-        stack = docker_cloud_api.stack_by_name(stack_name)
-        { name: stack.name, state: stack.state }
-      }
-    end
-
-    def service_state_provider
-      docker_cloud_api = DockerCloudApi.new
-      lambda {
-        services = docker_cloud_api.services_by_stack_name(stack_name)
-        services.select! { |service| service.name != 'geckoboardwidget' }
-        { name: 'services', state: services.map { |s| s.state }.uniq.join }
-      }
-    end
-
     def run_command(cmd)
       puts "Executing -> #{cmd}"
       puts `#{cmd}`

data/lib/kumo_dockercloud/errors.rb

@@ -1,4 +1,7 @@
 module KumoDockerCloud
   class Error < RuntimeError; end
   class ServiceDeployError < RuntimeError; end
+  class EnvironmentApplyError < RuntimeError; end
+  class StackCheckError < RuntimeError; end
+  class InvalidStackError < RuntimeError; end
 end

data/lib/kumo_dockercloud/stack.rb

@@ -18,6 +18,11 @@ module KumoDockerCloud
       checker.verify(service)
     end
 
+    def services
+      services = docker_cloud_api.services_by_stack_name(stack_name)
+      services.map { |service| Service.new(stack_name, service.name) }
+    end
+
     def deploy_blue_green(options)
       service_names = options[:service_names]
       version = options[:version]
@@ -48,5 +53,9 @@ module KumoDockerCloud
       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
+
+    def docker_cloud_api
+      @docker_cloud_api ||= DockerCloudApi.new
+    end
   end
 end

data/lib/kumo_dockercloud/stack_checker.rb

@@ -0,0 +1,34 @@
+module KumoDockerCloud
+  class StackChecker
+    def initialize(specific_checks = {}, common_check = nil, timeout = 300)
+      @checks = specific_checks
+      @default_check = common_check
+      @timeout = timeout
+    end
+
+    def verify(stack)
+      raise InvalidStackError.new("The stack being verified is not a valid KumoDockerCloud::Stack.") unless stack.instance_of? KumoDockerCloud::Stack
+
+      services = stack.services
+
+      default_checks = services.reduce({}) { |result, service| result.merge(service.name => default_check) }
+      service_checks = default_checks.merge(@checks)
+
+      begin
+        service_checker_threads = services.map do |service|
+          Thread.new { ServiceChecker.new(service_checks[service.name], @timeout).verify(service) }
+        end
+        service_checker_threads.each(&:join)
+        true
+      rescue ServiceDeployError
+        raise StackCheckError.new("The stack is not in the expected state.")
+      end
+    end
+
+    private
+
+    def default_check
+      @default_check ||= [lambda { |container| container.state == 'Running' }]
+    end
+  end
+end

data/lib/kumo_dockercloud/version.rb

@@ -1,3 +1,3 @@
 module KumoDockerCloud
-  VERSION = '3.0.0'
+  VERSION = '3.1.0'
 end

data/spec/kumo_dockercloud/environment_spec.rb

@@ -1,11 +1,12 @@
 describe KumoDockerCloud::Environment do
   let(:env_vars) { {app_name => {'KEY' => 'VALUE'}} }
   let(:app_name) { 'application-stack-name' }
-  let(:config) { KumoDockerCloud::EnvironmentConfig.new(app_name: app_name, env_name: 'test', config_path: 'a path') }
+  let(:env_name) { 'test' }
+  let(:config) { KumoDockerCloud::EnvironmentConfig.new(app_name: app_name, env_name: env_name, config_path: 'a path') }
 
   let(:stack_file) {
     {
-      'application-stack-name': {
+      'application-stack-name' => {
         image: 'a-thing',
         environment: {
           TEST_ENV: 'FAKE',
@@ -19,7 +20,7 @@ describe KumoDockerCloud::Environment do
   let(:confirmation_timeout) { 0.5 }
   let(:stack_template_path) { File.join(__dir__, '../fixtures/stack.yml.erb') }
 
-  let(:params) { {name: 'test', env_vars: env_vars, app_name: app_name, config_path: 'a path', stack_template_path: stack_template_path, confirmation_timeout: confirmation_timeout} }
+  let(:params) { {name: env_name, env_vars: env_vars, app_name: app_name, config_path: 'a path', stack_template_path: stack_template_path, confirmation_timeout: confirmation_timeout} }
 
   subject(:env) { described_class.new(params) }
 
@@ -30,13 +31,15 @@ describe KumoDockerCloud::Environment do
 
   describe "#apply" do
     subject { env.apply }
+    let(:stack) { {"#{full_stack_name}" => 'stack stuff'} }
+    let(:stack_checker) { instance_double(KumoDockerCloud::StackChecker, :stack_checker, verify: true) }
     before do
       allow(config).to receive(:image_tag).and_return('latest')
       allow(env).to receive(:evaluate_command).and_return app_name
       allow(env).to receive(:run_command)
-      docker_cloud_api = double("DockerCloudApi", stack_by_name: {"#{full_stack_name}": 'stack stuff'})
-      allow(KumoDockerCloud::DockerCloudApi).to receive(:new).and_return docker_cloud_api
-      allow_any_instance_of(KumoDockerCloud::StateValidator).to receive(:wait_for_state)
+      allow(KumoDockerCloud::StackChecker).to receive(:new).and_return(stack_checker)
+      allow(KumoDockerCloud::Stack).to receive(:new).with(app_name, env_name).and_return(stack)
+
     end
 
     it "writes a stack file" do
@@ -57,37 +60,58 @@ describe KumoDockerCloud::Environment do
       subject
     end
 
-    describe "waiting for running" do
-      let(:state_validator) { double(KumoDockerCloud::StateValidator, wait_for_state: nil) }
+    it 'uses the StackFile class' do
+      expect(KumoDockerCloud::StackFile).to receive(:create_from_template).with(File.read(stack_template_path), config, env_vars)
+
+      subject
+    end
+
+    it 'passs a KumoDockerCloud::Stack to the stack_checker' do
+      expect(stack_checker).to receive(:verify).with(stack).and_return(true)
+
+      subject
+    end
+
+    context 'with specific stack checker passed in' do
+      let(:stack_checker_passed_in) { instance_double(KumoDockerCloud::StackChecker, :passed_in_stack_checker, verify: true) }
+      subject { env.apply(stack_checker_passed_in) }
 
-      before do
-        allow(KumoDockerCloud::StateValidator).to receive(:new).exactly(3).times.and_return(state_validator)
+      it 'returns true when status check is successful' do
+        expect(subject).to be true
       end
 
-      it "makes sure it waits until it's running" do
-        expect(state_validator).to receive(:wait_for_state).with(anything, 120).exactly(3).times
-        subject
+      it 'raise and stack_apply_exception when status check is not successful' do
+        expect(stack_checker_passed_in).to receive(:verify).with(stack).and_raise(KumoDockerCloud::StackCheckError)
+        expect{subject}.to raise_error(KumoDockerCloud::EnvironmentApplyError, "The stack is not in the expected state." )
       end
 
-      context "setting a different timeout value" do
-        let(:params) { {name: 'test', env_vars: env_vars, app_name: app_name, config_path: 'a path', stack_template_path: stack_template_path, timeout: 240} }
+      it 'uses the user passed in stack checker' do
+        expect(stack_checker_passed_in).to receive(:verify).with(stack).and_return(true)
+        subject
+      end
+    end
 
-        it "sends the timeout value to the StateValidator" do
-          expect(state_validator).to receive(:wait_for_state).with(anything, 240).exactly(3).times
-          subject
-        end
+    context 'without specific stack checker passed in' do
+      subject { env.apply }
+      it 'returns true when status check is successful' do
+        expect(subject).to be true
       end
 
-    end
+      it 'raises a stack_apply_exception when status check is not successful' do
+        expect(stack_checker).to receive(:verify).with(stack).and_raise(KumoDockerCloud::StackCheckError)
+        expect{subject}.to raise_error(KumoDockerCloud::EnvironmentApplyError, "The stack is not in the expected state." )
+      end
 
-    it 'uses the StackFile class' do
-      expect(KumoDockerCloud::StackFile).to receive(:create_from_template).with(File.read(stack_template_path), config, env_vars)
+      it 'does create a new instance of stack checker' do
+        expect(KumoDockerCloud::StackChecker).to receive(:new).and_return(stack_checker)
+        subject
+      end
 
-      subject
     end
   end
 
 
+
   describe "#destroy" do
     subject { env.destroy }
     before do

data/spec/kumo_dockercloud/service_checker_spec.rb

@@ -56,7 +56,7 @@ describe KumoDockerCloud::ServiceChecker do
 
     context "second time is the charm" do
       let(:mutating_state) { [] }
-      let(:mutating_check) { lambda { |container| mutating_state << 1; mutating_state.size > 1 } }
+      let(:mutating_check) { lambda { |_container| mutating_state << 1; mutating_state.size > 1 } }
       let(:checks) { [mutating_check] }
 
       it "runs without incident" do

data/spec/kumo_dockercloud/stack_checker_spec.rb

@@ -0,0 +1,125 @@
+describe KumoDockerCloud::StackChecker do
+
+  let(:stack) { instance_double(KumoDockerCloud::Stack, :stack, stack_name: 'stack' )}
+  let(:service) { double(:service, name: 'redbubble', state: 'Running') }
+  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)] } }
+
+  subject { described_class.new.verify(stack) }
+
+  before do
+    allow(stack).to receive(:services).and_return(services)
+    allow(stack).to receive(:instance_of?).with(KumoDockerCloud::Stack).and_return(true)
+  end
+
+  describe '#verify' do
+
+    before do
+        allow(KumoDockerCloud::ServiceChecker).to receive(:new).and_return(service_checker)
+    end
+
+    context 'invalid stack passed in' do
+      let(:invalid_stack) { double(:stack) }
+      subject{ described_class.new.verify(invalid_stack) }
+
+      it 'raises invalid stack exception when received a non KumoDockerCloud::Stack' do
+        expect { subject }.to raise_error( KumoDockerCloud::InvalidStackError, "The stack being verified is not a valid KumoDockerCloud::Stack." )
+      end
+    end
+
+
+    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) }
+        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)
+          subject
+        end
+
+
+        it 'uses user specify timeout value' do
+          user_timeout = 1
+          allow_any_instance_of(KumoDockerCloud::StackChecker).to receive(:default_check).and_return(default_service_check)
+          expect(KumoDockerCloud::ServiceChecker).to receive(:new).with(default_service_check,user_timeout)
+          described_class.new({}, nil, user_timeout).verify(stack)
+        end
+
+        it 'raise StackCheckError when verify unsuccessful' do
+          allow(service_checker).to receive(:verify).with(service).and_raise KumoDockerCloud::ServiceDeployError
+          expect {subject}.to raise_error(KumoDockerCloud::StackCheckError, "The stack is not in the expected state." )
+        end
+      end
+
+      context 'with user specified common checks' do
+        it 'uses user specified common check as the default' do
+          common_checks = [double(:common_check)]
+          expect(KumoDockerCloud::ServiceChecker).to receive(:new).with(common_checks, 300)
+          described_class.new({}, common_checks).verify(stack)
+        end
+      end
+
+      context 'with specific services checks passing in' do
+        subject { described_class.new(specific_service_check).verify(stack) }
+
+        it 'returns true when verify successful' do
+          expect(subject).to be true
+        end
+
+        it 'raise StackCheckError when verify unsuccessful' do
+          allow(service_checker).to receive(:verify).with(service).and_raise KumoDockerCloud::ServiceDeployError
+          expect {subject}.to raise_error(KumoDockerCloud::StackCheckError, "The stack is not in the expected state." )
+        end
+
+        it 'uses specific check' do
+          expect(KumoDockerCloud::ServiceChecker).to receive(:new).with(specific_service_check[service.name], 300)
+          subject
+        end
+      end
+    end
+
+    context 'multiple services' do
+      let(:services) {[double(:redbubble_service, name: 'redbubble', state: 'Running'), double(:nginx_service, name: 'nginx', state: 'Running')]}
+      let(:redbubble_check) { double(:redbubble_check) }
+      let(:nginx_check) { double(:nginx_check) }
+      let(:specific_service_check) { { "redbubble" => [redbubble_check], "nginx" => [nginx_check] } }
+      let(:single_override_service_check) { { "redbubble" => [redbubble_check] } }
+
+      subject { described_class.new(specific_service_check).verify(stack) }
+
+      context 'default checks' do
+        before { allow_any_instance_of(KumoDockerCloud::StackChecker).to receive(:default_check).and_return(default_service_check)  }
+
+        it 'does the correct checking for each service' do
+          expect(KumoDockerCloud::ServiceChecker).to receive(:new).with([redbubble_check], 300)
+          expect(KumoDockerCloud::ServiceChecker).to receive(:new).with([nginx_check], 300)
+          subject
+        end
+
+        it 'uses default checking if one of the service check is not provided' do
+          expect(KumoDockerCloud::ServiceChecker).to receive(:new).with([redbubble_check], 300)
+          expect(KumoDockerCloud::ServiceChecker).to receive(:new).with(default_service_check, 300)
+          described_class.new(single_override_service_check).verify(stack)
+        end
+      end
+
+      context 'passing common checks' do
+        let(:specific_service_check) { { "redbubble" => [redbubble_check] } }
+        let(:common_service_checks) { [double(:common_service_check)] }
+        subject { described_class.new(specific_service_check, common_service_checks).verify(stack) }
+
+        it 'overrides the default check with the common checks for non-specified services' do
+          expect(KumoDockerCloud::ServiceChecker).to receive(:new).with([redbubble_check], 300)
+          expect(KumoDockerCloud::ServiceChecker).to receive(:new).with(common_service_checks, 300)
+          subject
+        end
+      end
+    end
+  end
+end