indocker 0.0.6 → 0.1.0

data/bin/indocker

@@ -1,9 +0,0 @@
-#!/usr/bin/env ruby
-# -*- encoding: utf-8 -*-
-
-require 'rubygems'
-require 'bundler/setup'
-require 'indocker'
-
-# $thor_runner = true
-Indocker::CLI::Application.start( ARGV )

data/lib/indocker/application_initializer.rb

@@ -1,19 +0,0 @@
-class Indocker::ApplicationInitializer
-  include SmartIoC::Iocify
-
-  bean :application_initializer
-
-  inject :config_locator
-  inject :docker_api
-  inject :registry_authenticator
-  inject :config
-
-
-  def init_app(current_path, env: :development)
-    docker_api.check_docker_installed!
-
-    require(config_locator.locate(current_path))
-
-    # registry_authenticator.authenticate!()
-  end
-end

data/lib/indocker/cli.rb

@@ -1,27 +0,0 @@
-require 'thor'
-
-module Indocker
-  module CLI
-    class Application < Thor
-      desc   "container:run CONTAINER_NAME", "runs specified container"
-      option :env
-      define_method('container:run') do |name, env = :development|
-        ioc.run_container_handler.perform(
-          name:         name,
-          current_path: Dir.pwd,
-          env:          env
-        )
-      end
-
-      desc   "container:stop CONTAINER_NAME", "stops specified container"
-      option :env
-      define_method('container:stop') do |name, env = :development|
-        ioc.stop_container_handler.perform(
-          name:         name,
-          current_path: Dir.pwd,
-          env:          env
-        )
-      end
-    end
-  end
-end

data/lib/indocker/configs/config.rb

@@ -1,147 +0,0 @@
-module Indocker::Configs
-  class Config
-    attr_reader :scope
-
-    def scope
-      @scope ||= Hash.new()
-    end
-
-    def options
-      scope.reject {|_, opt| opt.is_a?(Indocker::Configs::Config)}.keys
-    end
-
-    def configs
-      scope.select {|_, opt| opt.is_a?(Indocker::Configs::Config)}.keys
-    end
-
-    def set(&block)
-      instance_exec(&block)
-
-      self
-    end
-
-    def option(name, group: nil, type: nil, required: nil)
-      raise Indocker::Errors::ReservedKeywordUsed, name if respond_to?(name.to_sym)
-
-      define_singleton_method(name) do |value = nil, &block|
-        if type == :config and options.include?(name) and block
-          return read_setting(name).set(&block)
-        end
-
-        if block || value
-          write_setting(
-            name:        name, 
-            value:       block || value, 
-            group:       group, 
-            type:        type, 
-            required:    required
-          )
-        else
-          read_setting(name)
-        end
-      end
-    end
-
-    def config(name, group: :default, &block)
-      raise Indocker::Errors::ReservedKeywordUsed, name if respond_to?(name.to_sym)
-
-      subconfiguration = Indocker::Configs::Config.new
-      subconfiguration.instance_exec(&block)
-  
-      option(name, group: group, type: :config)
-      send(name, subconfiguration)
-
-      subconfiguration
-    end
-
-    def hash_config(hash_config_name, group: :default, &hash_config_block)
-      raise Indocker::Errors::ReservedKeywordUsed, hash_config_name if respond_to?(hash_config_name.to_sym)
-
-      define_singleton_method(hash_config_name) do |name, &self_block|
-        config = config(name, &hash_config_block)
-        config.set(&self_block)
-        
-        config
-      end
-    end
-
-    private
-
-    def read_setting(name)
-      read_value = scope.has_key?(name.intern) ? scope[name.intern].value : nil
-      
-      read_value.is_a?(Proc) ? read_value.call : read_value
-    end
-
-    def write_setting(name:, value:, group:, type:, required:)
-      new_option = Option.new(
-        name:     name,
-        value:    value,
-        group:    group,
-        required: required,
-        type:     type
-      )
-
-      new_option.validate!
-
-      scope[name.intern] = new_option
-    end
-
-
-    def method_missing(method, *args, &block)
-      raise "Undefined keyword #{method.inspect} for Indocker configuration file"
-    end
-  end
-
-  class Option
-    attr_reader :value, :required, :type, :group
-
-    def initialize(name:, value:, required: nil, type: nil, group: nil)
-      @name     = name
-      @value    = value
-      @required = required || false
-      @type     = type     || :string
-      @group    = group    || :default
-    end
-
-    def validate!
-      check_required
-      check_type
-    end
-
-    private
-
-    def check_required
-      if @required && @value.nil?
-        raise Indocker::Errors::ConfigInitializationError, 
-          "Configuration option :#{option} is required"
-      end
-    end
-
-    def check_type
-      value_type = cast_class_to_type(@value)
-      
-      if @type != value_type
-        raise Indocker::Errors::ConfigOptionTypeMismatch, 
-          "Expected option #{@name.inspect} => #{@value.inspect} to be a #{@type.inspect}, not a #{value_type.inspect}"
-      end
-
-      nil
-    end
-
-    def cast_class_to_type(value)
-      case value
-      when Proc
-        cast_class_to_type(value.call)
-      when TrueClass
-        :boolean
-      when FalseClass
-        :boolean
-      when Indocker::Configs::Config
-        :config
-      else
-        Indocker::StringUtils.underscore(value.class.name).to_sym
-      end
-    end
-  end
-end

data/lib/indocker/configs/config_factory.rb

