indocker 0.0.6 → 0.1.0

data/lib/indocker/container_helper.rb

@@ -0,0 +1,13 @@
+class Indocker::ContainerHelper
+  class << self
+    def hostname(configuration_name, container, number = nil)
+      scale = container.get_start_option(:scale)
+
+      if scale == 1 || number.nil?
+        "#{configuration_name}_#{container.name}"
+      else
+        "#{configuration_name}_#{container.name}_#{number}"
+      end
+    end
+  end
+end

data/lib/indocker/container_runner.rb

@@ -0,0 +1,23 @@
+class Indocker::ContainerRunner
+  def initialize(logger)
+    @logger = logger
+  end
+
+  def run(configuration:, container_name:, force_restart:)
+    path = Indocker.container_files.fetch(container_name) do
+      @logger.error("container #{container_name} was not found in configuration #{configuration.name}")
+      exit 1
+    end
+
+    require path
+
+    deploy_context = Indocker::DeployContext.new(
+      logger: @logger,
+      configuration: configuration,
+      server: nil
+    )
+
+    container = configuration.containers.detect { |c| c.name == container_name }
+    deploy_context.deploy(container, force_restart)
+  end
+end

data/lib/indocker/containers/container.rb

@@ -0,0 +1,118 @@
+class Indocker::Containers::Container
+  attr_reader :name, :parent_containers, :dependent_containers, :soft_dependent_containers,
+              :volumes, :networks, :servers, :start_command,
+              :before_start_proc, :after_start_proc, :after_deploy_proc,
+              :build_args, :start_options, :redeploy_schedule
+
+  def initialize(name)
+    @name = name
+    @daemonize = true
+    @parent_containers = []
+    @dependent_containers = []
+    @soft_dependent_containers = []
+    @volumes = []
+    @networks = []
+    @servers = []
+    @start_options = {}
+    @build_args = {}
+    @redeploy_schedule = nil
+  end
+
+  def set_build_args(opts)
+    @build_args = opts
+  end
+
+  def set_before_start_proc(proc)
+    @before_start_proc = proc
+  end
+
+  def set_after_start_proc(proc)
+    @after_start_proc = proc
+  end
+
+  def set_after_deploy_proc(proc)
+    @after_deploy_proc = proc
+  end
+
+  def set_start_command(name)
+    @start_command = name
+  end
+
+  def set_tags(tag_list)
+    @tags = tag_list
+  end
+
+  def set_scale(count)
+    @start_options[:scale] = count
+  end
+
+  def set_attached
+    @daemonize = false
+  end
+
+  def tags
+    @tags || (raise ArgumentError.new("tags not defined for container :#{@name}"))
+  end
+
+  def set_image(image)
+    @image = image
+  end
+
+  def image
+    @image || (raise ArgumentError.new("image not defined for container :#{@name}"))
+  end
+
+  def servers
+    @servers || (raise ArgumentError.new("servers not defined for container :#{@name}"))
+  end
+
+  def daemonize(flag)
+    @daemonize = flag
+    @attach = false
+  end
+
+  def is_daemonized?
+    @daemonize
+  end
+
+  def set_servers(servers)
+    @servers = servers
+  end
+
+  def add_parent_container(container)
+    @parent_containers.push(container) if !@parent_containers.include?(container)
+  end
+
+  def add_dependent_container(container)
+    container.add_parent_container(self)
+    @dependent_containers.push(container) if !@dependent_containers.include?(container)
+  end
+
+  def add_soft_dependent_container(container)
+    @soft_dependent_containers.push(container) if !@soft_dependent_containers.include?(container)
+  end
+
+  def set_start_options(opts)
+    @start_options = opts
+  end
+
+  def get_start_option(name, default: nil)
+    @start_options.fetch(name) { default }
+  end
+
+  def set_volumes(volumes)
+    @volumes = volumes
+  end
+
+  def set_networks(networks)
+    @networks = networks
+
+    networks.each do |network|
+      network.add_container(self)
+    end
+  end
+
+  def set_redeploy_schedule(schedule)
+    @redeploy_schedule = schedule
+  end
+end

data/lib/indocker/containers/container_builder.rb

