indocker 0.0.2 → 0.0.5

data/lib/indocker/{docker_api.rb → docker_api/docker_api.rb}

@@ -1,5 +1,11 @@
-class Indocker::DockerApi
+require 'docker-api'
+require 'io/console'
+
+Docker.options = { read_timeout: 600, write_timeout: 600, chunk_size: 1 }
+
+class Indocker::DockerAPI
   include SmartIoC::Iocify
+  include Indocker::ImageHelper
 
   bean :docker_api
 
@@ -35,7 +41,7 @@ class Indocker::DockerApi
     Docker::Network.get(network_name.to_s).connect(container_id.to_s)
   end
 
-  def remove_network(name)
+  def delete_network(name)
     Docker::Network.get(name.to_s).remove
   end
 
@@ -59,20 +65,20 @@ class Indocker::DockerApi
 
   # Images
 
-  def get_image_id(repo, tag: Indocker::ImageMetadata::DEFAULT_TAG)
-    Docker::Image.get(full_name(repo, tag)).id
+  def get_image_id(repo, tag: nil)
+    Docker::Image.get(full_name(repo, tag)).id rescue nil
   end
 
-  def image_exists?(repo, tag: Indocker::ImageMetadata::DEFAULT_TAG)
+  def image_exists?(repo, tag: nil)
     Docker::Image.exist?(full_name(repo, tag))
   end
 
-  def delete_image(repo, tag: Indocker::ImageMetadata::DEFAULT_TAG)
+  def delete_image(repo, tag: nil)
     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|
+    image = Docker::Image.build_from_dir(build_dir, { 't' => "#{repo}:#{tag}" }) do |x|
       x.split("\r\n").each do |y|
         if (log = JSON.parse(y)) && log.has_key?("stream")
           yield log["stream"].strip
@@ -80,15 +86,21 @@ class Indocker::DockerApi
       end
     end
 
-    image.tag(
-      repo:  repo, 
-      tag:   tag, 
-      force: true
-    )
-
     image.id
   end
 
+  def tag(repo:, tag: nil, new_repo:, new_tag:)
+    Docker::Image.get(full_name(repo, tag)).tag('repo' => new_repo, 'tag' => new_tag)
+
+    nil
+  end
+
+  def push(repo:, tag:, push_to_repo:, push_to_tag:)
+    Docker::Image.get(full_name(repo, tag)).push(nil, repo_tag: full_name(push_to_repo, push_to_tag))
+
+    nil
+  end
+
   def pull(opts)
     image = Docker::Image.create(opts)
 
@@ -101,6 +113,37 @@ class Indocker::DockerApi
     end
   end
 
+  #Volumes
+
+  def create_volume(name)
+    Docker::Volume.create(name.to_s).id
+  end
+
+  def get_volume_id(name)
+    Docker::Volume.get(name.to_s).id
+  end
+
+  def all_volumes(name)
+    Docker::Volume.all
+  end
+
+  def delete_volume(name)
+    Docker::Volume.get(name.to_s).remove
+  end
+
+  def volume_exists?(name)
+    !Docker::Volume.get(name.to_s).nil? rescue false
+  end
+
+  def inspect_volume(name)
+    Docker::Volume.get(name.to_s).info
+  end
+
+  def delete_volumes_where(&condition)
+    Docker::Volume.all.select(&condition).map do |volume|
+      volume.remove
+    end
+  end
 
   # Containers
 
@@ -109,7 +152,11 @@ class Indocker::DockerApi
   end
 
   def get_container_id(name)
-    Docker::Container.get(name.to_s).id
+    Docker::Container.get(name.to_s).id rescue nil
+  end
+
+  def get_container_image_id(name)
+    Docker::Container.get(name.to_s).info['Image'] rescue nil
   end
 
   def get_container_state(name)
@@ -120,38 +167,31 @@ class Indocker::DockerApi
     !Docker::Container.get(name.to_s).nil? rescue false
   end
 
-  def start_container(name)
-    Docker::Container.get(name.to_s).start!.id
+  def start_container(name, attach: false)
+    container = Docker::Container.get(name.to_s).start!
+
+    if attach
+      STDIN.raw do |stdin| 
+        container.attach(stdin: stdin, tty: true) do |chunk|
+          logger << chunk
+        end
+      end
+    end
+
+    container.id
   end
 
   def stop_container(name)
-    Docker::Container.get(name.to_s).stop
+    Docker::Container.get(name.to_s).stop rescue nil
   end
 
