centurion 1.6.0 → 1.8.0

data/lib/centurion/version.rb

@@ -1,3 +1,3 @@
 module Centurion
-  VERSION = '1.6.0'
+  VERSION = '1.8.0'
 end

data/lib/core_ext/numeric_bytes.rb

@@ -1,4 +1,4 @@
-# Copied from ActiveSupport 4.2.1 lib/active_support/core_ext/numeric/bytes.rb
+# Modified from ActiveSupport 4.2.1 lib/active_support/core_ext/numeric/bytes.rb
 #
 # NOTE that THIS LICENSE ONLY APPLIES TO THIS FILE itself, not
 # to the rest of the project.
@@ -25,68 +25,70 @@
 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+unless Numeric.constants.include?(:KILOBYTE)
+  class Numeric
+    KILOBYTE = 1024 unless defined? KILOBYTE
+    MEGABYTE = KILOBYTE * 1024 unless defined? MEGABYTE
+    GIGABYTE = MEGABYTE * 1024 unless defined? GIGABYTE
+    TERABYTE = GIGABYTE * 1024 unless defined? TERABYTE
+    PETABYTE = TERABYTE * 1024 unless defined? PETABYTE
+    EXABYTE  = PETABYTE * 1024 unless defined? EXABYTE
 
-class Numeric
-  KILOBYTE = 1024
-  MEGABYTE = KILOBYTE * 1024
-  GIGABYTE = MEGABYTE * 1024
-  TERABYTE = GIGABYTE * 1024
-  PETABYTE = TERABYTE * 1024
-  EXABYTE  = PETABYTE * 1024
+    # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
+    #
+    #   2.bytes # => 2
+    def bytes
+      self
+    end unless method_defined? :bytes
+    alias :byte :bytes unless method_defined? :byte
 
-  # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
-  #
-  #   2.bytes # => 2
-  def bytes
-    self
-  end
-  alias :byte :bytes
-
-  # Returns the number of bytes equivalent to the kilobytes provided.
-  #
-  #   2.kilobytes # => 2048
-  def kilobytes
-    self * KILOBYTE
-  end
-  alias :kilobyte :kilobytes
+    # Returns the number of bytes equivalent to the kilobytes provided.
+    #
+    #   2.kilobytes # => 2048
+    def kilobytes
+      self * KILOBYTE
+    end unless method_defined? :kilobytes
+    alias :kilobyte :kilobytes unless method_defined? :kilobyte
 
-  # Returns the number of bytes equivalent to the megabytes provided.
-  #
-  #   2.megabytes # => 2_097_152
-  def megabytes
-    self * MEGABYTE
-  end
-  alias :megabyte :megabytes
+    # Returns the number of bytes equivalent to the megabytes provided.
+    #
+    #   2.megabytes # => 2_097_152
+    def megabytes
+      self * MEGABYTE
+    end unless method_defined? :megabytes?
+    alias :megabyte :megabytes unless method_defined? :megabyte
 
-  # Returns the number of bytes equivalent to the gigabytes provided.
-  #
-  #   2.gigabytes # => 2_147_483_648
-  def gigabytes
-    self * GIGABYTE
-  end
-  alias :gigabyte :gigabytes
+    # Returns the number of bytes equivalent to the gigabytes provided.
+    #
+    #   2.gigabytes # => 2_147_483_648
+    def gigabytes
+      self * GIGABYTE
+    end unless method_defined? :gigabytes
+    alias :gigabyte :gigabytes unless method_defined? :gigabyte
 
-  # Returns the number of bytes equivalent to the terabytes provided.
-  #
-  #   2.terabytes # => 2_199_023_255_552
-  def terabytes
-    self * TERABYTE
-  end
-  alias :terabyte :terabytes
+    # Returns the number of bytes equivalent to the terabytes provided.
+    #
+    #   2.terabytes # => 2_199_023_255_552
+    def terabytes
+      self * TERABYTE
+    end unless method_defined? :terabytes
+    alias :terabyte :terabytes unless method_defined? :terabyte
 
