docker-armada 2.0.53

data/lib/armada/thor.rb

@@ -0,0 +1 @@
+require 'armada/cli'

data/lib/armada/ui.rb

@@ -0,0 +1,15 @@
+module Armada
+  module UI
+    def info(message, color = :green)
+      say(message, color)
+    end
+
+    def warn(message, color = :yellow)
+      say(message, color)
+    end
+
+    def error(message, color = :red)
+      say(message, color)
+    end
+  end
+end

data/lib/armada/utils.rb

@@ -0,0 +1,2 @@
+require_relative 'utils/time'
+require_relative 'utils/array'

data/lib/armada/utils/array.rb

@@ -0,0 +1,9 @@
+class Array
+  def each_in_parallel(&block)
+    threads = map do |s|
+      Thread.new { block.call(s) }
+    end
+
+    threads.each { |t| t.join }
+  end
+end

data/lib/armada/utils/time.rb

@@ -0,0 +1,23 @@
+class Time
+  def self.seconds_to_string(s)
+    # d = days, h = hours, m = minutes, s = seconds
+    m = (s / 60).floor
+    s = s % 60
+    h = (m / 60).floor
+    m = m % 60
+    d = (h / 24).floor
+    h = h % 24
+
+    output = "#{s} second#{Time.pluralize(s)}" if (s > 0)
+    output = "#{m} minute#{Time.pluralize(m)}, #{s} second#{Time.pluralize(s)}" if (m > 0)
+    output = "#{h} hour#{Time.pluralize(h)}, #{m} minute#{Time.pluralize(m)}, #{s} second#{Time.pluralize(s)}" if (h > 0)
+    output = "#{d} day#{Time.pluralize(d)}, #{h} hour#{Time.pluralize(h)}, #{m} minute#{Time.pluralize(m)}, #{s} second#{Time.pluralize(s)}" if (d > 0)
+
+    return output
+  end
+
+  def self.pluralize number
+    return "s" unless number == 1
+    return ""
+  end
+end

data/lib/armada/version.rb

@@ -0,0 +1,3 @@
+module Armada
+  VERSION = IO.read(File.join(File.dirname(__FILE__), '..', '..', 'VERSION')) rescue "0.0.1"
+end

data/spec/connection/health_check_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Armada::Connection::HealthCheck do
+
+  describe ".healthy?" do
+    context "when the container health check passes" do
+      subject { Armada::Connection::HealthCheck.new("foo-01", 2181) }
+      let(:mock_ok_status)  { double('http_status_ok').tap { |s| s.stub(status: 200) } }
+      before { expect(Excon).to receive(:get).with(any_args).and_return(mock_ok_status) }
+
+      it "should return true" do
+        subject.healthy?.should be_true
+      end
+    end
+
+    context "when the container health check fails" do
+      subject { Armada::Connection::HealthCheck.new("foo-01", 2181) }
+      let(:mock_bad_status)  { double('http_status_ok').tap { |s| s.stub(status: 500) } }
+      before { expect(Excon).to receive(:get).with(any_args).and_return(mock_bad_status) }
+
+      it "should return false" do
+        subject.healthy?.should be_false
+      end
+    end
+
+    context "when the container health check throws an error" do
+      subject { Armada::Connection::HealthCheck.new("foo-01", 2181) }
+      before { expect(Excon).to receive(:get).with(any_args).and_raise(Excon::Errors::SocketError.new(RuntimeError.new())) }
+
+      it "should return false" do
+        subject.healthy?.should be_false
+      end
+    end
+  end
+
+end

