indocker 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7be87d422b3b08f1387554c0eea9824254ab0fc6
-  data.tar.gz: 5b4122b752a58078fdf16ff960050d76f5944cfa
+  metadata.gz: 7df51bb131afb666d9ca1348d33e322f3d37d327
+  data.tar.gz: 685f173290c9de44e22d15afec6203f2d2bbb94f
 SHA512:
-  metadata.gz: d28df954032d69e1d108054bfee34b0f7b3d5376d75a35be145469c9ed4dfdb734b88586e9532e040ae731cabc04ebf847dde3d236fed8b57f47ea99132c7f3c
-  data.tar.gz: 00f0a7cf60712d31b45d51369df0a78ba390fde250ea1adbc21a795e73cf51e8db404dad16eaf69533a3ebc865304ec8a1e8d7204146f87c778cbb68dec996ee
+  metadata.gz: 71e13fe051887fe13b7675e26ac06441ae9318165c1ef98949ebe2e43fda8562b8a7d4d839789ba844d62e565b0e480f5e2165399d50f4e38e42f2d808acd31c
+  data.tar.gz: 01a359422b06ef1f4246a2b0fc20eb49699413a4cd45b907663d8e568a8243a98a2d39c0bd0fce86b93e309e918b38e0d241f0b3adbab0642b07978ea6b1eac4

data/.gitignore

@@ -1,2 +1,3 @@
 .DS_Store