-  # Returns the number of bytes equivalent to the petabytes provided.
-  #
-  #   2.petabytes # => 2_251_799_813_685_248
-  def petabytes
-    self * PETABYTE
-  end
-  alias :petabyte :petabytes
+    # Returns the number of bytes equivalent to the petabytes provided.
+    #
+    #   2.petabytes # => 2_251_799_813_685_248
+    def petabytes
+      self * PETABYTE
+    end unless method_defined? :petabytes
+    alias :petabyte :petabytes unless method_defined? :petabyte
 
-  # Returns the number of bytes equivalent to the exabytes provided.
-  #
-  #   2.exabytes # => 2_305_843_009_213_693_952
-  def exabytes
-    self * EXABYTE
+    # Returns the number of bytes equivalent to the exabytes provided.
+    #
+    #   2.exabytes # => 2_305_843_009_213_693_952
+    def exabytes
+      self * EXABYTE
+    end unless method_defined? :exabytes
+    alias :exabyte :exabytes unless method_defined? :exabyte
   end
-  alias :exabyte :exabytes
 end
+

data/lib/tasks/centurion.rake

@@ -7,6 +7,9 @@ namespace :centurion do
   task :clean_environment do
     ENV.delete('DOCKER_HOST')
     ENV.delete('DOCKER_TLS_VERIFY')
+    # Preserve original DOCKER_CERT_PATH for use by dogestry.
+    # See also Centurion::Dogestry#set_envs
+    set(:original_docker_cert_path, ENV['DOCKER_CERT_PATH'])
     ENV.delete('DOCKER_CERT_PATH')
   end
 end

data/lib/tasks/deploy.rake

@@ -25,6 +25,18 @@ end
 
 task :stop => ['deploy:stop']
 
+namespace :dev do
+  task :export_only do
+    # This removes the known-to-be-problematic bundler env
+    # vars but doesn't try to sanitize the whole ENV. Doing
+    # so breaks things like rbenv which we need to use when
+    # testing. A /bin/bash -l will help further clean it up.
+    ENV.reject! { |(var, val)| var =~ /^BUNDLE_/ }
+    fetch(:env_vars).each { |(var, value)| ENV[var] = value }
+    exec fetch(:development_shell, '/bin/bash -l')
+  end
+end
+
 namespace :deploy do
   include Centurion::Deploy
 
@@ -47,6 +59,10 @@ namespace :deploy do
         aws_secret_key: fetch(:aws_secret_key),
         s3_bucket: fetch(:s3_bucket),
         s3_region: fetch(:s3_region) || 'us-east-1',
+        tlsverify: fetch(:tlsverify),
+        tlscacert: fetch(:tlscacert),
+        tlscert: fetch(:tlscert),
+        original_docker_cert_path: fetch(:original_docker_cert_path)
       )
 
       target_servers = Centurion::DockerServerGroup.new(fetch(:hosts), fetch(:docker_path))
@@ -75,7 +91,7 @@ namespace :deploy do
   # - remote: stop
   task :stop do
     on_each_docker_host do |server|
-      stop_containers(server, fetch(:port_bindings), fetch(:stop_timeout, 30))
+      stop_containers(server, defined_service, fetch(:stop_timeout, 30))
     end
   end
 
@@ -85,59 +101,32 @@ namespace :deploy do
   # - remote: inspect container
   task :start_new do
     on_each_docker_host do |server|
-      start_new_container(
-        server,
-        fetch(:image_id),
-        fetch(:port_bindings),
-        fetch(:binds),
-        fetch(:env_vars),
-        fetch(:command),
-        fetch(:memory),
-        fetch(:cpu_shares)
-      )
+      start_new_container(server, defined_service, defined_restart_policy)
     end
   end
 
   task :launch_console do
     on_each_docker_host do |server|
