indocker 0.0.2 → 0.0.5

data/lib/indocker/container/container_metadata.rb

@@ -1,7 +1,5 @@
 class Indocker::ContainerMetadata
-  attr_reader :name
-
-  HOSTPORT = 'HostPort'
+  attr_reader :name, :attach
 
   module States
     CREATED    = 'created'
@@ -14,9 +12,10 @@ class Indocker::ContainerMetadata
     ALL = [CREATED, RESTARTING, RUNNING, PAUSED, EXITED, DEAD]
   end
 
-  def initialize(name:, directives:)
+  def initialize(name:, directives:, attach: false)
     @name         = name
     @directives   = directives
+    @attach       = attach
   end
 
   def repo
@@ -35,36 +34,34 @@ class Indocker::ContainerMetadata
     network_directives.map(&:name)
   end
 
-  def env_files
-    env_directives.map(&:path)
+  def volumes
+    volume_directives.map(&:docker_name)
   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
+  def binds
+    volume_directives.map(&:to_hash)
+  end
 
-    ports_directives.each do |d|
-      result[d.docker_port] = {}
-    end
+  def envs
+    envs_directives.inject([]) { |all, dir| all.concat dir.env_string }
+  end
+  
+  def env_files
+    env_files_directives.map(&:path)
+  end
 
-    result
+  def exposed_ports
+    expose_directives.map(&:port) + ports_directives.map(&:container_port)
   end
 
   def port_bindings
-    return nil if ports_directives.empty?
-
-    result = Hash.new
+    ports_directives.map(&:to_hash)
+  end
 
-    ports_directives.each do |d|
-      result[d.docker_port] = [{ HOSTPORT => d.host_port }]
-    end
+  def command
+    directive = @directives.detect {|c| c.instance_of?(Indocker::ContainerDirectives::Cmd)}
 
-    result
+    directive ? directive.cmd : nil
   end
 
   def container_dependencies
@@ -89,10 +86,14 @@ class Indocker::ContainerMetadata
     @directives.select {|d| d.instance_of?(Indocker::ContainerDirectives::Network)}
   end
 
-  def env_directives
+  def env_files_directives
     @directives.select {|d| d.instance_of?(Indocker::ContainerDirectives::EnvFile)}
   end
 
+  def envs_directives
+    @directives.select {|d| d.instance_of?(Indocker::ContainerDirectives::Env)}
+  end
+
   def expose_directives
     @directives.select {|d| d.instance_of?(Indocker::ContainerDirectives::Expose)}
   end
@@ -104,4 +105,8 @@ class Indocker::ContainerMetadata
   def depends_on_directives
     @directives.select {|d| d.instance_of?(Indocker::ContainerDirectives::DependsOn)}
   end
+
+  def volume_directives
+    @directives.select {|d| d.instance_of?(Indocker::ContainerDirectives::Volume)}
+  end
 end

data/lib/indocker/container/container_metadata_factory.rb

@@ -8,12 +8,14 @@ class Indocker::ContainerMetadataFactory
   inject :image_metadata_repository
   inject :network_metadata_repository
   inject :container_metadata_repository
+  inject :volume_metadata_repository
 
-  def create(name, &definition)
+  def create(name, attach: false, &definition)
     context = Indocker::DSLContext.new(
       images:         image_metadata_repository,
       networks:       network_metadata_repository,
       containers:     container_metadata_repository,
+      volumes:        volume_metadata_repository,
       container_name: name
     )
 
@@ -21,7 +23,8 @@ class Indocker::ContainerMetadataFactory
 
     Indocker::ContainerMetadata.new(
       name:         name.to_s,
-      directives:   directives     
+      directives:   directives,
+      attach:       attach  
     )
   end
 end

data/lib/indocker/directives/base.rb

@@ -1,20 +1,16 @@
 module Indocker
   module Directives
     class Base
-      def partial?
-        self.is_a?(Indocker::Directives::Partial)
+      def partial_directive?
+        false
       end
 
-      def prepare_directive?
-        self.is_a?(Indocker::PrepareDirectives::Base)
-      end
-
-      def build_directive?
-        self.is_a?(Indocker::DockerDirectives::Base)
+      def container_directive?
+        false
       end
 
