kumo_dockercloud 3.2.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d56a26a559069438a8dffe96f6197a43ff784a88
-  data.tar.gz: b8b55150263ca7259d21524b8bd759c412561122
+  metadata.gz: 3e7a3083ac7e9265513cc75563a7b7e161e1a286
+  data.tar.gz: 42ae9a4b63c95fb00f8ee706cc5df18f1a81cb51
 SHA512:
-  metadata.gz: 36456d19ed2a73171023e65d5ed7e09de4a71d4c23d1e305a4c57c73dd488c5f43963289550f88648657dd0354e0c6184d725ed55df064694927f349e30073a7
-  data.tar.gz: 65858ebe4cabbd00d82b18e281c978cc1e2e5016925f4056a610a703844fc94b36669615bff7a8e1fe7edcc0448d9ef6945314c60a0bdbb042ac4af5ba4bbd2d
+  metadata.gz: 0cb94285609c0da1c6197adf3548e089000d8d8c0cdee521e38de7ca770cf5c28e2fa2b5d4b39bbcda43fb6a185297d4d2cd3df36e5c10ba499f10709637a61a
+  data.tar.gz: 0736d09ec8b388a88e7f415c38c94241fff02739ee0065f4a356cf34bbcba2fae25bb5031e585e9bf5e0513cc7085d6b9fef5724580872407befdc1d4048e2a6

data/Gemfile

@@ -3,6 +3,8 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in kumo_dockercloud.gemspec
 gemspec
 
+gem 'docker_cloud', git: 'git@github.com:redbubble/ruby-docker-cloud.git', branch: 'container-exec'
+
 group :development do
   gem 'pry'
 end

data/kumo_dockercloud.gemspec

@@ -26,5 +26,6 @@ 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 'pry-byebug', '~> 3.4'
   spec.add_development_dependency 'rubocop', '~> 0.40'
 end

data/lib/kumo_dockercloud/docker_cloud_api.rb

@@ -5,6 +5,7 @@ module KumoDockerCloud
   class DockerCloudApi
     extend Forwardable
     def_delegators :@client, :services, :stacks
+    attr_reader :client
 
     def initialize(options = {})
       options[:username] ||= ENV['DOCKERCLOUD_USER']

data/lib/kumo_dockercloud/errors.rb

@@ -1,6 +1,8 @@
 module KumoDockerCloud
   class Error < RuntimeError; end
   class ServiceDeployError < RuntimeError; end
+  class HaproxySocketError < RuntimeError; end
+  class HAProxyStateError < Error; end
   class EnvironmentApplyError < RuntimeError; end
   class StackCheckError < RuntimeError; end
   class InvalidStackError < RuntimeError; end

data/lib/kumo_dockercloud/haproxy_command.rb

@@ -0,0 +1,24 @@
+require 'json'
+
+module KumoDockerCloud
+  class HaproxyCommand
+    def initialize(container_id, dc_client)
+      @container_id = container_id
+      @dc_client = dc_client
+    end
+
+    def execute(command)
+      cmd = %(sh -c "echo #{command} | nc -U /var/run/haproxy.stats")
+      api = DockerCloud::ContainerStreamAPI.new(@container_id, cmd, @dc_client.headers, @dc_client)
+
+      handler = KumoDockerCloud::HaproxyEventHandler.new
+      api.on(:open, &handler.on_open)
+      api.on(:message, &handler.on_message)
+      api.on(:error, &handler.on_error)
+      api.on(:close, &handler.on_close)
+
+      api.run!
+      handler.data
+    end
+  end
+end

data/lib/kumo_dockercloud/haproxy_container.rb