-      launch_console(
-        server,
-        fetch(:image_id),
-        fetch(:port_bindings),
-        fetch(:binds),
-        fetch(:env_vars)
-      )
+      launch_console(server, defined_service)
     end
   end
 
   task :rolling_deploy do
     on_each_docker_host do |server|
-      stop_containers(server, fetch(:port_bindings), fetch(:stop_timeout, 30))
-
-      start_new_container(
-        server,
-        fetch(:image_id),
-        fetch(:port_bindings),
-        fetch(:binds),
-        fetch(:env_vars),
-        fetch(:command),
-        fetch(:memory),
-        fetch(:cpu_shares)
-      )
+      service = defined_service
 
-      skip_ports = Array(fetch(:rolling_deploy_skip_ports, [])).map(&:to_s)
+      stop_containers(server, service, fetch(:stop_timeout, 30))
 
-      fetch(:port_bindings).each_pair do |container_port, host_ports|
-        port = host_ports.first['HostPort']
-        next if skip_ports.include?(port)
+      container = start_new_container(server, service, defined_restart_policy)
 
+      public_ports = service.public_ports - fetch(:rolling_deploy_skip_ports, [])
+      public_ports.each do |port|
         wait_for_health_check_ok(
           fetch(:health_check, method(:http_status_ok?)),
           server,
+          container['Id'],
           port,
           fetch(:status_endpoint, '/'),
-          fetch(:image),
-          fetch(:tag),
           fetch(:rolling_deploy_wait_time, 5),
           fetch(:rolling_deploy_retries, 24)
         )
@@ -148,8 +137,8 @@ namespace :deploy do
   end
 
   task :cleanup do
-    on_each_docker_host do |target_server|
-      cleanup_containers(target_server, fetch(:port_bindings))
+    on_each_docker_host do |server|
+      cleanup_containers(server, defined_service)
     end
   end
 
@@ -189,10 +178,7 @@ namespace :deploy do
     if fetch(:registry) == 'dogestry'
       invoke 'deploy:dogestry:pull_image'
     else
-      hosts, docker_path = fetch(:hosts, []), fetch(:docker_path)
-      target_servers = Centurion::DockerServerGroup.new(hosts, docker_path,
-                                                        build_tls_params)
-      target_servers.each_in_parallel do |target_server|
+      build_server_group.each_in_parallel do |target_server|
         target_server.pull(fetch(:image), fetch(:tag))
       end
     end
@@ -250,4 +236,5 @@ namespace :deploy do
 
     invoke 'deploy'
   end
+
 end

data/spec/deploy_dsl_spec.rb

@@ -23,23 +23,53 @@ describe Centurion::DeployDSL do
   end
 
   it 'has a DSL method for specifying the start command' do
-    command = ['/bin/echo', 'hi']
+    command = %w{ /bin/echo hi }
     DeployDSLTest.command command
-    expect(DeployDSLTest.fetch(:command)).to equal(command)
+    expect(DeployDSLTest.defined_service.command).to eq(command)
   end
 
   it 'adds new env_vars to the existing ones, as strings' do
-    DeployDSLTest.set(:env_vars, { 'SHAKESPEARE' => 'Hamlet' })
+    DeployDSLTest.env_vars('SHAKESPEARE' => 'Hamlet')
     DeployDSLTest.env_vars('DICKENS' => 'David Copperfield',
                            :DICKENS_BIRTH_YEAR => 1812)
 
-    expect(DeployDSLTest.fetch(:env_vars)).to include(
+    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')
@@ -67,25 +97,16 @@ describe Centurion::DeployDSL do
     end
 
     it 'adds new bind ports to the list' do
-      dummy_value = { '666/tcp' => ['value'] }
-      DeployDSLTest.set(:port_bindings, dummy_value)
+      DeployDSLTest.host_port(666, container_port: 666)
       DeployDSLTest.host_port(999, container_port: 80)
 
-      expect(DeployDSLTest).to have_key_and_value(
-        :port_bindings,
-        dummy_value.merge('80/tcp' => [{ 'HostPort' => '999' }])
-      )
+      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
-      dummy_value = { '666/tcp' => ['value'] }
-      DeployDSLTest.set(:port_bindings, dummy_value)
       DeployDSLTest.host_port(999, container_port: 80, host_ip: '0.0.0.0')
 
-      expect(DeployDSLTest).to have_key_and_value(
-        :port_bindings,
-        dummy_value.merge('80/tcp' => [{ 'HostIp' => '0.0.0.0', 'HostPort' => '999' }])
-      )
+      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
@@ -97,6 +118,27 @@ describe Centurion::DeployDSL do
     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/)