-      def container_directive?
-        self.is_a?(Indocker::ContainerDirectives::Base)
+      def image_directive?
+        false
       end
     end
   end

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

@@ -1,5 +1,9 @@
 module Indocker::ContainerDirectives
   class Base < Indocker::Directives::Base
+    def container_directive?
+      true
+    end
+
     def before_start?
       false
     end

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

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

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

@@ -0,0 +1,7 @@
+class Indocker::ContainerDirectives::Env < Indocker::ContainerDirectives::Base
+  attr_reader :env_string
+  
+  def initialize(env_string)
+    @env_string = env_string.split(' ')
+  end
+end

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

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

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

@@ -1,12 +1,14 @@
 class Indocker::ContainerDirectives::From < Indocker::ContainerDirectives::Base
+  include Indocker::ImageHelper
+
   attr_accessor :repo, :tag
 
-  def initialize(repo, tag: Indocker::ImageMetadata::DEFAULT_TAG)
+  def initialize(repo, tag: Indocker::ImageHelper::DEFAULT_TAG)
     @repo = repo
     @tag  = tag
   end
 
   def image
-    "#{@repo}:#{@tag}"
+    full_name(@repo, @tag)
   end
 end

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

@@ -1,8 +1,15 @@
 class Indocker::ContainerDirectives::Ports < Indocker::ContainerDirectives::Base
-  attr_accessor :docker_port, :host_port
+  attr_accessor :container_port, :host_port
 
-  def initialize(docker_port:, host_port:)
-    @docker_port = docker_port
-    @host_port   = host_port
+  def initialize(container_port:, host_port:)
+    @container_port = container_port
+    @host_port      = host_port
+  end
+
+  def to_hash
+    {
+      container_port: @container_port,
+      host_port:      @host_port
+    }
   end
 end

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

@@ -0,0 +1,23 @@
+class Indocker::ContainerDirectives::Volume < Indocker::ContainerDirectives::Base
+  attr_accessor :name, :to
+
+  def initialize(name:, to:)
+    @name = name
+    @to   = to
+  end
+
+  def before_start?
+    true
+  end
+
+  def to_hash
+    {
+      name: @name,
+      to:   @to
+    }
+  end
+  
+  def docker_name
+    '/' + @name.to_s.gsub(/(\A\/)/, '')
+  end
+end

data/lib/indocker/directives/{docker_directives → image_directives}/base.rb

@@ -1,5 +1,5 @@
 module Indocker
-  module DockerDirectives
+  module ImageDirectives
     class Base < Indocker::Directives::Base
       attr_reader :args
       
@@ -10,6 +10,18 @@ module Indocker
       def to_s
         "#{type} #{@args.join(' ')}"
       end
+
+      def prepare_directive?
+        false
+      end
+
+      def build_directive?
+        false
+      end
+
+      def after_build_directive?
+        false
+      end
     end
   end
 end

data/lib/indocker/directives/{docker_directives → image_directives}/cmd.rb

@@ -1,4 +1,4 @@
-class Indocker::DockerDirectives::Cmd < Indocker::DockerDirectives::Base
+class Indocker::ImageDirectives::Cmd < Indocker::ImageDirectives::Base
   attr_reader :command
 
   def initialize(command)
@@ -12,4 +12,8 @@ class Indocker::DockerDirectives::Cmd < Indocker::DockerDirectives::Base
   def type
     'CMD'
   end
+
+  def build_directive?
+    true
+  end
 end

data/lib/indocker/directives/image_directives/copy.rb

@@ -0,0 +1,32 @@
+class Indocker::ImageDirectives::Copy < Indocker::ImageDirectives::Base
+  attr_reader :copy_actions, :compile, :locals, :build_dir
+
+  def initialize(copy_actions:, compile:, locals:, build_dir:)
+    @copy_actions = copy_actions
+    @compile      = compile
+    @locals       = locals
+    @build_dir    = build_dir
+  end
+
+  def type
+    'COPY'
+  end
+
+  def to_s
+    result = []
+    
+    copy_actions.each do |from, to|
+      result.push "#{type} #{from} #{to}"
+    end
+
+    result.join("\n")
+  end
+
+  def prepare_directive?
+    true
+  end
+
+  def build_directive?
+    true
+  end
+end

data/lib/indocker/directives/{prepare_directives → image_directives}/docker_cp.rb