@@ -1,37 +0,0 @@
-class Indocker::Configs::ConfigFactory
-  include SmartIoC::Iocify
-
-  bean :config, factory_method: :build
-
-  CONFIG_STRUCTURE = Proc.new do
-    option :namespace, group: :common, type: :symbol
-    option :build_dir, group: :common, type: :pathname
-
-    option :load_env_file,      group: :load, type: :array
-    option :load_docker_items,  group: :load, type: :array
-
-    config :git, group: :git do
-      option :cache_dir, group: :common, type: :pathname
-    
-      hash_config :repo do
-        option :repository
-        option :tag
-        option :branch
-      end
-    end
-
-    config :docker, group: :docker do
-      hash_config :registry do
-        option :serveraddress, required: true
-        option :email
-        option :password
-        option :username
-        option :skip_push, type: :boolean
-      end
-    end
-  end
-
-  def build(&block)    
-    @configuration ||= Indocker::Configs::Config.new.set(&CONFIG_STRUCTURE)
-  end
-end

data/lib/indocker/configs/config_initializer.rb

@@ -1,9 +0,0 @@
-class Indocker::Configs::ConfigInitializer
-  include SmartIoC::Iocify
-  
-  bean :config_initializer
-
-  def initialize
-    
-  end
-end

data/lib/indocker/configs/locator.rb

@@ -1,23 +0,0 @@
-class Indocker::Configs::Locator
-  include SmartIoC::Iocify
-
-  bean :config_locator
-
-  ROOT = '/'
-
-  def locate(path)
-    expand_path = potential_config_file File.expand_path(path)
-    
-    return expand_path if File.exists?(expand_path)
-    
-    raise Indocker::Errors::ConfigFilesDoesNotFound if path == ROOT
-
-    locate(File.dirname(path))
-  end
-
-  private
-
-  def potential_config_file(path)
-    File.join(path, '.indocker', 'config.rb')
-  end
-end

data/lib/indocker/container/container_builder.rb

@@ -1,29 +0,0 @@
-class Indocker::ContainerBuilder
-  include SmartIoC::Iocify
-  
-  bean :container_builder
-
-  inject :container_metadata_repository
-  inject :envs_loader
-  inject :config
-
-  def build(name)
-    container_metadata = container_metadata_repository.get_by_name(name)
-        
-    env_metadata = container_metadata.env_files.inject(Indocker::Envs::EnvMetadata.new) do |all, path|
-      all += envs_loader.parse(path)
-    end
-
-    Indocker::DockerAPI::ContainerConfig.new(
-      name:          name, 
-      repo:          container_metadata.repo, 
-      tag:           container_metadata.tag,
-      exposed_ports: container_metadata.exposed_ports,
-      port_bindings: container_metadata.port_bindings,
-      cmd:           container_metadata.command,
-      volumes:       container_metadata.volumes,
-      binds:         container_metadata.binds,
-      env:           env_metadata.to_array + container_metadata.envs
-    )
-  end
-end

data/lib/indocker/container/container_directives_runner.rb

@@ -1,54 +0,0 @@
-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)
-    when Indocker::ContainerDirectives::Volume
-      run_volume(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
-
-  def run_volume(directive)
-    if !docker_api.volume_exists?(directive.name)
-      docker_api.create_volume(directive.name)
-    end
-  end
-end

data/lib/indocker/container/container_dsl.rb

@@ -1,83 +0,0 @@
-class Indocker::ContainerDSL
-  attr_reader :directives
-
-  def initialize(context)
-    @context  = context
-    @directives = []
-  end
-
-  def method_missing(method, *args)
-    @context.send(method)
-  rescue
-    super
-  end
-
-  private
-
-  def use(item)
-    case item
-    when Indocker::ImageMetadata
-      from_directive = @directives.detect {|d| d.instance_of?(Indocker::ContainerDirectives::From)}
-      raise Indocker::Errors::ContainerImageAlreadyDefined, from_directive.image if from_directive
-        
-      @directives << Indocker::ContainerDirectives::From.new(item.repo, tag: item.tag)
-    when Indocker::Networks::NetworkMetadata
-      @directives << Indocker::ContainerDirectives::Network.new(
-        container_name: @context.container_name,
-        network_name:   item.name
-      )
-    when Indocker::Volumes::VolumeMetadata
-      @directives << Indocker::ContainerDirectives::Volume.new(
-        volume_name: item.name
-      ) 
-    end
-  end
-
-  # TODO: Add contract
-  def mount(volume, to:)
-    @directives << Indocker::ContainerDirectives::Volume.new(
-      name: volume.name,
-      to:   to
-    ) 
-  end
-
-  def cmd(command)
-    first_cmd_directive = @directives.detect {|c| c.instance_of?(Indocker::ContainerDirectives::Cmd)}
-    raise Indocker::Errors::DirectiveAlreadyInUse, first_cmd_directive if first_cmd_directive
-
-    @directives << Indocker::ContainerDirectives::Cmd.new(command)
-  end
-
-  def env_file(path)
-    @directives << Indocker::ContainerDirectives::EnvFile.new(path)
-  end
-
-  def env(env_string)
-    @directives << Indocker::ContainerDirectives::Env.new(env_string)
-  end
-
-  def expose(port)
-    @directives << Indocker::ContainerDirectives::Expose.new(path)
-  end
-
-  def ports(ports)
-    container_port, host_port = ports.split(':').map(&:strip)
-
-    @directives << Indocker::ContainerDirectives::Ports.new(
-      container_port: container_port, 
-      host_port:      host_port
-    )
-  end
-
-  def depends_on(container_metadata)
-    @directives << Indocker::ContainerDirectives::DependsOn.new(container_metadata.name)
-  end
-
-  def ready(sleep:, timeout:, &ready_block)
-    @directives << Indocker::ContainerDirectives::Ready.new(
-      sleep:       sleep,
-      timeout:     timeout,
-      ready_block: ready_block
-    )
-  end
-end