@@ -110,7 +152,20 @@ describe Centurion::DeployDSL 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 }
+     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
 
@@ -120,4 +175,10 @@ describe Centurion::DeployDSL do
 
     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

@@ -6,8 +6,10 @@ describe Centurion::Deploy do
   let(:mock_bad_status) { double('http_status_ok', status: 500) }
   let(:server)          { double('docker_server', attach: true, hostname: hostname) }
   let(:port)            { 8484 }
-  let(:container)       { { 'Ports' => [{ 'PublicPort' => port }, 'Created' => Time.now.to_i ], 'Id' => '21adfd2ef2ef2349494a', 'Names' => [ 'name1' ] } }
+  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)
@@ -19,7 +21,6 @@ describe Centurion::Deploy do
 
   before do
     allow(test_deploy).to receive(:fetch).and_return nil
-    allow(test_deploy).to receive(:fetch).with(:container_hostname, hostname).and_return(hostname)
     allow(test_deploy).to receive(:host_ip).and_return('172.16.0.1')
   end
 
@@ -50,23 +51,16 @@ describe Centurion::Deploy do
 
   describe '#container_up?' do
     it 'recognizes when no containers are running' do
-      expect(server).to receive(:find_containers_by_public_port).and_return([])
+      expect(server).to receive(:find_container_by_id).and_return(nil)
 
-      expect(test_deploy.container_up?(server, port)).to be_falsey
-    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/
-
-      expect(test_deploy.container_up?(server, port)).to be_falsey
+      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_containers_by_public_port).and_return([container])
+      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, port)).to be_truthy
+      expect(test_deploy.container_up?(server, container_id)).to be_truthy
     end
   end
 
@@ -79,7 +73,7 @@ describe Centurion::Deploy 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, port, '/foo', 'image_id', 'chaucer')
+      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
@@ -91,7 +85,7 @@ describe Centurion::Deploy do
       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, port, '/foo', 'image_id', 'chaucer', 0, 1)
+      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
 
@@ -102,40 +96,42 @@ describe Centurion::Deploy do
       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, port, '/foo', 'image_id', 'chaucer', 1, 0)
+      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
-      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']},
+      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, {'80/tcp' => [{'HostIp' => '0.0.0.0', 'HostPort' => port.to_s}]})
+      test_deploy.cleanup_containers(server, service)
     end
   end
 
   describe '#stop_containers' do
     it 'calls stop_container on the right containers' do
+      service = Centurion::Service.new(:centurion)
+      service.add_port_bindings(80, 80)
+
       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(: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, bindings)
+      test_deploy.stop_containers(server, service)
     end
   end
 
@@ -149,348 +145,54 @@ describe Centurion::Deploy do
     end
   end
 
