centurion 1.0.6

data/lib/tasks/list.rake

@@ -0,0 +1,52 @@
+require 'centurion/docker_registry'
+
+task :list do
+  invoke 'list:tags'
+  invoke 'list:running_containers'
+end
+
+namespace :list do
+  task :running_container_tags do
+
+    tags = get_current_tags_for(fetch(:image))
+
+    $stderr.puts "\n\nCurrent #{current_environment} tags for #{fetch(:image)}:\n\n"
+    tags.each do |info|
+      if info && !info[:tags].empty?
+        $stderr.puts "#{'%-20s' % info[:server]}: #{info[:tags].join(', ')}"
+      else
+        $stderr.puts "#{'%-20s' % info[:server]}: NO TAGS!"
+      end
+    end
+
+    $stderr.puts "\nAll tags for this image: #{tags.map { |t| t[:tags] }.flatten.uniq.join(', ')}"
+  end
+
+  task :tags do
+    begin
+      registry = Centurion::DockerRegistry.new()
+      tags = registry.respository_tags(fetch(:image))
+      tags.each do |tag|
+        puts "\t#{tag[0]}\t-> #{tag[1][0..11]}"
+      end
+    rescue StandardError => e
+      error "Couldn't communicate with Registry: #{e.message}"
+    end
+    puts
+  end
+
+  task :running_containers do
+    on_each_docker_host do |target_server|
+      begin
+        running_containers = target_server.ps
+        running_containers.each do |container|
+          puts container.inspect
+        end
+      rescue StandardError => e
+        error "Couldn't communicate with Docker on #{target_server.hostname}: #{e.message}"
+        raise
+      end
+      puts
+    end
+  end
+end

data/spec/capistrano_dsl_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'capistrano_dsl'
+
+class DSLTest
+  extend Capistrano::DSL
+end
+
+describe Capistrano::DSL do
+  before do
+    DSLTest.clear_env
+  end
+
+  context 'handling multiple environments' do
+    it 'sets the environment' do
+      expect { DSLTest.set_current_environment(:test) }.not_to raise_error
+    end
+
+    it 'fetchs the current environment' do
+      DSLTest.set_current_environment(:test)
+      expect(DSLTest.current_environment).to eq(:test)
+    end
+  end
+
+  context 'without a current environment set' do
+    it 'dies if the current_environment is not set' do
+      expect { DSLTest.set(:foo, 'asdf') }.to raise_error(Capistrano::DSL::CurrentEnvironmentNotSetError)
+    end
+  end
+
+  context 'with a current environment set' do 
+    before do
+      DSLTest.set_current_environment(:test)
+    end
+
+    it 'stores variables in the environment' do
+      expect { DSLTest.set(:foo, 'bar') }.not_to raise_error
+      expect(DSLTest).to have_key_and_value(:foo, 'bar')
+    end
+
+    it 'deletes keys from the environment' do
+      DSLTest.set(:foo, 'bar')
+      expect(DSLTest).to have_key_and_value(:foo, 'bar')
+      DSLTest.delete(:foo)
+      expect(DSLTest.fetch(:foo)).to be_nil
+    end
+
+    it 'returns true for any? when the value exists' do
+      DSLTest.set(:foo, 'bar')
+      expect(DSLTest.any?(:foo)).to be_true
+    end
+
+    it 'returns false for any? when the value does not exist' do
+      expect(DSLTest.any?(:foo)).to be_false
+    end
+
+    it 'passes through the any? method to values that support it' do
+      class NoAny
+        def any?
+          'oh no'
+        end
+      end
+
+      DSLTest.set(:foo, NoAny.new)
+      DSLTest.any?(:foo).should eq('oh no')
+    end
+  end
+end

