indocker 0.0.0 → 0.0.1

data/lib/indocker/directives/container_directives/from.rb

@@ -0,0 +1,12 @@
+class Indocker::ContainerDirectives::From < Indocker::ContainerDirectives::Base
+  attr_accessor :repo, :tag
+
+  def initialize(repo, tag: Indocker::ImageMetadata::DEFAULT_TAG)
+    @repo = repo
+    @tag  = tag
+  end
+
+  def image
+    "#{@repo}:#{@tag}"
+  end
+end

data/lib/indocker/directives/container_directives/network.rb

@@ -0,0 +1,12 @@
+class Indocker::ContainerDirectives::Network < Indocker::ContainerDirectives::Base
+  attr_accessor :network_name, :container_name
+
+  def initialize(network_name:, container_name:)
+    @network_name   = network_name
+    @container_name = container_name
+  end
+
+  def before_start?
+    true
+  end
+end

data/lib/indocker/directives/container_directives/ports.rb

@@ -0,0 +1,8 @@
+class Indocker::ContainerDirectives::Ports < Indocker::ContainerDirectives::Base
+  attr_accessor :docker_port, :host_port
+
+  def initialize(docker_port:, host_port:)
+    @docker_port = docker_port
+    @host_port   = host_port
+  end
+end

data/lib/indocker/directives/container_directives/ready.rb

@@ -0,0 +1,16 @@
+class Indocker::ContainerDirectives::Ready < Indocker::ContainerDirectives::Base
+  attr_accessor :ready_block, :sleep, :timeout
+
+  DEFAULT_SLEEP   = 0.1
+  DEFAULT_TIMEPUT = 10
+
+  def initialize(sleep: DEFAULT_SLEEP, timeout: DEFAULT_TIMEPUT, ready_block:)
+    @sleep       = sleep
+    @timeout     = timeout
+    @ready_block = ready_block
+  end
+
+  def after_start?
+    true
+  end
+end

data/lib/indocker/directives/container_directives_runner.rb

@@ -0,0 +1,46 @@
+require 'timeout'
+
+class Indocker::ContainerDirectivesRunner
+  include SmartIoC::Iocify
+
+  bean :container_directives_runner
+
+  inject :docker_api
+  inject :config
+
+  def run_all(directives)
+    directives.each {|c| run(c)}
+  end
+
+  def run(directive)
+    case directive
+    when Indocker::ContainerDirectives::Network
+      run_network(directive)
+    when Indocker::ContainerDirectives::Ready
+      run_ready(directive)
+    else
+      # do nothing
+    end
+  end
+
+  def run_network(directive)
+    if !docker_api.network_exists?(directive.network_name)
+      docker_api.create_network(directive.network_name)
+    end
+
+    docker_api.add_container_to_network(
+      container_name: directive.container_name,
+      network_name:   directive.network_name
+    )
+  end
+
+  def run_ready(directive)
+    Timeout::timeout(directive.timeout) do
+      while (!directive.ready_block.call)
+        sleep directive.sleep
+      end
+    end
+  rescue Timeout::Error
+    raise Indocker::Errors::ContainerTimeoutError
+  end
+end

data/lib/indocker/directives/docker_directives/base.rb

@@ -0,0 +1,15 @@
+module Indocker
+  module DockerDirectives
+    class Base < Indocker::Directives::Base
+      attr_reader :args
+      
+      def initialize(*args)
+        @args = args
+      end
+
+      def to_s
+        "#{type} #{@args.join(' ')}"
+      end
+    end
+  end
+end

data/lib/indocker/directives/docker_directives/cmd.rb

@@ -0,0 +1,15 @@
+class Indocker::DockerDirectives::Cmd < Indocker::DockerDirectives::Base
+  attr_reader :command
+
+  def initialize(command)
+    @command = command
+  end
+
+  def to_s
+    "#{type} #{command.inspect}"
+  end
+
+  def type
+    'CMD'
+  end
+end

data/lib/indocker/directives/docker_directives/copy.rb

