rory-deploy 1.8.4.1

data/lib/centurion/dogestry.rb

@@ -0,0 +1,92 @@
+require_relative 'logging'
+require_relative 'shell'
+require 'fileutils'
+
+module Centurion; end
+
+class Centurion::Dogestry
+  include Centurion::Logging
+  attr_accessor :options
+
+  def initialize(options = {})
+    @options = options
+  end
+
+  # Cross-platform way of finding an executable in the $PATH.
+  #   which('ruby') #=> /usr/bin/ruby
+  def which(cmd)
+    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+    ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+      exts.each do |ext|
+        exe = File.join(path, "#{cmd}#{ext}")
+        return exe if File.executable?(exe) && !File.directory?(exe)
+      end
+    end
+    return nil
+  end
+
+  def validate_before_exec
+    unless which('dogestry')
+      message = 'Unable to find "dogestry" executable'
+      error message
+      raise message
+    end
+  end
+
+  def aws_access_key_id
+    @options[:aws_access_key_id]
+  end
+
+  def aws_secret_key
+    @options[:aws_secret_key]
+  end
+
+  def s3_bucket
+    @options[:s3_bucket]
+  end
+
+  def s3_region
+    @options[:s3_region] || 'us-east-1'
+  end
+
+  def s3_url
+    "s3://#{s3_bucket}/?region=#{s3_region}"
+  end
+
+  def set_envs()
+    ENV['AWS_ACCESS_KEY'] = aws_access_key_id
+    ENV['AWS_SECRET_KEY'] = aws_secret_key
+
+    # If we want TLS, then try to pass a sane directory to Dogestry, which doesn't
+    # speak individual filenames.
+    if @options[:tlsverify]
+      ENV['DOCKER_CERT_PATH'] =
+        if @options[:tlscacert] || @options[:tlscert]
+          File.dirname(
+            @options[:tlscacert] ||
+            @options[:tlscert]
+          )
+        else
+          @options[:original_docker_cert_path]
+        end
+    end
+
+    info "Dogestry ENV: #{ENV.inspect}"
+  end
+
+  def exec_command(command, repo, flags="")
+    command = "dogestry #{flags} #{command} #{s3_url} #{repo}"
+    info "Executing: #{command}"
+    command
+  end
+
+  def pull(repo, pull_hosts)
+    validate_before_exec
+    set_envs()
+
+    hosts = pull_hosts.join(",")
+    flags = "-pullhosts #{hosts}"
+
+    Centurion::Shell.echo(exec_command('pull', repo, flags))
+  end
+end

data/lib/centurion/logging.rb

@@ -0,0 +1,28 @@
+require 'logger/colors'
+require 'logger'
+
+module Centurion; end
+
+module Centurion::Logging
+  def info(*args)
+    log.info args.join(' ')
+  end
+
+  def warn(*args)
+    log.warn args.join(' ')
+  end
+
+  def error(*args)
+    log.error args.join(' ')
+  end
+
+  def debug(*args)
+    log.debug args.join(' ')
+  end
+
+  private
+
+  def log(*args)
+    @@logger ||= Logger.new(STDOUT)
+  end
+end

data/lib/centurion/service.rb

