docker-armada 2.0.53

data/lib/armada/deploy_dsl.rb

@@ -0,0 +1,156 @@
+# Copyright (c) 2014 New Relic, Inc.
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE 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.
+
+require 'singleton'
+
+module Armada::DeployDSL
+  class CurrentEnvironmentNotSetError < RuntimeError; end
+
+  class Store < Hash
+    include Singleton
+  end
+
+  def env
+    Store.instance
+  end
+
+  def fetch(key, default=nil, &block)
+    env[current_environment][key] || default
+  end
+
+  def any?(key)
+    value = fetch(key)
+    if value && value.respond_to?(:any?)
+      value.any?
+    else
+      !fetch(key).nil?
+    end
+  end
+
+  def set(key, value)
+    env[current_environment][key] = value
+  end
+
+  def delete(key)
+    env[current_environment].delete(key)
+  end
+
+  def set_current_environment(environment)
+    env[:current_environment] = environment
+    env[environment] ||= {}
+  end
+
+  def current_environment
+    raise CurrentEnvironmentNotSetError.new('Must set current environment') unless env[:current_environment]
+    env[:current_environment]
+  end
+
+  def clear_env
+    env.clear
+  end
+
+  def container_name(name)
+    set(:container_name, name)
+  end
+
+  def env_vars(new_vars)
+    current = fetch(:env_vars, {})
+    new_vars.each_pair do |new_key, new_value|
+      current[new_key.to_s] = new_value
+    end
+    set(:env_vars, current)
+  end
+
+  def host(hostname)
+    current = fetch(:hosts, [])
+    current << hostname
+    set(:hosts, current)
+  end
+
+  def localhost
+    # DOCKER_HOST is like 'tcp://127.0.0.1:4243'
+    docker_host_uri = URI.parse(ENV['DOCKER_HOST'] || "tcp://127.0.0.1")
+    host_and_port = [docker_host_uri.host, docker_host_uri.port].compact.join(':')
+    host(host_and_port)
+  end
+
+  def host_port(port, options)
+    validate_options_keys(options, [ :host_ip, :container_port, :type ])
+    require_options_keys(options,  [ :container_port ])
+
+    add_to_bindings(
+      options[:host_ip] || '0.0.0.0',
+      options[:container_port],
+      port,
+      options[:type] || 'tcp'
+    )
+  end
+
+  def restart_policy(opts)
+    set(:restart_policy, opts)
+  end
+
+  def secret_value(key)
+    `conjur variable value #{key}`
+  end
+
+  def public_port_for(port_bindings)
+    # {'80/tcp'=>[{'HostIp'=>'0.0.0.0', 'HostPort'=>'80'}]}
+    first_port_binding = port_bindings.values.first
+    first_port_binding.first['HostPort']
+  end
+
+  def host_volume(volume, options)
+    validate_options_keys(options, [ :container_volume ])
+    require_options_keys(options,  [ :container_volume ])
+
+    binds            = fetch(:binds, [])
+    container_volume = options[:container_volume]
+
+    binds << "#{volume}:#{container_volume}"
+    set(:binds, binds)
+  end
+
+  def container_config(cfg)
+    set(:container_config, cfg)
+  end
+
+  private
+
+  def add_to_bindings(host_ip, container_port, port, type='tcp')
+    ports = fetch(:port_bindings, {})
+    ports["#{container_port.to_s}/#{type}"] = [{'HostIp' => host_ip, 'HostPort' => port.to_s}]
+    set(:port_bindings, ports)
+  end
+
+  def validate_options_keys(options, valid_keys)
+    unless options.keys.all? { |k| valid_keys.include?(k) }
+      raise ArgumentError.new('Options passed with invalid key!')
+    end
+  end
+
+  def require_options_keys(options, required_keys)
+    missing = required_keys.reject { |k| options.keys.include?(k) }
+
+    unless missing.empty?
+      raise ArgumentError.new("Options must contain #{missing.inspect}")
+    end
+  end
+end

data/lib/armada/docker.rb

@@ -0,0 +1,6 @@
+require 'docker'
+
+require_relative 'docker/container'
+require_relative 'docker/image'
+require_relative 'docker/config'
+require_relative 'docker/host'

data/lib/armada/docker/config.rb

