indocker 0.0.2 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fdb2662214284a258402e89353e394035152a7c7
-  data.tar.gz: 783bc54b20a2d70d7382b3d9f7822ff07b5f15a8
+  metadata.gz: bbe4627a9f936ec5d771857d794648c14cb5ebf8
+  data.tar.gz: 58d394820260d8b77bddbd87c72d56df2682c317
 SHA512:
-  metadata.gz: 4d614dd32a0202080dafb6f9d6469fb1a8158804ba86a58556c6c74f1f1a5d7ebab8941a658696752bde584893c507d0dd85f59eece3a7b57472fe18d4b62e98
-  data.tar.gz: 3d6cd30433a7c2173633b30b730783d32f43b2869310f678fe404ad11c47da2386491b6ec2b5484e24372245df9a891cdf50e313e0ff60951b4e847d256b5bf8
+  metadata.gz: d57be13657ee31659a52d4adcec2deec04e12ee2f6b8e9f2addfbc3483c4e59410b551fd13416f35607c38e4c576639fa119f30b16b1369d7b717949e529888f
+  data.tar.gz: d4e51c196fb6ea6532f957bef347f0f6c01e92cf383ded6b902c6fb467525c271fa5b8cd8e2d51ecca7a0c5fcbc87624c6bcbb4e40c25b1dedce1fe0ddffb51b

data/Gemfile.lock

@@ -1,9 +1,12 @@
 PATH
   remote: .
   specs:
-    indocker (0.0.0)
+    indocker (0.0.5)
+      byebug
       colorize
       docker-api
+      docker_registry2
+      git
       smart_ioc
       thor
 
@@ -12,13 +15,45 @@ GEM
   specs:
     byebug (9.1.0)
     colorize (0.8.1)
-    docker-api (1.33.6)
-      excon (>= 0.38.0)
-      json
+    diff-lcs (1.3)
+    docker-api (1.34.0)
+      excon (>= 0.47.0)
+      multi_json
+    docker_registry2 (1.3.0)
+      rest-client (>= 1.8.0)
+    domain_name (0.5.20170404)
+      unf (>= 0.0.5, < 1.0.0)
     excon (0.59.0)
-    json (2.1.0)
+    git (1.3.0)
+    http-cookie (1.0.3)
+      domain_name (~> 0.5)
+    mime-types (3.1)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2016.0521)
+    multi_json (1.12.2)
+    netrc (0.11.0)
+    rest-client (2.0.2)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 4.0)
+      netrc (~> 0.8)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
     smart_ioc (0.2.1)
     thor (0.20.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.4)
 
 PLATFORMS
   ruby
@@ -26,6 +61,7 @@ PLATFORMS
 DEPENDENCIES
   byebug
   indocker!
+  rspec
 
 BUNDLED WITH
-   1.15.4
+   1.16.0.pre.3

data/bin/indocker

@@ -3,7 +3,7 @@
 
 require 'rubygems'
 require 'bundler/setup'
-require 'indocker'
+require_relative '../lib/indocker'
 
 # $thor_runner = true
 Indocker::CLI::Application.start( ARGV )

data/indocker.gemspec

@@ -13,11 +13,15 @@ Gem::Specification.new do |s|
   s.test_files  = s.files.grep(%r{^(spec)/})
 
   s.add_development_dependency "byebug"
+  s.add_development_dependency "rspec"
   
   s.add_dependency "smart_ioc"
   s.add_dependency "docker-api"
+  s.add_dependency "docker_registry2"
   s.add_dependency "thor"
   s.add_dependency "colorize"
+  s.add_dependency "git"
+  s.add_dependency "byebug" # TODO: remove after release
 
   s.homepage    = 'https://github.com/droidlabs/indocker'
   s.license     = 'MIT'

data/lib/indocker/application_initializer.rb

@@ -6,25 +6,14 @@ class Indocker::ApplicationInitializer
   inject :config_locator
   inject :docker_api
   inject :registry_authenticator
-  inject :envs_manager
   inject :config
 
 
   def init_app(current_path, env: :development)
     docker_api.check_docker_installed!
 
-    config.root(
-      Pathname.new(
-        File.expand_path(
-          File.join(config_locator.locate(current_path), '../..')
-        )
-      )
-    )
-
     require(config_locator.locate(current_path))
 
-    registry_authenticator.authenticate!
-
-    envs_manager.load_init_application_env_variables
+    # registry_authenticator.authenticate!()
   end
 end

data/lib/indocker/cli.rb

@@ -12,6 +12,16 @@ module Indocker
           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,21 +1,41 @@
 module Indocker::Configs
   class Config
