rory-deploy 1.8.4.1

data/spec/deploy_dsl_spec.rb

@@ -0,0 +1,184 @@
+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 'has a DSL method for specifying the start command' do
+    command = %w{ /bin/echo hi }
+    DeployDSLTest.command command
+    expect(DeployDSLTest.defined_service.command).to eq(command)
+  end
+
+  it 'adds new env_vars to the existing ones, as strings' do
+    DeployDSLTest.env_vars('SHAKESPEARE' => 'Hamlet')
+    DeployDSLTest.env_vars('DICKENS' => 'David Copperfield',
+                           DICKENS_BIRTH_YEAR: 1812)
+
+    expect(DeployDSLTest.defined_service.env_vars).to eq(
+      'SHAKESPEARE'        => 'Hamlet',
+      'DICKENS'            => 'David Copperfield',
+      'DICKENS_BIRTH_YEAR' => '1812'
+    )
+  end
+
+  describe '#add_capability' do
+    it 'adds one capability' do
+      DeployDSLTest.add_capability 'IPC_LOCK'
+      expect(DeployDSLTest.defined_service.cap_adds).to eq(['IPC_LOCK'])
+    end
+
+    it 'adds multiple capabilites' do 
+      DeployDSLTest.add_capability 'IPC_LOCK'
+      DeployDSLTest.add_capability 'SYS_RESOURCE'
+      expect(DeployDSLTest.defined_service.cap_adds).to eq(['IPC_LOCK', 'SYS_RESOURCE'])
+    end
+
+    it 'fails when an invalid capability is added' do
+      lambda{ DeployDSLTest.add_capability 'FOO_BAR' }.should raise_error SystemExit
+    end
+  end
+
+  describe '#drop_capability' do
+    it 'drops one capability' do
+      DeployDSLTest.drop_capability 'IPC_LOCK'
+      expect(DeployDSLTest.defined_service.cap_drops).to eq(['IPC_LOCK'])
+    end
+
+    it 'drops multiple capabilites' do 
+      DeployDSLTest.drop_capability 'IPC_LOCK'
+      DeployDSLTest.drop_capability 'SYS_RESOURCE'
+      expect(DeployDSLTest.defined_service.cap_drops).to eq(['IPC_LOCK', 'SYS_RESOURCE'])
+    end
+  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
+      DeployDSLTest.host_port(666, container_port: 666)
+      DeployDSLTest.host_port(999, container_port: 80)
+
+      expect(DeployDSLTest.defined_service.port_bindings).to eq([Centurion::Service::PortBinding.new(666, 666, 'tcp'), Centurion::Service::PortBinding.new(999, 80, 'tcp')])
+    end
+
+    it 'adds new bind ports to the list with an IP binding when supplied' do
+      DeployDSLTest.host_port(999, container_port: 80, host_ip: '0.0.0.0')
+
+      expect(DeployDSLTest.defined_service.port_bindings).to eq([Centurion::Service::PortBinding.new(999, 80, 'tcp', '0.0.0.0')])
+    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 '#network_mode' do
+    it 'accepts host mode' do
+      DeployDSLTest.network_mode('host')
+      expect(DeployDSLTest.defined_service.network_mode).to eq('host')
+    end
+
+    it 'accepts bridge mode' do
+      DeployDSLTest.network_mode('bridge')
+      expect(DeployDSLTest.defined_service.network_mode).to eq('bridge')
+    end
+
+    it 'accepts container link mode' do
+      DeployDSLTest.network_mode('container:a2e8937b')
+      expect(DeployDSLTest.defined_service.network_mode).to eq('container:a2e8937b')
+    end
+
+    it 'fails when invalid mode is passed' do
+      expect { DeployDSLTest.network_mode('foo') }.to raise_error(SystemExit)
+    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.defined_service.volumes).to eq [Centurion::Service::Volume.new('volume1', '/dev/sdd'), Centurion::Service::Volume.new('volume2', '/dev/sde')]
+    end
+  end
+
+  describe '#extra_host' do
+    it 'adds new hosts to the list' do
+      DeployDSLTest.extra_host('192.168.33.10', 'newrelic.dev')
+      DeployDSLTest.extra_host('192.168.33.93', 'd.newrelic.dev')
+
+      expect(DeployDSLTest.defined_service.extra_hosts).to eq(['newrelic.dev:192.168.33.10', 'd.newrelic.dev:192.168.33.93'])
+    end
+
+    it 'extra_hosts list is nil by default' do
+      expect(DeployDSLTest.defined_service.extra_hosts).to eq(nil)
+    end
+  end
+
+  it 'gets current tags for an image' do
+    allow_any_instance_of(Centurion::DockerServer).to receive(:current_tags_for).and_return([ 'foo' ])
+    DeployDSLTest.set(:hosts, [ 'host1' ])
+
+    expect(DeployDSLTest.get_current_tags_for('asdf')).to eq [ { server: 'host1', tags: [ 'foo'] } ]
+  end
+
+  it 'appends tags to the image name when returning a service' do
+    DeployDSLTest.set(:tag, 'roland')
+    DeployDSLTest.set(:image, 'charlemagne')
+    expect(DeployDSLTest.defined_service.image).to eq('charlemagne:roland')
+  end
+end

