phoebo 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c2f04f78db0118a1c401d6e8fb38767540a0770c
+  data.tar.gz: 6b74da1cd4f1d534057c5e67c001a315978087ee
+SHA512:
+  metadata.gz: 354236b15bef8f208762c2bbe4459a60066d7c323a3aacac03625cd56fa3417b89d573d4c8ca1c7746def9ee4889d4dfa9505962ac12b3ab5fc6c4a71c004cba
+  data.tar.gz: f5d1ef725707f8427491bf10fb525ad8a30c77503160b6a2f3de7ce44ea08c02bbc60a1d235c9e7849dc67100133e264b880b5d37088e2cf692690c38bbefff5

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in phoebo.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Adam Staněk
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,11 @@
+# Run
+
+```bash
+$ bundle exec bin/phoebo
+```
+
+# Run tests
+
+```bash
+rspec
+```

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/phoebo

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+# Exit cleanly from an early interrupt
+Signal.trap("INT") { exit 130 }
+
+require 'phoebo'
+
+begin
+  app = Phoebo::Application.new(ARGV)
+  code = app.run
+  app.cleanup
+  exit code
+
+rescue Phoebo::PhoeboError => err
+  $stderr.puts "Error: ".red + err.message
+  $stdout.puts
+  exit err.status_code
+ensure
+  app.cleanup
+end

data/lib/phoebo.rb

@@ -0,0 +1,34 @@
+require 'phoebo/version'
+
+module Phoebo
+  autoload :Application, 'phoebo/application'
+  autoload :Config,      'phoebo/config'
+  autoload :Console,     'phoebo/console'
+  autoload :Docker,      'phoebo/docker'
+  autoload :Environment, 'phoebo/environment'
+  autoload :Util,        'phoebo/util'
+
+  class PhoeboError < StandardError
+    def self.status_code(code)
+      define_method(:status_code) { code }
+    end
+  end
+
+  class InvalidArgumentError < PhoeboError; status_code(4) ; end
+  class IOError < PhoeboError; status_code(5) ; end
+  class ExternalError < PhoeboError; status_code(6) ; end
+
+  # Phoebofile errors
+  class ConfigError < PhoeboError; status_code(7) ; end
+  class SyntaxError < ConfigError; end
+
+  # Error while generating Docker image
+  class DockerError < PhoeboError; status_code(8) ; end
+
+  # Configure Phoebo environment from Phoebofile
+  def self.configure(version, &block)
+    raise ConfigError, "Configuration version #{version} not supported" if version != 1
+    Config.load_from_block(block)
+  end
+
+end

data/lib/phoebo/application.rb