data/spec/deploy_dsl_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'centurion/deploy_dsl'
+require 'capistrano_dsl'
+
+class DeployDSLTest
+  extend Capistrano::DSL
+  extend Centurion::DeployDSL
+end
+
+describe Centurion::DeployDSL do
+  before do
+    DeployDSLTest.clear_env
+    DeployDSLTest.set_current_environment('test')
+  end
+
+  it 'exposes an easy wrapper for handling each Docker host' do
+    recipient = double('recipient')
+    expect(recipient).to receive(:ping).with('host1')
+    expect(recipient).to receive(:ping).with('host2')
+
+    DeployDSLTest.set(:hosts, %w{ host1 host2 })
+    DeployDSLTest.on_each_docker_host { |h| recipient.ping(h.hostname) }
+  end
+
+  it 'adds new env_vars to the existing ones' do
+    DeployDSLTest.set(:env_vars, { 'SHAKESPEARE' => 'Hamlet' })
+    DeployDSLTest.env_vars('DICKENS' => 'David Copperfield')
+
+    expect(DeployDSLTest.fetch(:env_vars)).to include(
+      'SHAKESPEARE' => 'Hamlet',
+      'DICKENS'     => 'David Copperfield'
+    )
+  end
+
+  it 'adds hosts to the host list' do
+    DeployDSLTest.set(:hosts, [ 'host1' ])
+    DeployDSLTest.host('host2')
+
+    expect(DeployDSLTest).to have_key_and_value(:hosts, %w{ host1 host2 })
+  end
+
+  describe '#localhost' do
+    it 'adds a host by reading DOCKER_HOST if present' do
+      expect(ENV).to receive(:[]).with('DOCKER_HOST').and_return('tcp://127.1.1.1:4240')
+      DeployDSLTest.localhost
+      expect(DeployDSLTest).to have_key_and_value(:hosts, %w[ 127.1.1.1:4240 ])
+    end
+
+    it 'adds a host defaulting to loopback if DOCKER_HOST is not present' do
+      expect(ENV).to receive(:[]).with('DOCKER_HOST').and_return(nil)
+      DeployDSLTest.localhost
+      expect(DeployDSLTest).to have_key_and_value(:hosts, %w[ 127.0.0.1 ])
+    end
+  end
+
+  describe '#host_port' do
+    it 'raises unless passed container_port in the options' do
+      expect { DeployDSLTest.host_port(666, {}) }.to raise_error(ArgumentError, /:container_port/)
+    end
+
+    it 'adds new bind ports to the list' do
+      dummy_value = { '666/tcp' => ['value'] }
+      DeployDSLTest.set(:port_bindings, dummy_value)
+      DeployDSLTest.host_port(999, container_port: 80)
+
+      expect(DeployDSLTest).to have_key_and_value(
+        :port_bindings,
+        dummy_value.merge('80/tcp' => [{ 'HostIp' => '0.0.0.0', 'HostPort' => '999' }])
+      )
+    end
+
+    it 'does not explode if port_bindings is empty' do
+      expect { DeployDSLTest.host_port(999, container_port: 80) }.not_to raise_error
+    end
+
+    it 'raises if invalid options are passed' do
+      expect { DeployDSLTest.host_port(80, asdf: 'foo') }.to raise_error(ArgumentError, /invalid key!/)
+    end
+  end
+
+  describe '#host_volume' do
+    it 'raises unless passed the container_volume option' do
+      expect { DeployDSLTest.host_volume('foo', {}) }.to raise_error(ArgumentError, /:container_volume/)
+    end
+
+    it 'raises when passed bogus options' do
+      expect { DeployDSLTest.host_volume('foo', bogus: 1) }.to raise_error(ArgumentError, /invalid key!/)
+    end
+
+    it 'adds new host volumes' do
+     expect(DeployDSLTest.fetch(:binds)).to be_nil
+     DeployDSLTest.host_volume('volume1', container_volume: '/dev/sdd')
+     DeployDSLTest.host_volume('volume2', container_volume: '/dev/sde')
+     expect(DeployDSLTest.fetch(:binds)).to eq %w{ volume1:/dev/sdd volume2:/dev/sde }
+    end
+  end
+
+  it 'gets current tags for an image' do
+    Centurion::DockerServer.any_instance.stub(current_tags_for: [ 'foo' ])
+    DeployDSLTest.set(:hosts, [ 'host1' ])
+
+    expect(DeployDSLTest.get_current_tags_for('asdf')).to eq [ { server: 'host1', tags: [ 'foo'] } ]
+  end
+end

data/spec/deploy_spec.rb

