indocker 0.0.0 → 0.0.1

data/lib/indocker/handlers/base.rb

@@ -0,0 +1,13 @@
+module Indocker::Handlers
+  class Base 
+    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)
+    end
+  end
+end

data/lib/indocker/handlers/run_container.rb

@@ -0,0 +1,29 @@
+class Indocker::Handlers::RunContainer < Indocker::Handlers::Base
+  include SmartIoC::Iocify
+
+  bean   :run_container_handler
+  
+  inject :container_manager
+  inject :container_metadata_repository
+  inject :image_builder
+  inject :application_initializer
+  inject :docker_api
+  inject :logger
+
+  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)
+  end
+end

data/lib/indocker/image/image_builder.rb

@@ -0,0 +1,39 @@
+class Indocker::ImageBuilder
+  include SmartIoC::Iocify
+
+  bean   :image_builder
+  
+  inject :image_metadata_repository
+  inject :image_dependencies_manager
+  inject :image_directives_runner
+  inject :image_evaluator
+  inject :docker_api
+  inject :logger
+
+  def build(repo, tag: Indocker::ImageMetadata::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}
+    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) }
+  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

@@ -0,0 +1,43 @@
+class Indocker::ImageDependenciesManager
+  include SmartIoC::Iocify
+
+  bean   :image_dependencies_manager
+
+  inject :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(image_metadata)
+    container_dependencies = image_metadata.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)
+    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
+  end
+end

data/lib/indocker/image/image_dsl.rb

@@ -0,0 +1,69 @@
+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 from(*args)
+    @directives << Indocker::DockerDirectives::From.new(*args)
+  end
+  
+  def workdir(*args)
+    @directives << Indocker::DockerDirectives::Workdir.new(*args)
+  end
+
+  def run(*args)
+    @directives << Indocker::DockerDirectives::Run.new(*args)
+  end
+
+  def cmd(*args)
+    @directives << Indocker::DockerDirectives::Cmd.new(*args)
+  end
+
+  def copy(copy_actions)
+    @directives << Indocker::DockerDirectives::Copy.new(
+      context:      @context, 
+      copy_actions: copy_actions
+    )
+  end
+
+  def copy_compile(copy_actions)
+    @directives << Indocker::DockerDirectives::Copy.new(
+      context:      @context, 
+      copy_actions: copy_actions,
+      compile:      true
+    )
+  end
+
+  def entrypoint(*args)
+    @directives << Indocker::DockerDirectives::Entrypoint.new(*args)
+  end
+
+  def env(*args)
+    @directives << Indocker::DockerDirectives::Env.new(args)
+  end
+
+  def before_build(&block)
+    instance_exec &block
+  end
+
+  def docker_cp(container_name, &block)
+    @directives << Indocker::PrepareDirectives::DockerCp.new(container_name, @context.build_dir, &block)
+  end
+end

data/lib/indocker/image/image_evaluator.rb

@@ -0,0 +1,21 @@
+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?
+
+        partial = partial_metadata_repository.find_by_name(directive.name)
+        evaluate(directive.context, &partial.definition)
+      end
+      .flatten
+  end
+end

data/lib/indocker/image/image_metadata.rb

@@ -0,0 +1,50 @@
+class Indocker::ImageMetadata
+  DEFAULT_TAG = 'latest'
+
+  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
+    "#{repo}:#{tag}"
+  end
+
+  def full_name_with_registry
+    "#{Indocker.config.registry}/#{local_full_name}"
+  end
+
+  def prepare_directives
+    directives.select {|d| d.prepare_directive?}
+  end
+
+  def build_directives
+    directives.select {|d| d.build_directive?}
+  end
+
+  def docker_cp_directives
+    directives.select {|d| d.is_a?(Indocker::PrepareDirectives::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::DockerDirectives::From)}
+  end
+end

data/lib/indocker/image/image_metadata_factory.rb

@@ -0,0 +1,30 @@
+class Indocker::ImageMetadataFactory
+  include SmartIoC::Iocify
+
+  bean   :image_metadata_factory
+  
+  inject :image_evaluator
+  inject :docker_api
+  inject :config
+
+  def create(repo, tag: Indocker::ImageMetadata::DEFAULT_TAG, &definition)
+    context = Indocker::DSLContext.new(
+      build_dir: build_dir(repo),
+      root_dir:  config.root
+    )
+    directives = image_evaluator.evaluate(context, &definition)
+
+    Indocker::ImageMetadata.new(
+      repo:       repo.intern,
+      tag:        tag.intern,
+      directives: directives,
+      build_dir:  build_dir(repo)
+    )
+  end
+
+  private
+
+  def build_dir(name)
+    Pathname.new File.join(config.root, Indocker::BUILD_DIR, name.to_s)
+  end
+end