@@ -0,0 +1,238 @@
+require 'optparse'
+require 'colorize'
+require 'docker'
+require 'rugged'
+require 'pathname'
+
+module Phoebo
+  #
+  # Main Application
+  #
+  # Performs run sequence and holds instances of necessary services to ease
+  # access without need of dependency injection. You should still allow to
+  # pass dependency if necessary (for testing).
+  # Use following snippet in your class:
+  #
+  # class MyClass
+  #   attr_writer :environment
+  #   def environment
+  #     @environment ||= Application.instance.environment
+  #   end
+  # end
+  #
+  class Application
+    include Console
+
+    # Creates application
+    def initialize(args = [])
+      @args = args
+      @@instance = self
+    end
+
+    # Returns last application instance
+    def self.instance
+      @@instance
+    end
+
+    # Environment service instance
+    def environment
+      @environment ||= Environment.new
+    end
+
+    # Temporary File Manager
+    def temp_file_manager
+      @temp_file_manager ||= Util::TempFileManager.new(environment.temp_path)
+    end
+
+    # Run sequence
+    def run()
+      result = 0
+      options = parse_options
+
+      if options[:error]
+        result = 1
+        stderr.puts 'Error: '.red + options[:error]
+        stderr.puts
+      end
+
+      send(('run_' + options[:mode].to_s).to_sym, options).to_i || result
+    end
+
+    # Cleanup sequence
+    def cleanup
+      if @temp_file_manager && @temp_file_manager.need_cleanup?
+        stdout.puts "Cleaning up"
+        stdout.puts
+        @temp_file_manager.cleanup
+      end
+    end
+
+    private
+
+    # Run in normal mode
+    def run_normal(options)
+
+      # Default project path, is PWD
+      project_path = Dir.pwd
+
+      # If we are building image from Git repository
+      if options[:repository]
+
+        # Prepare SSH credentials if necessary
+        if options[:ssh_key]
+          private_path = Pathname.new(options[:ssh_key])
+
+          raise InvalidArgumentError, "SSH key not found" unless private_path.exist?
+          raise InvalidArgumentError, "Missing public SSH key" unless options[:ssh_public]
+
+          public_path = Pathname.new(options[:ssh_public])
+          raise InvalidArgumentError, "Public SSH key not found" unless public_path.exist?
+
+          cred = Rugged::Credentials::SshKey.new(
+            username: options[:ssh_user],
+            publickey: public_path.realpath.to_s,
+            privatekey: private_path.realpath.to_s
+          )
+        else
+          cred = nil
+        end
+
+        # Create temp dir.
+        project_path = temp_file_manager.path('project')
+
+        # Clone remote repository
+        begin
+          stdout.puts "Cloning remote repository " + "...".light_black
+          Rugged::Repository.clone_at options[:repository],
+            project_path, credentials: cred
+
+        rescue Rugged::SshError => e
+          raise unless e.message.include?('authentication')
+          raise IOError, "Unable to clone remote repository. SSH authentication failed."
+        end
+      end
+
+      # Prepare Docker credentials
+      if options[:docker_username]
+        raise InvalidArgumentError, "Missing docker password." unless options[:docker_password]
+        raise InvalidArgumentError, "Missing docker e-mail." unless options[:docker_email]
+
+        pusher = Docker::ImagePusher.new(
+          options[:docker_username],
+          options[:docker_password],
+          options[:docker_email]
+        )
+      else
+        pusher = nil
+      end
+
+      # Exit code
+      result = 0
+
+      # Process all the files
+      options[:files] << '.' if options[:files].empty?
+      options[:files].each do |rel_path|
+
+        path = (Pathname.new(project_path) + rel_path).realpath.to_s
+
+        # Prepare config path
+        config_filename = 'Phoebofile'
+        config_path = "#{path}#{File::SEPARATOR}#{config_filename}"
+
+        # Check if config exists -> resumable error
+        unless File.exists?(config_path)
+          stderr.puts "No #{config_filename} found in #{path}".red
+          result = 1
+          next
+        end
+
+        # Load config
+        config = Config.load_from_file(config_path)
+
+        # Build & push image
+        builder = Docker::ImageBuilder.new(path)
+        config.images.each do |image|
+          image_id = builder.build(image)
+          pusher.push(image_id) if pusher
+        end
+      end
+
+      puts "Everything done :-)".green
+
+      result
+    end
+
+    # Show help
+    def run_help(_options)
+      stdout.puts @option_parser
+      stdout.puts
+    end
+
+    # Show version info
+    def run_version(_options)
+      stdout.puts "Version: #{Phoebo::VERSION}"
+      stdout.puts
+    end
+
+    # Parse passed command-line options
+    def parse_options
+      options = { error: nil, mode: :normal, files: [], ssh_user: 'git' }
+
+      unless @option_parser
+        @option_parser = OptionParser.new
+        @option_parser.banner = \
+          "Usage: #{@option_parser.program_name} [options] file"
+
+        @option_parser.on_tail('-rURL', '--repository=URL', 'Repository URL') do |value|
+          options[:repository] = value
+        end
+
+        @option_parser.on_tail('--ssh-user=USERNAME', 'Username for Git over SSH (Default: git)') do |value|
+          options[:ssh_user] = value
+        end
+
+        @option_parser.on_tail('--ssh-public=PATH', 'Path to public SSH key for Git repository') do |value|
+          options[:ssh_public] = value
+        end
+
+        @option_parser.on_tail('--ssh-key=PATH', 'Path to SSH key for Git repository') do |value|
+          options[:ssh_key] = value
+        end
+
+        @option_parser.on_tail('--docker-user=USERNAME', 'Username for Docker Registry') do |value|
+          options[:docker_username] = value
+        end
+
+        @option_parser.on_tail('--docker-password=PASSWORD', 'Password for Docker Registry') do |value|
+          options[:docker_password] = value
+        end
+
+        @option_parser.on_tail('--docker-email=EMAIL', 'E-mail for Docker Registry') do |value|
+          options[:docker_email] = value
+        end
+
+        @option_parser.on_tail('--version', 'Show version info') do
+          options[:mode] = :version
+        end
+
+        @option_parser.on_tail('-h', '--help', 'Show this message') do
+          options[:mode] = :help
+        end
+      end
+
+      begin
+        # Parse and go through all non-options
+        @option_parser.parse(@args).each do |arg|
+          options[:files] << arg
+        end
+
+      rescue OptionParser::ParseError => err
+        options[:mode] = :help
+        options[:error] = err.message
+      end
+
+      options
+    end
+  end
+end
+

