indocker 0.0.6 → 0.1.4

data/lib/indocker/configurations/configuration.rb

@@ -0,0 +1,122 @@
+class Indocker::Configurations::Configuration
+  attr_reader :name
+  attr_reader :repositories
+  attr_reader :registries
+  attr_reader :build_servers
+  attr_reader :global_build_args
+  attr_reader :images
+  attr_reader :containers
+  attr_reader :volumes
+  attr_reader :networks
+  attr_reader :env_files
+  attr_reader :artifact_servers
+  attr_reader :confirm_deployment
+
+  def initialize(name)
+    @name = name
+    @repositories = {}
+    @registries = {}
+    @env_files = {}
+    @build_servers = []
+    @images = []
+    @volumes = []
+    @networks = []
+    @containers = []
+    @artifact_servers = {}
+    @confirm_deployment = false
+  end
+
+  def servers
+    @containers.map(&:servers).flatten.uniq
+  end
+
+  def set_artifact_servers(artifact, servers)
+    @artifact_servers[artifact] = servers
+  end
+
+  def set_confirm_deployment(flag)
+    @confirm_deployment = !!flag
+  end
+
+  def container(name)
+    @containers.detect {|c| c.name == name}
+  end
+
+  def set_enabled_containers(list)
+    @enabled_containers = list
+  end
+
+  def enabled_containers
+    @enabled_containers || (raise ArgumentError.new("enabled container list was not specified in configuration"))
+  end
+
+  def container_enabled?(container)
+    @enabled_containers.include?(container.name)
+  end
+
+  def set_repository(alias_name, repository)
+    if @repositories.has_key?(alias_name)
+      raise ArgumentError.new("alias name :#{alias_name} is already used by repository: #{@repositories[alias_name].inspect}")
+    end
+
+    @repositories[alias_name] = repository
+  end
+
+  def set_registry(alias_name, registry)
+    if @registries.has_key?(alias_name)
+      raise ArgumentError.new("alias name :#{alias_name} is already used by registry: #{@registries[alias_name].inspect}")
+    end
+
+    @registries[alias_name] = registry
+  end
+
+  def set_env_file(alias_name, env_file)
+    if @env_files.has_key?(alias_name)
+      raise ArgumentError.new("alias name :#{alias_name} is already used by env file: #{@env_files[alias_name].inspect}")
+    end
+
+    @env_files[alias_name] = env_file
+  end
+
+  def add_build_server(build_server)
+    if !@build_servers.include?(build_server)
+      @build_servers.push(build_server)
+    end
+  end
+
+  def set_global_build_args(hash)
+    @global_build_args = hash
+  end
+
+  def add_image(image)
+    @images.push(image)
+  end
+
+  def add_container(container)
+    @containers.push(container)
+  end
+
+  def next_build_server
+    @current_position ||= 0
+    build_server = @build_servers[@current_position]
+    @current_position += 1
+
+    if @current_position >= @build_servers.size - 1
+      @current_position = 0
+    end
+
+    build_server
+  end
+
+  def build_dir
+    "/tmp/#{@name}"
+  end
+
+  def hostname(container, number)
+    Indocker::ContainerHelper.hostname(@name, container, number)
+  end
+
+  def get_binding
+    binding
+  end
+end

data/lib/indocker/configurations/configuration_builder.rb

