indocker 0.0.6 → 0.1.0

data/lib/indocker/docker.rb

@@ -0,0 +1,87 @@
+require_relative './shell'
+
+class Indocker::Docker
+  class << self
+    def build(image, build_args = '')
+      Indocker::Shell.command_with_result("docker build #{build_args} --rm=true -t #{image} .", Indocker.logger)
+    end
+
+    def tag(image, tag)
+      Indocker::Shell.command_with_result("docker tag #{image} #{tag}", Indocker.logger)
+    end
+
+    def push(tag)
+      Indocker::Shell.command("docker push #{tag}", Indocker.logger)
+    end
+
+    def pull(url)
+      Indocker::Shell.command("docker pull #{url}", Indocker.logger)
+    end
+
+    def stop(container_name, time = 10, skip_errors: false)
+      Indocker::Shell.command("docker stop --time=#{time} #{container_name}", Indocker.logger, skip_errors: skip_errors)
+      rm(container_name, skip_errors: skip_errors)
+    end
+
+    def rm(container_name, skip_errors: false)
+      Indocker::Shell.command("docker rm -fv #{container_name}", Indocker.logger, skip_errors: skip_errors)
+    end
+
+    def run_command(image, args_list, command, service_args)
+      extra_args = ""
+
+      if service_args && service_args.is_a?(Hash)
+        service_args.each do |arg, val|
+          extra_args += " #{arg} #{val}"
+        end
+      end
+
+      "docker run #{args_list} #{image} #{command} #{extra_args}"
+    end
+
+    def run(image, args_list, command,  service_args)
+      Indocker::Shell.command(run_command(image, args_list, command, service_args), Indocker.logger)
+    end
+
+    def create_volume(name)
+      res = Indocker::Shell.command_with_result("docker volume ls --filter \"name=^#{name}$\" --format \"{{.Name}}\"", Indocker.logger)
+      volume_exist = !res.stdout.empty?
+
+      if !volume_exist
+        Indocker::Shell.command("docker volume create #{name}", Indocker.logger, skip_errors: true)
+      end
+    end
+
+    def create_network(name)
+      network_exist = false
+
+      res = Indocker::Shell.command_with_result("docker network ls --filter \"name=^#{name}$\" --format \"{{.Name}}\"", Indocker.logger)
+      network_exist = !res.stdout.empty?
+
+      if !network_exist
+        Indocker::Shell.command("docker network create #{name}", Indocker.logger, skip_errors: true)
+      end
+    end
+
+    def image_id(image_url)
+      command = "docker image inspect #{image_url} --format \"{{.Id}}\""
+
+      res = Indocker::Shell.command_with_result(command, Indocker.logger)
+      res.stdout
+    end
+
+    def container_id_by_name(container_name, only_healthy: false)
+      health_args = if only_healthy
+        '--filter="health=healthy"'
+      end
+
+      command = "docker ps -a #{health_args} --filter=\"status=running\" --filter \"name=#{container_name}$\" -q"
+
+      id = nil
+
+      res = Indocker::Shell.command_with_result(command, Indocker.logger)
+
+      res.stdout.empty? ? nil : res.stdout
+    end
+  end
+end

data/lib/indocker/docker_run_args.rb