data/lib/phoebo/config.rb

@@ -0,0 +1,52 @@
+module Phoebo
+  class Config
+    autoload :Image, 'phoebo/config/image'
+    autoload :ImageCommands, 'phoebo/config/image_commands'
+
+    attr_accessor :images
+
+    # Loads config from file
+    # @see Phoebo.configure()
+    def self.load_from_file(file_path)
+      begin
+        @instance = nil
+        Kernel.load File.expand_path(file_path), true
+        @instance
+
+      rescue ::SyntaxError => e
+        raise Phoebo::SyntaxError, e.message
+      end
+    end
+
+    def self.load_from_block(block)
+      @instance = self.new
+      @instance.dsl_eval(block)
+    end
+
+    # Instance initialization
+    def initialize
+      @images = []
+    end
+
+    # Evaluate block within DSL context
+    def dsl_eval(block)
+      @dsl ||= DSL.new(self)
+      @dsl.instance_eval(&block)
+      self
+    end
+
+    # Private DSL
+    class DSL
+      def initialize(config)
+        @config = config
+      end
+
+      def image(name, from, &block)
+        @config.images << (img_instance = Image.new(name, from))
+        img_instance.dsl_eval(block)
+        img_instance
+      end
+    end
+
+  end
+end

data/lib/phoebo/config/image.rb

@@ -0,0 +1,35 @@
+module Phoebo
+  class Config
+    class Image
+      attr_accessor :actions, :name, :from
+
+      def initialize(name, from)
+        @actions = []
+        @name = name
+        @from = from
+      end
+
+      # Evaluate block within DSL context
+      def dsl_eval(block)
+        @dsl ||= DSL.new(self)
+        @dsl.instance_eval(&block)
+        self
+      end
+
+      # Private DSL
+      class DSL
+        def initialize(image)
+          @image = image
+        end
+
+        # Define action methods for all commands
+        ImageCommands.commands.each do |id, command_class|
+          define_method(id) do |*args|
+            @image.actions << command_class.send(:action, *args)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/phoebo/config/image_commands.rb

@@ -0,0 +1,20 @@
+# Auto-require for all Image commands
+Dir[File.dirname(__FILE__) + '/image_commands/*.rb'].each { |file| require file }
+
+# Module containing all Image commands
+module Phoebo::Config::ImageCommands
+
+	# Returns all discovered commands
+	def self.commands
+		unless @commands
+			@commands = {}
+			self.constants.each do |c|
+				c = self.const_get(c)
+				next unless Class === c
+				@commands[c.id] = c
+			end
+		end
+
+		@commands
+	end
+end

data/lib/phoebo/config/image_commands/add.rb

@@ -0,0 +1,17 @@
+module Phoebo::Config::ImageCommands
+  class Add
+  	def self.id
+  		:add
+  	end
+
+  	def self.action(src, dest)
+      return Proc.new do |dockerfile, files|
+
+        virtual = 'project/' + src
+        files[virtual] = src
+
+        dockerfile << 'ADD ' + virtual + ' ' + dest
+      end
+  	end
+  end
+end

data/lib/phoebo/config/image_commands/run.rb