@@ -0,0 +1,218 @@
+require 'socket'
+require 'capistrano_dsl'
+
+module Centurion
+  class Service
+    extend ::Capistrano::DSL
+
+    attr_accessor :command, :dns, :extra_hosts, :image, :name, :volumes, :port_bindings, :network_mode, :cap_adds, :cap_drops 
+    attr_reader :memory, :cpu_shares, :env_vars
+
+    def initialize(name)
+      @name          = name
+      @env_vars      = {}
+      @volumes       = []
+      @port_bindings = []
+      @cap_adds      = []
+      @cap_drops     = []
+      @network_mode  = 'bridge'
+    end
+
+    def self.from_env
+      Service.new(fetch(:name)).tap do |s|
+        s.image = if fetch(:tag, nil)
+          "#{fetch(:image, nil)}:#{fetch(:tag)}"
+        else
+          fetch(:image, nil)
+        end
+
+        s.cap_adds      = fetch(:cap_adds, [])
+        s.cap_drops     = fetch(:cap_drops, [])
+        s.dns           = fetch(:dns, nil)
+        s.extra_hosts   = fetch(:extra_hosts, nil)
+        s.volumes       = fetch(:binds, [])
+        s.port_bindings = fetch(:port_bindings, [])
+        s.network_mode  = fetch(:network_mode, 'bridge')
+        s.command       = fetch(:command, nil)
+
+        s.add_env_vars(fetch(:env_vars, {}))
+      end
+    end
+
+    def add_env_vars(new_vars)
+      @env_vars.merge!(new_vars)
+    end
+
+    def add_port_bindings(host_port, container_port, type = 'tcp', host_ip = nil)
+      @port_bindings << PortBinding.new(host_port, container_port, type, host_ip)
+    end
+
+    def add_volume(host_volume, container_volume)
+      @volumes << Volume.new(host_volume, container_volume)
+    end
+
+    def cap_adds=(capabilites)
+      unless capabilites.is_a? Array
+        raise ArgumentError, "invalid value for capability additions: #{capabilites}, value must be an array"
+      end
+      @cap_adds = capabilites
+    end
+
+    def cap_drops=(capabilites)
+      unless capabilites.is_a? Array
+        raise ArgumentError, "invalid value for capability drops: #{capabilites}, value must be an array"
+      end
+      @cap_drops = capabilites
+    end
+
+    def network_mode=(mode)
+      @network_mode = mode
+    end
+
+    def memory=(bytes)
+      if !bytes || !is_a_uint64?(bytes)
+        raise ArgumentError, "invalid value for cgroup memory constraint: #{bytes}, value must be a between 0 and 18446744073709551615"
+      end
+      @memory = bytes
+    end
+
+    def cpu_shares=(shares)
+      if !shares || !is_a_uint64?(shares)
+        raise ArgumentError, "invalid value for cgroup CPU constraint: #{shares}, value must be a between 0 and 18446744073709551615"
+      end
+      @cpu_shares = shares
+    end
+
+    def image=(image)
+      @image = image
+    end
+
+    def build_config(server_hostname, &block)
+      container_config = {}.tap do |c|
+        c['Image'] = image
+        c['Hostname'] = block.call(server_hostname) if block_given?
+        c['Cmd'] = command if command
+        c['Memory'] = memory if memory
+        c['CpuShares'] = cpu_shares if cpu_shares
+      end
+
+      unless port_bindings.empty?
+        container_config['ExposedPorts'] = port_bindings.reduce({}) do |config, binding|
+          config["#{binding.container_port}/#{binding.type}"] = {}
+          config
+        end
+      end
+
+      unless env_vars.empty?
+        container_config['Env'] = env_vars.map do |k,v|
+          "#{k}=#{interpolate_var(v, server_hostname)}"
+        end
+      end
+
+      unless volumes.empty?
+        container_config['Volumes'] = volumes.inject({}) do |memo, v|
+          memo[v.container_volume] = {}
+          memo
+        end
+      end
+
+      container_config
+    end
+
+    def build_host_config(restart_policy = nil)
+      host_config = {}
+
+      # Set capability additions and drops
+      host_config['CapAdd'] = cap_adds if cap_adds
+      host_config['CapDrop'] = cap_drops if cap_drops
+
+      # Map some host volumes if needed
+      host_config['Binds'] = volume_binds_config if volume_binds_config
+
+      # Bind the ports
+      host_config['PortBindings'] = port_bindings_config
+
+      # Set the network mode
+      host_config['NetworkMode'] = network_mode
+
+      # DNS if specified
+      host_config['Dns'] = dns if dns
+
+      # Add ExtraHosts if needed
+      host_config['ExtraHosts'] = extra_hosts if extra_hosts
+
+      # Restart Policy
+      if restart_policy
+        host_config['RestartPolicy'] = {}
+
+        restart_policy_name = restart_policy.name
+        restart_policy_name = 'on-failure' unless ["always", "on-failure", "no"].include?(restart_policy_name)
+
+        host_config['RestartPolicy']['Name'] = restart_policy_name
+        host_config['RestartPolicy']['MaximumRetryCount'] = restart_policy.max_retry_count || 10 if restart_policy_name == 'on-failure'
+      end
+
+      host_config
+    end
+
+    def build_console_config(server_name, &block)
+      build_config(server_name, &block).merge({
+        'Cmd' => ['/bin/bash'],
+        'AttachStdin' => true,
+        'Tty'         => true,
+        'OpenStdin'   => true,
+      })
+    end
+
+    def volume_binds_config
+      @volumes.map { |volume| "#{volume.host_volume}:#{volume.container_volume}" }
+    end
+
+    def port_bindings_config
+      @port_bindings.inject({}) do |memo, binding|
+        config = {}
+        config['HostPort'] = binding.host_port.to_s
+        config['HostIp'] = binding.host_ip if binding.host_ip
+        memo["#{binding.container_port}/#{binding.type}"] = [config]
+        memo
+      end
+    end
+
+    def public_ports
+      @port_bindings.map(&:host_port)
+    end
+
+    private
+
+    def is_a_uint64?(value)
+      result = false
+      if !value.is_a? Integer
+        return result
+      end
+      if value < 0 || value > 0xFFFFFFFFFFFFFFFF
+        return result
+      end
+      return true
+    end
+
+    def interpolate_var(val, hostname)
+      val.to_s.gsub('%DOCKER_HOSTNAME%', hostname)
+        .gsub('%DOCKER_HOST_IP%', host_ip(hostname))
+    end
+
+    def host_ip(hostname)
+      @host_ip ||= {}
+      return @host_ip[hostname] if @host_ip.has_key?(hostname)
+      @host_ip[hostname] = Socket.getaddrinfo(hostname, nil).first[2]
+    end
+
+    class RestartPolicy < Struct.new(:name, :max_retry_count)
+    end
+
+    class Volume < Struct.new(:host_volume, :container_volume)
+    end
+
+    class PortBinding < Struct.new(:host_port, :container_port, :type, :host_ip)
+    end
+  end
+end