-  def copy_from_container(name:, path:)
-    Docker::Container.get(name.to_s).copy(path) { |chunk| yield chunk }
+  def copy_from_container(name:, path:, &block)
+    Docker::Container.get(name.to_s).copy(path, &block)
   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
+  # TODO: Add contract
+  def create_container(container_config)
+    Docker::Container.create(container_config.to_hash).id
   end
 
   def delete_container(name)
@@ -164,17 +204,4 @@ class Indocker::DockerApi
       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

@@ -14,4 +14,8 @@ class Indocker::DSLContext
   def set_value(key, value)
     @storage[key] = value
   end
+
+  def +(other)
+    Indocker::DSLContext.new(@storage.merge(other.storage))
+  end
 end

data/lib/indocker/envs/env_metadata.rb

@@ -18,6 +18,10 @@ module Indocker::Envs
       end
     end
 
+    def to_s
+      to_array.join(' ')
+    end
+
     def set(key:, value:)
       overwritten = @variables.has_key?(key) and @variables[key] != value
 

data/lib/indocker/errors.rb

@@ -1,5 +1,6 @@
 module Indocker::Errors         
   class ImageIsNotDefined                 < StandardError; end 
+  class ImageIsNotBuilded                 < StandardError; end 
   class PartialIsNotDefined               < StandardError; end 
   class ContainerIsNotDefined             < StandardError; end
   class CircularImageDependency           < StandardError; end
@@ -8,10 +9,13 @@ module Indocker::Errors
   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 ReservedKeywordUsed               < StandardError; end
+  class VolumeIsNotDefined                < StandardError; end
 
   class ContainerImageAlreadyDefined      < StandardError; end
   class NetworkAlreadyDefined             < StandardError; end
+  
+  class InvalidParams                     < StandardError; end
 end

data/lib/indocker/git/git_api.rb

@@ -0,0 +1,32 @@
+require 'git'
+
+class Indocker::Git::GitAPI
+  include SmartIoC::Iocify
+
+  bean :git_api
+
+  DEFAULT_REMOTE = 'origin'
+  
+  def get_remote_from_directory(dir)
+    Git.open(dir).remote(DEFAULT_REMOTE).url
+  rescue ArgumentError
+    nil
+  end
+
+  def fetch(dir)
+    Git.open(dir).pull
+  end
+
+  def clone(repository:, dir:)
+    dir = File.expand_path(dir)
+
+    git_path = File.dirname(dir)
+    app_name = File.basename(dir)
+
+    Git.clone(repository, app_name, path: git_path)
+  end
+
+  def checkout(revision:, dir:)
+    Git.open(dir).checkout(revision)
+  end
+end

data/lib/indocker/git/git_helper.rb

@@ -0,0 +1,34 @@
+module Indocker::Git
+  class GitHelper
+    include SmartIoC::Iocify
+
+    bean :git_helper
+
+    inject :config
+    inject :git_service
+
+    def method_missing(method, *args)
+      git_config    = config.git.send(method)
+      git_cache_dir = config.git.cache_dir.join(method.to_s)
+
+      return git_cache_dir if updated?(git_config.repository)
+
+      git_service.update(
+        repository: git_config.repository,
+        revision:   git_config.branch || git_config.tag,
+        workdir:    git_cache_dir
+      )
+      git_cache.push(git_config.repository)
+
+      Pathname.new(git_cache_dir)
+    end
+
+    def git_cache
+      @git_cache ||= []
+    end
+
+    def updated?(url)
+      git_cache.include?(url)
+    end
+  end
+end

data/lib/indocker/git/git_service.rb

@@ -0,0 +1,21 @@
+class Indocker::Git::GitService
+  include SmartIoC::Iocify
+
+  bean :git_service
+
+  inject :git_api
+
+  def update(repository:, revision:, workdir:)
+    workdir_repository = git_api.get_remote_from_directory(workdir)
+
+    if workdir_repository == repository
+      git_api.fetch(workdir)
+      git_api.checkout(revision: revision, dir: workdir)
+    else
+      FileUtils.rm_rf(workdir)
+      
+      git_api.clone(repository: repository, dir: workdir)
+      git_api.checkout(revision: revision, dir: workdir)
+    end
+  end
+end

data/lib/indocker/handlers/{run_container.rb → container_run.rb}