data/spec/deploy_dsl_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+class DeployDSLTest
+  extend Armada::DeployDSL
+end
+
+describe Armada::DeployDSL do
+  before do
+    DeployDSLTest.clear_env
+    DeployDSLTest.set_current_environment('test')
+  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.fetch(:hosts)).to include("host1", "host2")
+  end
+
+  it 'adds the restart policy' do
+    DeployDSLTest.restart_policy({:foo => "bar"})
+    expect(DeployDSLTest.fetch(:restart_policy)).to eq({:foo => "bar"})
+  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.fetch(:hosts)).to include("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.fetch(:hosts)).to include("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.fetch(:port_bindings)).to include(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
+
+end

data/spec/docker/container_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Armada::Container do
+  let(:container_name) { "some_container" }
+  let(:container_id) { "123456789abc123" }
+  let(:image_id) { "123456789abc123" }
+  let(:image_name) { "quay.io/someorg/someimage" }
+  let(:tag) { "latest" }
+  let(:options) {{
+    :container_name => container_name,
+    :image          => image_name,
+    :tag            => tag
+  }}
+
+  let(:docker_host) { Armada::Host.create("http://foo-01:4243") }
+  let(:docker_connection) { ::Docker::Connection.new("http://foo-01:4243", {})}
+  let(:armada_image) { Armada::Image.new(docker_host, options) }
+  let(:docker_image) { ::Docker::Image.new(docker_connection, "id" => image_id) }
+  let(:docker_container) { ::Docker::Container.send(:new, docker_connection, {'id' => container_id, 'Names' => ["/#{container_name}"]}) }
+  let(:armada_container) { Armada::Container.new(armada_image, docker_host, options) }
+  let(:config) {{
+    :port_bindings => { "1111/tcp" => [{"HostIp" => "0.0.0.0", "HostPort" => "1111"}],
+                        "2222/udp" => [{"HostIp" => "0.0.0.0", "HostPort" => "2222"}]},
+    :env_vars      => { "KEY" => "VALUE" },
+    :binds         => [ "/host/log:/container/log" ],
+    :restart_policy => { "MaximumRetryCount" => 5, "Name" => "always" }
+  }}
+
+  describe "#stop" do
+    context "when the container exists" do
+      before { docker_host.should_receive(:get_container).and_return(docker_container) }
+      it "should call kill and remove" do
+        expect(armada_container).to receive(:kill)
+        expect(armada_container).to receive(:remove)
+        armada_container.stop
+      end
+    end
+
+    context "when the container does not exist" do
+      before { docker_host.should_receive(:get_container).and_return(nil) }
+      it "should not call kill and remove" do
+        expect(armada_container).not_to receive(:kill)
+        expect(armada_container).not_to receive(:remove)
+        expect(Armada.ui).to receive(:warn).with(/No container found with the name/)
+        armada_container.stop
+      end
+    end
+  end
+
+  describe "#kill" do
+    context "when the container exists" do
+      before { docker_host.should_receive(:get_container).and_return(docker_container) }
+      it "should call kill on the container" do
+        expect(armada_container.container).to receive(:kill)
+        armada_container.kill
+      end
+
+      it "should call kill on the docker container" do
+        expect(docker_container).to receive(:kill)
+        armada_container.kill
+      end
+    end
+
+    context "when the container does not exist" do
+      before { docker_host.should_receive(:get_container).and_return(nil) }
+      it "should not call kill" do
+        allow_message_expectations_on_nil
+        expect(armada_container.container).not_to receive(:kill)
+        armada_container.kill
+      end
+    end
+  end
+
+  describe "#remove" do
+    context "when the container exists" do
+      before { docker_host.should_receive(:get_container).and_return(docker_container) }
+      it "should call remove on the container" do
+        expect(armada_container.container).to receive(:remove)
+        armada_container.remove
+      end
+
+      it "should call remove on the docker container" do
+        expect(docker_container).to receive(:remove)
+        armada_container.remove
+      end
+
+      it "should catch any exception that is thrown" do
+        expect(docker_container).to receive(:remove).and_raise(Exception.new("Could not remove container"))
+        expect(Armada.ui).to receive(:error).with(/Could not remove container/)
+        armada_container.remove
+      end
+    end
+
+    context "when the container does not exist" do
+      before { docker_host.should_receive(:get_container).and_return(nil) }
+      it "should not call remove" do
+        allow_message_expectations_on_nil
+        expect(armada_container.container).not_to receive(:remove)
+        armada_container.remove
+      end
+    end
+  end
+
+  describe ".create_container_config" do
+    subject { Armada::Container.create_container_config(image_id, container_name, "hostname", config) }
+    it { should include("Image"        => "123456789abc123") }
+    it { should include("Hostname"     => "hostname") }
+    it { should include("name"         => "some_container") }
+    it { should include("ExposedPorts" => { "1111/tcp" => {}, "2222/udp" => {}}) }
+    it { should include("Env"          => ["KEY=VALUE"]) }
+    it { should include("Volumes"      => { "/container/log" => {}}) }
+    it { should include("VolumesFrom"  => "parent") }
+    it { should include("RestartPolicy" => { "MaximumRetryCount" => 5, "Name" => "always" }) }
+  end
+
+  describe ".create_host_config" do
+    subject { Armada::Container.create_host_config(config) }
+    it { should include("Binds" => ["/host/log:/container/log"])}
+    it { should include("PortBindings" => {"1111/tcp" => [{"HostIp" => "0.0.0.0", "HostPort" => "1111"}],
+                                    "2222/udp" => [{"HostIp" => "0.0.0.0", "HostPort" => "2222"}]}) }
+    it { should include("PublishAllPorts" => true) }
+  end
+
+end

data/spec/docker/image_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Armada::Image do
+  let(:image_id) { "123456789abc123" }
+  let(:image_name) { "quay.io/someorg/someimage" }
+  let(:tag) { "latest" }
+  let(:pull) { true }
+  let(:credentials) {
+    Armada::Docker::Credentials.new image_name, 'username', 'password', 'email'
+  }
+  let(:dockercfg) {
+    Armada::Docker::Config.new [credentials]
+  }
+  let(:options) {{
+    :image => image_name,
+    :tag   => tag,
+    :pull  => pull
+  }}
+
+  let(:docker_host) { Armada::Host.create("foo-01:4243") }
+  let(:docker_connection) { ::Docker::Connection.new("http://foo-01", {}) }
+  let(:armada_image) { Armada::Image.new(docker_host, options) }
+  let(:docker_image) { ::Docker::Image.new(docker_connection, "id" => image_id) }
+
+  describe "#pull" do
+    context "when pull is false" do
+      let(:pull) { false }
+
+      it "should not call Docker::Image.create" do
+        options.merge!({
+          :docker_image => docker_image,
+          :id           => image_id
+        })
+        expect(Docker::Image).not_to receive(:create)
+        armada_image.pull
+
+        expect(armada_image.id).to be(image_id)
+        expect(armada_image.image).to be(docker_image)
+      end
+
+      it { expect { armada_image.pull }.to raise_error }
+    end
+
+    context "when pull is true" do
+      it "should call Docker::Image.create" do
+        expect(::Docker::Image).to receive(:create).and_return(docker_image)
+        armada_image.pull
+      end
+    end
+  end
+
+  describe '#generate_auth' do
+    context 'with auth and dockercfg' do
+      let(:my_options) {
+        options.merge({
+          username: 'foobar',
+          password: 'herpderp',
+          dockercfg: dockercfg
+        })
+      }
+
+      let (:image) { Armada::Image.new(docker_host, my_options) }
+
+      it "should use username and password from options" do
+        expect(image.auth[:username]).to be(my_options[:username])
+        expect(image.auth[:password]).to be(my_options[:password])
+      end
+    end
+
+    context 'with no auth and dockercfg' do
+      let(:my_options) {
+        options.merge({
+          dockercfg: dockercfg
+        })
+      }
+
+      let (:image) { Armada::Image.new(docker_host, my_options) }
+
+      it "should use username and password from dockercfg" do
+        expect(image.auth).not_to be_nil
+        expect(image.auth[:username]).to be(credentials.username)
+        expect(image.auth[:password]).to be(credentials.password)
+      end
+    end
+
+    context 'with auth and no dockercfg' do
+      let(:my_options) {
+        options.merge({
+          username: 'foobar',
+          password: 'herpderp'
+        })
+      }
+
+      let (:image) { Armada::Image.new(docker_host, my_options) }
+
+      it "should use username and password from options" do
+        expect(image.auth[:username]).to be(my_options[:username])
+        expect(image.auth[:password]).to be(my_options[:password])
+      end
+    end
+
+    context 'with no auth and no dockercfg' do
+      let (:image) { Armada::Image.new(docker_host, options)}
+
+      it "should have no auth credentials" do
+        expect(image.auth).to be_nil
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rspec'
+require 'armada'
+require 'webmock/rspec'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.color                             = true
+  config.formatter                         = :documentation
+  config.tty                               = true
+end

metadata

@@ -0,0 +1,289 @@
+--- !ruby/object:Gem::Specification
+name: docker-armada
+version: !ruby/object:Gem::Version
+  version: 2.0.53
+platform: ruby
+authors:
+- Jonathan Chauncey
+- Matt Farrar
+- Darrell Hamilton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.33'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.33'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-ssh-gateway
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: table_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: conjur-cli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+- !ruby/object:Gem::Dependency
+  name: thor-scmversion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: geminabox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Deploy utility for docker containers
+email: 
+executables:
+- armada
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- Thorfile
+- armada.gemspec
+- bin/armada
+- lib/armada.rb
+- lib/armada/clean.rb
+- lib/armada/clean/containers.rb
+- lib/armada/clean/images.rb
+- lib/armada/cli.rb
+- lib/armada/cli/clean.rb
+- lib/armada/cli/deploy.rb
+- lib/armada/cli/inspect.rb
+- lib/armada/configuration.rb
+- lib/armada/connection.rb
+- lib/armada/connection/docker.rb
+- lib/armada/connection/health_check.rb
+- lib/armada/connection/remote.rb
+- lib/armada/deploy.rb
+- lib/armada/deploy/parallel.rb
+- lib/armada/deploy/rolling.rb
+- lib/armada/deploy_dsl.rb
+- lib/armada/docker.rb
+- lib/armada/docker/config.rb
+- lib/armada/docker/container.rb
+- lib/armada/docker/host.rb
+- lib/armada/docker/image.rb
+- lib/armada/thor.rb
+- lib/armada/ui.rb
+- lib/armada/utils.rb
+- lib/armada/utils/array.rb
+- lib/armada/utils/time.rb
+- lib/armada/version.rb
+- spec/connection/health_check_spec.rb
+- spec/deploy_dsl_spec.rb
+- spec/docker/container_spec.rb
+- spec/docker/image_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/RallySoftware/armada
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Deploy utility for docker containers
+test_files:
+- spec/connection/health_check_spec.rb
+- spec/deploy_dsl_spec.rb
+- spec/docker/container_spec.rb
+- spec/docker/image_spec.rb
+- spec/spec_helper.rb