indocker 0.0.6 → 0.1.4

data/lib/indocker/images/image_compiler.rb

@@ -0,0 +1,68 @@
+require 'fileutils'
+
+class Indocker::Images::ImageCompiler
+  BUILDS_DIR = 'image_build'.freeze
+  DOCKERIGNORE = <<~EOS
+    Dockerfile
+    .DS_Store
+    **/.DS_Store
+    **/*.log
+    **/*_spec.rb
+    node_modules
+    .vagrant
+    .vscode
+    tmp
+    logs
+  EOS
+
+  def initialize
+    @compiled_images = Hash.new(false)
+  end
+
+  def compile(build_context, image, skip_dependent)
+    if !skip_dependent
+      image.dependent_images.each do |dependent_image|
+        compile_image(build_context, dependent_image)
+      end
+    end
+
+    compile_image(build_context, image)
+  end
+
+  def compile_image(build_context, image)
+    return if @compiled_images[image]
+
+    compile_dir = File.join(build_context.configuration.build_dir, BUILDS_DIR, image.name.to_s)
+    FileUtils.rm_rf(compile_dir)
+    FileUtils.mkdir_p(compile_dir)
+
+    if image.build_context
+      templates_compiler = Indocker::Images::TemplatesCompiler.new
+
+      templates_compiler.compile(
+        templates_dir: image.build_context,
+        compile_dir: compile_dir,
+        context: build_context
+      )
+    end
+
+    compiler = Indocker::Images::TemplateCompiler.new
+
+    target_dockerfile = File.join(compile_dir, 'Dockerfile')
+    FileUtils.cp(image.dockerfile, target_dockerfile)
+    compiler.compile(target_dockerfile, build_context)
+
+    File
+      .join(compile_dir, '.dockerignore')
+      .tap { |_| File.write(_, Indocker.dockerignore.join("\n")) }
+
+    if image.before_build
+      image.before_build.call(build_context, compile_dir)
+    end
+
+    build_context.build_image(image, compile_dir)
+    build_context.set_compiled(image)
+
+    @compiled_images[image] = true
+  end
+end

data/lib/indocker/images/template_compiler.rb

@@ -0,0 +1,15 @@
+require 'erb'
+
+class Indocker::Images::TemplateCompiler
+  def compile(path, context)
+    Indocker.logger.debug("compiling template file #{path}".grey)
+    template = File.read(path)
+    content = ERB.new(template).result(context.helper.get_binding)
+    File.write(path, content)
+  rescue Errno::EACCES => e
+    # do nothing for read only files
+  rescue => e
+    Indocker.logger.error("compilation failed for template file #{path}. #{e.inspect}")
+    raise e
+  end
+end

data/lib/indocker/images/templates_compiler.rb

@@ -0,0 +1,28 @@
+require 'erb'
+require 'fileutils'
+
+class Indocker::Images::TemplatesCompiler
+  def compile(templates_dir:, compile_dir:, context:)
+    prepare_dirs!(templates_dir, compile_dir)
+
+    compiler = Indocker::Images::TemplateCompiler.new
+
+    Dir[File.join(compile_dir, '**/**')].each do |file|
+      next if !File.file?(file)
+      compiler.compile(file, context)
+    end
+  end
+
+  private
+
+  def prepare_dirs!(templates_dir, compile_dir)
+    Indocker.logger.debug("recreating directory #{compile_dir}".grey)
+    FileUtils.rm_rf(compile_dir)
+    FileUtils.mkdir_p(compile_dir)
+
+    Indocker.logger.debug("copy template files".grey)
+    Indocker.logger.debug("  from: #{templates_dir}".grey)
+    Indocker.logger.debug("    to: #{compile_dir}".grey)
+    FileUtils.cp_r(File.join(templates_dir, '.'), compile_dir)
+  end
+end

data/lib/indocker/images_compiler.rb

@@ -0,0 +1,38 @@
+class Indocker::ImagesCompiler
+  def initialize(logger)
+    @logger = logger
+  end
+
+  def compile(configuration:, image_list:, skip_dependent:)
+    preload_images(configuration, image_list)
+
+    build_context = Indocker::BuildContext.new(
+      configuration: configuration,
+      build_server:  nil,
+      logger: Indocker.logger
+    )
+
+    image_compiler = Indocker::Images::ImageCompiler.new
+
+    image_list.each do |image_name|
+      image = Indocker.configuration.images.detect do |i|
+        i.name == image_name
+      end
+
+      image_compiler.compile(build_context, image, skip_dependent)
+    end
+  end
+
+  private
+
+  def preload_images(configuration, image_list)
+    image_list.each do |image_name|
+      image_path = Indocker.image_files.fetch(image_name) do
+        @logger.error("image not found :#{image_name} in configuration :#{configuration.name}")
+        exit 1
+      end
+
+      require image_path
+    end
+  end
+end