@@ -1,4 +1,4 @@
-class Indocker::Handlers::RunContainer < Indocker::Handlers::Base
+class Indocker::Handlers::ContainerRun
   include SmartIoC::Iocify
 
   bean   :run_container_handler
@@ -6,24 +6,15 @@ class Indocker::Handlers::RunContainer < Indocker::Handlers::Base
   inject :container_manager
   inject :container_metadata_repository
   inject :image_builder
-  inject :application_initializer
-  inject :docker_api
-  inject :logger
+
+  include Indocker::Handlers::Performable
 
   def handle(name:, current_path:)
     name = name.to_s
 
     container_metadata = container_metadata_repository.get_by_name(name)
-
-    if docker_api.container_exists?(name)
-      container_manager.stop(name)
-      container_manager.delete(name)
-    end
-    
     image_builder.build(container_metadata.repo, tag: container_metadata.tag)
     
-    container_manager.create(name)
-
-    container_manager.start(name)
+    container_manager.run(name)
   end
 end

data/lib/indocker/handlers/container_stop.rb

@@ -0,0 +1,17 @@
+class Indocker::Handlers::ContainerStop
+  include SmartIoC::Iocify
+  
+  bean   :stop_container_handler
+
+  inject :container_manager
+  inject :container_metadata_repository
+  inject :image_builder
+
+  include Indocker::Handlers::Performable
+
+  def handle(name:, current_path:)
+    name = name.to_s
+
+    container_manager.stop(name)
+  end
+end

data/lib/indocker/handlers/performable.rb

@@ -0,0 +1,22 @@
+module Indocker
+  module Handlers
+    module Performable
+      def self.included(klass)
+        klass.inject(:logger)
+        klass.inject(:application_initializer)
+      end
+
+      def perform(options)
+        env = options.delete(:env)
+
+        application_initializer.init_app(options[:current_path], env: env)
+
+        self.method(:handle).call(options)
+      rescue Docker::Error::ClientError => e
+        logger.error e.message
+      rescue Docker::Error::NotFoundError => e
+        logger.error(e.message)
+      end
+    end
+  end
+end

data/lib/indocker/image/image_builder.rb

@@ -6,31 +6,46 @@ class Indocker::ImageBuilder
   inject :image_metadata_repository
   inject :image_dependencies_manager
   inject :image_directives_runner
-  inject :image_evaluator
   inject :docker_api
   inject :logger
+  inject :image_dockerfile_builder
 
-  def build(repo, tag: Indocker::ImageMetadata::DEFAULT_TAG)
+  def build(repo, tag: Indocker::ImageHelper::DEFAULT_TAG)
     image_metadata = image_metadata_repository.find_by_repo(repo, tag: tag)
-    
+
     FileUtils.mkdir_p(image_metadata.build_dir)
     
     image_dependencies_manager.get_dependencies!(image_metadata).each do |dependency_metadata| 
       build(dependency_metadata.repo, tag: dependency_metadata.tag)
     end
-    
+
     image_directives_runner.run_all(image_metadata.prepare_directives)
 
     File.open(File.join(image_metadata.build_dir, Indocker::DOCKERFILE_NAME), 'w') do |f| 
-      f.puts       image_metadata.build_directives.map(&:to_s)
-      image_metadata.build_directives.map(&:to_s).each {|d| logger.debug d}
+      f.puts image_dockerfile_builder.build(*image_metadata.build_directives)
+
+      logger.debug image_dockerfile_builder.build(*image_metadata.build_directives)
     end
-    
+
+    File.open(File.join(image_metadata.build_dir, '.dockerignore'), 'w') do |f| 
+      f.puts '.git'
+      f.puts '.gitignore'
+      f.puts 'LICENSE'
+      f.puts 'VERSION'
+      f.puts 'README.md'
+      f.puts 'Changelog.md'
+      f.puts 'Makefile'
+      f.puts 'docker-compose.yml'
+      f.puts 'docs'
+    end
+
     docker_api.build_from_dir(
       repo:      image_metadata.repo,
       tag:       image_metadata.tag,
       build_dir: image_metadata.build_dir.to_s
     ) { |log| logger.info(log) }
+
+    image_directives_runner.run_all(image_metadata.after_build_directives)
   ensure
     image_metadata = image_metadata_repository.find_by_repo(repo, tag: tag)
 

data/lib/indocker/image/image_dependencies_manager.rb

@@ -3,7 +3,7 @@ class Indocker::ImageDependenciesManager
 
   bean   :image_dependencies_manager
 
