indocker 0.0.6 → 0.1.4

data/lib/indocker/image/image_builder.rb

@@ -1,54 +0,0 @@
-class Indocker::ImageBuilder
-  include SmartIoC::Iocify
-
-  bean   :image_builder
-  
-  inject :image_metadata_repository
-  inject :image_dependencies_manager
-  inject :image_directives_runner
-  inject :docker_api
-  inject :logger
-  inject :image_dockerfile_builder
-
-  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_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)
-
-    FileUtils.rm_rf(image_metadata.build_dir)
-  end
-end

data/lib/indocker/image/image_dependencies_manager.rb

@@ -1,47 +0,0 @@
-class Indocker::ImageDependenciesManager
-  include SmartIoC::Iocify
-
-  bean   :image_dependencies_manager
-
-  inject :repository, ref: :image_metadata_repository
-  inject :container_metadata_repository
-  inject :image_evaluator
-
-  def get_dependencies!(image_metadata)
-    check_circular_dependencies!(image_metadata)
-
-    get_dependencies(image_metadata)
-  end
-
-  private
-
-  def check_circular_dependencies!(image_metadata, used_images = [])
-    raise Indocker::Errors::CircularImageDependency if used_images.include?(image_metadata.full_name)
-
-    used_images.push(image_metadata.full_name)
-
-    get_dependencies(image_metadata).each do |dependency|
-      check_circular_dependencies!(dependency, used_images)
-    end
-
-    nil
-  end
-
-  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)
-      
-      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
-
-    dependencies.uniq
-  end
-end

data/lib/indocker/image/image_directives_runner.rb

@@ -1,99 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

data/lib/indocker/image/image_dsl.rb

@@ -1,89 +0,0 @@
-class Indocker::ImageDSL
-  attr_reader :directives
-
-  def initialize(context)
-    @context  = context
-    @directives = []
-  end
-
-  def method_missing(method, *args)
-    @context.send(method)
-  rescue
-    super
-  end
-
-  def set_arg(key, value)
-    @context.set_value(key, value)
-  end
-
-  def partial(name, opts = {})
-    @directives << Indocker::Directives::Partial.new(name, @context, opts)
-  end
-
-  def expose(port)
-    @directives << Indocker::ImageDirectives::Expose.new(port)
-  end
-  
-  def from(*args)
-    first_from_directive = @directives.detect {|c| c.instance_of?(Indocker::ImageDirectives::From)}
-    raise Indocker::Errors::DirectiveAlreadyInUse, first_from_directive if first_from_directive
-
-    @directives << Indocker::ImageDirectives::From.new(*args)
-  end
-
-  def use(item)
-    case item
-    when Indocker::Registry::RegistryHelper
-      first_from_directive = @directives.detect {|c| c.instance_of?(Indocker::ImageDirectives::Registry)}
-      raise Indocker::Errors::DirectiveAlreadyInUse, first_from_directive if first_from_directive
-
-      @directives << Indocker::ImageDirectives::Registry.new(
-        repo:     repo,
-        tag:      tag,
-        registry: item.registry, 
-        push:     item.push
-      )
-    end
-  end
-  
-  def workdir(*args)
-    @directives << Indocker::ImageDirectives::Workdir.new(*args)
-  end
-
-  def run(*args)
-    @directives << Indocker::ImageDirectives::Run.new(*args)
-  end
-
-  def cmd(*args)
-    @directives << Indocker::ImageDirectives::Cmd.new(*args)
-  end
-
-  def copy(copy_actions = {}, compile = false)
-    @directives << Indocker::ImageDirectives::Copy.new(
-      compile:      compile,
-      copy_actions: copy_actions,
-      locals:       @context.storage,
-      build_dir:    @context.build_dir
-    )
-  end
-
-  def entrypoint(*args)
-    @directives << Indocker::ImageDirectives::Entrypoint.new(*args)
-  end
-
-  def env(*args)
-    @directives << Indocker::ImageDirectives::Env.new(args)
-  end
-
-  def env_file(*paths)
-    @directives.concat paths.map {|p| Indocker::ImageDirectives::EnvFile.new(p)}
-  end
-
-  def before_build(&block)
-    instance_exec &block
-  end
-
-  def docker_cp(container_name, &block)
-    @directives << Indocker::ImageDirectives::DockerCp.new(container_name, @context.build_dir, &block)
-  end
-end