@@ -0,0 +1,27 @@
+class Indocker::DockerDirectives::Copy < Indocker::DockerDirectives::Base
+  attr_reader :copy_actions, :context, :compile
+
+  def initialize(context:, copy_actions:, compile: false)
+    @copy_actions = copy_actions
+    @context      = context
+    @compile      = compile
+  end
+
+  def type
+    'COPY'
+  end
+
+  def to_s
+    result = []
+    
+    copy_actions.each do |from, to|
+      result.push "#{type} #{from} #{to}"
+    end
+
+    result.join("\n")
+  end
+
+  def prepare_directive?
+    true
+  end
+end

data/lib/indocker/directives/docker_directives/entrypoint.rb

@@ -0,0 +1,15 @@
+class Indocker::DockerDirectives::Entrypoint < Indocker::DockerDirectives::Base
+  attr_reader :command
+
+  def initialize(command)
+    @command = command
+  end
+
+  def to_s
+    "#{type} #{command.inspect}"
+  end
+  
+  def type
+    'ENTRYPOINT'
+  end
+end

data/lib/indocker/directives/docker_directives/env.rb

@@ -0,0 +1,5 @@
+class Indocker::DockerDirectives::Env < Indocker::DockerDirectives::Base
+  def type
+    'ENV'
+  end
+end

data/lib/indocker/directives/docker_directives/from.rb

@@ -0,0 +1,30 @@
+class Indocker::DockerDirectives::From < Indocker::DockerDirectives::Base
+  attr_reader :repo, :tag
+
+  def initialize(repo_tag, tag: nil)
+    case repo_tag
+    when String
+      @repo = repo_tag.split(':')[0]
+      @tag  = tag || repo_tag.split(':')[1] || Indocker::ImageMetadata::DEFAULT_TAG
+    else
+      @repo = repo_tag
+      @tag  = tag || Indocker::ImageMetadata::DEFAULT_TAG
+    end
+  end
+
+  def full_name
+    "#{repo}:#{tag}"
+  end
+
+  def dockerhub_image?
+    repo.is_a?(String)
+  end
+
+  def to_s
+    "#{type} #{repo}:#{tag}"
+  end
+
+  def type
+    'FROM'
+  end
+end

data/lib/indocker/directives/docker_directives/run.rb

@@ -0,0 +1,5 @@
+class Indocker::DockerDirectives::Run < Indocker::DockerDirectives::Base
+  def type
+    'RUN'
+  end
+end

data/lib/indocker/directives/docker_directives/workdir.rb

@@ -0,0 +1,5 @@
+class Indocker::DockerDirectives::Workdir < Indocker::DockerDirectives::Base
+  def type
+    'WORKDIR'
+  end
+end

data/lib/indocker/directives/image_directives_runner.rb