@@ -0,0 +1,51 @@
+require 'csv'
+
+module KumoDockerCloud
+  class HaproxyContainer
+    def initialize(container_id, client)
+      @container_id = container_id
+      @client = client
+    end
+
+    def disable_server(server_name)
+      haproxy_server_name = haproxy_server_name(server_name)
+      HaproxyCommand.new(@container_id, @client).execute("disable server #{haproxy_server_name}")
+    end
+
+    def enable_server(server_name)
+      haproxy_server_name = haproxy_server_name(server_name)
+      HaproxyCommand.new(@container_id, @client).execute("enable server #{haproxy_server_name}")
+    end
+
+    private
+
+    def stats
+      haproxy_command = HaproxyCommand.new(@container_id, @client)
+      command_output = ''
+      retry_counter = 0
+      while command_output.empty? && retry_counter < 3
+        command_output = haproxy_command.execute('show stat')
+        retry_counter += 1
+      end
+      raise HAProxyStateError.new("Could not get stats from HAProxy backend") if command_output.empty?
+      CSV.parse(command_output, headers: true)
+    end
+
+    def haproxy_server_name(server_name)
+      current_stats = stats
+      haproxy_server_record = current_stats.find { |stat| prefix_match? stat, server_name }
+
+      raise HAProxyStateError.new("Unable to map #{server_name} to a HAProxy backend, I saw #{ get_server_names(current_stats) }") unless haproxy_server_record
+
+      "#{haproxy_server_record['# pxname']}/#{haproxy_server_record['svname']}"
+    end
+
+    def prefix_match?(stat_record, server_name)
+      stat_record["svname"].downcase.start_with? server_name.downcase.gsub('-', '_')
+    end
+
+    def get_server_names(stats_object)
+      stats_object.select { |record| record['# pxname'] == 'default_service' }.map { |record| record['svname']}.join(', ')
+    end
+  end
+end

data/lib/kumo_dockercloud/haproxy_event_handler.rb

@@ -0,0 +1,25 @@
+module KumoDockerCloud
+  class HaproxyEventHandler
+    attr_accessor :data
+
+    def initialize
+      @data = ''
+    end
+
+    def on_open
+      Proc.new { |_event| @data = '' }
+    end
+
+    def on_message
+      Proc.new { |event| @data << JSON.parse(event.data)['output'] }
+    end
+
+    def on_error
+      Proc.new { |event| raise HaproxySocketError.new(event.message) }
+    end
+
+    def on_close
+      Proc.new { |_event| EventMachine.stop }
+    end
+  end
+end

data/lib/kumo_dockercloud/haproxy_service.rb

@@ -0,0 +1,29 @@
+module KumoDockerCloud
+  class HaproxyService < Service
+    def initialize(stack_name)
+      super(stack_name, 'haproxy')
+
+      @client = docker_cloud_api.client
+    end
+
+    def disable_service(service)
+      service_to_disable = service.name
+      haproxy_containers = containers.map { |container| HaproxyContainer.new(container.uuid, @client) }
+
+      raise KumoDockerCloud::HAProxyStateError.new('Could not get instances of the haproxy container for this environment') if haproxy_containers.empty?
+
+      haproxy_threads = haproxy_containers.map { |haproxy_container| Thread.new { haproxy_container.disable_server(service_to_disable) } }
+      haproxy_threads.each(&:join)
+    end
+
+    def enable_service(service)
+      service_to_enable = service.name
+      haproxy_containers = containers.map { |container| HaproxyContainer.new(container.uuid, @client) }
+
+      raise KumoDockerCloud::HAProxyStateError.new('Could not get instances of the haproxy container for this environment') if haproxy_containers.empty?
+
+      haproxy_threads = haproxy_containers.map { |haproxy_container| Thread.new { haproxy_container.enable_server(service_to_enable) } }
+      haproxy_threads.each(&:join)
+    end
+  end
+end

data/lib/kumo_dockercloud/service.rb

@@ -30,6 +30,10 @@ module KumoDockerCloud
       get_service.linked_to_service
     end
 
+    def state
+      get_service.state
+    end
+
     def set_link(service_to_link, link_internal_name)
       linked_service = {
         to_service: service_to_link.resource_uri,
@@ -52,6 +56,10 @@ module KumoDockerCloud
       get_service.containers
     end
 
+    def uuid
+      get_service.uuid
+    end
+
     private
     attr_reader :stack_name
 
@@ -75,10 +83,6 @@ module KumoDockerCloud
       docker_cloud_api.service_by_stack_and_service_name(stack_name, name)
     end
 
-    def uuid
-      get_service.uuid
-    end
-
     def image_name
       get_service.image_name.split(':').first
     end

data/lib/kumo_dockercloud/stack.rb

@@ -1,3 +1,5 @@
+require 'timeout'
+
 module KumoDockerCloud
   class Stack
     attr_reader :stack_name, :app_name, :options
@@ -18,37 +20,36 @@ module KumoDockerCloud
       checker.verify(service)
     end
 
+    def deploy_blue_green(service_names, version, checker = ServiceChecker.new)
+      haproxy_service = HaproxyService.new(@stack_name)
+
+      services = service_names.map { |name| Service.new(stack_name, name) }
+      ordered_deployment(services).each do |service|
+        begin
+          haproxy_service.disable_service(service) unless service.state == "Stopped"
+          service.deploy(version)
+          checker.verify(service)
+          haproxy_service.enable_service(service)
+        rescue HAProxyStateError => e
+          raise ServiceDeployError.new("Unable to place service #{service.name} into maintainance mode on HAProxy with message: #{e.message}")
+        rescue ServiceDeployError => e
+          haproxy_service.disable_service(service)
+          raise ServiceDeployError.new("Deployment or verification of service #{service.name} failed with message: #{e.message}")
+        end
+      end
+    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]
-      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")
-
-      switching_service = Service.new(stack_name, switching_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)
+    private
 