data/spec/deploy_spec.rb

@@ -0,0 +1,212 @@
+require 'spec_helper'
+require 'centurion'
+
+describe Centurion::Deploy do
+  let(:mock_ok_status)  { double('http_status_ok', status: 200) }
+  let(:mock_bad_status) { double('http_status_ok', status: 500) }
+  let(:server)          { double('docker_server', attach: true, hostname: hostname) }
+  let(:port)            { 8484 }
+  let(:container_id)    { '21adfd2ef2ef2349494a' }
+  let(:container)       { { 'Ports' => [{ 'PublicPort' => port }, 'Created' => Time.now.to_i ], 'Id' => container_id, 'Names' => [ 'name1' ] } }
+  let(:endpoint)        { '/status/check' }
+  let(:container_id)    { '21adfd2ef2ef2349494a' }
+  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
+  let(:hostname) { 'host1' }
+
+  before do
+    allow(test_deploy).to receive(:fetch).and_return nil
+    allow(test_deploy).to receive(:host_ip).and_return('172.16.0.1')
+  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_truthy
+    end
+
+    it 'identifies bad HTTP responses' do
+      expect(Excon).to receive(:get).and_return(mock_bad_status)
+      allow(test_deploy).to receive(:warn)
+      expect(test_deploy.http_status_ok?(server, port, endpoint)).to be_falsey
+    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_falsey
+    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_falsey
+    end
+  end
+
+  describe '#container_up?' do
+    it 'recognizes when no containers are running' do
+      expect(server).to receive(:find_container_by_id).and_return(nil)
+
+      expect(test_deploy.container_up?(server, container_id)).to be_falsey
+    end
+
+    it 'recognizes when the container is actually running' do
+      expect(server).to receive(:find_container_by_id).and_return(container)
+      expect(test_deploy).to receive(:info).with /Found container/
+
+      expect(test_deploy.container_up?(server, container_id)).to be_truthy
+    end
+  end
+
+  describe '#wait_for_http_status_ok?' do
+    before do
+      allow(test_deploy).to receive(:info)
+    end
+
+    it 'identifies that a container is up' do
+      allow(test_deploy).to receive(:container_up?).and_return(true)
+      allow(test_deploy).to receive(:http_status_ok?).and_return(true)
+
+      test_deploy.wait_for_health_check_ok(test_deploy.method(:http_status_ok?), server, container_id, 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
+      allow(test_deploy).to receive(:container_up?).and_return(false)
+      allow(test_deploy).to receive(:error)
+      allow(test_deploy).to receive(:warn)
+      expect(test_deploy).to receive(:exit)
+      expect(test_deploy).to receive(:sleep).with(0)
+
+      test_deploy.wait_for_health_check_ok(test_deploy.method(:http_status_ok?), server, container_id, 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
+      allow(test_deploy).to receive(:container_up?).and_return(true)
+      allow(test_deploy).to receive(:http_status_ok?).and_return(false)
+      allow(test_deploy).to receive(:error)
+      allow(test_deploy).to receive(:warn)
+      expect(test_deploy).to receive(:exit)
+
+      test_deploy.wait_for_health_check_ok(test_deploy.method(:http_status_ok?), server, container_id, 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
+      service = Centurion::Service.new('walrus')
+      expect(server).to receive(:old_containers_for_name).with('walrus').and_return([
+        {'Id' => '123', 'Names' => ['walrus-3bab311b460bdf']},
+        {'Id' => '456', 'Names' => ['walrus-4bab311b460bdf']},
+        {'Id' => '789', 'Names' => ['walrus-5bab311b460bdf']},
+        {'Id' => '0ab', 'Names' => ['walrus-6bab311b460bdf']},
+        {'Id' => 'cde', 'Names' => ['walrus-7bab311b460bdf']},
+      ])
+      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, service)
+    end
+  end
+
+  describe '#stop_containers' do
+    it 'calls stop_container on the right containers when ports are mapped' do
+      service = Centurion::Service.new(:centurion)
+      service.add_port_bindings(80, 80)
+
+      second_container = container.dup.tap { |c| c['Id'] = c['Id'].sub(/49494/, '55555') }
+      containers = [ container, second_container ]
+
+      expect(server).to receive(:find_containers_by_public_port).with(80).and_return(containers)
+      expect(server).to receive(:stop_container).with(container['Id'], 30).once
+      expect(server).to receive(:stop_container).with(second_container['Id'], 30).once
+
+      test_deploy.stop_containers(server, service)
+    end
+
+    it 'calls stop_container on the right containers when ports are not mapped' do
+      service = Centurion::Service.new(:centurion)
+
+      second_container = container.dup
+      second_container = container.dup.tap { |c| c['Id'] = c['Id'].sub(/49494/, '55555') }
+      containers = [ container, second_container ]
+
+      expect(server).to receive(:find_containers_by_name).with(:centurion).and_return(containers)
+      expect(server).to receive(:stop_container).with(container['Id'], 30).once
+      expect(server).to receive(:stop_container).with(second_container['Id'], 30).once
+
+      test_deploy.stop_containers(server, service)
+    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 '#hostname_proc' do
+    it 'does not provide a container hostname if no override is given' do
+      expect(test_deploy).to receive(:fetch).with(:container_hostname).and_return nil
+      expect(test_deploy.hostname_proc).to be_nil
+    end
+
+    it 'provides container hostname if an override string is given' do
+      expect(test_deploy).to receive(:fetch).with(:container_hostname).and_return 'example.com'
+      expect(test_deploy.hostname_proc.call('foo')).to eq('example.com')
+    end
+
+    context 'container_hostname is overridden with a proc' do
+      it 'provides a container hostname by executing the proc given' do
+        expect(test_deploy).to receive(:fetch).with(:container_hostname).and_return ->(s) { "container.#{s}" }
+        expect(test_deploy.hostname_proc.call('example.com')).to eq('container.example.com')
+      end
+    end
+  end
+
+  describe '#start_new_container' do
+    let(:bindings) { {'80/tcp'=>[{'HostIp'=>'0.0.0.0', 'HostPort'=>'80'}]} }
+    let(:env)      { { 'FOO' => 'BAR' } }
+    let(:volumes)  { ['/foo:/bar'] }
+    let(:command)  { ['/bin/echo', 'hi'] }
+
+    it 'ultimately asks the server object to do the work' do
+      service = double(:Service, name: :centurion, build_config: {"Image" => "abcdef"}, build_host_config: {})
+      restart_policy = double(:RestartPolicy)
+
+      expect(server).to receive(:create_container).with({"Image" => "abcdef"}, :centurion).and_return(container)
+
+      expect(server).to receive(:start_container)
+      expect(server).to receive(:inspect_container)
+
+      new_container = test_deploy.start_new_container(server, service, restart_policy)
+      expect(new_container).to eq(container)
+    end
+  end
+
+  describe '#launch_console' do
+    it 'starts the console' do
+      service = double(:Service, name: :centurion, build_console_config: {"Image" => "abcdef"}, build_host_config: {})
+
+      expect(server).to receive(:create_container).with({"Image" => "abcdef"}, :centurion).and_return(container)
+      expect(server).to receive(:start_container)
+
+      test_deploy.launch_console(server, service)
+      expect(server).to have_received(:attach).with(container_id)
+    end
+  end
+end

data/spec/docker_registry_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'centurion/docker_registry'
+
+describe Centurion::DockerRegistry do
+  let(:registry_url) { 'http://localhost/' }
+  let(:registry)     { Centurion::DockerRegistry.new(registry_url) }
+
+  describe '#repository_tags' do
+    let(:repository) { 'foobar' }
+    let(:tag_name)   { 'arbitrary_tag' }
+    let(:image_id)   { 'deadbeef0000' }
+    let(:url)        { any_args() }
+
+    before do
+      expect(Excon).to receive(:get).with(url).and_return(
+        double(status: 200, body: response)
+      )
+    end
+
+    subject { registry.repository_tags(repository) }
+
+    describe 'handling different responses from open source and official registries' do
+      context 'when given a response from the official Docker registry' do
+        let(:registry_url) { Centurion::DockerRegistry::OFFICIAL_URL }
+        let(:response)     { <<-JSON.strip }
+          [{"layer": "#{image_id}", "name": "#{tag_name}"}]
+        JSON
+
+        it 'normalizes the response' do
+          expect(subject).to eq(tag_name => image_id)
+        end
+      end
+
+      context 'when given a response from the open-source Docker registry' do
+        let(:response) { <<-JSON.strip }
+          {"#{tag_name}": "#{image_id}"}
+        JSON
+
+        it 'normalizes the response' do
+          expect(subject).to eq(tag_name => image_id)
+        end
+      end
+    end
+
+    context 'when given the official Docker registry and a repository with a hostname' do
+      let(:registry_url) { Centurion::DockerRegistry::OFFICIAL_URL }
+      let(:repository)   { 'docker-reg.example.com/foobar' }
+      let(:response)     { <<-JSON.strip }
+        [{"layer": "#{image_id}", "name": "#{tag_name}"}]
+      JSON
+
+      it 'fetches from the image-referenced registry' do
+        expect(subject).to eq(tag_name => image_id)
+      end
+    end
+
+    context 'when given any other registry' do
+      let(:registry_url) { 'http://my-registry.example.com' }
+      let(:response)     { <<-JSON.strip }
+        {"#{tag_name}": "#{image_id}"}
+      JSON
+
+      context 'and a repository with a hostname' do
+        let(:repository) { 'docker-reg.example.com/foobar' }
+
+        it 'fetches from the image-referenced registry' do
+          expect(subject).to eq(tag_name => image_id)
+        end
+      end
+
+      context 'and a repository with no hostname' do
+        let(:repository) { 'foobar' }
+
+        it 'fetches from the image-referenced registry' do
+          expect(subject).to eq(tag_name => image_id)
+        end
+      end
+    end
+  end
+
+  describe '#repository_auth' do
+    let(:tag_name)   { 'arbitrary_tag' }
+    let(:image_id)   { 'deadbeef0000' }
+    let(:user)       { 'user_foo' }
+    let(:password)   { 'pass_bar' }
+    let(:registry)     { Centurion::DockerRegistry.new(registry_url, user, password) }
+
+    context 'when authentication data is provided to the DockerRegistry object' do
+      let(:registry_url) { Centurion::DockerRegistry::OFFICIAL_URL }
+      let(:repository)   { 'docker-reg.example.com/foobar' }
+      let(:response)     { <<-JSON.strip }
+        [{"layer": "#{image_id}", "name": "#{tag_name}"}]
+      JSON
+
+      before do
+        expect(Excon).to receive(:get).with(kind_of(String), hash_including(user: user, password: password)).and_return(
+          double(status: 200, body: response)
+        )
+      end
+      it 'uses it to connect to the registry' do
+        registry.repository_tags(repository)
+      end
+    end
+  end
+end