-.byebug_history
+.byebug_history
+tmp/*

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile.lock

@@ -2,11 +2,23 @@ PATH
   remote: .
   specs:
     indocker (0.0.0)
+      colorize
+      docker-api
+      smart_ioc
+      thor
 
 GEM
   remote: https://rubygems.org/
   specs:
     byebug (9.1.0)
+    colorize (0.8.1)
+    docker-api (1.33.6)
+      excon (>= 0.38.0)
+      json
+    excon (0.59.0)
+    json (2.1.0)
+    smart_ioc (0.2.1)
+    thor (0.20.0)
 
 PLATFORMS
   ruby

data/bin/indocker

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

data/indocker.gemspec

@@ -2,8 +2,8 @@ require_relative 'lib/indocker/version'
 
 Gem::Specification.new do |s|
   s.name        = 'indocker'
-  s.version     = InDocker::VERSION
-  s.summary     = "InDocker"
+  s.version     = Indocker::VERSION
+  s.summary     = "Indocker"
   s.description = "DSL for build, run and deploy docker containers"
   s.authors     = ["Droid Labs"]
   s.email       = 'hello@droidlabs.pro'
@@ -13,6 +13,11 @@ Gem::Specification.new do |s|
   s.test_files  = s.files.grep(%r{^(spec)/})
 
   s.add_development_dependency "byebug"
+  
+  s.add_dependency "smart_ioc"
+  s.add_dependency "docker-api"
+  s.add_dependency "thor"
+  s.add_dependency "colorize"
 
   s.homepage    = 'https://github.com/droidlabs/indocker'
   s.license     = 'MIT'

data/lib/indocker/application_initializer.rb

@@ -0,0 +1,30 @@
+class Indocker::ApplicationInitializer
+  include SmartIoC::Iocify
+
+  bean :application_initializer
+
+  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
+  end
+end

data/lib/indocker/cli.rb

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

data/lib/indocker/configs/config.rb

@@ -0,0 +1,76 @@
+module Indocker::Configs
+  class Config
+    def scope
+      @scope ||= Hash.new({})
+    end
+
+    def set(&block)
+      instance_exec(&block)
+    end
+
+    def option(name, group: :default, type: :string)
+      define_singleton_method(name) do |value = nil, &block|
+        write_value = block || value
+
+        if write_value
+          validate!(name, write_value, type)
+
+          write_setting(name, write_value, group)
+        else
+          read_setting(name)
+        end
+      end
+    end
+
+    def config(name, group: :default, &block)
+      subconfiguration = Indocker::Configs::Config.new
+      subconfiguration.instance_exec(&block)
+  
+      option(name, group: group, type: :config)
+      send(name, subconfiguration)
+    end
+
+    def read_setting(key)
+      read_value = scope[key.to_s][:value]
+      
+      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
+      }
+    end
+
+    def validate!(name, value, 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
+
+    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

@@ -0,0 +1,36 @@
+class Indocker::Configs::ConfigFactory
+  include SmartIoC::Iocify
+
+  bean :config, factory_method: :build
+
+  CONFIG_STRUCTURE = Proc.new do
+    option :namespace, group: :common
+    option :root,      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 
+    end
+
+    config :docker, group: :docker do
+      option :registry
+      option :email
+      option :password
+      option :username
+      option :skip_push, type: :boolean
+    end
+  end
+
+  def build(&block)    
+    return @configuration if @configuration
+
+    @configuration = Indocker::Configs::Config.new
+    @configuration.instance_exec(&CONFIG_STRUCTURE)
+    @configuration
+  end
+end

data/lib/indocker/configs/locator.rb

@@ -0,0 +1,23 @@
+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_dsl.rb

@@ -0,0 +1,60 @@
+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
+      )
+    end
+  end
+
+  def env_file(path)
+    @directives << Indocker::ContainerDirectives::EnvFile.new(path)
+  end
+
+  def expose(port)
+    @directives << Indocker::ContainerDirectives::Expose.new(path)
+  end
+
+  def ports(ports)
+    docker_port, host_port = ports.split(':').map(&:strip)
+
+    @directives << Indocker::ContainerDirectives::Ports.new(
+      docker_port: docker_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

data/lib/indocker/container/container_evaluator.rb

@@ -0,0 +1,13 @@
+class Indocker::ContainerEvaluator
+  include SmartIoC::Iocify
+
+  bean :container_evaluator
+
+  def evaluate(context, &block)
+    container_dsl = Indocker::ContainerDSL.new(context)
+
+    container_dsl.instance_exec(&block)
+
+    container_dsl.directives
+  end
+end

data/lib/indocker/container/container_manager.rb

@@ -0,0 +1,111 @@
+class Indocker::ContainerManager
+  KEEP_CONTAINER_RUNNING_COMMAND = %w(tail -F -n0 /etc/hosts)
+
+  include SmartIoC::Iocify
+  
+  bean   :container_manager
+
+  inject :container_metadata_repository
+  inject :image_metadata_repository
+  inject :container_directives_runner
+  inject :docker_api
+  inject :logger
+  inject :tar_helper
+  inject :config
+  inject :envs_loader
+
+  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_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
+    )
+
+    logger.info "Successfully created container :#{name}"
+
+    container_id
+  end
+
+  def start(name)
+    container_metadata = container_metadata_repository.get_by_name(name)
+    
+    container_directives_runner.run_all(
+      container_metadata.before_start_directives
+    )
+
+    container_metadata.container_dependencies.each do |dependency|
+      create(dependency) unless docker_api.container_exists?(dependency)
+      
+      unless docker_api.get_container_state(dependency) == Indocker::ContainerMetadata::States::RUNNING
+        start(dependency)  
+      end
+    end
+
+    container_id = docker_api.start_container(name)
+
+    logger.info "Successfully started container :#{name}"
+    
+    container_directives_runner.run_all(
+      container_metadata.after_start_directives
+    )
+
+    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)
+    container_id = docker_api.stop_container(name)
+
+    logger.info "Successfully stopped container :#{name}"
+
+    container_id
+  end
+
+  def delete(name)
+    container_id = docker_api.delete_container(name)
+
+    logger.info "Successfully deleted container :#{name}"
+
+    container_id
+  end
+
+  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")
+
+    docker_api.copy_from_container(name: container_id, path: copy_from) do |tar_archive|
+      File.open(tar_snapshot, 'w') {|f| f.write(tar_archive)}
+    end
+    
+    files_list = tar_helper.untar(
+      io:                    File.open(tar_snapshot, 'r'),
+      destination:           copy_to,
+      ignore_wrap_directory: File.basename(copy_from) == '.'
+    )
+
+    FileUtils.rm_rf(tar_snapshot)
+    
+    docker_api.stop_container(container_id)
+    docker_api.delete_container(container_id)
+
+    files_list
+  end
+end

data/lib/indocker/container/container_metadata.rb

@@ -0,0 +1,107 @@
+class Indocker::ContainerMetadata
+  attr_reader :name
+
+  HOSTPORT = 'HostPort'
+
+  module States
+    CREATED    = 'created'
+    RESTARTING = 'restarting'
+    RUNNING    = 'running'
+    PAUSED     = 'paused'
+    EXITED     = 'exited'
+    DEAD       = 'dead'
+
+    ALL = [CREATED, RESTARTING, RUNNING, PAUSED, EXITED, DEAD]
+  end
+
+  def initialize(name:, directives:)
+    @name         = name
+    @directives   = directives
+  end
+
+  def repo
+    from_directive.repo
+  end
+
+  def tag
+    from_directive.tag
+  end
+
+  def image
+    from_directive.image
+  end
+
+  def networks
+    network_directives.map(&:name)
+  end
+
+  def env_files
+    env_directives.map(&:path)
+  end
+
+  def exposed_ports
+    return nil if ports_directives.empty? && expose_directives.empty?
+
+    result = Hash.new
+
+    expose_directives.each do |d|
+      result[d.port.to_s] = {}
+    end
+
+    ports_directives.each do |d|
+      result[d.docker_port] = {}
+    end
+
+    result
+  end
+
+  def port_bindings
+    return nil if ports_directives.empty?
+
+    result = Hash.new
+
+    ports_directives.each do |d|
+      result[d.docker_port] = [{ HOSTPORT => d.host_port }]
+    end
+
+    result
+  end
+
+  def container_dependencies
+    depends_on_directives.map(&:container_name)
+  end
+
+  def before_start_directives
+    @directives.select(&:before_start?)
+  end
+
+  def after_start_directives
+    @directives.select(&:after_start?)
+  end
+
+  private
+
+  def from_directive
+    @directives.detect {|c| c.instance_of?(Indocker::ContainerDirectives::From)}
+  end
+
+  def network_directives
+    @directives.select {|d| d.instance_of?(Indocker::ContainerDirectives::Network)}
+  end
+
+  def env_directives
+    @directives.select {|d| d.instance_of?(Indocker::ContainerDirectives::EnvFile)}
+  end
+
+  def expose_directives
+    @directives.select {|d| d.instance_of?(Indocker::ContainerDirectives::Expose)}
+  end
+
+  def ports_directives
+    @directives.select {|d| d.instance_of?(Indocker::ContainerDirectives::Ports)}
+  end
+
+  def depends_on_directives
+    @directives.select {|d| d.instance_of?(Indocker::ContainerDirectives::DependsOn)}
+  end
+end

data/lib/indocker/container/container_metadata_factory.rb

@@ -0,0 +1,27 @@
+class Indocker::ContainerMetadataFactory
+  include SmartIoC::Iocify
+
+  bean :container_metadata_factory
+
+  inject :docker_api
+  inject :container_evaluator
+  inject :image_metadata_repository
+  inject :network_metadata_repository
+  inject :container_metadata_repository
+
+  def create(name, &definition)
+    context = Indocker::DSLContext.new(
+      images:         image_metadata_repository,
+      networks:       network_metadata_repository,
+      containers:     container_metadata_repository,
+      container_name: name
+    )
+
+    directives = container_evaluator.evaluate(context, &definition)
+
+    Indocker::ContainerMetadata.new(
+      name:         name.to_s,
+      directives:   directives     
+    )
+  end
+end

data/lib/indocker/container/container_metadata_repository.rb

@@ -0,0 +1,27 @@
+class Indocker::ContainerMetadataRepository
+  include SmartIoC::Iocify
+  
+  bean :container_metadata_repository
+
+  def put(metadata)
+    if get_by_name(metadata.name)
+      raise Indocker::Errors::InvalidParams, "Container name '#{metadata.name}' already in use"
+    end
+    
+    all.push(metadata)
+  end
+
+  def get_by_name(container_name)
+    container = all.detect {|container| container.name == container_name.to_s}
+
+    container
+  end
+
+  def clear
+    @all = []
+  end
+
+  def all
+    @all ||= []
+  end
+end

data/lib/indocker/directives/base.rb

@@ -0,0 +1,21 @@
+module Indocker
+  module Directives
+    class Base
+      def partial?
+        self.is_a?(Indocker::Directives::Partial)
+      end
+
+      def prepare_directive?
+        self.is_a?(Indocker::PrepareDirectives::Base)
+      end
+
+      def build_directive?
+        self.is_a?(Indocker::DockerDirectives::Base)
+      end
+
+      def container_directive?
+        self.is_a?(Indocker::ContainerDirectives::Base)
+      end
+    end
+  end
+end

data/lib/indocker/directives/container_directives/base.rb

@@ -0,0 +1,19 @@
+module Indocker::ContainerDirectives
+  class Base < Indocker::Directives::Base
+    def before_start?
+      false
+    end
+
+    def after_start?
+      false
+    end
+
+    def before_stop?
+      false
+    end
+
+    def after_stop?
+      false
+    end
+  end
+end

data/lib/indocker/directives/container_directives/depends_on.rb

@@ -0,0 +1,7 @@
+class Indocker::ContainerDirectives::DependsOn < Indocker::ContainerDirectives::Base
+  attr_accessor :container_name
+
+  def initialize(container_name)
+    @container_name = container_name
+  end
+end

data/lib/indocker/directives/container_directives/env_file.rb

@@ -0,0 +1,7 @@
+class Indocker::ContainerDirectives::EnvFile < Indocker::ContainerDirectives::Base
+  attr_accessor :path
+
+  def initialize(path)
+    @path = path
+  end
+end

data/lib/indocker/directives/container_directives/expose.rb

@@ -0,0 +1,7 @@
+class Indocker::ContainerDirectives::Expose < Indocker::ContainerDirectives::Base
+  attr_accessor :port
+
+  def initialize(port)
+    @port = port
+  end
+end