indocker 0.0.0 → 0.0.1

data/lib/indocker.rb

@@ -1,2 +1,124 @@
-module InDocker
+require 'smart_ioc'
+require 'docker-api'
+require 'logger'
+
+SmartIoC.find_package_beans(:indocker, __dir__)
+SmartIoC.set_load_proc do |location|
+  require(location)
+end
+
+Docker.options = { read_timeout: 600, write_timeout: 600 }
+
+require 'indocker/errors'
+require 'indocker/cli'
+require 'indocker/docker_api'
+require 'indocker/dsl_context'
+
+require 'indocker/configs/config'
+require 'indocker/configs/config_factory'
+require 'indocker/configs/locator'
+
+require 'indocker/utils/logger'
+require 'indocker/utils/logger_factory'
+require 'indocker/utils/test_logger_factory'
+require 'indocker/utils/tar_helper'
+require 'indocker/utils/string_utils'
+require 'indocker/utils/registry_authenticator'
+require 'indocker/utils/render_util'
+require 'indocker/utils/render_namespace'
+
+require 'indocker/handlers/base'
+require 'indocker/handlers/run_container'
+
+require 'indocker/utils/ioc_container'
+
+require 'indocker/envs/env_metadata'
+require 'indocker/envs/manager'
+require 'indocker/envs/loader'
+
+require 'indocker/image/image_metadata'
+require 'indocker/image/image_metadata_factory'
+require 'indocker/image/image_dsl'
+require 'indocker/image/image_metadata_repository'
+require 'indocker/image/image_builder'
+require 'indocker/image/image_dependencies_manager'
+require 'indocker/image/image_evaluator'
+
+require 'indocker/container/container_metadata'
+require 'indocker/container/container_metadata_repository'
+require 'indocker/container/container_metadata_factory'
+require 'indocker/container/container_manager'
+require 'indocker/container/container_evaluator'
+require 'indocker/container/container_dsl'
+
+require 'indocker/partial/partial_metadata'
+require 'indocker/partial/partial_metadata_repository'
+
+require 'indocker/directives/image_directives_runner'
+require 'indocker/directives/container_directives_runner'
+require 'indocker/directives/base'
+require 'indocker/directives/partial'
+
+require 'indocker/networks/network_metadata'
+require 'indocker/networks/network_metadata_factory'
+require 'indocker/networks/network_metadata_repository'
+
+require 'indocker/directives/docker_directives/base'
+require 'indocker/directives/docker_directives/cmd'
+require 'indocker/directives/docker_directives/entrypoint'
+require 'indocker/directives/docker_directives/env'
+require 'indocker/directives/docker_directives/copy'
+require 'indocker/directives/docker_directives/from'
+require 'indocker/directives/docker_directives/run'
+require 'indocker/directives/docker_directives/workdir'
+
+require 'indocker/directives/prepare_directives/base'
+require 'indocker/directives/prepare_directives/docker_cp'
+
+require 'indocker/directives/container_directives/base'
+require 'indocker/directives/container_directives/from'
+require 'indocker/directives/container_directives/network'
+require 'indocker/directives/container_directives/env_file'
+require 'indocker/directives/container_directives/ports'
+require 'indocker/directives/container_directives/expose'
+require 'indocker/directives/container_directives/depends_on'
+require 'indocker/directives/container_directives/ready'
+
+module Indocker
+  DOCKERFILE_NAME = 'Dockerfile'
+  BUILD_DIR       = 'tmp/build'
+
+  class << self
+    def define_image(name, &definition)
+      ioc.image_metadata_repository.put(
+        ioc.image_metadata_factory.create(name, &definition)
+      )
+    end
+
+    def define_container(name, &definition)
+      ioc.container_metadata_repository.put(
+        ioc.container_metadata_factory.create(name, &definition)
+      )
+    end
+
+    def define_partial(name, &definition)
+      ioc.partial_metadata_repository.put(
+        Indocker::PartialMetadata.new(name, &definition)
+      )
+    end
+
+    def define_network(name)
+      ioc.network_metadata_repository.put(
+        ioc.network_metadata_factory.create(name)
+      )
+    end
+
+    def setup(&block)
+      ioc.config.set(&block)
+    end
+
+    def root(dir = nil)
+      ioc.config.root(dir)
+    end
+  end
 end

data/spec/example/.indocker/config.rb