data/lib/indocker/image/image_metadata_repository.rb

@@ -0,0 +1,30 @@
+class Indocker::ImageMetadataRepository
+  include SmartIoC::Iocify
+  
+  bean :image_metadata_repository
+
+  def put(image_metadata)
+    all.push(image_metadata)
+  end
+
+  def find_by_repo(repo, tag: Indocker::ImageMetadata::DEFAULT_TAG)
+    image_metadata = all.detect { |im| im.repo == repo.intern and im.tag == tag.intern }
+    raise Indocker::Errors::ImageIsNotDefined, "#{repo}:#{tag}" if image_metadata.nil?
+
+    image_metadata
+  end
+
+  def clear
+    @all = []
+  end
+
+  def all
+    @all ||= []
+  end
+
+  def method_missing(method, **args)
+    tag = args[:tag] || Indocker::ImageMetadata::DEFAULT_TAG
+
+    find_by_repo(method, tag: tag)
+  end
+end

data/lib/indocker/networks/network_metadata.rb

@@ -0,0 +1,9 @@
+module Indocker::Networks
+  class NetworkMetadata
+    attr_reader :name
+    
+    def initialize(name)
+      @name = name
+    end
+  end
+end

data/lib/indocker/networks/network_metadata_factory.rb

@@ -0,0 +1,9 @@
+class Indocker::Networks::NetworkMetadataFactory
+  include SmartIoC::Iocify
+
+  bean :network_metadata_factory
+
+  def create(name)
+    Indocker::Networks::NetworkMetadata.new(name.to_s)
+  end
+end

data/lib/indocker/networks/network_metadata_repository.rb

@@ -0,0 +1,34 @@
+class Indocker::Networks::NetworkMetadataRepository
+  include SmartIoC::Iocify
+
+  bean :network_metadata_repository
+  
+  def put(network_metadata)
+    if all.any? {|n| n.name == network_metadata.name}
+      raise Indocker::Errors::NetworkAlreadyDefined, network_metadata.name 
+    end
+
+    all.push(network_metadata)
+  end
+
+  def find_by_name(name)
+    network_metadata = @all.detect {|network| network.name == name.to_s}
+    raise Indocker::Errors::NetworkIsNotDefined unless network_metadata
+
+    network_metadata
+  end
+
+  def clear
+    @all = []
+  end
+
+  def all
+    @all ||= []
+  end
+
+  def method_missing(method)
+    find_by_name(method)
+  rescue 
+    super
+  end
+end

data/lib/indocker/partial/partial_metadata.rb

@@ -0,0 +1,8 @@
+class Indocker::PartialMetadata
+  attr_reader :name, :definition
+
+  def initialize(name, &definition)
+    @name       = name
+    @definition = definition
+  end
+end

data/lib/indocker/partial/partial_metadata_repository.rb

@@ -0,0 +1,26 @@
+class Indocker::PartialMetadataRepository
+  include SmartIoC::Iocify
+  
+  bean :partial_metadata_repository
+
+  def put(partial_metadata)
+    all.push(partial_metadata)
+  end
+
+  def find_by_name(name)
+    partial = all.detect do |p| 
+      p.name == name
+    end
+    raise Indocker::Errors::PartialIsNotDefined, name if partial.nil?
+
+    partial
+  end
+
+  def clear
+    @all = []
+  end
+
+  def all
+    @all ||= []
+  end
+end

data/lib/indocker/utils/ioc_container.rb

@@ -0,0 +1,17 @@
+require 'smart_ioc'
+
+class IocContainer
+  class << self
+    def [](meth, *args)
+      SmartIoC::Container.get_instance.get_bean(meth, *args)
+    end
+  end
+
+  def self.method_missing(meth, *args, &block)
+    SmartIoC::Container.get_instance.get_bean(meth, *args)
+  end
+end
+
+def ioc
+  IocContainer
+end

data/lib/indocker/utils/logger.rb