@@ -0,0 +1,14 @@
+module Phoebo::Config::ImageCommands
+  class Run
+  	def self.id
+  		:run
+  	end
+
+  	def self.action(cmd, *args)
+      return Proc.new do |dockerfile, files|
+        # TODO: decide which exec method we will use and enforce escaping
+        dockerfile << "RUN #{cmd} #{args.join(' ')}"
+      end
+  	end
+  end
+end

data/lib/phoebo/console.rb

@@ -0,0 +1,42 @@
+#
+# Helper mixin which allows to pass different IO objects as STDOUT/STDERR.
+# It creates consistent output layer for our classes.
+#
+# Use `include Phoebo::Console` in classes which require to write console output.
+# You can override output stream for each object on class and instance level.
+#
+# MyClass.stdout = StringIO.new sets stream for all future instances
+# MyClass.new.stdout = StringIO.new sets stream for a particular instance
+#
+# Default output streams are $stdout / $stderr
+#
+module Phoebo::Console
+
+  attr_writer :stdout, :stderr
+
+  def stdout
+    @stdout ||= self.class.stdout
+  end
+
+  def stderr
+    @stderr ||= self.class.stderr
+  end
+
+  # We want to also allow Class defaults
+  module ClassMethods
+    attr_writer :stdout, :stderr
+
+    def stdout
+      @stdout ||= $stdout
+    end
+
+    def stderr
+      @stderr ||= $stderr
+    end
+  end
+
+  # On include: also extend by ClassMethods
+  def self.included(host_class)
+    host_class.extend(ClassMethods)
+  end
+end

data/lib/phoebo/docker.rb

@@ -0,0 +1,6 @@
+module Phoebo
+  module Docker
+    autoload :ImageBuilder, 'phoebo/docker/image_builder'
+    autoload :ImagePusher, 'phoebo/docker/image_pusher'
+  end
+end

data/lib/phoebo/docker/image_builder.rb

@@ -0,0 +1,85 @@
+require 'rubygems/package'
+
+module Phoebo
+  module Docker
+    class ImageBuilder
+      include Console
+
+      def initialize(base_path)
+        @base_path = Pathname.new(base_path)
+      end
+
+      def build(image)
+        project_files = { }
+        dockerfile = []
+        dockerfile << "FROM #{image.from}"
+
+        # Apply all defined actions
+        image.actions.each do |action|
+          action.call(dockerfile, project_files)
+        end
+
+        # TODO: Honor file mode
+        tar_stream = StringIO.new
+        Gem::Package::TarWriter.new(tar_stream) do |tar|
+          tar.add_file('Dockerfile', 0640) { |out_stream| out_stream.write(dockerfile.join("\n")) }
+          tar.mkdir('project', 0750)
+
+          # Copy project file into virtual destination
+          while !project_files.empty? do
+            virtual, relative = project_files.shift
+            real = @base_path + relative
+
+            if real.directory?
+              real.each_entry do |child|
+                next if child.fnmatch?('..') or child.fnmatch?('.')
+                if child.directory?
+                  tar.mkdir("#{virtual}/#{child}", 0750)
+                end
+
+                # Add to stack
+                project_files["#{virtual}/#{child}"] = "#{relative}/#{child}"
+              end
+
+            elsif real.file?
+
+              # 'file.txt' -> 'dest/'
+              if virtual.end_with?('/')
+                dest += real.basename.to_s
+              end
+
+              # Read file to our TAR output stream
+              tar.add_file(virtual, 0640) do |out_stream|
+                in_stream = real.open('r')
+                IO.copy_stream(in_stream, out_stream)
+              end
+            end
+          end
+        end
+
+        begin
+          stdout.puts "Building image " + "...".light_black
+          built_image = ::Docker::Image.build_from_tar(tar_stream.tap(&:rewind))
+
+
+          # TODO: Perhaps we should calculate size from virtual size of the base,
+          # this is not working very well while merging layers.
+          stdout.puts "Image build successful".green
+          stdout.print "ID: " + built_image.id.to_s.cyan
+          stdout.print " size: " + ('%.2f MB' % (built_image.json['Size'].to_f / 1000 / 1000)).cyan if built_image.json['Size'] > 100
+          stdout.print " virtual size: " + ('%.2f MB' % (built_image.json['VirtualSize'].to_f / 1000 / 1000)).cyan
+          stdout.puts
+
+          stdout.puts "Tagging image #{built_image.id.to_s.cyan} -> #{image.name.cyan}"
+          built_image.tag('repo' => image.name, 'force' => true)
+
+          # Return image ID
+          built_image.id
+
+        rescue ::Docker::Error::UnexpectedResponseError => e
+          raise DockerError, e.message
+        end
+      end
+    end
+  end
+end