@@ -0,0 +1,250 @@
+class Indocker::Configurations::ConfigurationBuilder
+  attr_reader :repositories
+  attr_reader :registries
+  attr_reader :servers
+  attr_reader :build_servers
+  attr_reader :volumes
+  attr_reader :networks
+  attr_reader :env_files
+  attr_reader :configuration
+
+  def initialize(repositories:, name:, registries:, servers:, build_servers:, volumes:, networks:, env_files:, containers:)
+    @repositories = repositories
+    @registries = registries
+    @servers = servers
+    @volumes = volumes
+    @networks = networks
+    @build_servers = build_servers
+    @env_files = env_files
+    @containers = containers
+    @configuration = Indocker::Configurations::Configuration.new(name)
+  end
+
+  def use_repository(name, as:)
+    repository = @repositories.detect do |repo|
+      repo.name == name
+    end
+
+    if !repository
+      raise ArgumentError.new("repository :#{name} was not found")
+    end
+
+    @configuration.set_repository(as, repository)
+
+    self
+  end
+
+  def confirm_deployment
+    @configuration.set_confirm_deployment(true)
+    self
+  end
+
+  def artifacts(server_artifacts)
+    if !server_artifacts.is_a?(Hash)
+      Indocker.logger.error("artifacts should be a hash for configuration :#{@configuration.name}")
+      exit 1
+    end
+
+    server_artifacts.each do |artifact_name, server_names|
+      artifact = Indocker.artifacts.detect do |a|
+        a.name == artifact_name
+      end
+
+      if !artifact
+        Indocker.logger.error("artifact :#{artifact_name} was not found")
+        exit 1
+      end
+
+      if @configuration.servers.empty?
+        Indocker.logger.error("artifacts should go after enabled_containers section")
+        exit 1
+      end
+
+      servers = @configuration.servers.select do |s|
+        server_names.include?(s.name)
+      end
+
+      servers += @configuration.build_servers.select do |s|
+        server_names.include?(s.name)
+      end
+
+      extra_servers = server_names - servers.map(&:name)
+
+      if !extra_servers.empty?
+        Indocker.logger.error("invalid servers #{extra_servers.inspect} provided for artifact :#{artifact_name}")
+        exit 1
+      end
+
+      @configuration.set_artifact_servers(artifact, servers)
+    end
+
+    self
+  end
+
+  def use_registry(name, as:)
+    registry = @registries.detect do |r|
+      r.repository_name == name
+    end
+
+    if !registry
+      raise ArgumentError.new("registry :#{name} was not found")
+    end
+
+    @configuration.set_registry(as, registry)
+
+    self
+  end
+
+  def use_env_file(name, as:)
+    env_file = @env_files.detect do |ef|
+      ef.name == name
+    end
+
+    if !env_file
+      raise ArgumentError.new("env_file :#{name} was not found")
+    end
+
+    @configuration.set_env_file(as, env_file)
+
+    self
+  end
+
+  def use_build_server(name)
+    build_server = @build_servers.detect do |bs|
+      bs.name == name
+    end
+
+    if !build_server
+      raise ArgumentError.new("build_server :#{name} was not found")
+    end
+
+    @configuration.add_build_server(build_server)
+
+    self
+  end
+
+  def enabled_containers(container_list)
+    containers = container_list.keys
+    extra_containers = containers - Indocker.container_files.keys
+
+    if !extra_containers.empty?
+      Indocker.logger.error("unrecognised containers: #{extra_containers.inspect} for configuration :#{Indocker.configuration.name}")
+      exit 1
+    end
+
+    containers.each do |name|
+      path = Indocker.container_files.fetch(name) do
+        Indocker.logger.error("invalid container name :#{name} provided in enabled containers for configuration :#{@configuration.name}")
+      end
+
+      require path
+    end
+
+    @configuration.set_enabled_containers(containers.map(&:to_sym))
+
+    container_list.each do |container_name, opts|
+      if !opts.is_a?(Hash)
+        Indocker.logger.error("container options should be a Hash for :#{container_name} in configuration :#{@configuration.name}")
+        exit 1
+      end
+
+      count = opts[:scale] || 1
+
+      if count <= 0
+        raise ArgumentError.new("count should be > 0")
+      end
+
+      container = @configuration.containers.detect {|c| c.name == container_name}
+
+      builder = Indocker::Containers::ContainerBuilder
+        .new(name: container.name, configuration: @configuration, container: container)
+
+      builder.scale(count)
+
+      if opts[:build_args]
+        builder.build_args(opts[:build_args])
+      end
+
+      if opts[:start]
+        builder.start(opts[:start])
+      end
+
+      if opts[:redeploy_schedule]
+        builder.redeploy_schedule(opts[:redeploy_schedule])
+      end
+
+      if !opts[:servers] && !opts[:servers_from]
+        Indocker.logger.error("servers or servers_from should be defined for container :#{container_name} in configuration :#{@configuration.name}")
+        exit 1
+      end
+
+      servers = recursively_fetch_servers(container_list, container_name)
+      builder.servers(*servers)
+    end
+
+    self
+  end
+
+  def scale(opts)
+    opts.each do |container_name, count|
+      if count <= 0
+        raise ArgumentError.new("count should be > 0")
+      end
+
+      container = @containers.detect {|c| c.name == container_name}
+
+      if !container
+        Indocker.logger.error("container :#{name} is not presented in enabled containers for configuration :#{@configuration.name}")
+      end
+
+      Indocker::Containers::ContainerBuilder
+        .new(name: container.name, configuration: @configuration, container: container)
+        .scale(count)
+    end
+  end
+
+  def global_build_args(hash)
+    @configuration.set_global_build_args(hash)
+    self
+  end
+
+  private
+
+  def recursively_fetch_servers(container_list, container_name)
+    opts = container_list.fetch(container_name) do
+      Indocker.logger.error("container :#{container_name} is not presented in enabled containers for configuration :#{@configuration.name}")
+      exit 1
+    end
+
+    if !opts[:servers] && !opts[:servers_from]
+      Indocker.logger.error("servers or servers_from should be defined for container :#{container_name} in configuration :#{@configuration.name}")
+      exit 1
+    end
+
+    servers = if opts[:servers_from]
+      if !opts[:servers_from].is_a?(Array)
+        Indocker.logger.error("servers_from should be Array[Symbol] for container :#{container_name} in configuration :#{@configuration.name}")
+        exit 1
+      end
+
+      opts[:servers_from].map do |name|
+        recursively_fetch_servers(container_list, name)
+      end.flatten
+    else
+      []
+    end
+
+    servers += if opts[:servers]
+      if !opts[:servers].is_a?(Array)
+        Indocker.logger.error("servers should be Array[Symbol] for container :#{container_name} in configuration :#{@configuration.name}")
+        exit 1
+      end
+
+      opts[:servers]
+    else
+      []
+    end
+
+    servers.uniq
+  end
+end