@@ -0,0 +1,186 @@
+class Indocker::Containers::ContainerBuilder
+  attr_reader :container
+
+  def initialize(name:, configuration:, container: nil)
+    @container = container || Indocker::Containers::Container.new(name)
+    @configuration = configuration
+    configuration.add_container(@container)
+  end
+
+  def command(name)
+    @container.set_start_command(name)
+  end
+
+  def build_args(opts)
+    raise ArgumentError.new("build args should be a Hash") if !opts.is_a?(Hash)
+    opts = Indocker::HashMerger.deep_merge(@container.build_args, opts) # merge with already defined args
+    @container.set_build_args(opts)
+    self
+  end
+
+  def tags(*tag_list)
+    if !tag_list.is_a?(Array)
+      tag_list = [tag_list]
+    end
+
+    @container.set_tags(tag_list)
+    self
+  end
+
+  def image(name)
+    path = Indocker.image_files[name]
+
+    if !path
+      raise ArgumentError.new("Image :#{name} was not found in bounded contexts folder")
+    else
+      require path
+    end
+
+    image = @configuration.images.detect do |image|
+      image.name == name
+    end
+
+    if !image
+      Indocker.logger.error("image :#{name} was not found in configuration :#{@configuration.name}")
+      exit 1
+    end
+
+    @container.set_image(image)
+    self
+  end
+
+  def servers(*server_list)
+    server_list.uniq!
+
+    extra_servers = server_list - Indocker.servers.map(&:name)
+
+    if !extra_servers.empty?
+      Indocker.logger.error("unrecognized servers #{extra_servers.inspect} for container :#{@container.name} in configuration :#{@configuration.name}")
+      exit 1
+    end
+
+    servers = Indocker.servers.select {|s| server_list.include?(s.name)}
+    @container.set_servers(servers)
+    self
+  end
+
+  def networks(*network_list)
+    network_list.uniq!
+
+    networks = Indocker.networks.select do |network|
+      network_list.include?(network.name)
+    end
+
+    extra_networks = network_list - networks.map(&:name)
+
+    if !extra_networks.empty?
+      raise ArgumentError.new("unknown networks: #{extra_networks.inspect} for container :#{@container.name}")
+    end
+
+    @container.set_networks(networks)
+    self
+  end
+
+  def volumes(*volume_list)
+    volume_list.uniq!
+
+    volumes = Indocker.volumes.select do |volume|
+      volume_list.include?(volume.name)
+    end
+
+    extra_volumes = volume_list - volumes.map(&:name)
+
+    if !extra_volumes.empty?
+      raise Indocker.logger.error("unknown volumes: #{extra_volumes.inspect} for container :#{@container.name}")
+      exit 1
+    end
+
+    @container.set_volumes(volumes)
+    self
+  end
+
+  def daemonize(flag)
+    @container.daemonize(flag)
+    self
+  end
+
+  def depends_on(*container_list)
+    if !container_list.is_a?(Array)
+      container_list = [container_list]
+    end
+
+    container_list.uniq!
+
+    container_list.each do |name|
+      path = Indocker.container_files.fetch(name) do
+        Indocker.logger.error("Dependent container :#{name} was not found in bounded contexts dir for container :#{@container.name}")
+        exit 1
+      end
+
+      require path
+    end
+
+    containers = @configuration.containers.select do |container|
+      container_list.include?(container.name)
+    end
+
+    containers.each do |container|
+      @container.add_dependent_container(container)
+    end
+
+    self
+  end
+
+  def soft_depends_on(*container_list)
+    container_list = Array(container_list).uniq
+
+    container_list.each do |name|
+      path = Indocker.container_files.fetch(name) do
+        Indocker.logger.error("Soft dependent container :#{name} was not found in bounded contexts dir for container :#{@container.name}")
+        exit 1
+      end
+
+      require path
+    end
+
+    containers = @configuration.containers.select do |container|
+      container_list.include?(container.name)
+    end
+
+    containers.each do |container|
+      @container.add_soft_dependent_container(container)
+    end
+
+    self
+  end
+
+  def before_start(proc)
+    container.set_before_start_proc(proc)
+    self
+  end
+
+  def after_start(proc)
+    container.set_after_start_proc(proc)
+    self
+  end
+
+  def after_deploy(proc)
+    container.set_after_deploy_proc(proc)
+    self
+  end
+
+  def start(opts)
+    opts = Indocker::HashMerger.deep_merge(container.start_options, opts)
+    container.set_start_options(opts)
+    self
+  end
+
+  def scale(number)
+    container.set_scale(number)
+  end
+
+  def redeploy_schedule(schedule)
+    container.set_redeploy_schedule(schedule)
+    self
+  end
+end