data/lib/phoebo/docker/image_pusher.rb

@@ -0,0 +1,30 @@
+module Phoebo
+  module Docker
+    class ImagePusher
+      include Console
+
+      def initialize(username, password, email)
+        @username = username
+        @password = password
+        @email = email
+      end
+
+      def push(image_id)
+        unless @authenticated
+          @authenticated = true
+          stdout.puts "Authenticating " + "...".light_black
+          begin
+            ::Docker.authenticate!({'username' => @username, 'password' => @password, 'email' => @email}, ::Docker.connection)
+          rescue ::Docker::Error::AuthenticationError => e
+            raise DockerError, 'Authentication to docker registry failed.'
+          end
+        end
+
+        stdout.puts "Pushing image " + image_id.cyan + " ...".light_black
+
+        built_image = ::Docker::Image.get(image_id)
+        built_image.push
+      end
+    end
+  end
+end

data/lib/phoebo/environment.rb

@@ -0,0 +1,63 @@
+# Provides layer for accessing external environment
+class Phoebo::Environment
+
+  # Reader definition macro
+  def self.exe_path_reader(name, bin = nil)
+    define_method("#{name}_path".to_sym) do
+      if instance_variable_defined? "@#{name}"
+        instance_variable_get "@#{name}"
+      else
+        instance_variable_set "@#{name}", path = exe_lookup(bin || name)
+        path
+      end
+    end
+  end
+
+  # Path to executables
+  # Example: exe_path_reader :our_bin, 'binary-name-to-lookup'
+  #   -> Environment.our_bin_path
+  exe_path_reader :git
+  exe_path_reader :bash
+  exe_path_reader :ssh_agent,   'ssh-agent'
+  exe_path_reader :ssh_add,     'ssh-add'
+
+  # Constructor
+  def initialize(env = ENV)
+    @env = env
+  end
+
+  # Temporary files
+  def temp_path
+    "#{File::SEPARATOR}tmp"
+  end
+
+  # Check availability
+  def check_availability(*executables)
+    executables.each do |exe|
+      fail Phoebo::ExternalError, "Program #{exe} not found" \
+        unless send("#{exe}_path".to_sym)
+    end
+  end
+
+  private
+
+  # Look up executable in system path ($PATH)
+  def exe_lookup(bin)
+    if @system_path || @env['PATH']
+      @system_path ||= @env['PATH'].encode(
+        'UTF-8', 'binary',
+        invalid: :replace,
+        undef: :replace,
+        replace: ''
+      ).split(File::PATH_SEPARATOR)
+
+      @system_path.each do |path|
+        file_path = "#{path}#{File::SEPARATOR}#{bin}"
+        return file_path if File.executable? file_path
+      end
+
+      nil
+    end
+  end
+end
+

data/lib/phoebo/util.rb

@@ -0,0 +1,5 @@
+module Phoebo
+  module Util
+    autoload :TempFileManager, 'phoebo/util/temp_file_manager'
+  end
+end

data/lib/phoebo/util/temp_file_manager.rb

@@ -0,0 +1,35 @@
+require 'fileutils'
+
+# Temporary File Manager
+#
+# - Creates temporary directory exclusive for our process
+# - Cleans up
+#
+class Phoebo::Util::TempFileManager
+
+  def initialize(temp_path)
+    @base_path = temp_path
+  end
+
+  def path(*components)
+    unless @process_path
+      @process_path = "#{@base_path}#{File::SEPARATOR}phoebo-#{Process.pid}"
+      FileUtils::mkdir_p @process_path
+      FileUtils::chmod 0600, @process_path
+    end
+
+    File.join(@process_path, components)
+  end
+
+  def need_cleanup?
+    @process_path != nil && File.exist?(@process_path)
+  end
+
+  def cleanup
+    if @process_path
+      FileUtils.remove_dir @process_path
+      @process_path = nil
+    end
+  end
+
+end