@@ -0,0 +1,175 @@
+class Indocker::DockerRunArgs
+  DEFAULT_LOG_MAX_SIZE = "400m"
+  DEFAULT_LOG_MAX_FILE = "2"
+
+  class << self
+    def get(container, configuration, number)
+      args = []
+      restart = container.get_start_option(:restart)
+
+      if restart
+        args.push("--restart #{restart}")
+      end
+
+      env_files = container.get_start_option(:env_files)
+
+      if env_files
+        env_files = env_files.is_a?(Array) ? env_files : [env_files]
+
+        env_files.each do |val|
+          env_file = configuration.env_files.fetch(val) do
+            Indocker.logger.error("env file :#{val} for container :#{container.name} is not specified in configuration :#{configuration.name}")
+            exit 1
+          end
+
+          path = Indocker::EnvFileHelper.path(env_file)
+
+          if !File.exists?(path)
+            raise ArgumentError.new("env file not found: #{path}")
+          end
+
+          args.push("--env-file #{path}")
+        end
+      end
+
+      expose = container.get_start_option(:expose)
+
+      if expose
+        expose = expose.is_a?(Array) ? expose : [expose]
+
+        expose.each do |val|
+          args.push("--expose #{val}")
+        end
+      end
+
+      ports = container.get_start_option(:ports)
+
+      if ports
+        ports = ports.is_a?(Array) ? ports : [ports]
+
+        ports.each do |val|
+          args.push("--publish #{val}")
+        end
+      end
+
+      environment = container.get_start_option(:environment)
+
+      if environment
+        environment.each do |key, val|
+          args.push("--env #{key}=#{val}")
+        end
+      end
+
+      if container.is_daemonized?
+        args.push("--detach")
+      end
+
+      hostname = Indocker::ContainerHelper.hostname(configuration.name, container, number)
+      args.push("--hostname #{hostname}")
+      args.push("--name #{hostname}")
+
+      read_only = container.get_start_option(:read_only) || false
+
+      if read_only
+        args.push("--read-only")
+      end
+
+      labels = container.get_start_option(:labels) || []
+
+      labels += container.tags
+      labels.uniq!
+
+      labels.each do |label|
+        args.push("--label #{label}")
+      end
+
+      stop_timeout = container.get_start_option(:stop_timeout)
+
+      if stop_timeout
+        args.push("--stop-timeout #{stop_timeout}")
+      end
+
+      add_hosts = container.get_start_option(:add_hosts) || []
+
+      add_hosts.each do |host|
+        args.push("--add-host #{host}")
+      end
+
+      mounts = container.get_start_option(:mounts) || []
+
+      mounts.each do |mount|
+        args.push("--mount #{mount}")
+      end
+
+      nets = container.get_start_option(:nets) || []
+
+      nets.each do |net|
+        args.push("--net #{net}")
+      end
+
+      user = container.get_start_option(:user)
+
+      if user
+        args.push("--user #{user}")
+      end
+
+      max_size = container.get_start_option(:max_size) || DEFAULT_LOG_MAX_SIZE
+
+      if max_size
+        args.push("--log-opt max-size=#{max_size}")
+      end
+
+      max_file = container.get_start_option(:max_file) || DEFAULT_LOG_MAX_FILE
+
+      if max_file
+        args.push("--log-opt max-file=#{max_file}")
+      end
+
+      health = container.get_start_option(:health) || {}
+
+      if !health.is_a?(Hash)
+        raise ArgumentError.new("health should be a Hash for container :#{container.name}")
+      end
+
+      if health.has_key?(:cmd)
+        args.push("--health-cmd \"#{health[:cmd]}\"")
+      end
+
+      if health.has_key?(:interval)
+        args.push("--health-interval #{health[:interval]}")
+      end
+
+      if health.has_key?(:retries)
+        args.push("--health-retries #{health[:retries]}")
+      end
+
+      if health.has_key?(:timeout)
+        args.push("--health-timeout #{health[:timeout]}")
+      end
+
+      container.volumes.each do |volume|
+        if volume.is_a?(Indocker::Volumes::Local)
+          args.push("-v #{volume.local_path}:#{volume.path}")
+        elsif volume.is_a?(Indocker::Volumes::External)
+          name = Indocker::VolumeHelper.name(configuration.name, volume)
+          args.push("-v #{name}:#{volume.path}")
+        elsif volume.is_a?(Indocker::Volumes::Repository)
+          repository = configuration.repositories.fetch(volume.repository_name) do
+            raise ArgumentError.new("specified repository :#{volume.repository_name} for volume :#{volume.name} was not found")
+          end
+
+          args.push("-v #{File.join(repository.clone_path)}:#{volume.path}:cached")
+        else
+          raise NotImplementedError.new("unsupported volume type: #{volume.inspect}")
+        end
+      end
+
+      container.networks.each do |network|
+        name = Indocker::NetworkHelper.name(configuration.name, network)
+        args.push("--network #{name}")
+      end
+
+      args
+    end
+  end
+end

data/lib/indocker/env_file_helper.rb

@@ -0,0 +1,13 @@
+class Indocker::EnvFileHelper
+  ENV_FILES_FOLDER = 'env_files'.freeze
+
+  class << self
+    def path(env_file)
+      File.expand_path(File.join(folder, File.basename(env_file.path)))
+    end
+
+    def folder
+       File.join(Indocker.deploy_dir, ENV_FILES_FOLDER)
+    end
+  end
+end

data/lib/indocker/env_files/local.rb

@@ -0,0 +1,8 @@
+class Indocker::EnvFiles::Local
+  attr_reader :name, :path
+
+  def initialize(name, path)
+    @name = name
+    @path = path
+  end
+end

data/lib/indocker/env_files/remote.rb

@@ -0,0 +1,8 @@
+class Indocker::EnvFiles::Remote
+  attr_reader :name, :path
+
+  def initialize(name, path)
+    @name = name
+    @path = path
+  end
+end