@@ -0,0 +1,23 @@
+Idocker.setup do
+  namespace     'indocker_example'
+  root          File.dirname(__dir__)
+
+  load_env_file '.indocker/env_files'
+  load_docker_items [
+    '.indocker/images_and_containers.rb'
+  ]
+
+  git do
+    repository 'https://github.com/droidlabs/indocker'
+    tag        'latest'
+    branch     'master'
+    workdir    'some/path'
+  end
+  
+  docker do
+    registry   'localhost:5000'
+    skip_push  true
+  end
+
+  build_server :build_server
+end

data/spec/example/.indocker/images_and_containers.rb

@@ -0,0 +1,25 @@
+Indocker.define_image 'sample_package' do
+  before_build do
+    docker_cp 'assets_compiler' do
+      copy 'assets' => 'assets'
+    end
+  end
+
+  from 'ubuntu'
+
+  run        'mkdir /app'
+  workdir    'app'
+  entrypoint 'ls > ls.txt'
+
+  cmd        'pwd'
+end
+
+Indocker.define_container 'assets_compiler' do
+  use images.assets_compiler
+end
+
+Indocker.define_image 'assets_compiler' do
+  from 'ubuntu'
+
+  copy 'assets/.', '/assets'
+end

data/spec/example/assets/index.css

@@ -0,0 +1 @@
+* { display: <%= display %>; }

data/spec/example/assets/index.js

@@ -0,0 +1 @@
+<% if use_strict %>'use strict';<% end %>

data/spec/indocker/configs/config_factory_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Indocker::Configs::ConfigFactory do
+  subject { ioc.config }
+
+  it 'returns Indocker::Configs::Config object' do
+    expect(subject).to be_a(Indocker::Configs::Config)
+  end
+
+  context '#option' do
+    it 'pass method to Indocker::Configs::Config object' do
+      subject.option(:example_method)
+      subject.example_method('example_value')
+
+      expect(subject.example_method).to eq('example_value')
+    end
+  end
+end

data/spec/indocker/configs/config_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Indocker::Configs::Config do
+  subject { described_class.new }
+
+  describe '#option' do
+    it 'creates setter and getter methods with the same name' do
+      subject.option(:some_key, group: :default, type: :string)
+      subject.some_key('some_value')
+
+      expect(subject.some_key).to eq('some_value')
+    end
+
+    it 'validates setter value with :type attribute' do
+      subject.option(:some_key, group: :default, type: :boolean)
+
+      expect{
+        subject.some_key('test')
+      }.to raise_error(Indocker::Errors::ConfigOptionTypeMismatch, 'Expected option :some_key => "test" to be a :boolean, not a :string')
+    end
+  end
+
+  describe '#config' do
+    it 'creates getter and subconfiguration object' do
+      subject.config(:example_config) do
+        option(:key1)
+        option(:key2, type: :array)
+      end
+
+      subject.example_config.key1('value1')
+      subject.example_config.key2(['value2'])
+
+      expect(subject.example_config.key1).to eq('value1')
+      expect(subject.example_config.key2).to match(['value2'])
+    end
+  end
+end