@@ -1,4 +1,4 @@
-class Indocker::PrepareDirectives::DockerCp < Indocker::PrepareDirectives::Base
+class Indocker::ImageDirectives::DockerCp < Indocker::ImageDirectives::Base
   attr_reader :container_name, :copy_actions, :build_dir
 
   def initialize(container_name, build_dir, &block)
@@ -8,6 +8,10 @@ class Indocker::PrepareDirectives::DockerCp < Indocker::PrepareDirectives::Base
     instance_exec &block if block_given?
   end
 
+  def prepare_directive?
+    true
+  end
+
   private
 
   def copy(copy_actions)

data/lib/indocker/directives/{docker_directives → image_directives}/entrypoint.rb

@@ -1,4 +1,4 @@
-class Indocker::DockerDirectives::Entrypoint < Indocker::DockerDirectives::Base
+class Indocker::ImageDirectives::Entrypoint < Indocker::ImageDirectives::Base
   attr_reader :command
 
   def initialize(command)
@@ -12,4 +12,8 @@ class Indocker::DockerDirectives::Entrypoint < Indocker::DockerDirectives::Base
   def type
     'ENTRYPOINT'
   end
+
+  def build_directive?
+    true
+  end
 end

data/lib/indocker/directives/image_directives/env.rb

@@ -0,0 +1,9 @@
+class Indocker::ImageDirectives::Env < Indocker::ImageDirectives::Base
+  def type
+    'ENV'
+  end
+
+  def build_directive?
+    true
+  end
+end

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

@@ -0,0 +1,19 @@
+class Indocker::ImageDirectives::EnvFile < Indocker::ImageDirectives::Base
+  attr_reader :path
+  
+  def initialize(path)
+    @path = path
+  end
+
+  def type
+    'ENV'
+  end
+  
+  def to_s(env_string)
+    "#{type} #{env_string}"
+  end
+
+  def build_directive?
+    true
+  end
+end

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

@@ -0,0 +1,9 @@
+class Indocker::ImageDirectives::Expose < Indocker::ImageDirectives::Base
+  def type
+    'EXPOSE'
+  end
+
+  def build_directive?
+    true
+  end
+end

data/lib/indocker/directives/image_directives/from.rb

@@ -0,0 +1,36 @@
+class Indocker::ImageDirectives::From < Indocker::ImageDirectives::Base
+  include Indocker::ImageHelper
+
+  attr_reader :repo, :tag
+
+  def initialize(repo_tag, tag: nil)
+    case repo_tag
+    when String
+      @repo = repo_tag.split(':')[0]
+      @tag  = tag || repo_tag.split(':')[1] || Indocker::ImageHelper::DEFAULT_TAG
+    else
+      @repo = repo_tag
+      @tag  = tag || Indocker::ImageHelper::DEFAULT_TAG
+    end
+  end
+
+  def full_name
+    super(@repo, @tag)
+  end
+
+  def dockerhub_image?
+    repo.is_a?(String)
+  end
+
+  def to_s
+    "#{type} #{full_name}"
+  end
+
+  def type
+    'FROM'
+  end
+
+  def build_directive?
+    true
+  end
+end

data/lib/indocker/directives/image_directives/registry.rb

@@ -0,0 +1,30 @@
+class Indocker::ImageDirectives::Registry < Indocker::ImageDirectives::Base
+  attr_reader :registry, :push, :repo, :tag
+
+  def initialize(repo:, tag:, registry:, push:)
+    @repo     = repo.to_s
+    @tag      = tag.to_s
+    @registry = format_registry(registry)
+    @push     = push
+  end
+
+  def new_repo
+    "#{@registry}/#{@repo}"
+  end
+
+  def new_tag
+    @tag
+  end
+
+  def after_build_directive?
+    true
+  end
+
+  private
+
+  def format_registry(serveraddress)
+    serveraddress
+      .gsub('http://', '')
+      .gsub(/\/\Z/, '')
+  end
+end

data/lib/indocker/directives/image_directives/run.rb

@@ -0,0 +1,17 @@
+class Indocker::ImageDirectives::Run < Indocker::ImageDirectives::Base
+  def type
+    'RUN'
+  end
+
+  def initialize(command)
+    @command = command.split("\n").map(&:strip).join(' ')
+  end
+
+  def to_s
+    "#{type} #{@command}"
+  end
+
+  def build_directive?
+    true
+  end
+end