data/lib/indocker/hash_merger.rb

@@ -0,0 +1,9 @@
+class Indocker::HashMerger
+  def self.deep_merge(source, target)
+    merger = proc { |key, v1, v2|
+      Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2
+    }
+
+    source.merge(target, &merger)
+  end
+end

data/lib/indocker/images/image.rb

@@ -0,0 +1,86 @@
+class Indocker::Images::Image
+  attr_reader :name
+  attr_reader :dependent_images
+  attr_reader :build_args
+
+  def initialize(name)
+    @name = name
+    @dependent_images = []
+    @build_args = {}
+  end
+
+  def image_name
+    "#{@name}_image"
+  end
+
+  def set_tag(tag)
+    @tag = tag
+  end
+
+  def tag
+    @tag || (raise ArgumentError.new("tag is not set for image :#{@name}"))
+  end
+
+  def set_build_args(opts)
+    @build_args = opts
+  end
+
+  def set_registry(registry)
+    @registry = registry
+  end
+
+  def registry
+    @registry || (raise ArgumentError.new("registry is not set for image :#{@name}"))
+  end
+
+  def set_dockerfile(path)
+    @dockerfile = path
+  end
+
+  def dockerfile
+    @dockerfile || (raise ArgumentError.new("Dockerfile path is not set for image :#{@name}"))
+  end
+
+  def set_build_context(path)
+    @build_context = path
+  end
+
+  def build_context
+    @build_context
+  end
+
+  def set_before_build(proc)
+    @before_build = proc
+  end
+
+  def before_build
+    @before_build
+  end
+
+  def set_after_build(proc)
+    @after_build = proc
+  end
+
+  def after_build
+    @after_build
+  end
+
+  def registry_url
+    url = if registry.is_local?
+      File.join(registry.repository_name.to_s, image_name)
+    else
+      File.join(registry.url, registry.repository_name.to_s, image_name)
+    end
+
+    "#{url}:#{tag}"
+  end
+
+  def local_registry_url
+    url = File.join(registry.repository_name.to_s, image_name)
+    "#{url}:#{tag}"
+  end
+
+  def add_dependent_image(image)
+    @dependent_images.push(image) if !@dependent_images.include?(image)
+  end
+end

data/lib/indocker/images/image_builder.rb

@@ -0,0 +1,98 @@
+class Indocker::Images::ImageBuilder
+  attr_reader :image
+
+  def initialize(name:, configuration:, dir:)
+    @configuration = configuration
+    @image = Indocker::Images::Image.new(name)
+    dockerfile = File.join(dir, 'Dockerfile')
+
+    if File.exists?(dockerfile)
+      @image.set_dockerfile(dockerfile)
+    end
+
+    build_context = File.join(dir, 'build_context')
+
+    if Dir.exist?(build_context)
+      @image.set_build_context(build_context)
+    end
+
+    @image.set_tag('latest')
+    @configuration.add_image(@image)
+  end
+
+  def build_args(opts)
+    @image.set_build_args(opts)
+    self
+  end
+
+  def registry(name)
+    registry = @configuration.registries.fetch(name) do
+      raise ArgumentError.new("registry with alias name :#{name} is not defined in configuration :#{@configuration.name}")
+    end
+
+    @image.set_registry(registry)
+    self
+  end
+
+  def dockerfile(path)
+    if !File.exists?(path)
+      raise ArgumentError.new("Dockerfile was not found in #{path}")
+    end
+
+    @image.set_dockerfile(path)
+    self
+  end
+
+  def depends_on(*image_list)
+    if !image_list.is_a?(Array)
+      image_list = [image_list]
+    end
+
+    image_list.uniq!
+
+    image_list.each do |name|
+      path = Indocker.image_files.fetch(name) do
+        Indocker.logger.error("Dependent image :#{name} was not found in bounded contexts dir for image :#{@image.name}")
+        exit 1
+      end
+
+      require path
+    end
+
+    images = image_list.map do |image_sym|
+      @configuration.images.detect do |i|
+        i.name == image_sym
+      end
+    end
+
+    images.each do |image|
+      @image.add_dependent_image(image)
+    end
+
+    self
+  end
+
+  def tag(tag)
+    @image.set_tag(tag)
+    self
+  end
+
+  def build_context(path)
+    if !File.directory?(path)
+      raise ArgumentError.new("No directory found in #{path}")
+    end
+
+    @image.set_build_context(path)
+    self
+  end
+
+  def before_build(proc)
+    @image.set_before_build(proc)
+    self
+  end
+
+  def after_build(proc)
+    @image.set_after_build(proc)
+    self
+  end
+end