@@ -0,0 +1,62 @@
+require 'logger'
+require 'colorize'
+
+class Indocker::Logger < Logger
+  def initialize(*)
+    super
+    @formatter = IndockerLoggerFormatter.new
+  end
+
+  def clear
+    # do nothing
+  end
+end
+
+
+class Indocker::TestLogger < Indocker::Logger
+  attr_reader :strio
+
+  def initialize
+    @strio = StringIO.new
+    super(@strio)
+  end
+
+  def messages
+    @strio.string.split("\n")
+  end
+
+  def clear
+    @strio.string.clear
+  end
+end
+
+class IndockerLoggerFormatter
+  DEBUG = 'DEBUG'
+  ERROR = 'ERROR'
+  FATAL = 'FATAL'
+  WARN  = 'WARN'
+  INFO  = 'INFO'
+
+  def call(severity, datetime, progname, msg)
+    "#{colorize_log_level(severity)}: #{msg}\n"
+  end
+
+  private
+
+  def colorize_log_level(severity)
+    case severity
+    when DEBUG
+      severity.colorize(:grey)
+    when ERROR
+      severity.colorize(:red)
+    when FATAL
+      severity.colorize(:dark_red)
+    when WARN
+      severity.colorize(:white)
+    when INFO
+      severity.colorize(:green)
+    else
+      severity.colorize(:white)
+    end
+  end
+end

data/lib/indocker/utils/logger_factory.rb

@@ -0,0 +1,12 @@
+class Indocker::LoggerFactory
+  include SmartIoC::Iocify
+
+  bean :logger, factory_method: :build
+
+  def build
+    Indocker::Logger.new(STDOUT)
+  end
+end
+
+
+

data/lib/indocker/utils/registry_authenticator.rb

@@ -0,0 +1,19 @@
+class Indocker::RegistryAvaliabilityChecker
+  include SmartIoC::Iocify
+
+  bean :registry_authenticator
+
+  inject :config
+  inject :docker_api
+
+  def authenticate!
+    docker_api.authenticate!(
+      serveraddress: config.docker.registry,
+      username:      config.docker.username,
+      email:         config.docker.email,
+      password:      config.docker.password
+    )
+  rescue Docker::Error::AuthenticationError
+    raise Indocker::Errors::DockerRegistryAuthenticationError
+  end
+end

data/lib/indocker/utils/render_namespace.rb

@@ -0,0 +1,11 @@
+class Indocker::Utils::RenderNamespace
+  def initialize(hash)
+    hash.each do |key, value|
+      singleton_class.send(:define_method, key) { value }
+    end
+  end
+
+  def get_binding
+    binding
+  end
+end

data/lib/indocker/utils/render_util.rb

@@ -0,0 +1,15 @@
+require 'erb'
+
+module Indocker::Utils
+  class RenderUtil
+    include SmartIoC::Iocify
+
+    bean :render_util
+
+    def render(template, locals)
+      namespace = Indocker::Utils::RenderNamespace.new(locals)
+
+      ERB.new(template).result(namespace.get_binding)
+    end
+  end
+end

data/lib/indocker/utils/string_utils.rb

@@ -0,0 +1,11 @@
+class Indocker::StringUtils
+  def self.underscore(word)
+    word = word.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+end

data/lib/indocker/utils/tar_helper.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'rubygems/package'
+require 'zlib'
+require 'fileutils'
+
+class Indocker::TarHelper
+  include SmartIoC::Iocify
+
+  bean :tar_helper
+
+  def untar(io:, destination:, ignore_wrap_directory: false)
+    files_list = []
+
+    Gem::Package::TarReader.new io do |tar|
+      tar.each do |tarfile|
+        if ignore_wrap_directory
+          tarfile_full_name = tarfile.full_name.split('/')[1..-1].join('/')
+        else 
+          tarfile_full_name = tarfile.full_name
+        end
+
+        destination_file = File.join destination, tarfile_full_name
+        
+        if tarfile.directory?
+          FileUtils.mkdir_p destination_file
+        else
+          files_list.push(tarfile_full_name)
+
+          destination_directory = File.dirname(destination_file)
+          FileUtils.mkdir_p destination_directory unless File.directory?(destination_directory)
+          File.open destination_file, "wb" do |f|
+            f.print tarfile.read
+          end
+        end
+      end
+    end
+
+    files_list
+  end
+end

data/lib/indocker/utils/test_logger_factory.rb

@@ -0,0 +1,9 @@
+class Indocker::TestLoggerFactory
+  include SmartIoC::Iocify
+
+  bean :logger, context: :test, factory_method: :build
+
+  def build
+    Indocker::TestLogger.new
+  end
+end

data/lib/indocker/version.rb

@@ -1,3 +1,3 @@
-module InDocker
-  VERSION = '0.0.0'.freeze
+module Indocker
+  VERSION = '0.0.1'.freeze
 end