data/lib/indocker/configurations/formatters/stdout.rb

@@ -0,0 +1,36 @@
+class Indocker::Configurations::Formatters::Stdout
+  def print(configuration)
+    c = configuration
+    <<~EOS
+      Name: #{c.name}
+
+      Repositories: {
+      #{c.repositories.map do |alias_name, repository|
+            "  #{alias_name}: #{repository.inspect}"
+        end.join("\n")}
+      }
+
+      Registries: {
+      #{c.registries.map do |alias_name, registry|
+            "  #{alias_name}: #{registry.inspect}"
+        end.join("\n")}
+      }
+
+      Servers: {
+      #{c.servers.map do |alias_name, server|
+            "  #{alias_name}: #{server.inspect}"
+        end.join("\n")}
+      }
+
+      Build Servers: [
+      #{c.build_servers.map do |build_server|
+            "  #{build_server.inspect}"
+        end.join("\n")}
+      ]
+
+      Tags: #{c.tags.inspect}
+
+      Global build args: #{c.global_build_args.inspect}
+    EOS
+  end
+end

data/lib/indocker/container_deployer.rb

@@ -0,0 +1,73 @@
+class Indocker::ContainerDeployer
+  attr_reader :server_pool
+
+  def initialize(configuration:, logger:)
+    @configuration = configuration
+    @logger = logger
+
+    @server_pool = Indocker::ServerPool.new(
+      configuration: @configuration,
+      logger: logger
+    )
+
+    @deployed_containers = Hash.new(false)
+    @deployed_servers = {}
+  end
+
+  def deploy(container, force_restart, skip_force_restart, progress)
+    return if @deployed_containers[container]
+
+    container.servers.each do |server|
+      progress.start_deploying_container(container, server)
+
+      exec_proc = if !container.is_daemonized?
+        Proc.new do |&block|
+          block.call
+        end
+      else
+        Proc.new do |&block|
+          Thread.new do
+            block.call
+          end
+        end
+      end
+
+      exec_proc.call do
+        deploy_context = @server_pool.get(server)
+        @logger.info("{timestamp}")
+        @logger.info("Deploying container: #{container.name.to_s.green} to #{server.user}@#{server.host}")
+
+        command_output  = @logger.debug? ? "" : " > /dev/null"
+        debug_options   = @logger.debug? ? "-d" : ""
+
+        if force_restart && !skip_force_restart.include?(container.name)
+          force_restart_options = force_restart ? "-f" : ""
+        end
+
+        result = deploy_context
+          .session
+          .exec!(
+            "cd #{Indocker::IndockerHelper.indocker_dir} && ./bin/remote/run -C #{Indocker.configuration_name} -c #{container.name} #{debug_options} #{command_output} #{force_restart_options}"
+          )
+
+        Indocker::SshResultLogger
+          .new(@logger)
+          .log(result, "#{container.name.to_s.green} deployment for server #{server.name} failed")
+
+        exit 1 if result.exit_code != 0
+        @logger.info("Container deployment to #{server.user}@#{server.host} finished: #{container.name.to_s.green}")
+
+        deploy_context.close_session
+        progress.finish_deploying_container(container, server)
+      end
+    end
+
+    @deployed_containers[container] = true
+  end
+
+  def close_sessions
+    @server_pool.close_sessions
+  rescue => e
+    @logger.error("error during closing sessions #{e.inspect}")
+  end
+end