@@ -0,0 +1,120 @@
+class Indocker::ImageDirectivesRunner
+  include SmartIoC::Iocify
+
+  bean :image_directives_runner
+
+  inject :container_manager
+  inject :config
+  inject :render_util
+
+  def run_all(directives)
+    directives.each {|c| run(c)}
+  end
+
+  def run(directive)
+    case directive
+    when Indocker::PrepareDirectives::DockerCp
+      run_docker_cp(directive)
+    when Indocker::DockerDirectives::Copy
+      run_copy(directive)
+    else
+      # do nothing
+    end
+  end
+
+  def run_docker_cp(directive)
+    directive.copy_actions.each do |from, to|
+      container_manager.copy(
+        name:      directive.container_name,
+        copy_from: from,
+        copy_to:   to
+      )
+    end
+  end
+
+  def run_copy(directive)
+    directive.copy_actions.each do |from, to|
+      build_dir_file = File.join(directive.context.build_dir, from)
+
+      source_dir = File.join(config.root, from)
+      
+      if File.directory?(from)
+        dest_dir = File.join(directive.context.build_dir, from)
+      else
+        dest_dir = File.join(directive.context.build_dir, File.dirname(from))
+      end
+
+      if File.exists?(build_dir_file) && File.file?(build_dir_file)
+        copy_compile_file(
+          from:    build_dir_file, 
+          to:      build_dir_file, 
+          locals:  directive.context.storage, 
+          compile: directive.compile
+        )
+
+        return
+      end
+      
+      if File.exist?(build_dir_file) && File.directory?(build_dir_file)
+        files_list = Dir.glob(File.join(build_dir_file, '**', '*'), File::FNM_DOTMATCH)
+
+        files_list.each do |from|
+          copy_compile_file(
+            from:    from, 
+            to:      from, 
+            locals:  directive.context.storage, 
+            compile: directive.compile
+          )
+        end
+
+        return
+      end
+
+      if File.exists?(source_dir) && File.file?(source_dir)
+        copy_compile_file(
+          from:    source_dir, 
+          to:      File.join(dest_dir, File.basename(source_dir)), 
+          locals:  directive.context.storage, 
+          compile: directive.compile
+        )
+
+        return
+      end
+
+      if Dir.exist?(source_dir) && File.directory?(source_dir)
+        files_list = Dir.glob(File.join(source_dir, '**', '*'), File::FNM_DOTMATCH)
+
+        files_list.each do |from|
+          relative_to = Pathname.new(from).relative_path_from( Pathname.new(source_dir) ).to_s
+          absolute_to = File.join(dest_dir, relative_to)
+
+          copy_compile_file(
+            from:    from, 
+            to:      absolute_to, 
+            locals:  directive.context.storage, 
+            compile: directive.compile
+          )
+        end
+
+        return
+      end
+
+      raise Indocker::Errors::FileDoesNotExists
+    end
+  end
+
+  private
+
+  def copy_compile_file(from:, to:, locals: {}, compile: false)
+    return if !File.exists?(from) || File.directory?(from)
+    
+    FileUtils.mkdir_p(File.dirname(to)) unless Dir.exist?(File.dirname(to))
+
+    write_content = compile ? render_util.render( File.read(from), locals ) : 
+                              File.read(from)
+
+    File.write(to, write_content)
+
+    File.chmod(File.stat(from).mode, to)
+  end
+end

data/lib/indocker/directives/partial.rb

@@ -0,0 +1,13 @@
+class Indocker::Directives::Partial < Indocker::Directives::Base
+  attr_reader :name, :context
+
+  def initialize(name, context, opts = {})
+    @name    = name
+    @context = context
+    @opts    = opts
+  end
+
+  def to_s
+    inspect
+  end
+end

data/lib/indocker/directives/prepare_directives/base.rb

@@ -0,0 +1,6 @@
+module Indocker
+  module PrepareDirectives
+    class Base < Indocker::Directives::Base
+    end
+  end
+end

data/lib/indocker/directives/prepare_directives/docker_cp.rb

@@ -0,0 +1,16 @@
+class Indocker::PrepareDirectives::DockerCp < Indocker::PrepareDirectives::Base
+  attr_reader :container_name, :copy_actions, :build_dir
+
+  def initialize(container_name, build_dir, &block)
+    @container_name = container_name
+    @build_dir      = build_dir
+
+    instance_exec &block if block_given?
+  end
+
+  private
+
+  def copy(copy_actions)
+    @copy_actions = copy_actions
+  end
+end

data/lib/indocker/docker_api.rb