data/lib/phoebo/version.rb

@@ -0,0 +1,3 @@
+module Phoebo
+  VERSION = "0.1.1"
+end

data/phoebo.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'phoebo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "phoebo"
+  spec.version       = Phoebo::VERSION
+  spec.authors       = ["Adam Staněk"]
+  spec.email         = ["adam.stanek@v3net.cz"]
+  spec.summary       = %q{CI worker for creating Docker images}
+  spec.description   = %q{Phoebo creates ready-to-deploy Docker images from project Git repository}
+  spec.homepage      = "https://gitlab.fit.cvut.cz/phoebo/phoebo"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '~> 2.1'
+
+  spec.add_dependency "colorize", '~> 0'
+  spec.add_dependency "docker-api", '~> 1.17'
+  spec.add_dependency "rugged", '~> 0.21'
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", '~> 3.0'
+end

data/spec/phoebo/application_spec.rb

@@ -0,0 +1,51 @@
+require_relative '../spec_helper'
+
+describe Phoebo::Application do
+
+  # Set output stream before test
+  before(:all) {
+    described_class.stdout = StringIO.new
+    described_class.stderr = StringIO.new
+  }
+
+  # Clean output streams before each run
+  before(:each) {
+    described_class.stdout.truncate(0)
+    described_class.stderr.truncate(0)
+  }
+
+  context 'general' do
+    subject(:app) { described_class.new }
+
+    it 'is runnable' do
+      expect(app.respond_to?(:run)).to eq true
+    end
+
+    it 'holds instance' do
+      app
+      expect(described_class.instance.is_a?(described_class)).to be true
+    end
+
+    it 'creates Environment' do
+      expect(app.environment.is_a?(Phoebo::Environment)).to be true
+    end
+
+    it 'creates TemporaryFileManager' do
+      expect(app.temp_file_manager.is_a?(Phoebo::Util::TempFileManager)).to be true
+    end
+  end
+
+  context '--version argument' do
+    subject(:app) { described_class.new(['--version']) }
+
+    it 'returns 0' do
+      expect(app.run).to eq 0
+    end
+
+    it 'shows version' do
+      app.run
+      expect(app.stdout.string).to include(Phoebo::VERSION)
+    end
+  end
+
+end

data/spec/phoebo/console_spec.rb

@@ -0,0 +1,80 @@
+require_relative '../spec_helper'
+
+describe Phoebo::Console do
+  before {
+    @sample_class = Class.new do
+      include Phoebo::Console
+    end
+  }
+
+  context 'default streams' do
+    subject {
+      @sample_class.new
+    }
+
+    it 'stdout returns io' do
+      expect(subject.stdout.is_a?(IO)).to eq true
+    end
+
+    it 'stderr returns io' do
+      expect(subject.stderr.is_a?(IO)).to eq true
+    end
+  end
+
+  context 'streams set for class' do
+    subject {
+      sample_class = @sample_class.dup
+      sample_class.stdout = StringIO.new
+      sample_class.stderr = StringIO.new
+      sample_class.new
+    }
+
+    it 'does not effect default streams' do
+      expect(subject.stdout).not_to be @sample_class.stdout
+      expect(subject.stderr).not_to be @sample_class.stderr
+    end
+
+    it 'stdout returns class default' do
+      expect(subject.stdout.is_a?(StringIO)).to eq true
+      expect(subject.stdout).to be subject.class.stdout
+    end
+
+    it 'stderr returns class default' do
+      expect(subject.stderr.is_a?(StringIO)).to eq true
+      expect(subject.stderr).to be subject.class.stderr
+    end
+
+    it 'stdout != stderr' do
+      expect(subject.stdout).not_to be subject.stderr
+    end
+  end
+
+  context 'streams set for instance' do
+    subject {
+      sample_class = @sample_class.dup
+      sample_class.stdout = StringIO.new
+      sample_class.stderr = StringIO.new
+
+      subject = sample_class.new
+      subject.stdout = StringIO.new
+      subject.stderr = StringIO.new
+
+      subject
+    }
+
+    it 'stdout returns set io' do
+      expect(subject.stdout.is_a?(StringIO)).to eq true
+      expect(subject.stdout).not_to be subject.class.stdout
+    end
+
+    it 'stderr returns set io' do
+      expect(subject.stderr.is_a?(StringIO)).to eq true
+      expect(subject.stderr).not_to be subject.class.stderr
+    end
+
+    it 'stdout != stderr' do
+      expect(subject.stdout).not_to be subject.stderr
+    end
+  end
+
+end