+    attr_reader :scope
+
     def scope
-      @scope ||= Hash.new({})
+      @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: :default, type: :string)
-      define_singleton_method(name) do |value = nil, &block|
-        write_value = block || value
+    def option(name, group: nil, type: nil, required: nil)
+      raise Indocker::Errors::ReservedKeywordUsed, name if respond_to?(name.to_sym)
 
-        if write_value
-          validate!(name, write_value, type)
+      define_singleton_method(name) do |value = nil, &block|
+        if type == :config and options.include?(name) and block
+          return read_setting(name).set(&block)
+        end
 
-          write_setting(name, write_value, group)
+        if block || value
+          write_setting(
+            name:        name, 
+            value:       block || value, 
+            group:       group, 
+            type:        type, 
+            required:    required
+          )
         else
           read_setting(name)
         end
@@ -23,32 +43,87 @@ module Indocker::Configs
     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
 
-    def read_setting(key)
-      read_value = scope[key.to_s][:value]
+    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(key, value, group)
-      scope[key.to_s] = {
-        value: value,
-        group: group
-      }
+    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 validate!(name, value, type)
-      value_type = cast_class_to_type(value)
 
-      if type != value_type
+    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}"
+          "Expected option #{@name.inspect} => #{@value.inspect} to be a #{@type.inspect}, not a #{value_type.inspect}"
       end
 
       nil
@@ -68,9 +143,5 @@ module Indocker::Configs
         Indocker::StringUtils.underscore(value.class.name).to_sym
       end
     end
-
-    def method_missing(method, *args, &block)
-      raise "Undefined keyword #{method.inspect} for Indocker configuration file"
-    end
   end
 end

data/lib/indocker/configs/config_factory.rb

@@ -4,33 +4,34 @@ class Indocker::Configs::ConfigFactory
   bean :config, factory_method: :build
 
   CONFIG_STRUCTURE = Proc.new do
-    option :namespace, group: :common
-    option :root,      group: :common, type: :pathname
+    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 :repository
-      option :tag
-      option :branch
-      option :workdir 
+      option :cache_dir, group: :common, type: :pathname
+    
+      hash_config :repo do
+        option :repository
+        option :tag
+        option :branch
+      end
     end
 
     config :docker, group: :docker do
-      option :registry
-      option :email
-      option :password
-      option :username
-      option :skip_push, type: :boolean
+      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)    
-    return @configuration if @configuration
-
-    @configuration = Indocker::Configs::Config.new
-    @configuration.instance_exec(&CONFIG_STRUCTURE)
-    @configuration
+    @configuration ||= Indocker::Configs::Config.new.set(&CONFIG_STRUCTURE)
   end
 end

data/lib/indocker/configs/config_initializer.rb

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

data/lib/indocker/container/container_builder.rb

@@ -0,0 +1,29 @@
+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/{directives → container}/container_directives_runner.rb

@@ -18,6 +18,8 @@ class Indocker::ContainerDirectivesRunner
       run_network(directive)
     when Indocker::ContainerDirectives::Ready
       run_ready(directive)
+    when Indocker::ContainerDirectives::Volume
+      run_volume(directive)  
     else
       # do nothing
     end
@@ -43,4 +45,10 @@ class Indocker::ContainerDirectivesRunner
   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

@@ -26,23 +26,46 @@ class Indocker::ContainerDSL
         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)
-    docker_port, host_port = ports.split(':').map(&:strip)
+    container_port, host_port = ports.split(':').map(&:strip)
 
     @directives << Indocker::ContainerDirectives::Ports.new(
-      docker_port: docker_port, 
-      host_port:   host_port
+      container_port: container_port, 
+      host_port:      host_port
     )
   end
 

data/lib/indocker/container/container_inspector.rb

@@ -0,0 +1,26 @@
+class Indocker::ContainerInspector
+  include SmartIoC::Iocify
+
+  bean :container_inspector
+
+  inject :container_builder
+
+  def changed?(name)
+    container_config = docker_api.inspect_container(name)[Config]
+    host_config      = docker_api.inspect_container(name)[HostConfig]
+
+    inspected_config = Indocker::ContainerConfig.new(
+      image:         container_config['Image'], 
+      cmd:           container_config['Cmd'], 
+      env:           container_config['Env'], 
+      volumes:       container_config['Volumes'], 
+      binds:         host_config['Binds'], 
+      exposed_ports: container_config['ExposedPorts'], 
+      port_bindings: host_config['PortBindings']
+    )
+
+    metadata_config = container_builder.build(name)
+
+    inspected_config == metadata_config
+  end
+end