data/spec/indocker/container/container_manager_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+describe Indocker::ContainerManager do
+  let(:container_manager) { ioc.container_manager }
+  let(:docker_api)        { ioc.docker_api }
+
+  describe '#create' do
+    before do
+      Indocker.define_image 'indocker_image' do
+        from 'alpine:latest'
+        workdir '.'
+        cmd %w(tail -F -n0 /etc/hosts)
+      end
+
+      ioc.image_builder.build('indocker_image')
+    end
+
+    context 'for existing image' do
+      before do
+        Indocker.define_container 'indocker_simple_container' do
+          use images.indocker_image
+        end
+      end
+
+      it 'runs container' do
+        container_manager.create('indocker_simple_container')
+
+        expect(
+          ioc.docker_api.container_exists?('indocker_simple_container')
+        ).to be true
+      end
+    end
+  end
+
+  describe '#start' do
+    before do
+      Indocker.define_image 'indocker_image' do
+        from 'alpine:latest'
+        workdir '.'
+        cmd %w(tail -F -n0 /etc/hosts)
+      end
+
+      ioc.image_builder.build('indocker_image')
+    end
+    
+    context 'with ready timeout' do
+      before do
+        Indocker.define_container 'indocker_timeout_container' do
+          use images.indocker_image
+
+          ready sleep: 0.1, timeout: 1 do
+            sleep 0.5
+            true
+          end
+        end
+
+        Indocker.define_container 'indocker_timeout_error_container' do
+          use images.indocker_image
+
+          ready sleep: 0.1, timeout: 1 do
+            false
+          end
+        end
+
+
+        ioc.container_manager.create('indocker_timeout_container')
+        ioc.container_manager.create('indocker_timeout_error_container')
+      end
+
+      after do
+        container_manager.stop('indocker_timeout_container')
+        container_manager.delete('indocker_timeout_container')
+        container_manager.stop('indocker_timeout_error_container')
+        container_manager.delete('indocker_timeout_error_container')
+      end
+
+      it 'starts container if ready_block returns true' do
+        container_manager.start('indocker_timeout_container')
+
+        expect(
+          docker_api.get_container_state('indocker_timeout_container')
+        ).to eq(Indocker::ContainerMetadata::States::RUNNING)
+      end
+
+      it 'raises Indocker::Errors::ContainerTimeoutError error if ready_block returns false' do
+        expect{
+          container_manager.start('indocker_timeout_error_container')
+        }.to raise_error(Indocker::Errors::ContainerTimeoutError)
+      end
+    end
+
+    context 'with container dependencies' do
+      let(:main_container_id)      { docker_api.get_container_id('indocker_main_container') }
+      let(:dependecy_container_id) { docker_api.get_container_id('indocker_dependency_container') }
+
+      before do
+        Indocker.define_container 'indocker_dependency_container' do
+          use images.indocker_image
+        end
+
+        Indocker.define_container 'indocker_main_container' do
+          use images.indocker_image
+
+          depends_on containers.get_by_name('indocker_dependency_container')
+        end
+
+        ioc.container_manager.create('indocker_main_container')
+        ioc.container_manager.create('indocker_dependency_container')
+
+        container_manager.start('indocker_main_container')
+      end
+
+      after do
+        container_manager.stop('indocker_main_container')
+        container_manager.delete('indocker_main_container')
+        container_manager.stop('indocker_dependency_container')
+        container_manager.delete('indocker_dependency_container')
+      end
+
+      it 'runs dependency container before' do
+        expect(
+          docker_api.get_container_state('indocker_dependency_container')
+        ).to eq(Indocker::ContainerMetadata::States::RUNNING)
+      end
+    end
+
+    context 'with specified network' do
+      let(:container_id) { docker_api.get_container_id('indocker_simple_container') }
+      let(:network_id)   { docker_api.get_network_id('indocker_network') }
+
+      before do
+        Indocker.define_network 'indocker_network'
+
+        Indocker.define_container 'indocker_simple_container' do
+          use images.indocker_image
+          use networks.indocker_network
+        end
+
+        ioc.container_manager.create('indocker_simple_container')
+
+        container_manager.start('indocker_simple_container')
+      end
+
+      after do
+        container_manager.stop('indocker_simple_container')
+        container_manager.delete('indocker_simple_container')
+        docker_api.remove_network('indocker_network')
+      end
+
+      context 'creates network before start' do
+        it 'for new network' do
+          expect(network_id).to match(/[\w\d]{64}/)
+          expect(docker_api.network_exists?('indocker_network')).to be true
+        end
+
+        it 'if network already exists' do
+          container_manager.stop('indocker_simple_container')
+          container_manager.start('indocker_simple_container')
+
+          expect(network_id).to match(/[\w\d]{64}/)
+          expect(docker_api.network_exists?('indocker_network')).to be true
+        end
+      end
+
+      it 'connect container to specified network' do
+        expect(
+          docker_api.inspect_network(network_id)['Containers'].keys
+        ).to include(container_id)
+      end
+
+      it 'starts container' do
+        expect(
+          docker_api.get_container_state(container_id)
+        ).to eq(Indocker::ContainerMetadata::States::RUNNING)
+      end
+    end
+  end
+
+  describe '#copy' do
+    let(:copy_to_path) { File.expand_path File.join(__dir__, '../../tmp/indocker_list_container_files') }
+
+    before do
+      Indocker.define_image 'indocker_copy_image' do
+        from 'alpine'
+
+        run 'mkdir -p /sample'
+        run 'mkdir -p /sample/deeper'
+        run 'echo "example1.txt" > /sample/example1.txt'
+        run 'echo "example2.txt" > /sample/example2.txt'
+        run 'echo "example3.txt" > /sample/deeper/example3.txt'
+        run 'echo "example4.txt" > /sample/deeper/example4.txt'
+
+        cmd ['ls']
+      end
+      ioc.image_builder.build('indocker_copy_image')
+
+      Indocker.define_container :indocker_copy_container do
+        use images.indocker_copy_image
+      end
+    end
+
+    it 'returns files list' do
+      expect(
+        container_manager.copy(
+          name:      :indocker_copy_container,
+          copy_from: '/sample/deeper',
+          copy_to:   copy_to_path
+        )
+      ).to match(
+        [
+          'deeper/example3.txt',
+          'deeper/example4.txt'
+        ]
+      )
+    end
+
+    it 'copies files to output path' do
+      container_manager.copy(
+        name:      :indocker_copy_container,
+        copy_from: '/sample/.',
+        copy_to:   copy_to_path
+      )
+
+      ensure_content(File.join(copy_to_path, 'example1.txt'), 'example1.txt')
+      ensure_content(File.join(copy_to_path, 'example2.txt'), 'example2.txt')
+      ensure_content(File.join(copy_to_path, 'deeper/example3.txt'), 'example3.txt')
+      ensure_content(File.join(copy_to_path, 'deeper/example4.txt'), 'example4.txt')
+    end
+  end
+end