-  describe '#container_config_for' do
-    let(:image_id) { 'image_id' }
-    let(:port_bindings) { nil }
-    let(:env) { nil }
-    let(:volumes) { nil }
-    let(:command) { nil }
-
-    it 'works without env_vars, port_bindings, or a command' 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
-
-    context 'when port bindings are specified' do
-      let(:port_bindings) { {1234 => 80, 9876 => 80} }
-
-      it 'sets the ExposedPorts key in the config correctly' do
-        config = test_deploy.container_config_for(server, image_id, port_bindings)
-
-        expect(config['ExposedPorts']).to be_a(Hash)
-        expect(config['ExposedPorts'].keys).to eq port_bindings.keys
-      end
-    end
-
-    context 'when env vars are specified' do
-      let(:env) { {
-        'FOO' => 'BAR',
-        'BAZ' => '%DOCKER_HOSTNAME%.example.com',
-        'BAR' => '%DOCKER_HOST_IP%:1234'
-      } }
-
-      it 'sets the Env key in the config' do
-        config = test_deploy.container_config_for(server, image_id, port_bindings, env)
-
-        expect(config).to be_a(Hash)
-        expect(config.keys).to match_array(%w{ Hostname Image Env })
-        expect(config['Env']).to include('FOO=BAR')
-      end
-
-      it 'interpolates the hostname into env_vars' do
-        config = test_deploy.container_config_for(server, image_id, port_bindings, env)
-
-        expect(config['Env']).to include('BAZ=host1.example.com')
-      end
-
-      it 'interpolates the host IP into the env_vars' do
-        config = test_deploy.container_config_for(server, image_id, port_bindings, env)
-
-        expect(config['Env']).to include('BAR=172.16.0.1:1234')
-      end
-    end
-
-    context 'when volumes are specified' do
-      let(:volumes) { ["/tmp/foo:/tmp/chaucer"] }
-
-      it 'sets the Volumes key in the config' do
-        config = test_deploy.container_config_for(server, image_id, port_bindings, env, volumes)
-
-        expect(config).to be_a(Hash)
-        expect(config.keys).to match_array(%w{ Hostname Image Volumes VolumesFrom })
-        expect(config['Volumes']['/tmp/chaucer']).to eq({})
-      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
 