-      switching_service.set_link(inactive_service, link[:name])
-      active_service.stop
+    def ordered_deployment(services)
+      services.sort { |service_a, service_b| service_b.state <=> service_a.state }
     end
 
-    private
-
     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?

data/lib/kumo_dockercloud/version.rb

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

data/lib/kumo_dockercloud.rb

@@ -7,3 +7,7 @@ require 'kumo_dockercloud/service_checker'
 require 'kumo_dockercloud/service_check'
 require 'kumo_dockercloud/errors'
 require 'kumo_dockercloud/console_jockey'
+require 'kumo_dockercloud/haproxy_service'
+require 'kumo_dockercloud/haproxy_container'
+require 'kumo_dockercloud/haproxy_command'
+require 'kumo_dockercloud/haproxy_event_handler'

data/spec/kumo_dockercloud/haproxy_command_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe KumoDockerCloud::HaproxyCommand do
+  describe '#execute' do
+    let(:command) { 'enable' }
+    let(:dc_client) { double(:dc_client, headers: nil)}
+    let(:container_id) { 'id' }
+    let(:api) { instance_double(DockerCloud::ContainerStreamAPI, on: nil, run!: nil)}
+    let(:cmd) { %(sh -c "echo #{command} | nc -U /var/run/haproxy.stats") }
+    let(:handler) { KumoDockerCloud::HaproxyEventHandler.new }
+
+
+    subject { described_class.new(container_id, dc_client).execute(command) }
+
+    it 'uses the ContainerStreamAPI with the passed in command' do
+      expect(DockerCloud::ContainerStreamAPI).to receive(:new).with(container_id, cmd, dc_client.headers, dc_client).and_return(api)
+      subject
+    end
+
+    before do
+      allow(DockerCloud::ContainerStreamAPI).to receive(:new).with(container_id, cmd, dc_client.headers, dc_client).and_return(api)
+    end
+
+    it 'configures the callback handlers' do
+      allow(KumoDockerCloud::HaproxyEventHandler).to receive(:new).and_return(handler)
+
+      expect(api).to receive(:on).with(:open)
+      expect(api).to receive(:on).with(:message)
+      expect(api).to receive(:on).with(:error)
+      expect(api).to receive(:on).with(:close)
+      subject
+    end
+
+    it 'runs the event machine' do
+      expect(api).to receive(:run!)
+      subject
+    end
+
+    it 'returns the data from the callback handler' do
+      allow(KumoDockerCloud::HaproxyEventHandler).to receive(:new).and_return(handler)
+      expect(handler).to receive(:data)
+      subject
+    end
+  end
+end