@@ -0,0 +1,180 @@
+class Indocker::DockerApi
+  include SmartIoC::Iocify
+
+  bean :docker_api
+
+  inject :logger
+
+  def check_docker_installed!
+    Docker.info
+    nil
+  rescue Excon::Error::Socket
+    raise Indocker::Errors::DockerDoesNotInstalled
+  end
+
+  def authenticate!(serveraddress:, email:, password:, username:)
+    params = {
+      'serveraddress' => serveraddress,
+      'email'         => email,
+      'password'      => password,
+      'username'      => username
+    }.delete_if {|_, value| value.to_s.empty?}
+
+    Docker.authenticate!(params)
+  end
+
+  # Networks
+
+  def create_network(name)
+    Docker::Network.create(name.to_s).id
+  end
+
+  def add_container_to_network(network_name:, container_name:)
+    container_id = get_container_id(container_name.to_s)
+
+    Docker::Network.get(network_name.to_s).connect(container_id.to_s)
+  end
+
+  def remove_network(name)
+    Docker::Network.get(name.to_s).remove
+  end
+
+  def network_exists?(name)
+    !Docker::Network.get(name.to_s).nil? rescue false
+  end
+
+  def get_network_id(name)
+    Docker::Network.get(name.to_s).id
+  end
+
+  def inspect_network(name)
+    Docker::Network.get(name.to_s).info
+  end
+
+  def delete_networks_where(&condition)
+    Docker::Network.all.select(&condition).map do |network|
+      network.remove
+    end
+  end
+
+  # Images
+
+  def get_image_id(repo, tag: Indocker::ImageMetadata::DEFAULT_TAG)
+    Docker::Image.get(full_name(repo, tag)).id
+  end
+
+  def image_exists?(repo, tag: Indocker::ImageMetadata::DEFAULT_TAG)
+    Docker::Image.exist?(full_name(repo, tag))
+  end
+
+  def delete_image(repo, tag: Indocker::ImageMetadata::DEFAULT_TAG)
+    Docker::Image.get(full_name(repo, tag)).remove(force: true)
+  end
+
+  def build_from_dir(repo:, tag:, build_dir:)
+    image = Docker::Image.build_from_dir(build_dir) do |x|
+      x.split("\r\n").each do |y|
+        if (log = JSON.parse(y)) && log.has_key?("stream")
+          yield log["stream"].strip
+        end
+      end
+    end
+
+    image.tag(
+      repo:  repo, 
+      tag:   tag, 
+      force: true
+    )
+
+    image.id
+  end
+
+  def pull(opts)
+    image = Docker::Image.create(opts)
+
+    image.id
+  end
+
+  def delete_images_where(&condition)
+    Docker::Image.all.select(&condition).map do |image|
+      image.remove(force: true)
+    end
+  end
+
+
+  # Containers
+
+  def inspect_container(name)
+    Docker::Container.get(name.to_s).info
+  end
+
+  def get_container_id(name)
+    Docker::Container.get(name.to_s).id
+  end
+
+  def get_container_state(name)
+    Docker::Container.get(name.to_s).info["State"]["Status"]
+  end
+
+  def container_exists?(name)
+    !Docker::Container.get(name.to_s).nil? rescue false
+  end
+
+  def start_container(name)
+    Docker::Container.get(name.to_s).start!.id
+  end
+
+  def stop_container(name)
+    Docker::Container.get(name.to_s).stop
+  end
+
+  def copy_from_container(name:, path:)
+    Docker::Container.get(name.to_s).copy(path) { |chunk| yield chunk }
+  end
+
+  def create_container(repo:, tag:, name: nil, command: nil, env: nil, 
+                        exposed_ports: nil, port_bindings: nil)
+    params = {
+      'Image'          => full_name(repo, tag), 
+      'name'           => name.to_s,
+      'Cmd'            => command,
+      'Env'            => env,
+      'ExposedPorts'   => exposed_ports,
+      'HostConfig' => {
+        'PortBindings' => port_bindings
+      }
+    }.delete_if { |_, value| value.to_s.empty? }
+
+    Docker::Container.create(params).id
+  end
+
+  def exec_container(name:, command:)
+    Docker::Container.get(name.to_s).exec(command) do |stream, chunk|
+      yield stream, chunk
+    end
+  end
+
+  def delete_container(name)
+    Docker::Container.get(name.to_s).delete(:force => true)
+  end
+
+  def delete_containers_where(&condition)
+    Docker::Container.all(all: true).select(&condition).map do |container|
+      container.stop
+      container.delete(force: true)
+    end
+  end
+
+  def container_run(repo:, tag:, command:)
+    container = Docker::Container.create(
+      'Image'        => full_name(repo, tag), 
+      'Cmd'          => command
+    ).id
+  end
+
+  private
+
+  def full_name(repo, tag)
+    "#{repo.to_s}:#{tag.to_s}"
+  end
+end