data/spec/phoebo/environment_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../spec_helper'
+
+describe Phoebo::Environment do
+  before(:all) {
+    @path = [
+      "#{File::SEPARATOR}a",
+      "#{File::SEPARATOR}b",
+      "#{File::SEPARATOR}c"
+    ]
+  }
+
+  subject(:env) {
+    described_class.new({'PATH' => @path.join(File::PATH_SEPARATOR) })
+  }
+
+  context 'path lookup' do
+    it 'looks up path' do
+      allow(File).to receive(:executable?).with("#{@path[0]}#{File::SEPARATOR}bash").and_return(false)
+      allow(File).to receive(:executable?).with("#{@path[1]}#{File::SEPARATOR}bash").and_return(true)
+      allow(File).to receive(:executable?).with("#{@path[2]}#{File::SEPARATOR}bash").and_return(true)
+      expect(env.bash_path).to eq "#{@path[1]}#{File::SEPARATOR}bash"
+    end
+
+    it 'nil if not found' do
+      @path.each { |path|
+        allow(File).to receive(:executable?).with("#{path}#{File::SEPARATOR}git").and_return(false)
+      }
+      expect(env.git_path).to eq nil
+    end
+  end
+end

data/spec/phoebo/util/temp_file_manager_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../../spec_helper'
+
+describe Phoebo::Util::TempFileManager, :order => :defined do
+    before (:all) {
+      @manager = described_class.new("#{File::SEPARATOR}tmp")
+    }
+
+    it 'does not need clean-up at init' do
+      expect(@manager.need_cleanup?).to eq false
+    end
+    # ->
+    it 'creates path' do
+      @manager.path 'a', 'b'
+    end
+    # ->
+    it 'does need to clean-up' do
+      expect(@manager.need_cleanup?).to eq true
+    end
+    # ->
+    it 'cleans up' do
+      @manager.cleanup
+    end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,99 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'bundler/setup'
+Bundler.setup
+
+require 'phoebo'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+
+  config.formatter = :documentation
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: phoebo
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Adam Staněk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rugged
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Phoebo creates ready-to-deploy Docker images from project Git repository
+email:
+- adam.stanek@v3net.cz
+executables:
+- phoebo
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/phoebo
+- lib/phoebo.rb
+- lib/phoebo/application.rb
+- lib/phoebo/config.rb
+- lib/phoebo/config/image.rb
+- lib/phoebo/config/image_commands.rb
+- lib/phoebo/config/image_commands/add.rb
+- lib/phoebo/config/image_commands/run.rb
+- lib/phoebo/console.rb
+- lib/phoebo/docker.rb
+- lib/phoebo/docker/image_builder.rb
+- lib/phoebo/docker/image_pusher.rb
+- lib/phoebo/environment.rb
+- lib/phoebo/util.rb
+- lib/phoebo/util/temp_file_manager.rb
+- lib/phoebo/version.rb
+- phoebo.gemspec
+- spec/phoebo/application_spec.rb
+- spec/phoebo/console_spec.rb
+- spec/phoebo/environment_spec.rb
+- spec/phoebo/util/temp_file_manager_spec.rb
+- spec/spec_helper.rb
+homepage: https://gitlab.fit.cvut.cz/phoebo/phoebo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: CI worker for creating Docker images
+test_files:
+- spec/phoebo/application_spec.rb
+- spec/phoebo/console_spec.rb
+- spec/phoebo/environment_spec.rb
+- spec/phoebo/util/temp_file_manager_spec.rb
+- spec/spec_helper.rb