data/spec/kumo_dockercloud/haproxy_container_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe KumoDockerCloud::HaproxyContainer do
+  subject { KumoDockerCloud::HaproxyContainer.new('container-id', client) }
+
+  let(:client) { instance_double(DockerCloud::Client) }
+  let(:haproxy_command) { instance_double(KumoDockerCloud::HaproxyCommand, :haproxy_command, execute: nil )}
+  let(:csv_output) do <<EOF
+# pxname,svname
+default_frontend,FRONTEND
+default_service,BLUE_SERVICE_1
+default_service,GREEN_SERVICE
+default_service,BACKEND
+EOF
+  end
+  let(:haproxy_server_name) { 'default_service/BLUE_SERVICE_1' }
+  let(:server_name) { 'blue-service' }
+  let(:non_existant_server_name) { 'derpy-service' }
+
+  before do
+    allow(KumoDockerCloud::HaproxyCommand).to receive(:new).and_return(haproxy_command)
+    allow(haproxy_command).to receive(:execute).with('show stat').and_return(csv_output)
+  end
+
+  describe '#disable_server' do
+    it "runs disable server using HAProxy's name" do
+      expect(haproxy_command).to receive(:execute).with("disable server #{haproxy_server_name}")
+      subject.disable_server(server_name)
+    end
+
+    it 'raises an error if it is unable to map a server name to a haproxy name' do
+      expect { subject.disable_server(non_existant_server_name) }.to raise_error(
+        KumoDockerCloud::HAProxyStateError,
+        "Unable to map #{non_existant_server_name} to a HAProxy backend, I saw BLUE_SERVICE_1, GREEN_SERVICE, BACKEND"
+      )
+    end
+
+    it 'tries 3 times if it is unable to get stats from haproxy' do
+      expect(haproxy_command).to receive(:execute).with('show stat').exactly(3).times.and_return('')
+      expect { subject.disable_server(server_name) }.to raise_error(
+        KumoDockerCloud::HAProxyStateError,
+        "Could not get stats from HAProxy backend"
+      )
+    end
+
+    it 'stops trying getting haproxy server name when it gets the haproxy record' do
+      expect(haproxy_command).to receive(:execute).with('show stat').once.ordered.and_return('')
+      expect(haproxy_command).to receive(:execute).with('show stat').once.ordered.and_return(csv_output)
+
+      expect(haproxy_command).to receive(:execute).with("disable server #{haproxy_server_name}").once.ordered
+      subject.disable_server(server_name)
+    end
+  end
+
+  describe '#enable_server' do
+    it "runs enable server using HAProxy's name" do
+      expect(haproxy_command).to receive(:execute).with("enable server #{haproxy_server_name}")
+      subject.enable_server(server_name)
+    end
+
+    it 'raises an error if it is unable to map a server name to a haproxy name' do
+      expect { subject.disable_server(non_existant_server_name) }.to raise_error(
+        KumoDockerCloud::HAProxyStateError,
+        "Unable to map #{non_existant_server_name} to a HAProxy backend, I saw BLUE_SERVICE_1, GREEN_SERVICE, BACKEND"
+      )
+    end
+
+    it 'tries 3 times if it is unable to get stats from haproxy' do
+      expect(haproxy_command).to receive(:execute).with('show stat').exactly(3).times.and_return('')
+      expect { subject.enable_server(server_name) }.to raise_error(
+        KumoDockerCloud::HAProxyStateError,
+        "Could not get stats from HAProxy backend"
+      )
+    end
+
+    it 'stops trying getting haproxy server name when it gets the haproxy record' do
+      expect(haproxy_command).to receive(:execute).with('show stat').once.ordered.and_return('')
+      expect(haproxy_command).to receive(:execute).with('show stat').once.ordered.and_return(csv_output)
+
+      expect(haproxy_command).to receive(:execute).with("enable server #{haproxy_server_name}").once.ordered
+      subject.enable_server(server_name)
+    end
+  end
+end

data/spec/kumo_dockercloud/haproxy_event_handler_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe KumoDockerCloud::HaproxyEventHandler do
+  subject { described_class.new }
+
+  describe '#on_open' do
+    it 'resets the handler state' do
+      subject.data = 'fred'
+      subject.on_open.call(nil)
+      expect(subject.data).to eq ''
+    end
+  end
+
+  describe '#on_message' do
+    let(:event) { double(:event, data: '{"output": "data"}')}
+
+    it 'parses json' do
+      expect(JSON).to receive(:parse).with(event.data).and_return({'output' => 'data'})
+      subject.on_message.call(event)
+    end
+
+    it 'accumulate the message to data' do
+      subject.on_message.call(event)
+      subject.on_message.call(event)
+      subject.on_message.call(event)
+      expect(subject.data).to eq('datadatadata')
+    end
+  end
+
+  describe '#on_error' do
+    let(:event) { double(:event, message: 'woops!') }
+
+    it 'raises a HaproxySocketError with the correct message' do
+      expect { subject.on_error.call(event) }.to raise_error(KumoDockerCloud::HaproxySocketError, 'woops!')
+    end
+  end
+
+  describe '#on_close' do
+    it 'closes the event machine' do
+      expect(EventMachine).to receive(:stop)
+      subject.on_close.call(nil)
+    end
+  end
+end

