construi 0.30.0 → 0.31.0

data/lib/construi/runner.rb

@@ -0,0 +1,41 @@
+
+require 'construi/container'
+require 'construi/image'
+require 'construi/target'
+
+require 'construi/version'
+
+require 'colorize'
+require 'docker'
+
+module Construi
+
+  class Runner
+    def initialize(config)
+      @config = config
+    end
+
+    def setup_docker
+      docker_host = ENV['DOCKER_HOST']
+      Docker.url = docker_host if docker_host
+
+      puts "Docker url: #{Docker.url}"
+
+      Docker.validate_version!
+      Docker.options[:read_timeout] = 60
+      Docker.options[:chunk_size] = 8
+    end
+
+    def run(targets)
+      puts "Construi version: #{Construi::VERSION}"
+
+      setup_docker
+
+      puts "Current directory: #{Dir.pwd}"
+
+      targets.map {|t| Target.new t, @config.target(t) } .each(&:run)
+    end
+  end
+
+end
+

data/lib/construi/target.rb

@@ -0,0 +1,35 @@
+
+
+module Construi
+
+  class Target
+    attr_reader :name, :config
+
+    def initialize(name, config)
+      @name = name
+      @config = config
+    end
+
+    def commands
+      @config.commands
+    end
+
+    def run
+      puts "Running #{name}...".green
+
+      final_image = IntermediateImage.seed(initial_image).reduce(commands) do |image, command|
+        puts
+        puts " > #{command}".green
+        image.run(command, @config.env)
+      end
+
+      final_image.delete
+    end
+
+    def initial_image
+      return Image.from(@config)
+    end
+  end
+
+end
+

data/lib/construi/version.rb

@@ -1,3 +1,3 @@
 module Construi
-  VERSION = "0.30.0"
+  VERSION = "0.31.0"
 end

data/spec/lib/construi/config_spec.rb