@@ -0,0 +1,220 @@
+require 'centurion/deploy'
+require 'centurion/deploy_dsl'
+require 'centurion/logging'
+
+describe Centurion::Deploy do
+  let(:mock_ok_status)  { double('http_status_ok').tap { |s| s.stub(status: 200) } }
+  let(:mock_bad_status) { double('http_status_ok').tap { |s| s.stub(status: 500) } }
+  let(:server)          { double('docker_server').tap { |s| s.stub(hostname: 'host1'); s.stub(:attach) } }
+  let(:port)            { 8484 }
+  let(:container)       { { 'Ports' => [{ 'PublicPort' => port }, 'Created' => Time.now.to_i ], 'Id' => '21adfd2ef2ef2349494a', 'Names' => [ 'name1' ] } }
+  let(:endpoint)        { '/status/check' }
+  let(:test_deploy) do 
+    Object.new.tap do |o| 
+      o.send(:extend, Centurion::Deploy)
+      o.send(:extend, Centurion::DeployDSL)
+      o.send(:extend, Centurion::Logging)
+    end
+  end
+
+  describe '#http_status_ok?' do
+    it 'validates HTTP status checks when the response is good' do
+      expect(Excon).to receive(:get).and_return(mock_ok_status)
+      expect(test_deploy.http_status_ok?(server, port, endpoint)).to be_true
+    end
+
+    it 'identifies bad HTTP responses' do
+      expect(Excon).to receive(:get).and_return(mock_bad_status)
+      test_deploy.stub(:warn)
+      expect(test_deploy.http_status_ok?(server, port, endpoint)).to be_false
+    end
+
+    it 'outputs the HTTP status when it is not OK' do
+      expect(Excon).to receive(:get).and_return(mock_bad_status)
+      expect(test_deploy).to receive(:warn).with(/Got HTTP status: 500/)
+      expect(test_deploy.http_status_ok?(server, port, endpoint)).to be_false
+    end
+
+    it 'handles SocketErrors and outputs a message' do
+      expect(Excon).to receive(:get).and_raise(Excon::Errors::SocketError.new(RuntimeError.new()))
+      expect(test_deploy).to receive(:warn).with(/Failed to connect/)
+      expect(test_deploy.http_status_ok?(server, port, endpoint)).to be_false
+    end
+  end
+
+  describe '#container_up?' do
+    it 'recognizes when no containers are running' do
+      expect(server).to receive(:find_containers_by_public_port).and_return([])
+
+      test_deploy.container_up?(server, port).should be_false
+    end
+
+    it 'complains when more than one container is bound to this port' do
+      expect(server).to receive(:find_containers_by_public_port).and_return([1,2])
+      expect(test_deploy).to receive(:error).with /More than one container/
+
+      test_deploy.container_up?(server, port).should be_false
+    end
+
+    it 'recognizes when the container is actually running' do
+      expect(server).to receive(:find_containers_by_public_port).and_return([container])
+      expect(test_deploy).to receive(:info).with /Found container/
+
+      test_deploy.container_up?(server, port).should be_true
+    end
+  end
+
+  describe '#wait_for_http_status_ok?' do
+    before do
+      test_deploy.stub(:info)
+    end
+
+    it 'identifies that a container is up' do
+      test_deploy.stub(:container_up? => true)
+      test_deploy.stub(:http_status_ok? => true)
+
+      test_deploy.wait_for_http_status_ok(server, port, '/foo', 'image_id', 'chaucer')
+      expect(test_deploy).to have_received(:info).with(/Waiting for the port/)
+      expect(test_deploy).to have_received(:info).with('Container is up!')
+    end
+
+    it 'waits when the container is not yet up' do
+      test_deploy.stub(:container_up? => false)
+      test_deploy.stub(:error)
+      test_deploy.stub(:warn)
+      expect(test_deploy).to receive(:exit)
+      expect(test_deploy).to receive(:sleep).with(0)
+       
+      test_deploy.wait_for_http_status_ok(server, port, '/foo', 'image_id', 'chaucer', 0, 1)
+      expect(test_deploy).to have_received(:info).with(/Waiting for the port/)
+    end
+
+    it 'waits when the HTTP status is not OK' do
+      test_deploy.stub(:container_up? => true)
+      test_deploy.stub(:http_status_ok? => false)
+      test_deploy.stub(:error)
+      test_deploy.stub(:warn)
+      expect(test_deploy).to receive(:exit)
+       
+      test_deploy.wait_for_http_status_ok(server, port, '/foo', 'image_id', 'chaucer', 1, 0)
+      expect(test_deploy).to have_received(:info).with(/Waiting for the port/)
+    end
+  end
+
+  describe '#cleanup_containers' do
+    it 'deletes all but two containers' do
+      expect(server).to receive(:old_containers_for_port).with(port.to_s).and_return([
+        {'Id' => '123', 'Names' => ['foo']},
+        {'Id' => '456', 'Names' => ['foo']},
+        {'Id' => '789', 'Names' => ['foo']},
+        {'Id' => '0ab', 'Names' => ['foo']},
+        {'Id' => 'cde', 'Names' => ['foo']},
+      ])
+      expect(server).to receive(:remove_container).with('789')
+      expect(server).to receive(:remove_container).with('0ab')
+      expect(server).to receive(:remove_container).with('cde')
+
+      test_deploy.cleanup_containers(server, {'80/tcp' => [{'HostIp' => '0.0.0.0', 'HostPort' => port.to_s}]})
+    end
+  end
+
+  describe '#stop_containers' do
+    it 'calls stop_container on the right containers' do
+      second_container = container.dup
+      containers = [ container, second_container ]
+      bindings = {'80/tcp'=>[{'HostIp'=>'0.0.0.0', 'HostPort'=>'80'}]}
+
+      expect(server).to receive(:find_containers_by_public_port).and_return(containers)
+      expect(test_deploy).to receive(:public_port_for).with(bindings).and_return('80')
+      expect(server).to receive(:stop_container).with(container['Id']).once
+      expect(server).to receive(:stop_container).with(second_container['Id']).once
+
+      test_deploy.stop_containers(server, bindings)
+    end
+  end
+
+  describe '#wait_for_load_balancer_check_interval' do
+    it 'knows how long to sleep' do
+      timing = double(timing)
+      expect(test_deploy).to receive(:fetch).with(:rolling_deploy_check_interval, 5).and_return(timing)
+      expect(test_deploy).to receive(:sleep).with(timing)
+
+      test_deploy.wait_for_load_balancer_check_interval
+    end
+  end
+
+  describe '#container_config_for' do
+    it 'works with env_vars provided' do
+      config = test_deploy.container_config_for(server, 'image_id', {}, 'FOO' => 'BAR')
+
+      expect(config).to be_a(Hash)
+      expect(config.keys).to match_array(%w{ Hostname Image Env ExposedPorts })
+      expect(config['Env']).to eq(['FOO=BAR'])
+    end
+
+    it 'works without env_vars or port_bindings' do
+      config = test_deploy.container_config_for(server, 'image_id')
+
+      expect(config).to be_a(Hash)
+      expect(config.keys).to match_array(%w{ Hostname Image })
+    end
+  end
+
+  describe '#start_new_container' do
+    let(:bindings) { {'80/tcp'=>[{'HostIp'=>'0.0.0.0', 'HostPort'=>'80'}]} }
+
+    it 'configures the container' do
+      expect(test_deploy).to receive(:container_config_for).with(server, 'image_id', bindings, nil).once
+      test_deploy.stub(:start_container_with_config)
+
+      test_deploy.start_new_container(server, 'image_id', bindings, {})
+    end
+
+    it 'starts the container' do
+      expect(test_deploy).to receive(:start_container_with_config).with(server, {}, anything(), anything())
+
+      test_deploy.start_new_container(server, 'image_id', bindings, {})
+    end
+
+    it 'ultimately asks the server object to do the work' do
+      server.should_receive(:create_container).with(
+        hash_including({'Image'=>'image_id', 'Hostname'=>'host1', 'ExposedPorts'=>{'80/tcp'=>{}}})
+      ).and_return(container)
+
+      server.should_receive(:start_container)
+      server.should_receive(:inspect_container)
+
+      new_container = test_deploy.start_new_container(server, 'image_id', bindings, {})
+      expect(new_container).to eq(container)
+    end
+  end
+
+  describe '#launch_console' do
+    let(:bindings) { {'80/tcp'=>[{'HostIp'=>'0.0.0.0', 'HostPort'=>'80'}]} }
+
+    it 'configures the container' do
+      expect(test_deploy).to receive(:container_config_for).with(server, 'image_id', bindings, nil).once
+      test_deploy.stub(:start_container_with_config)
+
+      test_deploy.start_new_container(server, 'image_id', bindings, {})
+    end
+
+    it 'augments the container_config' do
+      expect(test_deploy).to receive(:start_container_with_config).with(server, {},
+        anything(),
+        hash_including('Cmd' => [ '/bin/bash' ], 'AttachStdin' => true , 'Tty' => true , 'OpenStdin' => true)
+      ).and_return({'Id' => 'shakespeare'})
+
+      test_deploy.launch_console(server, 'image_id', bindings, {})
+    end
+
+    it 'starts the console' do
+      expect(test_deploy).to receive(:start_container_with_config).with(
+        server, {}, anything(), anything()
+      ).and_return({'Id' => 'shakespeare'})
+
+      test_deploy.launch_console(server, 'image_id', bindings, {})
+      expect(server).to have_received(:attach).with('shakespeare')
+    end
+  end
+end

data/spec/docker_server_group_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'centurion/docker_server'
+require 'centurion/docker_server_group'
+
+describe Centurion::DockerServerGroup do
+  let(:docker_path) { 'docker' }
+  let(:group) { Centurion::DockerServerGroup.new(['host1', 'host2'], docker_path) }
+
+  it 'takes a hostlist and instantiates DockerServers' do
+    expect(group.hosts).to have(2).items
+    expect(group.hosts.first).to be_a(Centurion::DockerServer)
+    expect(group.hosts.last).to be_a(Centurion::DockerServer)
+  end
+
+  it 'implements Enumerable' do
+    expect(group.methods).to be_a_kind_of(Enumerable)
+  end
+
+  it 'prints a friendly message to stderr when iterating' do
+    expect(group).to receive(:info).with(/Connecting to Docker on host[0-9]/).twice
+
+    group.each { |host| }
+  end
+
+  it 'can run parallel operations' do
+    item = double('item').tap { |i| i.stub(:dummy_method) }
+    expect(item).to receive(:dummy_method).twice
+
+    expect { group.each_in_parallel { |host| item.dummy_method } }.not_to raise_error
+  end
+end