@@ -0,0 +1,55 @@
+require 'base64'
+
+module Armada
+  module Docker
+    class Config
+      attr_reader :configs
+      def initialize(configs)
+        @configs = configs
+      end
+
+      def for_image(url)
+        @configs.each do |config|
+          # debate starts_with? vs ==
+          return config if url.start_with? config.url
+        end
+
+        return nil
+      end
+
+      def self.load(path)
+        abs_path = File.expand_path path
+        configs = []
+
+        if File.readable? abs_path
+          json_hash = JSON.parse(IO.read(abs_path))
+          Armada.ui.info "Loading dockercfg from: #{abs_path}"
+          json_hash.each do |url, obj|
+            configs.push Credentials.parse(url, obj)
+          end
+        end
+
+        Config.new configs
+      end
+    end
+
+    class Credentials
+      attr_reader :url, :username, :password, :email
+      def initialize(url, username, password, email)
+        @username = username
+        @password = password
+        @email = email
+        @url = url
+      end
+
+      def self.parse(url, obj)
+        username, password = Base64.decode64(obj["auth"]).split(':', 2)
+        return self.new url, username, password, obj["email"]
+      end
+
+      def self.dummy()
+        self.new '', nil, nil, ''
+      end
+    end
+  end
+end

data/lib/armada/docker/container.rb

@@ -0,0 +1,120 @@
+module Armada
+  class Container
+
+    attr_reader :id, :container, :name
+    def initialize(image, docker_host, options)
+      @docker_host = docker_host
+      @id          = nil
+      @image       = image
+      @name        = options[:container_name]
+      @container   = docker_host.get_container(@name)
+      @options     = options
+    end
+
+    def stop
+      if @container
+        info "Stopping the running container named - #{@name}"
+        kill
+        remove
+      else
+        warn "No container found with the name #{@name}"
+      end
+    end
+
+    def start
+      info "Creating new container for image - #{@image.name}:#{@image.tag} with image id (#{@image.id}) with container name #{@name}"
+      container_config = Armada::Container.create_container_config(@image.id, @name, @docker_host.host, @options)
+      begin
+        @container = create(container_config)
+        @id = @container.id
+        info "Starting new container #{@id[0..11]}"
+        @container.start!(Armada::Container.create_host_config(@options))
+      rescue Exception => e
+        raise "Error occured on #{@docker_host.host}:#{@docker_host.port}: #{e.message}"
+      end
+    end
+
+    def create(container_config)
+      ::Docker::Container.create(container_config, @docker_host.connection)
+    end
+
+    def kill
+      return if @container.nil?
+      info "Stopping old container #{@container.id[0..7]} (#{@name})"
+      @container.kill
+    end
+
+    def remove
+      return if @container.nil?
+      info "Deleting old container #{@container.id[0..7]} (#{@name})"
+      begin
+        @container.remove
+      rescue Exception => e
+        error "Could not remove container #{@container.id[0..7]} (#{@name}).\nException was: #{e.message}"
+      end
+    end
+
+    def self.create_host_config(options)
+      host_config = {}
+      host_config['Binds'] = options[:binds] if options[:binds] && !options[:binds].empty?
+      host_config['PortBindings'] = options[:port_bindings] if options[:port_bindings]
+      host_config['PublishAllPorts'] = true
+      host_config
+    end
+
+    def self.create_container_config(image_id, container_name, host, options = {})
+      container_config = options[:container_config] || {}
+
+      container_config['Image'] = image_id || options[:image]
+      container_config['Hostname'] = host
+
+      if options[:port_bindings]
+        container_config['ExposedPorts'] ||= {}
+        options[:port_bindings].keys.each do |port|
+          container_config['ExposedPorts'][port] = {}
+        end
+      end
+
+      if options[:env_vars]
+        container_config['Env'] = options[:env_vars].map { |k,v| "#{k}=#{v}" }
+      end
+
+      if options[:binds]
+        container_config['Volumes'] = options[:binds].inject({}) do |memo, v|
+          memo[v.split(/:/).last] = {}
+          memo
+        end
+        container_config['VolumesFrom'] = 'parent'
+      end
+
+      if container_name
+        container_config['name'] = container_name
+        #should we do soemthing if container name isnt set?
+      end
+
+      if options[:restart_policy]
+        container_config["RestartPolicy"] = options[:restart_policy]
+      end
+
+      container_config
+    end
+
+    def ports
+      return @container.json["NetworkSettings"]["Ports"]
+    end
+
+    private
+
+    def info(message)
+      Armada.ui.info "#{@docker_host.host} -- #{message}"
+    end
+
+    def warn(message)
+      Armada.ui.warn "#{@docker_host.host} -- #{message}"
+    end
+
+    def error(message)
+      Armada.ui.error "#{@docker_host.host} -- #{message}"
+    end
+  end
+end