@@ -0,0 +1,287 @@
+
+require 'spec_helper'
+require 'construi/config'
+
+RSpec.describe Construi::Config do
+  let(:config_content) { '{}' }
+
+  subject(:config) { Construi::Config.load(config_content) }
+
+  describe '.load_file' do
+    let(:config_file) { Tempfile.new('config.load_file') }
+    let(:config_content) do
+      <<-YAML
+      image: test-image
+      YAML
+    end
+
+    before do
+      config_file.write(config_content)
+      config_file.close
+    end
+
+    after do
+      config_file.unlink
+    end
+
+    subject { Construi::Config.load_file(config_file) }
+
+    it { is_expected.to_not be(nil) }
+    it { expect(subject.image).to eq('test-image') }
+  end
+
+  describe '#image' do
+    let(:config_content) do
+      <<-YAML
+      image: #{image}
+      YAML
+    end
+
+    subject { config.image }
+
+    %w{ test-image:latest lstephen/construi:latest }.each do |image_name|
+      context "when image is #{image_name}" do
+        let(:image) { image_name }
+        it { is_expected.to eq(image) }
+      end
+    end
+  end
+
+  describe '#build' do
+    let(:config_content) do
+      <<-YAML
+      build: #{build}
+      YAML
+    end
+
+    subject { config.build }
+
+    %w{ . construi/dev etc/docker/ }.each do |build|
+      context "when build is #{build}" do
+        let(:build) { build }
+        it { is_expected.to eq(build) }
+      end
+    end
+  end
+
+  describe '#env' do
+    subject { config.env }
+
+    context 'when no environment section' do
+      it { is_expected.to eq([]) }
+    end
+
+    context 'when explicitly set environment values' do
+      let(:config_content) do
+        <<-YAML
+        environment:
+          - VAR1=VALUE_1
+          - VAR2=VALUE_2
+        YAML
+      end
+
+      it { is_expected.to contain_exactly('VAR1=VALUE_1', 'VAR2=VALUE_2') }
+    end
+
+    context 'when passing through environment varaibles' do
+      before do
+        ENV['VAR1'] = 'VALUE_1'
+        ENV['VAR2'] = 'VALUE_2'
+      end
+
+      let(:config_content) do
+        <<-YAML
+        environment:
+          - VAR1
+          - VAR2
+        YAML
+      end
+
+      it { is_expected.to contain_exactly('VAR1=VALUE_1', 'VAR2=VALUE_2') }
+    end
+  end
+
+  describe '#target' do
+    let(:target) { 'build' }
+
+    subject { config.target target }
+
+    context 'when no target name' do
+      let(:target) { nil }
+      it { is_expected.to be(nil) }
+    end
+
+    context 'when no targets configured' do
+      it { is_expected.to be(nil) }
+    end
+
+    context 'when targets configured' do
+      let(:config_content) do
+        <<-YAML
+        targets:
+          build:
+            - cmd1
+            - cmd2
+          release:
+            - cmd3
+            - cmd4
+        YAML
+      end
+
+      it { is_expected.to_not be(nil) }
+      it { expect(subject.commands).to eq(['cmd1', 'cmd2']) }
+    end
+
+    context 'when single command' do
+      let(:config_content) do
+        <<-YAML
+        targets:
+          build: cmd1
+        YAML
+      end
+
+      it { is_expected.to_not be(nil) }
+      it { expect(subject.commands).to eq(['cmd1']) }
+    end
+    context 'when using run command' do
+      let(:config_content) do
+        <<-YAML
+        targets:
+          build:
+            run:
+              - cmd1
+              - cmd2
+        YAML
+      end
+
+      it { is_expected.to_not be(nil) }
+      it { expect(subject.commands).to eq(['cmd1', 'cmd2']) }
+    end
+
+    context 'when using single run command' do
+      let(:config_content) do
+        <<-YAML
+        targets:
+          build:
+            run: cmd1
+        YAML
+      end
+
+      it { is_expected.to_not be(nil) }
+      it { expect(subject.commands).to eq(['cmd1']) }
+    end
+
+    context 'when no image for target' do
+      let(:config_content) do
+        <<-YAML
+        image: global:image
+        targets:
+          build: cmd1
+          release:
+            image: release:image
+            run:
+              - cmd3
+              - cmd4
+        YAML
+      end
+
+      it { is_expected.to have_attributes(:image => 'global:image', :build => nil) }
+    end
+
+    context 'when image for target' do
+      let(:config_content) do
+        <<-YAML
+        image: global:image
+        targets:
+          build:
+            image: build:image
+            run: cmd1
+        YAML
+      end
+
+      it { is_expected.to have_attributes(:image => 'build:image', :build => nil) }
+    end
+
+    context 'when build for target and image for global' do
+      let(:config_content) do
+        <<-YAML
+        image: global:image
+        targets:
+          build:
+            build: build/build
+            run: cmd1
+        YAML
+      end
+
+      it { is_expected.to have_attributes(:image => nil, :build => 'build/build') }
+    end
+  end
+
+  describe '#files' do
+    let(:host) { '/path/on/host' }
+    let(:container) { '/path/on/container' }
+    let(:permissions) { '0644' }
+
+    subject { config.target('build').files }
+
+    context 'when no files' do
+      let(:config_content) do
+        <<-YAML
+        targets:
+          build: cmd1
+        YAML
+      end
+
+      it { is_expected.to_not be(nil) }
+      it { is_expected.to eq([]) }
+    end
+
+    context 'when global files' do
+      let(:config_content) do
+        <<-YAML
+        files:
+          - #{host}:#{container}
+          - #{host}:#{container}:#{permissions}
+        targets:
+          build: cmd1
+        YAML
+      end
+
+      it { expect(subject.length).to eq(2) }
+      it do
+        expect(subject[0])
+           .to have_attributes :host => host, :container => container, :permissions => nil
+      end
+      it do
+        expect(subject[1])
+          .to have_attributes :host => host, :container => container, :permissions => permissions
+      end
+    end
+
+    context 'when target files' do
+      let(:config_content) do
+        <<-YAML
+        files:
+          - #{host}:#{container}
+        targets:
+          build:
+            run: cmd1
+            files:
+              - #{host}:#{container}:#{permissions}
+        YAML
+      end
+
+      it { expect(subject.length).to eq(2) }
+      it do
+        expect(subject[0])
+           .to have_attributes :host => host, :container => container, :permissions => nil
+      end
+      it do
+        expect(subject[1])
+          .to have_attributes :host => host, :container => container, :permissions => permissions
+      end
+    end
+
+  end
+end
+