data/lib/indocker/indocker_helper.rb

@@ -0,0 +1,9 @@
+class Indocker::IndockerHelper
+  INDOCKER_FOLDER = 'indocker'.freeze
+
+  class << self
+    def indocker_dir
+      File.join(Indocker.deploy_dir, INDOCKER_FOLDER)
+    end
+  end
+end

data/lib/indocker/network.rb

@@ -0,0 +1,12 @@
+class Indocker::Network
+  attr_reader :name, :containers
+
+  def initialize(name)
+    @name = name
+    @containers = []
+  end
+
+  def add_container(container)
+    @containers.push(container) if !@containers.include?(container)
+  end
+end

data/lib/indocker/network_helper.rb

@@ -0,0 +1,7 @@
+class Indocker::NetworkHelper
+  class << self
+    def name(configuration_name, network)
+      "#{configuration_name}_#{network.name}"
+    end
+  end
+end

data/lib/indocker/registries/abstract.rb

@@ -0,0 +1,17 @@
+class Indocker::Registries::Abstract
+  include Indocker::Concerns::Inspectable
+
+  attr_reader :repository_name
+
+  def initialize(repository_name)
+    @repository_name = repository_name
+  end
+
+  def setup(*args)
+    self
+  end
+
+  def is_local?
+    self.is_a?(Indocker::Registries::Local)
+  end
+end

data/lib/indocker/registries/local.rb

@@ -0,0 +1,5 @@
+class Indocker::Registries::Local < Indocker::Registries::Abstract
+  def url
+    ''
+  end
+end

data/lib/indocker/registries/remote.rb

@@ -0,0 +1,12 @@
+class Indocker::Registries::Remote < Indocker::Registries::Abstract
+  attr_reader :server_name
+
+  def setup(server_name)
+    @server_name = server_name
+    self
+  end
+
+  def url
+    @server_name
+  end
+end

data/lib/indocker/repositories/abstract.rb

@@ -0,0 +1,25 @@
+class Indocker::Repositories::Abstract
+  include Indocker::Concerns::Inspectable
+
+  attr_reader :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def setup(*args)
+    self
+  end
+
+  def is_local?
+    self.is_a?(Indocker::Repositories::Local)
+  end
+
+  def is_git?
+    self.is_a?(Indocker::Repositories::Git)
+  end
+
+  def is_no_sync?
+    self.is_a?(Indocker::Repositories::NoSync)
+  end
+end

data/lib/indocker/repositories/clonner.rb

@@ -0,0 +1,17 @@
+require 'net/ssh'
+
+class Indocker::Repositories::Clonner
+  def initialize(configuration, logger)
+    @configuration = configuration
+    @logger = logger
+  end
+
+  def clone(session, repository)
+    raise ArgumenError.new("only git repositories should be clonned") if !repository.is_git?
+
+    session.exec!("rm -rf #{repository.clone_path} && mkdir -p #{repository.clone_path}")
+    
+    git_command = "git clone -b #{repository.branch} --depth 1 #{repository.remote_url} #{repository.clone_path}"
+    session.exec!("ssh-agent bash -c 'ssh-add ~/.ssh/#{repository.ssh_key}; #{git_command}'")
+  end
+end

data/lib/indocker/repositories/git.rb

@@ -0,0 +1,24 @@
+class Indocker::Repositories::Git < Indocker::Repositories::Abstract
+  attr_reader :remote_url, :remote_name, :email, :password, :branch, :ssh_key
+
+  DEFAULT_SSH_KEY = "id_rsa"
+
+  def setup(remote_name:, remote_url:, email: nil, password: nil, branch:, clone_path: nil, ssh_key: DEFAULT_SSH_KEY)
+    @remote_name = remote_name
+    @remote_url = remote_url
+    @email = email
+    @password = password
+    @branch = branch
+    @clone_path = clone_path
+    @ssh_key = ssh_key
+    self
+  end
+
+  def project_name
+    @remote_url.split('/').last.gsub('.git', '')
+  end
+
+  def clone_path
+    @clone_path || "/tmp/#{Indocker.configuration.name}/repositories/git/#{project_name}/#{branch}"
+  end
+end

data/lib/indocker/repositories/local.rb