data/lib/indocker/image/image_evaluator.rb

@@ -1,21 +0,0 @@
-class Indocker::ImageEvaluator
-  include SmartIoC::Iocify
-
-  bean   :image_evaluator
-  inject :partial_metadata_repository
-
-  def evaluate(context, &block)
-    image_dsl = Indocker::ImageDSL.new(context)
-    
-    image_dsl.instance_eval(&block)
-    
-    image_dsl.directives
-      .map do |directive|
-        next directive if !directive.partial_directive?
-
-        partial = partial_metadata_repository.find_by_name(directive.name)
-        evaluate(directive.context, &partial.definition)
-      end
-      .flatten
-  end
-end

data/lib/indocker/image/image_helper.rb

@@ -1,9 +0,0 @@
-module Indocker::ImageHelper
-  DEFAULT_TAG = 'latest'
-
-  def full_name(repo, tag = nil)
-    tag ||= DEFAULT_TAG
-
-    "#{repo}:#{tag}"
-  end
-end

data/lib/indocker/image/image_metadata.rb

@@ -1,50 +0,0 @@
-class Indocker::ImageMetadata
-  include Indocker::ImageHelper
-
-  attr_reader :repo, :tag, :directives, :build_dir
-
-  def initialize(repo:, tag:, directives:, build_dir:)
-    @repo       = repo
-    @tag        = tag
-    @directives = directives
-    @build_dir  = build_dir
-  end
-
-  def full_name
-    super(@repo, @tag)
-  end
-
-  def prepare_directives
-    directives.select {|d| d.prepare_directive?}
-  end
-
-  def after_build_directives
-    directives.select {|d| d.after_build_directive?}
-  end
-
-  def build_directives
-    directives.select {|d| d.build_directive?}
-  end
-
-  def docker_cp_directives
-    directives.select {|d| d.is_a?(Indocker::ImageDirectives::DockerCp)}
-  end
-
-  def from_repo
-    from_directive.repo
-  end
-
-  def from_tag
-    from_directive.tag
-  end
-
-  def dockerhub_image?
-    from_directive.dockerhub_image?
-  end
-
-  private
-
-  def from_directive
-    @directives.detect {|c| c.instance_of?(Indocker::ImageDirectives::From)}
-  end
-end

data/lib/indocker/image/image_metadata_factory.rb

@@ -1,31 +0,0 @@
-class Indocker::ImageMetadataFactory
-  include Indocker::ImageHelper
-  include SmartIoC::Iocify
-
-  bean   :image_metadata_factory
-  
-  inject :image_evaluator
-  inject :docker_api
-  inject :config
-  inject :git_helper
-  inject :registry_service
-
-  def create(repo, tag: Indocker::ImageHelper::DEFAULT_TAG, &definition)
-    context = Indocker::DSLContext.new(
-      build_dir:  config.build_dir.join(repo.to_s),
-      git:        git_helper,
-      repo:       repo,
-      tag:        tag,
-      registry:   registry_service
-    )
-    
-    directives = image_evaluator.evaluate(context, &definition)
-
-    Indocker::ImageMetadata.new(
-      repo:       repo.intern,
-      tag:        tag.intern,
-      directives: directives,
-      build_dir:  config.build_dir.join(repo.to_s)
-    )
-  end
-end

data/lib/indocker/image/image_metadata_repository.rb

@@ -1,29 +0,0 @@
-class Indocker::ImageMetadataRepository
-  include SmartIoC::Iocify
-  include Indocker::ImageHelper
-  
-  bean :image_metadata_repository
-
-  def put(image_metadata)
-    all.push(image_metadata)
-  end
-
-  def find_by_full_name(image_metadata_full_name)
-    image_metadata = all.detect { |image_metadata| image_metadata.full_name == image_metadata_full_name }
-    raise Indocker::Errors::ImageIsNotDefined, image_metadata_full_name if image_metadata.nil?
-
-    image_metadata
-  end
-
-  def find_by_repo(repo, tag: nil)
-    find_by_full_name(full_name(repo, tag))
-  end
-
-  def clear
-    @all = []
-  end
-
-  def all
-    @all ||= []
-  end
-end