data/spec/lib/construi/container_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+require 'securerandom'
+
+RSpec.describe Construi::Container do
+  let!(:docker_container_class) { class_spy(Docker::Container).as_stubbed_const }
+  let(:docker_container) do
+    instance_double(Docker::Container, :id => SecureRandom.hex(16)).as_null_object
+  end
+
+  let(:image_id) { SecureRandom.hex(16) }
+  let(:image) { instance_double(Docker::Image, :id => image_id).as_null_object }
+
+  let(:container) { Construi::Container.wrap docker_container }
+
+  describe '#delete' do
+    subject! { container.delete }
+
+    it { expect(docker_container).to have_received(:delete) }
+  end
+
+  describe '#attach_stdout' do
+    subject(:attach_stdout) { -> { container.attach_stdout } }
+
+    context 'when attached succesfully' do
+      before do
+        allow(docker_container)
+          .to receive(:attach)
+          .and_yield('stream', 'msg1')
+          .and_yield('stream', 'msg2')
+      end
+
+      subject! { attach_stdout.call }
+
+      it { expect(docker_container).to have_received(:attach).with(:stream => true, :logs => true) }
+      it { expect($stdout.string).to include("msg1\nmsg2") }
+    end
+
+    context 'when attach times out' do
+      before do
+        allow(docker_container)
+          .to receive(:attach)
+          .and_raise(Docker::Error::TimeoutError.new)
+      end
+
+      subject! { attach_stdout.call }
+
+      it { expect($stdout.string).to include('Failed to attach to stdout'.yellow) }
+    end
+  end
+
+  describe '#commit' do
+    before { allow(docker_container).to receive(:commit).and_return image }
+
+    subject! { container.commit }
+
+    it { expect(docker_container).to have_received(:commit) }
+    it { is_expected.to eq(Construi::Image.wrap(image)) }
+  end
+
+  describe '#run' do
+    before { allow(docker_container).to receive(:wait).and_return({'StatusCode' => status_code}) }
+    before { allow(docker_container).to receive(:commit).and_return image }
+
+    subject(:run) { -> { container.run } }
+
+    context 'when command succeeds' do
+      let(:status_code) { 0 }
+
+      subject! { run.call }
+
+      it { expect(docker_container).to have_received(:start) }
+      it { expect(docker_container).to have_received(:attach).with(:stream => true, :logs => true) }
+      it { expect(docker_container).to have_received(:wait) }
+      it { expect(docker_container).to have_received(:commit) }
+      it { is_expected.to eq(Construi::Image.wrap(image)) }
+    end
+
+    context 'when command fails' do
+      let(:status_code) { 1 }
+
+      it { expect { run.call }.to raise_error Construi::Container::Error,  /status code: 1/}
+    end
+  end
+
+  describe '.create' do
+    let(:cmd) { 'cmd1 p1 p2' }
+    let(:env) { ['ENV1=VAL1', 'ENV2=VAL2'] }
+    let(:pwd) { '/project/dir' }
+
+    before { allow(docker_container_class).to receive(:create).and_return docker_container }
+    before { allow(Dir).to receive(:pwd).and_return(pwd) }
+
+    subject! { Construi::Container::create(image, cmd, env) }
+
+    it do
+      expect(docker_container_class).to have_received(:create).with( {
+        'Cmd' => ['cmd1', 'p1', 'p2' ],
+        'Image' => image_id,
+        'Env' => env.to_json,
+        'Tty' => false,
+        'WorkingDir' => '/var/workspace',
+        'HostConfig' => { 'Binds' => ["#{pwd}:/var/workspace"] }
+        } )
+    end
+    it { is_expected.to eq(Construi::Container.wrap docker_container) }
+  end
+
+  describe '.run' do
+    let(:cmd) { 'cmd1 p1 p2' }
+
+    before { allow(docker_container_class).to receive(:create).and_return docker_container }
+    before { allow(docker_container).to receive(:wait).and_return({'StatusCode' => 0}) }
+    before { allow(docker_container).to receive(:commit).and_return image }
+
+    subject! { Construi::Container.run(image, cmd, []) }
+
+    it do
+      expect(docker_container_class).to have_received(:create).with(
+        hash_including( {
+          'Cmd' => ['cmd1', 'p1', 'p2'],
+          'Image' => image_id
+        }))
+    end
+    it { is_expected.to eq(Construi::Image.wrap image) }
+    it { expect(docker_container).to have_received(:start) }
+    it { expect(docker_container).to have_received(:commit) }
+    it { expect(docker_container).to have_received(:delete) }
+  end
+
+end
+