@@ -0,0 +1,20 @@
+class Indocker::Repositories::Local < Indocker::Repositories::Abstract
+  attr_reader :root_path
+
+  def setup(root_path)
+    @root_path = File.expand_path(root_path)
+    self
+  end
+
+  def project_name
+    root_path.split('/').last
+  end
+
+  def root_path
+    @root_path || (raise ArgumentError.new("root path was not set. Set it using setup method"))
+  end
+
+  def clone_path
+    "/tmp/#{Indocker.configuration.name}/repositories/local/#{project_name}"
+  end
+end

data/lib/indocker/repositories/no_sync.rb

@@ -0,0 +1,20 @@
+class Indocker::Repositories::NoSync < Indocker::Repositories::Abstract
+  attr_reader :root_path
+
+  def setup(root_path)
+    @root_path = File.expand_path(root_path)
+    self
+  end
+
+  def project_name
+    root_path.split('/').last
+  end
+
+  def root_path
+    @root_path || (raise ArgumentError.new("root path was not set. Set it using setup method"))
+  end
+
+  def clone_path
+    root_path
+  end
+end

data/lib/indocker/rsync.rb

@@ -0,0 +1,52 @@
+require_relative 'shell'
+
+class Indocker::Rsync
+  def self.local_sync(from, to, create_path: nil, raise_on_error: false, exclude: nil)
+    @session ||= Indocker::SshSession.new(
+      host: 'localhost',
+      user: nil,
+      port: nil,
+      logger: Indocker.logger
+    )
+
+    sync(@session, from, to, create_path: create_path, raise_on_error: raise_on_error, exclude: exclude)
+  end
+
+  def self.sync(session, from, to, create_path: nil, raise_on_error: false, exclude: nil)
+    if create_path
+      session.exec!("mkdir -p #{create_path}")
+    end
+
+    if session.local?
+      return if File.expand_path(to) == File.expand_path(from)
+
+      Indocker::Shell.command("rm -rf #{to}", Indocker.logger, raise_on_error: raise_on_error)
+
+      if Indocker::Shell.command_exist?("rsync")
+        sync_local_rsync(from, to, raise_on_error: raise_on_error, exclude: exclude)
+      else
+        Indocker.logger.debug("WARNING: exclude option skipped due to fallback to CP command")
+        sync_local_cp(from, to, raise_on_error: raise_on_error)
+      end
+    else
+      command = "rsync --delete-after -a -e 'ssh -p #{session.port}' #{from} #{session.user}@#{session.host}:#{to}"
+      Indocker.logger.debug("sync #{from} #{session.user}@#{session.host}:#{to}")
+      Indocker::Shell.command(command, Indocker.logger, raise_on_error: raise_on_error)
+    end
+  end
+
+  private
+    def self.sync_local_cp(from, to, raise_on_error:)
+      Indocker::Shell.command("cp -r #{from} #{to}", Indocker.logger, raise_on_error: raise_on_error)
+    end
+
+    def self.sync_local_rsync(from, to, raise_on_error:, exclude: nil)
+      options = []
+      options << " --exclude=#{exclude}" if exclude
+      # Add a trailing slash to directory to have behavior similar to CP command
+      if File.directory?(from) && !from.end_with?("/")
+        from = "#{from}/"
+      end
+      Indocker::Shell.command("rsync -a #{options.join(' ')} #{from} #{to}", Indocker.logger, raise_on_error: raise_on_error)
+    end
+end

data/lib/indocker/server.rb

@@ -0,0 +1,20 @@
+class Indocker::Server
+  include Indocker::Concerns::Inspectable
+
+  attr_reader :name, :host, :user, :port
+
+  def initialize(name:, host:, user:, port:)
+    @name = name
+    @host = host
+    @user = user
+    @port = port
+  end
+
+  def ==(value)
+    if value.is_a?(Indocker::Server)
+      @name == value.name
+    else
+      super
+    end
+  end
+end

data/lib/indocker/server_pool.rb

@@ -0,0 +1,30 @@
+class Indocker::ServerPool
+  def initialize(configuration:, logger:)
+    @logger = logger
+    @configuration = configuration
+
+    @contexts = configuration.servers.map do |server|
+      Indocker::DeployContext.new(
+        logger: @logger,
+        configuration: configuration,
+        server: server,
+      )
+    end
+  end
+
+  def get(server)
+    Indocker::DeployContext.new(
+      logger: @logger,
+      configuration: @configuration,
+      server: server,
+    )
+  end
+
+  def each(&proc)
+    @contexts.each(&proc)
+  end
+
+  def close_sessions
+    @contexts.each(&:close_session)
+  end
+end