data/lib/indocker/dsl_context.rb

@@ -0,0 +1,17 @@
+class Indocker::DSLContext
+  attr_reader :storage
+
+  def initialize(storage = {})
+    @storage = storage
+  end
+
+  def method_missing(method, *args)
+    super unless @storage.key?(method)
+
+    @storage.fetch(method)
+  end
+
+  def set_value(key, value)
+    @storage[key] = value
+  end
+end

data/lib/indocker/envs/env_metadata.rb

@@ -0,0 +1,35 @@
+module Indocker::Envs
+  class EnvMetadata
+    def initialize(variables = {})
+      @variables = variables
+    end
+
+    def to_hash
+      @variables
+    end
+
+    def to_json
+      to_hash.to_json
+    end
+
+    def to_array
+      to_hash.inject([]) do |all, (k, v)|
+        all.push "#{k}=#{v}"
+      end
+    end
+
+    def set(key:, value:)
+      overwritten = @variables.has_key?(key) and @variables[key] != value
+
+      @variables[key] = value
+
+      overwritten
+    end
+
+    def +(other)
+      combined_hash = to_hash.merge(other.to_hash)
+
+      Indocker::Envs::EnvMetadata.new(combined_hash)
+    end
+  end
+end

data/lib/indocker/envs/loader.rb

@@ -0,0 +1,19 @@
+class Indocker::Envs::Loader
+  include SmartIoC::Iocify
+
+  bean :envs_loader
+
+  def parse(path)
+    raise Indocker::Errors::EnvFileDoesNotExist if !File.exists?(path)
+
+    env_metadata = Indocker::Envs::EnvMetadata.new
+
+    File.foreach(path) do |line|
+      key, value = line.split('=').map(&:strip)
+
+      env_metadata.set(key: key, value: value)
+    end
+
+    env_metadata
+  end
+end

data/lib/indocker/envs/manager.rb

@@ -0,0 +1,30 @@
+class Indocker::Envs::Manager
+  include SmartIoC::Iocify
+
+  bean :envs_manager
+
+  inject :config
+  inject :logger
+  inject :envs_loader
+
+  def load_init_application_env_variables
+    config.load_env_file.each do |path|
+      env_file = File.join(config.root, path)
+
+      begin
+        metadata = envs_loader.parse(env_file) 
+      rescue Indocker::Errors::EnvFileDoesNotExist
+        logger.warn "File #{env_file} doesn't exist. Check path to environment_path"
+        return
+      end
+
+      metadata.to_hash.each do |key, value|
+        if ENV.has_key?(key) && ENV[key] != value
+          logger.warn "Environment file '#{path}' overwrites ENV['#{key}'] from '#{ENV[key]}' to '#{value}'!"
+        end
+
+        ENV[key] = value
+      end
+    end
+  end
+end

data/lib/indocker/errors.rb

@@ -0,0 +1,17 @@
+module Indocker::Errors         
+  class ImageIsNotDefined                 < StandardError; end 
+  class PartialIsNotDefined               < StandardError; end 
+  class ContainerIsNotDefined             < StandardError; end
+  class CircularImageDependency           < StandardError; end
+  class ImageForContainerDoesNotExist     < StandardError; end
+  class DockerDoesNotInstalled            < StandardError; end
+  class ConfigFilesDoesNotFound           < StandardError; end
+  class ConfigOptionTypeMismatch          < StandardError; end
+  class DockerRegistryAuthenticationError < StandardError; end
+  class FileDoesNotExists                 < StandardError; end
+  class EnvFileDoesNotExist               < StandardError; end
+  class ContainerTimeoutError             < StandardError; end
+
+  class ContainerImageAlreadyDefined      < StandardError; end
+  class NetworkAlreadyDefined             < StandardError; end
+end