data/spec/indocker/directives/image_directives_runner_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Indocker::ImageDirectivesRunner do
+  let(:image_directives_runner) { ioc.image_directives_runner }
+
+  let(:context) {
+    Indocker::DSLContext.new(
+      display:    'none',
+      use_strict: true,
+      build_dir:  build_dir
+    )
+  }
+
+  let(:directive) { 
+    Indocker::DockerDirectives::Copy.new(
+      context: context, 
+      copy_actions: { 
+        from_path => to_path 
+      }
+    ) 
+  }
+
+  let(:from_path) { 'assets/.' }
+  let(:to_path)   { '/assets' }
+
+  describe "#run_copy" do
+    let(:build_dir) { ioc.config.root.join('../../tmp/build_dir') }
+    
+    context 'for :from as directory path' do
+      context "when directory exists in build directory" do
+        before do
+          FileUtils.mkdir_p(File.join(build_dir, 'assets'))
+          File.open(build_dir.join('assets', 'index.css'), 'w') {|f| f.write("/* located at build directory */")}
+          File.open(build_dir.join('assets', 'index.js'), 'w')  {|f| f.write("// located at build directory")}
+        end
+
+        it 'copy files from root to build directory' do
+          image_directives_runner.run(directive)
+
+          ensure_content(build_dir.join('assets', 'index.css'), "/* located at build directory */")
+          ensure_content(build_dir.join('assets', 'index.js'), "// located at build directory")
+        end
+      end
+
+      context "when directory exists in project root directory" do
+        it 'copy files from root to build directory' do
+          image_directives_runner.run(directive)
+
+          ensure_content(build_dir.join('assets', 'index.css'), "* { display: <%= display %>; }")
+          ensure_content(build_dir.join('assets', 'index.js'), "<% if use_strict %>'use strict';<% end %>")
+        end
+      end
+
+      context "when directory does not exists" do
+        let(:from_path) { 'invalid/dir/.' }
+        let(:to_path)   { '/invalid/dir' }
+
+        it "raises error Indocker::Errors::FileDoesNotExists" do
+          expect{
+            image_directives_runner.run(directive)
+          }.to raise_error(Indocker::Errors::FileDoesNotExists)
+        end
+      end
+
+      context 'with compile: true option' do
+        let(:directive) { 
+          Indocker::DockerDirectives::Copy.new(
+            context: context, 
+            copy_actions: { 
+              from_path => to_path 
+            },
+            compile: true
+          ) 
+        }
+
+        it 'copy compiles files from root to build directory' do
+          image_directives_runner.run(directive)
+
+          ensure_content(build_dir.join('assets', 'index.css'), "* { display: none; }")
+          ensure_content(build_dir.join('assets', 'index.js'), "'use strict';")
+        end
+      end
+    end
+
+    context "for :from as single file path" do
+      let(:from_path) { 'assets/index.css' }
+      let(:to_path)   { '/assets' }
+
+      context 'without compilation' do
+        it 'copy files from root to build directory if no file in build directory' do
+          image_directives_runner.run(directive)
+          
+          ensure_content(build_dir.join('assets', 'index.css'), "* { display: <%= display %>; }")
+        end
+      end
+
+      context 'with compilaton' do
+        let(:directive) { 
+          Indocker::DockerDirectives::Copy.new(
+            context: context, 
+            copy_actions: { 
+              from_path => to_path 
+            },
+            compile: true
+          ) 
+        }
+        
+        before do
+          FileUtils.mkdir_p(File.join(build_dir, 'assets'))
+          File.open(build_dir.join('assets', 'index.css'), 'w') {|f| f.write("/* <%= display %>; */")}
+        end
+
+        it 'compiles and overwrites file is present in build directory' do
+          image_directives_runner.run(directive)
+
+          ensure_content(build_dir.join('assets', 'index.css'), "/* none; */")
+        end
+      end
+    end
+  end
+end