data/spec/kumo_dockercloud/haproxy_service_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe KumoDockerCloud::HaproxyService do
+  let(:service_name) { 'the-service' }
+  let(:container_uuid) { 'i-am-the-container'}
+  let(:docker_cloud_container) { double(:docker_cloud_haproxy, uuid: container_uuid)}
+  let(:containers) { [docker_cloud_container] }
+  let(:docker_cloud_service) { double(:service, containers: containers) }
+  let(:haproxy_container) { instance_double(KumoDockerCloud::HaproxyContainer, :haproxy_container, disable_server: nil, enable_server: nil) }
+  let(:docker_cloud_client) { double }
+  let(:kumo_docker_cloud_api) { instance_double(KumoDockerCloud::DockerCloudApi, :docker_cloud_api, client: docker_cloud_client ) }
+
+  before do
+    allow(KumoDockerCloud::DockerCloudApi).to receive(:new).and_return(kumo_docker_cloud_api)
+    allow(kumo_docker_cloud_api).to receive(:service_by_stack_and_service_name).with('stack_name', 'haproxy').and_return(docker_cloud_service)
+    allow(KumoDockerCloud::HaproxyContainer).to receive(:new).with(container_uuid, docker_cloud_client).and_return(haproxy_container)
+  end
+
+  describe '#disable_service' do
+    subject { KumoDockerCloud::HaproxyService.new('stack_name').disable_service(service_to_disable) }
+    let(:service_to_disable) { instance_double(KumoDockerCloud::Service, :service_to_disable, name: service_name) }
+
+    it 'sends the disable_server message to all its containers' do
+      expect(haproxy_container).to receive(:disable_server).with(service_name)
+      subject
+    end
+
+    it 'blows up when there are no instances of haproxy' do
+      allow(docker_cloud_service).to receive(:containers).and_return([])
+      expect { subject }.to raise_error(KumoDockerCloud::HAProxyStateError, 'Could not get instances of the haproxy container for this environment')
+    end
+  end
+
+  describe '#enable_service' do
+    subject { KumoDockerCloud::HaproxyService.new('stack_name').enable_service(service_to_enable) }
+    let(:service_to_enable) { instance_double(KumoDockerCloud::Service, :service_to_enable, name: service_name) }
+
+    it 'sends the enable_server message to all its containers' do
+      expect(haproxy_container).to receive(:enable_server).with(service_name)
+      subject
+    end
+
+    it 'blows up when there are no instances of haproxy' do
+      allow(docker_cloud_service).to receive(:containers).and_return([])
+      expect { subject }.to raise_error(KumoDockerCloud::HAProxyStateError, 'Could not get instances of the haproxy container for this environment')
+    end
+  end
+end

data/spec/kumo_dockercloud/stack_spec.rb

@@ -67,75 +67,65 @@ describe KumoDockerCloud::Stack do
   end
 
   describe '#deploy_blue_green' do
-    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: [active_service.name, inactive_service.name],
-        version: version,
-        checker: checker,
-        switching_service_name: "switcher"
-      }
-    end
-
-    subject { described_class.new(app_name, environment_name).deploy_blue_green(deploy_options) }
+    subject { stack.deploy_blue_green(service_names, version, checker) }
+    let(:checker) { instance_double(KumoDockerCloud::ServiceChecker, :service_checker, verify: true) }
+    let(:service_names) { ['service-a', 'service-b'] }
+    let(:version) { 1 }
+    let(:service_a) { instance_double(KumoDockerCloud::Service, :service_a, state: 'Running', deploy: nil, name: 'service_a') }
+    let(:service_b) { instance_double(KumoDockerCloud::Service, :service_b, state: 'Running', deploy: nil, name: 'service_b') }
+    let(:haproxy) { instance_double(KumoDockerCloud::HaproxyService, :haproxy_svc, disable_service: nil, enable_service: nil) }
 
     before do
-      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, active_service.name)
-        .and_return(active_service)
-
-      allow(KumoDockerCloud::Service).to receive(:new)
-        .with(stack_name, inactive_service.name)
-        .and_return(inactive_service)
-
-      allow(KumoDockerCloud::Service).to receive(:new)
-        .with(stack_name, deploy_options[:switching_service_name])
-        .and_return(switching_service)
+      allow(KumoDockerCloud::Service).to receive(:new).with(stack_name, 'service-a').and_return(service_a)
+      allow(KumoDockerCloud::Service).to receive(:new).with(stack_name, 'service-b').and_return(service_b)
+      allow(KumoDockerCloud::HaproxyService).to receive(:new).with(stack_name).and_return(haproxy)
     end
 