data/lib/indocker/container/container_manager.rb

@@ -3,7 +3,7 @@ class Indocker::ContainerManager
 
   include SmartIoC::Iocify
   
-  bean   :container_manager
+  bean :container_manager
 
   inject :container_metadata_repository
   inject :image_metadata_repository
@@ -12,30 +12,41 @@ class Indocker::ContainerManager
   inject :logger
   inject :tar_helper
   inject :config
-  inject :envs_loader
+  inject :container_builder
 
   def create(name)
-    container_metadata = container_metadata_repository.get_by_name(name)
-
-    env_metadata = container_metadata.env_files
-      .map {|path| envs_loader.parse(config.root.join(path))}
-      .inject(Indocker::Envs::EnvMetadata.new) {|sum, env| sum += env}
+    container_config = container_builder.build(name)
     
-    container_id = docker_api.create_container(
-      name:          name, 
-      repo:          container_metadata.repo, 
-      tag:           container_metadata.tag,
-      exposed_ports: container_metadata.exposed_ports,
-      port_bindings: container_metadata.port_bindings,
-      env:           env_metadata.to_array
-    )
+    container_id = docker_api.create_container(container_config)
 
     logger.info "Successfully created container :#{name}"
 
     container_id
   end
 
-  def start(name)
+  def run(name)
+    container_metadata = container_metadata_repository.get_by_name(name)
+
+    container_image_id = docker_api.get_container_image_id(name)
+    image_id           = docker_api.get_image_id(container_metadata.repo, tag: container_metadata.tag)
+
+    raise Indocker::Errors::ImageIsNotBuilded, container_metadata.image if image_id.nil?
+
+    if docker_api.container_exists?(name)
+      if image_id != container_image_id
+        stop(name)
+        delete(name)
+        create(name) 
+      end
+    else
+      create(name)
+    end
+
+    stop(name)
+    start(name, attach: container_metadata.attach)
+  end
+
+  def start(name, attach: false)
     container_metadata = container_metadata_repository.get_by_name(name)
     
     container_directives_runner.run_all(
@@ -43,14 +54,17 @@ class Indocker::ContainerManager
     )
 
     container_metadata.container_dependencies.each do |dependency|
+      dependency_metadata = container_metadata_repository.get_by_name(dependency)
       create(dependency) unless docker_api.container_exists?(dependency)
       
-      unless docker_api.get_container_state(dependency) == Indocker::ContainerMetadata::States::RUNNING
-        start(dependency)  
+      if docker_api.get_container_state(dependency) == Indocker::ContainerMetadata::States::RUNNING
+        logger.info "Dependency container :#{dependency} already running"
+      else
+        start(dependency, attach: dependency_metadata.attach)  
       end
     end
 
-    container_id = docker_api.start_container(name)
+    container_id = docker_api.start_container(name, attach: attach)
 
     logger.info "Successfully started container :#{name}"
     
@@ -59,9 +73,6 @@ class Indocker::ContainerManager
     )
 
     container_id
-  rescue Docker::Error::ClientError => e
-    logger.error "The following error occured when starting :#{name} container"
-    logger.error e.message
   end
 
   def stop(name)
@@ -73,6 +84,8 @@ class Indocker::ContainerManager
   end
 
   def delete(name)
+    stop(name)
+
     container_id = docker_api.delete_container(name)
 
     logger.info "Successfully deleted container :#{name}"
@@ -82,19 +95,17 @@ class Indocker::ContainerManager
 
   def copy(name:, copy_from:, copy_to:)
     container_metadata = container_metadata_repository.get_by_name(name)
-    
-    container_id = docker_api.create_container(
-      repo:    container_metadata.repo, 
-      tag:     container_metadata.tag,
-      command: KEEP_CONTAINER_RUNNING_COMMAND
-    ) if !docker_api.container_exists?(name)
-      
-    tar_snapshot    = File.join(config.root, 'tmp', "#{name.to_s}.tar")
 
+    container_id =  docker_api.get_container_id(name) ||
+                    docker_api.create_container(container_builder.build(name))
+      
+    tar_snapshot = config.build_dir.join('snapshots', "#{name.to_s}.tar")
+    
+    FileUtils.mkdir_p(File.dirname(tar_snapshot))
     docker_api.copy_from_container(name: container_id, path: copy_from) do |tar_archive|
-      File.open(tar_snapshot, 'w') {|f| f.write(tar_archive)}
+      File.open(tar_snapshot, 'a+') {|f| f.write(tar_archive)}
     end
-    
+
     files_list = tar_helper.untar(
       io:                    File.open(tar_snapshot, 'r'),
       destination:           copy_to,