data/lib/indocker/directives/image_directives/workdir.rb

@@ -0,0 +1,9 @@
+class Indocker::ImageDirectives::Workdir < Indocker::ImageDirectives::Base
+  def type
+    'WORKDIR'
+  end
+
+  def build_directive?
+    true
+  end
+end

data/lib/indocker/directives/partial.rb

@@ -1,5 +1,5 @@
 class Indocker::Directives::Partial < Indocker::Directives::Base
-  attr_reader :name, :context
+  attr_reader :name
 
   def initialize(name, context, opts = {})
     @name    = name
@@ -10,4 +10,12 @@ class Indocker::Directives::Partial < Indocker::Directives::Base
   def to_s
     inspect
   end
+
+  def context
+    @context + Indocker::DSLContext.new(@opts)
+  end
+
+  def partial_directive?
+    true
+  end
 end

data/lib/indocker/docker_api/container_config.rb

@@ -0,0 +1,121 @@
+class Indocker::DockerAPI::ContainerConfig
+  include Indocker::ImageHelper
+
+  attr_reader :image, :name, :cmd, :env, :exposed_ports, :host_config, :volumes_config
+
+  CONTAINER_DEFAULT_OPTIONS = {
+    'Tty'            => true,
+    'OpenStdin'      => true,
+    'StdinOnce'      => true,
+    'AttachStdin'    => true,
+    'AttachStdout'   => true
+  }
+
+  def initialize(
+    name:, 
+    repo:          nil, 
+    tag:           nil, 
+    image:         nil,              
+    cmd:           nil, 
+    env:           '', 
+    volumes:       [], 
+    binds:         [], 
+    exposed_ports: nil, 
+    port_bindings: nil
+  )
+
+    @image          = image_full_name(image, repo, tag)
+    @name           = name
+    @cmd            = cmd
+    @env            = env
+    @exposed_ports  = ExposedPortsConfig.new(exposed_ports)
+    @host_config    = HostConfig.new(port_bindings, binds)
+    @volumes_config = VolumesConfig.new(volumes)
+  end
+
+  def ==(other)
+    self.to_hash == other.to_hash
+  end
+
+  def image_full_name(image = nil, repo = nil, tag = nil)
+    result = image || full_name(repo, tag)
+    raise ArgumentError if result.to_s.empty?
+
+    result
+  end
+
+  def to_hash
+    state_config = {
+      'Image'        => @image,
+      'name'         => @name,
+      'Cmd'          => @cmd,
+      'Env'          => @env,
+      'ExposedPorts' => @exposed_ports.to_hash,
+      'Volumes'      => @volumes_config.to_hash,
+      'HostConfig'   => @host_config.to_hash
+    }
+
+    CONTAINER_DEFAULT_OPTIONS
+      .merge(state_config)
+      .delete_if {|_, value| value.to_s.empty?}
+  end
+
+  class ExposedPortsConfig
+    attr_reader :ports
+
+    def initialize(ports)
+      @ports = ports || []
+    end
+
+    def to_hash
+      @ports.inject({}) do |result, value|
+        result[value] = {}
+        result
+      end
+    end
+  end
+
+  class VolumesConfig
+    attr_reader :volumes
+
+    VOLUME_VALUE = {}
+
+    def initialize(volumes)
+      @volumes = volumes || []
+    end
+
+    def to_hash
+      volumes.inject({}) do |config, volume|
+        config[volume] = {}
+        config
+      end
+    end
+  end
+
+  class HostConfig
+    attr_reader :port_bindings, :binds
+
+    def initialize(port_bindings, binds)
+      @port_bindings = port_bindings || {}
+      @binds         = binds         || {}
+    end
+
+    def to_hash
+      format_port_bindings = port_bindings.inject({}) do |result, value|
+        result[value[:container_port]] = [{ "HostPort" => value[:host_port] }]
+        result
+      end
+
+      format_binds = binds.inject([]) do |result, value|
+        result.push("#{value[:name]}:#{value[:to]}")
+        result
+      end
+
+      {
+        'Binds'        => format_binds,
+        'PortBindings' => format_port_bindings
+      }
+    end
+  end
+end
+