-    context 'when parameters are 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 'deploys to each service when both are active' do
+      expect(haproxy).to receive(:disable_service).with(service_a)
+      expect(haproxy).to receive(:disable_service).with(service_b)
+      expect(service_a).to receive(:deploy).with(version)
+      expect(service_b).to receive(:deploy).with(version)
+      subject
+    end
 
-      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 'deploys to the stopped service first when one is inactive' do
+      allow(service_b).to receive(:state).and_return('Stopped')
 
-      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
+      expect(haproxy).to_not receive(:disable_service).with(service_b)
+      expect(service_b).to receive(:deploy).with(version).ordered
+      expect(haproxy).to receive(:disable_service).with(service_a).ordered
+      expect(service_a).to receive(:deploy).with(version).ordered
+      subject
     end
 
-    it 'deploys to the blue service only' do
-      expect(inactive_service).to receive(:deploy).with(version)
-      expect(checker).to receive(:verify).with(inactive_service)
-      expect(active_service).to_not receive(:deploy)
+    it 'runs the check on each service' do
+      expect(checker).to receive(:verify).with(service_a)
+      expect(checker).to receive(:verify).with(service_b)
       subject
     end
 
-    it 'switches over to the blue service on a successful deployment' do
-      expect(switching_service).to receive(:set_link).with(inactive_service, switching_service_internal_link_name)
+    it 're-enables each service in haproxy' do
+      expect(haproxy).to receive(:enable_service).with(service_a)
+      expect(haproxy).to receive(:enable_service).with(service_b)
       subject
     end
 
-    it 'shuts down the previously green service' do
-      expect(active_service).to receive(:stop)
-      subject
+    it 'cancels deployment if the first deploy fails' do
+      allow(checker).to receive(:verify).with(service_a).and_raise(KumoDockerCloud::ServiceDeployError)
+      expect(service_b).to_not receive(:deploy)
+      expect { subject }.to raise_error(KumoDockerCloud::ServiceDeployError)
+    end
+
+    it 'raises an error if any attempt to place a service into maintainance mode fails' do
+      expect(haproxy).to receive(:disable_service).with(service_a).and_raise(KumoDockerCloud::HAProxyStateError, 'Something broke!')
+      expect { subject }.to raise_error(KumoDockerCloud::ServiceDeployError)
+    end
+
+    it 'attempts to place a service into maintainance mode if deployment fails because HAProxy will take it out of maintainance mode on deploy' do
+      expect(haproxy).to receive(:disable_service).with(service_a).twice
+      allow(checker).to receive(:verify).with(service_a).and_raise(KumoDockerCloud::ServiceDeployError)
+      expect { subject }.to raise_error(KumoDockerCloud::ServiceDeployError)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumo_dockercloud
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.3.0
 platform: ruby
 authors:
 - Redbubble
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-30 00:00:00.000000000 Z
+date: 2016-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpi
@@ -110,6 +110,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.22'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -149,6 +163,10 @@ files:
 - lib/kumo_dockercloud/environment.rb
 - lib/kumo_dockercloud/environment_config.rb
 - lib/kumo_dockercloud/errors.rb
+- lib/kumo_dockercloud/haproxy_command.rb
+- lib/kumo_dockercloud/haproxy_container.rb
+- lib/kumo_dockercloud/haproxy_event_handler.rb
+- lib/kumo_dockercloud/haproxy_service.rb
 - lib/kumo_dockercloud/service.rb
 - lib/kumo_dockercloud/service_check.rb
 - lib/kumo_dockercloud/service_checker.rb
@@ -169,6 +187,10 @@ 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/haproxy_command_spec.rb
+- spec/kumo_dockercloud/haproxy_container_spec.rb
+- spec/kumo_dockercloud/haproxy_event_handler_spec.rb
+- spec/kumo_dockercloud/haproxy_service_spec.rb
 - spec/kumo_dockercloud/service_checker_spec.rb
 - spec/kumo_dockercloud/service_spec.rb
 - spec/kumo_dockercloud/stack_checker_spec.rb
@@ -210,6 +232,10 @@ 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/haproxy_command_spec.rb
+- spec/kumo_dockercloud/haproxy_container_spec.rb
+- spec/kumo_dockercloud/haproxy_event_handler_spec.rb
+- spec/kumo_dockercloud/haproxy_service_spec.rb
 - spec/kumo_dockercloud/service_checker_spec.rb
 - spec/kumo_dockercloud/service_spec.rb
 - spec/kumo_dockercloud/stack_checker_spec.rb