data/lib/centurion/shell.rb

@@ -0,0 +1,46 @@
+module Centurion; end
+
+module Centurion::Shell
+  def self.echo(command)
+    if Thread.list.find_all { |t| t.status == 'run' }.count > 1
+      run_without_echo(command)
+    else
+      run_with_echo(command)
+    end
+  end
+
+  def self.run_without_echo(command)
+    output = Queue.new
+    output_thread = Thread.new do
+      while true do
+        begin
+          puts output.pop
+        rescue => e
+          info "Rescuing... #{e.message}"
+        end
+      end
+    end
+
+    IO.popen(command) do |io|
+      io.each_line { |line| output << line }
+    end
+
+    output_thread.kill
+    validate_status(command)
+  end
+
+  def self.run_with_echo(command)
+    $stdout.sync = true
+    $stderr.sync = true
+    IO.popen(command) do |io|
+      io.each_char { |char| print char }
+    end
+    validate_status(command)
+  end
+
+  def self.validate_status(command)
+    unless $?.success?
+      raise "The command failed with a non-zero exit status: #{$?.exitstatus}. Command: '#{command}'"
+    end
+  end
+end

data/lib/centurion/version.rb

@@ -0,0 +1,3 @@
+module Centurion
+  VERSION = '1.8.4.1'
+end

data/lib/core_ext/numeric_bytes.rb

@@ -0,0 +1,94 @@
+# 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.
+#
+# ORIGINAL ACTIVE SUPPORT LICENSE FOLLOWS:
+#
+# Copyright (c) 2005-2015 David Heinemeier Hansson
+#
+# 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.
+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
+
+    # 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
+
+    # 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 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 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 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 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
+    end unless method_defined? :exabytes
+    alias :exabyte :exabytes unless method_defined? :exabyte
+  end
+end
+