data/lib/indocker/containers/restart_policy.rb

@@ -0,0 +1,36 @@
+require 'fileutils'
+
+class Indocker::Containers::RestartPolicy
+  TIMESTAMPS_DIR = 'timestamps'
+
+  def initialize(configuration, logger)
+    @configuration = configuration
+    @logger = logger
+  end
+
+  def restart?(container, timestamp)
+    file = timestamp_file(container)
+    return true if !File.exists?(file)
+
+    last_timestamp = File.read(file).strip
+    timestamp != last_timestamp
+  end
+
+  def update(container, timestamp)
+    FileUtils.mkdir_p(timestamp_folder)
+
+    File.open(timestamp_file(container), 'w') do |f|
+      f.write(timestamp)
+    end
+  end
+
+  private
+
+  def timestamp_folder
+    timestamp = File.join(File.expand_path(Indocker.deploy_dir), TIMESTAMPS_DIR)
+  end
+
+  def timestamp_file(container)
+    File.join(timestamp_folder, container.name.to_s)
+  end
+end

data/lib/indocker/context_args.rb

@@ -0,0 +1,44 @@
+class Indocker::ContextArgs
+  attr_reader :parent, :name
+
+  def initialize(name, context_args, parent, container = nil)
+    @name = name
+    @parent = parent
+    @container = container
+    @context_args = context_args
+  end
+
+  def method_missing(name, *args)
+    if args.size > 0
+      raise ArgumentError.new("context args does not accept any arguments")
+    end
+
+    value = @context_args.fetch(name) do
+      Indocker.logger.error("build arg '#{format_arg(name)}' is not defined#{@container ? " for container :#{@container.name}" : ""}")
+      Indocker.logger.error("available args: #{@context_args.inspect}")
+      exit 1
+    end
+
+    if value.is_a?(Hash)
+      Indocker::ContextArgs.new(name, value, self, @container)
+    else
+      value
+    end
+  end
+
+  private
+
+  def format_arg(name)
+    string = name
+    parent = @parent
+
+    while parent do
+      name = parent.name
+      string = "#{name}.#{string}" if name
+      parent = parent.parent
+      break if !parent
+    end
+
+    string
+  end
+end

data/lib/indocker/crontab_redeploy_rules_builder.rb

@@ -0,0 +1,54 @@
+class Indocker::CrontabRedeployRulesBuilder
+  CRONTAB = <<-CRONTAB
+SHELL=/bin/bash
+PATH=/usr/local/bundle/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+
+%{rules}
+
+  CRONTAB
+
+  LOG_FILE      = "/var/log/indocker-redeploy-%{env}.log"
+  COMMAND       = "export TERM=xterm;#{Indocker.deploy_dir}/indocker/bin/deploy -C %{env} -f -B -y -c %{container_name}"
+  REDEPLOY_RULE = %Q{%{schedule} echo `date` "- %{command}..." >> %{log_file}; %{command} 1>/dev/null 2>>%{log_file}; echo `date` "- done, exitcode = $?" >> %{log_file}}
+
+  def initialize(configuration:, logger:)
+    @configuration  = configuration
+    @logger         = logger
+  end
+
+  def call(containers)
+    CRONTAB % {
+      rules: containers.map{ |c| redeploy_rule(c) }.join("\n"),
+    }
+  end
+
+  private
+  def self.env
+    Indocker.configuration_name
+  end
+
+  def env
+    self.class.env
+  end
+
+  def log_file
+    LOG_FILE % {
+      env: env,
+    }
+  end
+
+  def command(container)
+    COMMAND % {
+      env:            env,
+      container_name: container.name,
+    }
+  end
+
+  def redeploy_rule(container)
+    REDEPLOY_RULE % {
+      schedule:   container.redeploy_schedule,
+      command:    command(container),
+      log_file:   log_file,
+    }
+  end
+end