data/lib/armada/docker/host.rb

@@ -0,0 +1,68 @@
+module Armada
+  class Host
+    attr_reader :docker_connection
+    def initialize(docker_connection)
+      @docker_connection = docker_connection
+    end
+
+    def get_image(name, tag, options = {})
+      begin
+        image = ::Docker::Image.get("#{name}:#{tag}", {}, connection)
+        options[:docker_image] = image
+        options[:id] = image.id if image
+      rescue Exception => e
+        Armada.ui.warn "#{host} -- #{e.message}"
+      ensure
+        return Image.new(self, options)
+      end
+    end
+
+    def get_image_by_id(id, options)
+      begin
+        image = ::Docker::Image.get(id, {}, connection)
+        options[:docker_image] = image
+        options[:id] = id
+      rescue Exception => e
+        Armada.ui.warn "#{host} -- #{e.message}"
+      ensure
+        return Image.new(self, options)
+      end
+    end
+
+    def get_all_images
+      ::Docker::Image.all({:all => true}, connection)
+    end
+
+    def get_all_containers
+      ::Docker::Container.all({:all => true}, connection)
+    end
+
+    def get_container(id)
+      begin
+        return ::Docker::Container.get(id, {}, connection)
+      rescue Exception => e
+        return nil
+      end
+    end
+
+    def connection
+      @docker_connection.connection
+    end
+
+    def host
+      @docker_connection.host
+    end
+
+    def port
+      @docker_connection.port
+    end
+
+    def to_s
+      "#{host}:#{port} -- #{connection}"
+    end
+
+    def self.create(host, options = {})
+      Host.new(Armada::Connection::Docker.new(host, options[:ssh_gateway], options[:ssh_gateway_user]))
+    end
+  end
+end

data/lib/armada/docker/image.rb

@@ -0,0 +1,86 @@
+module Armada
+  class Image
+
+    attr_reader :id, :image, :name, :tag, :auth
+    #do not use this method directly, instead call create
+    def initialize(docker_host, options)
+      @name        = options[:image]
+      @tag         = options[:tag]
+      @pull        = options[:pull]
+      @docker_host = docker_host
+      @image       = options[:docker_image]
+      @id          = @image.id if @image
+      @auth        = generate_auth(options)
+    end
+
+    def valid?
+      return @id && @image
+    end
+
+    def pull
+      if @pull
+        begin
+          info "Pulling image [#{@name}] with tag [#{@tag}]"
+          @image = ::Docker::Image.create({:fromImage => @name, :tag => @tag}, @auth, @docker_host.connection)
+          @id = @image.id
+        rescue Exception => e
+          raise "An error occurred while trying to pull image [#{@name}] with tag [#{@tag}] -- #{e.message}"
+        end
+      else
+        info "Not pulling image [#{@name}] with tag [#{@tag}] because `--no-pull` was specified."
+        raise "The image id is not set, you cannot proceed with the deploy until a valid image is found -- [#{@name}:#{@tag}]" unless valid?
+      end
+    end
+
+    def extract_credentials(options)
+      options_credentials = options.select { |k, v| [:username, :password, :email].include? k }
+      unless options_credentials.empty?
+        return options_credentials
+      else
+        dockercfg = options[:dockercfg].for_image @name if options[:dockercfg]
+        if dockercfg.nil?
+          return {}
+        else
+          return {
+            :username => dockercfg.username,
+            :password => dockercfg.password,
+            :email    => dockercfg.email
+          }
+        end
+      end
+    end
+
+    def valid_credentials?(m)
+      [:username, :password].each do |k|
+        unless m.include? k
+          return false
+        end
+      end
+
+      return true
+    end
+
+    def generate_auth(options)
+      credentials = extract_credentials(options)
+
+      if valid_credentials? credentials
+        return credentials
+      else
+        return nil
+      end
+    end
+
+    def info(message)
+      Armada.ui.info "#{@docker_host.host} -- #{message}"
+    end
+
+    def warn(message)
+      Armada.ui.warn "#{@docker_host.host} -- #{message}"
+    end
+
+    def error(message)
+      Armada.ui.error "#{@docker_host.host} -- #{message}"
+    end
+  end
+end
+