data/spec/indocker/handlers/run_container_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe 'Indocker::Handlers::RunContainer' do
+  subject { ioc.run_container_handler }
+
+  describe '#handle' do
+    context 'for valid cmd process in container' do
+      let(:container) { ioc.container_metadata_repository.get_by_name(:indocker_correct_container) }
+    
+      before do
+        Indocker.define_image :indocker_correct_image do
+          from 'alpine:latest'
+          
+          cmd  ['/bin/sh']
+        end
+
+        Indocker.define_container :indocker_correct_container do
+          use images.indocker_correct_image
+        end
+      end
+
+      context 'for new container' do
+        before do
+          subject.handle(name: :indocker_correct_container, current_path: nil)
+        end
+        
+        it 'creates container' do
+          expect(
+            ioc.docker_api.container_exists?(:indocker_correct_container)
+          ).to be true
+        end
+
+        it 'runs container' do
+          expect(
+            ioc.docker_api.get_container_state(:indocker_correct_container)
+          ).to eq(Indocker::ContainerMetadata::States::RUNNING)
+        end
+
+        it 'logs successfull result' do
+          expect(
+            ioc.logger.messages.last
+          ).to eq("INFO".colorize(:green) + ": Successfully started container :indocker_correct_container")
+        end
+      end
+
+      context 'for existing container' do
+        before do
+          subject.handle(name: :indocker_correct_container, current_path: nil)
+        end
+
+        it 'stops, destroy and create container again' do
+          old_container_id = ioc.docker_api.get_container_id(:indocker_correct_container)
+          
+          subject.handle(name: :indocker_correct_container, current_path: nil)
+
+          new_container_id = ioc.docker_api.get_container_id(:indocker_correct_container)
+
+          expect(new_container_id).not_to eq(old_container_id)
+        end
+
+        it 'runs container again' do
+          subject.handle(name: :indocker_correct_container, current_path: nil)
+
+          expect(
+            ioc.docker_api.get_container_state(:indocker_correct_container)
+          ).to eq(Indocker::ContainerMetadata::States::RUNNING)
+        end
+
+        it 'logs successfull result' do
+          expect(
+            ioc.logger.messages.last
+          ).to eq("INFO".colorize(:green) + ": Successfully started container :indocker_correct_container")
+        end
+      end
+    end
+    
+    context 'for falling cmd process in container' do
+      let(:container) { ioc.container_metadata_repository.get_by_name(:container_with_falling_cmd) }
+
+      before do
+        Indocker.define_image :indocker_image_with_falling_cmd do
+          from 'alpine:latest'
+          
+          cmd  ['invalid/process']
+        end
+
+        Indocker.define_container :container_with_falling_cmd do
+          use images.indocker_image_with_falling_cmd
+        end
+        
+        subject.handle(name: :container_with_falling_cmd, current_path: nil)
+      end
+      
+      it 'logs error text' do
+        expect(
+          ioc.logger.messages.last
+        ).to eq("ERROR".colorize(:red) + ": oci runtime error: container_linux.go:265: starting container process caused \"exec: \\\"invalid/process\\\": stat invalid/process: no such file or directory\"")
+      end
+
+      it 'does not run container' do
+        expect(
+          ioc.docker_api.get_container_state(:container_with_falling_cmd)
+        ).to eq(Indocker::ContainerMetadata::States::CREATED)
+      end
+    end
+  end
+end