-  inject :image_metadata_repository
+  inject :repository, ref: :image_metadata_repository
   inject :container_metadata_repository
   inject :image_evaluator
 
@@ -27,17 +27,21 @@ class Indocker::ImageDependenciesManager
     nil
   end
 
-  def get_dependencies(image_metadata)
-    container_dependencies = image_metadata.docker_cp_directives.map do |c|
+  def get_dependencies(meta)
+    dependencies = []
+
+    docker_cp_dependencies = meta.docker_cp_directives.map do |c|
       container = container_metadata_repository.get_by_name(c.container_name)
       
-      image_metadata_repository.find_by_repo(container.repo, tag: container.tag)
+      repository.find_by_repo(container.repo, tag: container.tag)
+    end
+
+    dependencies.concat(docker_cp_dependencies)
+
+    if !meta.dockerhub_image?
+      dependencies << repository.find_by_repo(meta.from_repo, tag: meta.from_tag)
     end
-    
-    return container_dependencies if image_metadata.dockerhub_image?
-    
-    from_image_dependency = image_metadata_repository.find_by_repo(image_metadata.from_repo, tag: image_metadata.from_tag)
 
-    container_dependencies.push from_image_dependency
+    dependencies.uniq
   end
 end

data/lib/indocker/image/image_directives_runner.rb

@@ -0,0 +1,99 @@
+class Indocker::ImageDirectivesRunner
+  include SmartIoC::Iocify
+
+  bean :image_directives_runner
+
+  inject :container_manager
+  inject :config
+  inject :render_util
+  inject :docker_api
+
+  def run_all(directives)
+    directives.each {|c| run(c)}
+  end
+
+  def run(directive)
+    case directive
+    when Indocker::ImageDirectives::DockerCp
+      run_docker_cp(directive)
+    when Indocker::ImageDirectives::Copy
+      run_copy(directive)
+    when Indocker::ImageDirectives::Registry
+      run_registry(directive)
+    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:   File.join(directive.build_dir, to)
+      )
+    end
+  end
+
+  def run_copy(directive)
+    directive.copy_actions.each do |from, _|
+      source      = File.exists?(from) ? from : File.join(directive.build_dir, from)
+      destination = File.join(directive.build_dir.to_s, from.to_s)
+
+      copy_compile_file(
+        from:    source,
+        to:      destination,
+        locals:  directive.locals,
+        compile: directive.compile
+      )
+    end
+  end
+
+  def run_registry(directive)
+    docker_api.tag(
+      repo:     directive.repo, 
+      tag:      directive.tag,
+      new_repo: directive.new_repo,
+      new_tag:  directive.new_tag
+    )
+    
+    docker_api.push(
+      repo:         directive.repo, 
+      tag:          directive.tag,
+      push_to_repo: directive.new_repo,
+      push_to_tag:  directive.new_tag
+    ) if directive.push
+  end
+
+  private
+
+  def copy_compile_file(from:, to:, locals: {}, compile: false)
+    raise ArgumentError, "Copy destination #{from} not exists" if !File.exists?(from)
+
+    if File.directory?(from)
+      Dir.glob(File.join(from, '**', '*'), File::FNM_DOTMATCH).each do |file_source_path|
+        next if File.directory?(file_source_path)
+
+        file_relative_path = Pathname.new(file_source_path).relative_path_from( Pathname.new(from) ).to_s
+        file_destination_path = File.join(to, file_relative_path)
+
+        copy_compile_file(
+          from:    file_source_path,
+          to:      file_destination_path,
+          locals:  locals,
+          compile: compile
+        )
+      end
+
+      return
+    end
+
+    if !Dir.exist?(File.dirname(to))
+      FileUtils.mkdir_p(File.dirname(to))
+    end
+
+    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/image/image_dockerfile_builder.rb

@@ -0,0 +1,24 @@
+class Indocker::ImageDockerfileBuilder
+  include SmartIoC::Iocify
+
+  bean :image_dockerfile_builder
+
+  inject :envs_loader
+
+  def build(*directives)
+    dockerfile_content = ""
+
+    dockerfile_content = directives.map do |directive|
+      case directive
+      when Indocker::ImageDirectives::EnvFile
+        env_metadata = envs_loader.parse(directive.path)
+
+        directive.to_s(env_metadata.to_s)
+      else
+        directive.to_s
+      end
+    end
+
+    dockerfile_content.join("\n")
+  end
+end