-    context 'when a custom command is specified' do
-      let(:command) { ['/bin/echo', 'hi'] }
-
-      it 'sets the Cmd key in the config' do
-        config = test_deploy.container_config_for(server, image_id, port_bindings, env, volumes, command)
-
-        expect(config).to be_a(Hash)
-        expect(config.keys).to match_array(%w{ Hostname Image Cmd })
-        expect(config['Cmd']).to eq(command)
-      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 'when cgroup limits are specified' do
-      let(:memory) { 10000000 }
-      let(:cpu_shares) { 1234 }
-
-      before do
-        allow(test_deploy).to receive(:error) # Make sure we don't have red output in tests
-      end
-
-      it 'sets cgroup limits in the config' do
-        config = test_deploy.container_config_for(server, image_id, port_bindings, env, volumes, command, memory, cpu_shares)
-
-        expect(config).to be_a(Hash)
-        expect(config.keys).to match_array(%w{ Hostname Image Memory CpuShares })
-        expect(config['Memory']).to eq(10000000)
-        expect(config['CpuShares']).to eq(1234)
-      end
-
-      it 'throws a fatal error value for Cgroup Memory limit is invalid' do
-        expect { config = test_deploy.container_config_for(server, image_id, port_bindings, env, volumes, command, "I like pie", cpu_shares) }.to terminate.with_code(102)
-        expect { test_deploy.container_config_for(server, image_id, port_bindings, env, volumes, command, -100, cpu_shares) }.to terminate.with_code(102)
-        expect { test_deploy.container_config_for(server, image_id, port_bindings, env, volumes, command, 0xFFFFFFFFFFFFFFFFFF, cpu_shares) }.to terminate.with_code(102)
-      end
-
-      it 'throws a fatal error value for Cgroup CPU limit is invalid' do
-        expect { test_deploy.container_config_for(server, image_id, port_bindings, env, volumes, command, memory, "I like pie") }.to terminate.with_code(101)
-        expect { test_deploy.container_config_for(server, image_id, port_bindings, env, volumes, command, memory, -100) }.to terminate.with_code(101)
-        expect { test_deploy.container_config_for(server, image_id, port_bindings, env, volumes, command, memory, 0xFFFFFFFFFFFFFFFFFF) }.to terminate.with_code(101)
-      end
-
-      it 'still works when memory is specified in gigabytes' do
-        memory = 3.gigabytes
-        config = test_deploy.container_config_for(server, image_id, port_bindings, env, volumes, command, memory, cpu_shares)
-        expect(config['Memory']).to eq(3 * 1024 * 1024 * 1024)
+    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_container_with_config' do
-    let(:bindings) { {'80/tcp'=>[{'HostIp'=>'0.0.0.0', 'HostPort'=>'80'}]} }
-
-    it 'pass host_config to start_container' do
-      allow(server).to receive(:container_config_for).and_return({
-        'Image'        => 'image_id',
-        'Hostname'     => server.hostname,
-      })
-
-      allow(server).to receive(:create_container).and_return({
-        'Id' => 'abc123456'
-      })
-
-      allow(server).to receive(:inspect_container)
-
-      allow(test_deploy).to receive(:fetch).with(:custom_dns).and_return('8.8.8.8')
-      allow(test_deploy).to receive(:fetch).with(:name).and_return(nil)
-
-      expect(server).to receive(:start_container).with(
-        'abc123456',
-        {
-          'PortBindings' => bindings,
-          'Dns' => '8.8.8.8',
-          'RestartPolicy' => {
-            'Name' => 'on-failure',
-            'MaximumRetryCount' => 10
-          }
-        }
-      ).once
-
-      test_deploy.start_new_container(server, 'image_id', bindings, {}, nil, nil)
-    end
-  end
-
-  describe '#start_container_with_restart_policy' do
-    let(:bindings) { {'80/tcp'=>[{'HostIp'=>'0.0.0.0', 'HostPort'=>'80'}]} }
-
-    before do
-      allow(server).to receive(:container_config_for).and_return({
-        'Image'        => 'image_id',
-        'Hostname'     => server.hostname,
-      })
-
-      allow(server).to receive(:create_container).and_return({
-        'Id' => 'abc123456'
-      })
-
-      allow(server).to receive(:inspect_container)
-    end
-
-    it 'pass no restart policy to start_container' do
-      expect(server).to receive(:start_container).with(
-        'abc123456',
-        {
-          'PortBindings' => bindings,
-          'RestartPolicy' => {
-            'Name' => 'on-failure',
-            'MaximumRetryCount' => 10
-          }
-        }
-      ).once
-
-      test_deploy.start_new_container(server, 'image_id', bindings, {}, nil, nil)
-    end
-
-    it 'pass "always" restart policy to start_container' do
-      allow(test_deploy).to receive(:fetch).with(:restart_policy_name).and_return('always')
-
-      expect(server).to receive(:start_container).with(
-        'abc123456',
-        {
-          'PortBindings' => bindings,
-          'RestartPolicy' => {
-            'Name' => 'always'
-          }
-        }
-      ).once
-
-      test_deploy.start_new_container(server, 'image_id', bindings, {}, nil, nil)
-    end
-
-    it 'pass "on-failure with 50 retries" restart policy to start_container' do
-      allow(test_deploy).to receive(:fetch).with(:restart_policy_name).and_return('on-failure')
-      allow(test_deploy).to receive(:fetch).with(:restart_policy_max_retry_count).and_return(50)
-
-      expect(server).to receive(:start_container).with(
-        'abc123456',
-        {
-          'PortBindings' => bindings,
-          'RestartPolicy' => {
-            'Name' => 'on-failure',
-            'MaximumRetryCount' => 50
-          }
-        }
-      ).once
-
-      test_deploy.start_new_container(server, 'image_id', bindings, {}, nil, nil)
-    end
-
-    it 'pass "no" restart policy to start_container' do
-      allow(test_deploy).to receive(:fetch).with(:restart_policy_name).and_return('no')
-
-      expect(server).to receive(:start_container).with(
-        'abc123456',
-        {
-          'PortBindings' => bindings,
-          'RestartPolicy' => {
-            'Name' => 'no'
-          }
-        }
-      ).once
-
-      test_deploy.start_new_container(server, 'image_id', bindings, {}, nil, nil)
-    end
-
-    it 'pass "garbage" restart policy to start_container' do
-      allow(test_deploy).to receive(:fetch).with(:restart_policy_name).and_return('garbage')
-
-      expect(server).to receive(:start_container).with(
-        'abc123456',
-        {
-          'PortBindings' => bindings,
-          'RestartPolicy' => {
-            'Name' => 'on-failure',
-            'MaximumRetryCount' => 10
-          }
-        }
-      ).once
-
-      test_deploy.start_new_container(server, 'image_id', bindings, {}, nil, nil)
-    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 'configures the container' do
-      expect(test_deploy).to receive(:container_config_for).with(server, 'image_id', bindings, nil, {}, nil, nil, nil).once
-
-      allow(test_deploy).to receive(:start_container_with_config)
-
-      test_deploy.start_new_container(server, 'image_id', bindings, {}, nil)
-    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 'sets the container hostname when asked' do
-      allow(test_deploy).to receive(:fetch).with(:container_hostname, anything()).and_return('chaucer')
-
-      expect(server).to receive(:create_container).with(
-        hash_including(
-          'Image'        => 'image_id',
-          'Hostname'     => 'chaucer',
-          'ExposedPorts' => {'80/tcp'=>{}},
-          'Cmd'          => command,
-          'Env'          => ['FOO=BAR'],
-          'Volumes'      => {'/bar' => {}},
-        ),
-        nil
-      ).and_return(container)
-
-      expect(server).to receive(:start_container)
-      expect(server).to receive(:inspect_container)
-      test_deploy.start_new_container(server, 'image_id', bindings, volumes, env, command)
-    end
-
     it 'ultimately asks the server object to do the work' do
-      allow(test_deploy).to receive(:fetch).with(:custom_dns).and_return(nil)
-      allow(test_deploy).to receive(:fetch).with(:name).and_return('app1')
-
-      expect(server).to receive(:create_container).with(
-        hash_including(
-          'Image'        => 'image_id',
-          'Hostname'     => hostname,
-          'ExposedPorts' => {'80/tcp'=>{}},
-          'Cmd'          => command,
-          'Env'          => ['FOO=BAR'],
-          'Volumes'      => {'/bar' => {}},
-        ),
-        'app1'
-      ).and_return(container)
+      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, 'image_id', bindings, volumes, env, command)
+      new_container = test_deploy.start_new_container(server, service, restart_policy)
       expect(new_container).to eq(container)
     end
   end
 
   describe '#launch_console' do
-    let(:bindings)   { {'80/tcp'=>[{'HostIp'=>'0.0.0.0', 'HostPort'=>'80'}]} }
-    let(:volumes)    { nil }
-    let(:env)        { nil }
-    let(:command)    { nil }
-    let(:memory)     { nil }
-    let(:cpu_shares) { nil }
-
-    it 'configures the container' do
-      expect(test_deploy).to receive(:container_config_for).with(server, 'image_id', bindings, env, volumes, command, memory, cpu_shares).once
-      allow(test_deploy).to receive(:start_container_with_config)
-
-      test_deploy.start_new_container(server, 'image_id', bindings, volumes, env, command, memory, cpu_shares)
-    end
-
-    it 'augments the container_config' do
-      expect(test_deploy).to receive(:start_container_with_config).with(server, volumes,
-        anything(),
-        hash_including('Cmd' => [ '/bin/bash' ], 'AttachStdin' => true , 'Tty' => true , 'OpenStdin' => true)
-      ).and_return({'Id' => 'shakespeare'})
-
-      test_deploy.launch_console(server, 'image_id', bindings, volumes, env)
-    end
-
     it 'starts the console' do
-      expect(test_deploy).to receive(:start_container_with_config).with(
-        server, nil, anything(), anything()
-      ).and_return({'Id' => 'shakespeare'})
+      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, 'image_id', bindings, volumes, env)
-      expect(server).to have_received(:attach).with('shakespeare')
+      test_deploy.launch_console(server, service)
+      expect(server).to have_received(:attach).with(container_id)
     end
   end
 end