rbld 1.0.0

data/cli/lib/commands/rbld_save.rb

@@ -0,0 +1,28 @@
+module Rebuild::CLI
+  class RbldSaveCommand < Command
+    private
+
+    def default_file(env)
+      "#{env.name}-#{env.tag}.rbld"
+    end
+
+    public
+
+    def initialize
+      @usage = "save [OPTIONS] [ENVIRONMENT] [FILE]"
+      @description = "Save local environment to file"
+    end
+
+    def run(parameters)
+      env, file = parameters
+      env = Environment.new( env )
+      file = default_file( env ) if !file or file.empty?
+      rbld_log.info("Going to save #{env} to #{file}")
+
+      warn_if_modified( env, 'saving' )
+      engine_api.save(env, file)
+
+      rbld_print.progress "Successfully saved environment #{env} to #{file}\n"
+    end
+  end
+end

data/cli/lib/commands/rbld_search.rb

@@ -0,0 +1,13 @@
+module Rebuild::CLI
+  class RbldSearchCommand < Command
+    def initialize
+      @usage = "search [OPTIONS] [NAME[:TAG]|PREFIX]"
+      @description = "Search remote registry for published environments"
+    end
+
+    def run(parameters)
+      env = Environment.new(parameters[0], allow_empty: true)
+      print_names( engine_api.search( env ) )
+    end
+  end
+end

data/cli/lib/commands/rbld_status.rb

@@ -0,0 +1,12 @@
+module Rebuild::CLI
+  class RbldStatusCommand < Command
+    def initialize
+      @usage = "status [OPTIONS]"
+      @description = "List modified environments"
+    end
+
+    def run(parameters)
+      print_names( engine_api.environments.select( &:modified? ), 'modified: ' )
+    end
+  end
+end

data/cli/lib/rbld_commands.rb

@@ -0,0 +1,207 @@
+require_relative 'rbld_log'
+require_relative 'rbld_utils'
+require_relative 'rbld_engine'
+
+module Rebuild::CLI
+  extend Rebuild::Utils::Errors
+
+  rebuild_errors \
+    EnvironmentNameEmpty: 'Environment name not specified',
+    EnvironmentNameWithoutTagExpected: 'Environment tag must not be specified',
+    EnvironmentNameError: 'Invalid %s, it may contain a-z, A-Z, 0-9, - and _ characters only',
+    HandlerClassNameError: '%s'
+
+  class Environment
+    def initialize(env, opts = {})
+      if env.respond_to?( :name ) && env.respond_to?( :tag )
+        @name, @tag = env.name, env.tag
+      else
+        deduce_name_tag( env, opts )
+        validate_name_tag(opts)
+      end
+      @full = "#{@name}:#{@tag}"
+    end
+
+    def self.validate_component( name, value )
+      raise EnvironmentNameError, "#{name} (#{value})" \
+        unless value.match( /^[[:alnum:]\_\-]*$/ )
+    end
+
+    def to_s
+      @full
+    end
+
+    attr_reader :name, :tag, :full
+
+    private
+
+    def parse_name_tag(cli_param, opts)
+      if opts[:allow_empty] && (!cli_param || cli_param.empty?)
+        @name, @tag = '', ''
+      elsif !cli_param || cli_param.empty?
+        raise EnvironmentNameEmpty
+      else
+        @name, @tag = cli_param.match( /^([^:]*):?(.*)/ ).captures
+        @tag = '' if @name.empty?
+      end
+    end
+
+    def deduce_name_tag(cli_param, opts)
+      parse_name_tag( cli_param, opts )
+
+      raise EnvironmentNameWithoutTagExpected \
+        if opts[:force_no_tag] && !@tag.empty?
+
+      @tag = 'initial' if @tag.empty? && !opts[:allow_empty]
+    end
+
+    def validate_name_tag(opts)
+      raise EnvironmentNameEmpty if @name.empty? && !opts[:allow_empty]
+      self.class.validate_component( "environment name", @name ) unless @name.empty?
+      self.class.validate_component( "environment tag", @tag ) unless @tag.empty?
+    end
+  end
+
+  class Commands
+    extend Enumerable
+
+    private
+
+    def self.deduce_cmd_name(handler_class)
+      match = handler_class.name.match(/Rbld(.*)Command/)
+      return nil unless match
+      match.captures[0].downcase
+    end
+
+    def self.handler!(command)
+      @handler_classes.each do |klass|
+        return klass.new if command == deduce_cmd_name( klass )
+      end
+
+      raise "Unknown command: #{command}"
+    end
+
+    @handler_classes = []
+
+    public
+
+    def self.register_handler_class(klass)
+      unless deduce_cmd_name( klass )
+        raise HandlerClassNameError, klass.name
+      end
+
+      @handler_classes << klass
+    end
+
+    def self.each
+      @handler_classes.each { |klass| yield( deduce_cmd_name( klass ) ) }
+    end
+
+    def self.usage(command)
+      handler!( command ).usage
+    end
+
+    def self.run(command, parameters)
+      handler = handler!( command )
+      handler.run( parameters )
+      handler.errno
+    end
+  end
+
+  class Command
+
+    private
+
+    def self.inherited( handler_class )
+      Commands.register_handler_class( handler_class )
+      rbld_log.info( "Command handler class #{handler_class} registered" )
+    end
+
+    def options_text
+      options = (@options || []) + [["-h, --help", "Print usage"]]
+      text = ""
+      options.each { |o| text << "  #{o[0].ljust(30)}#{o[1]}\n" }
+      text
+    end
+
+    def replace_argv(parameters)
+      orig_argv = ARGV.clone
+      ARGV.clear
+      parameters.each { |x| ARGV << x }
+      yield
+      ARGV.clear
+      orig_argv.each { |x| ARGV << x }
+    end
+
+    def print_names(names, prefix = '')
+      strings = names.map { |n| Environment.new(n).full }
+      puts
+      strings.sort.each { |s| puts "    #{prefix}#{s}"}
+      puts
+    end
+
+    def engine_api
+      @engine_api ||= Rebuild::Engine::API.new
+      @engine_api
+    end
+
+    def warn_if_modified(env, action)
+      rbld_print.warning "Environment is modified, #{action} original version" \
+        if engine_api.environments.select( &:modified? ).include?( env )
+    end
+
+    def get_cmdline_tail(parameters)
+      parameters.shift if parameters[0] == '--'
+      parameters
+    end
+
+    def format_usage_text
+      text = ""
+      if @usage.respond_to?(:each)
+        text << "\n"
+        @usage.each do |mode|
+          text << "\n  rbld #{mode[:syntax]}\n\n" \
+                  "    #{mode[:description]}\n"
+        end
+      else
+        text << "rbld #{@usage}\n"
+      end
+      text
+    end
+
+    public
+
+    attr_reader :errno
+
+    def usage
+      puts <<END_USAGE
+
+Usage: #{format_usage_text}
+#{@description}
+
+#{options_text}
+END_USAGE
+    end
+  end
+
+  class Main
+
+    def self.usage
+      usage_text = <<USAGE
+Usage:
+  rbld help                Show this help screen
+  rbld help COMMAND        Show help for COMMAND
+  rbld COMMAND [PARAMS]    Run COMMAND with PARAMS
+
+rebuild: Zero-dependency, reproducible build environments
+
+Commands:
+
+USAGE
+
+      Commands.sort.each { |cmd| usage_text << "  #{cmd}\n"}
+
+      usage_text
+    end
+  end
+end

data/cli/lib/rbld_config.rb

@@ -0,0 +1,20 @@
+require 'parseconfig'
+
+module Rebuild
+  class Config
+    def initialize()
+      cfg_file = File.join( Dir.home, '.rbld', 'rebuild.conf' )
+
+      if File.exist?( cfg_file )
+        cfg = ParseConfig.new( cfg_file )
+        rname = cfg['REMOTE_NAME']
+        @remote = rname ? cfg["REMOTE_#{rname}"] : nil
+      end
+    end
+
+    def remote!
+      raise 'Remote not defined' unless @remote
+      @remote
+    end
+  end
+end

data/cli/lib/rbld_engine.rb

@@ -0,0 +1,710 @@
+require 'docker'
+require 'etc'
+require 'thread'
+require 'forwardable'
+require_relative 'rbld_log'
+require_relative 'rbld_config'
+require_relative 'rbld_utils'
+require_relative 'rbld_print'
+require_relative 'rbld_registry'
+
+module Rebuild::Engine
+  extend Rebuild::Utils::Errors
+
+  class NamedDockerImage
+    extend Forwardable
+
+    def_delegators :@api_obj, :id
+    attr_reader :api_obj
+
+    def initialize(name, api_obj)
+      @name, @api_obj = name, api_obj
+    end
+
+    def remove!
+      @api_obj.remove( name: @name.to_s )
+    end
+
+    def tag
+      @api_obj.tag( repo: @name.repo,
+                    tag: @name.tag )
+    end
+
+    def identity
+      @name.to_s
+    end
+  end
+
+  class NamedDockerContainer
+    def initialize(name, api_obj)
+      @name, @api_obj = name, api_obj
+    end
+
+    def remove!
+      @api_obj.delete( force: true )
+    end
+
+    def flatten(img_name)
+      data_queue = Queue.new
+      new_img = nil
+
+      exporter = Thread.new do
+        @api_obj.export { |chunk| data_queue << chunk }
+        data_queue << ''
+      end
+
+      importer = Thread.new do
+        opts = commit_opts(img_name)
+        new_img = Docker::Image.import_stream(opts) {  data_queue.pop }
+      end
+
+      exporter.join
+      importer.join
+
+      rbld_log.info("Created image #{new_img} from #{@api_obj}")
+      remove!
+
+      new_img
+    end
+
+    def commit(img_name)
+      if squash_needed?
+        flatten( img_name )
+      else
+        new_img = @api_obj.commit( commit_opts( img_name ) )
+        rbld_log.info("Created image #{new_img} from #{@api_obj}")
+        remove!
+        new_img
+      end
+    end
+
+    private
+
+    def squash_needed?
+      #Different FS backends have different limitations for
+      #maximum number of layers, 40 looks like small enough
+      #to be supported by all possible configurations
+      Docker::Image.get(@api_obj.info["ImageID"]).history.size >= 40
+    end
+
+    def commit_opts(img_name)
+      {repo: img_name.repo,
+       tag: img_name.tag,
+       changes: ["LABEL re-build-environment=true",
+                 "ENTRYPOINT [\"/rebuild/re-build-entry-point\"]"]}
+    end
+  end
+
+  class NameFactory
+    def initialize(env)
+      @env = env
+    end
+
+    def identity
+      Rebuild::Utils::FullImageName.new("rbe-#{@env.name}", @env.tag)
+    end
+
+    def rerun
+      Rebuild::Utils::FullImageName.new("rbr-#{@env.name}-rt-#{@env.tag}", 'initial')
+    end
+
+    def running
+      container_name(:running)
+    end
+
+    def modified
+      container_name(:dirty)
+    end
+
+    def hostname
+      "#{@env.name}-#{@env.tag}"
+    end
+
+    def modified_hostname
+      "#{hostname}-M"
+    end
+
+    private
+
+    def container_name(type)
+      "rbe-#{type.to_s.chars.first}-#{@env.name}-rt-#{@env.tag}"
+    end
+  end
+
+  class Environment
+    def self.from_image(img_name, api_obj)
+      if match = img_name.match(/^rbe-(.*):(.*)/)
+        new( *match.captures, NamedDockerImage.new( img_name, api_obj ) )
+      else
+        nil
+      end
+    end
+
+    def attach_container(cont_name, api_obj)
+      try_attach_container(:dirty, cont_name, api_obj) ||
+        try_attach_container(:running, cont_name, api_obj)
+    end
+
+    def attach_rerun_image(img_name, api_obj)
+      match = img_name.match(/^rbr-(.*)-rt-(.*):initial/)
+      if my_object?( match )
+        @rerun_img = NamedDockerImage.new( img_name, api_obj )
+        true
+      else
+        false
+      end
+    end
+
+    def modified?
+      !@cont[:dirty].nil?
+    end
+
+    def execution_container
+      @cont[:running]
+    end
+
+    def modification_container
+      @cont[:dirty]
+    end
+
+    def ==(other)
+      (other.name == @name) && (other.tag == @tag)
+    end
+
+    attr_reader :name, :tag, :img, :rerun_img
+
+    private
+
+    def initialize(name, tag, img)
+      @name, @tag, @img, @cont = name, tag, img, {}
+    end
+
+    def my_object?(match)
+      match && (match[1] == @name) && (match[2] == @tag)
+    end
+
+    def try_attach_container(type, cont_name, api_obj)
+      match = cont_name.match(/^\/rbe-#{type.to_s.chars.first}-(.*)-rt-(.*)/)
+      if my_object?( match )
+        @cont[type] = NamedDockerContainer.new( cont_name, api_obj )
+        true
+      else
+        false
+      end
+    end
+
+    private_class_method :new
+  end
+
+  class PresentEnvironments
+    include Enumerable
+    extend Forwardable
+
+    def initialize(api_module = Docker)
+      @api_module = api_module
+      refresh!
+    end
+
+    def refresh!
+      cache_images
+      attach_containers
+      attach_rerun_images
+    end
+
+    def_delegators :@all, :each
+    attr_reader :all
+
+    def dangling
+      rbld_images(dangling: ['true'])
+    end
+
+    def get(name)
+      find { |e| e == name }
+    end
+
+    private
+
+    def rbld_obj_filter
+      { label: ["re-build-environment=true"] }
+    end
+
+    def rbld_images(filters = nil)
+      filters = rbld_obj_filter.merge( filters || {} )
+      @api_module::Image.all( :filters => filters.to_json )
+    end
+
+    def rbld_containers
+      @api_module::Container.all( all: true, filters: rbld_obj_filter.to_json )
+    end
+
+    def cache_images
+      @all = []
+      rbld_images.each do |img|
+        rbld_log.debug("Found docker image #{img}")
+        img.info['RepoTags'].each { |tag| @all << Environment.from_image( tag, img ) }
+      end
+      @all.compact!
+    end
+
+    def attach_containers
+      rbld_containers.each do |cont|
+        rbld_log.debug("Found docker container #{cont}")
+        cont.info['Names'].each do |name|
+          @all.find { |e| e.attach_container( name, cont ) }
+        end
+      end
+    end
+
+    def attach_rerun_images
+      rbld_images.each do |img|
+        rbld_log.debug("Found docker image #{img}")
+        img.info['RepoTags'].each do |tag|
+          @all.find { |e| e.attach_rerun_image( tag, img ) }
+        end
+      end
+    end
+  end
+
+  rebuild_errors \
+   UnsupportedDockerService: 'Unsupported docker service: %s',
+   EnvironmentIsModified: 'Environment is modified, commit or checkout first',
+   EnvironmentNotKnown: 'Unknown environment %s',
+   NoChangesToCommit: 'No changes to commit for %s',
+   EnvironmentLoadFailure: 'Failed to load environment from %s',
+   EnvironmentSaveFailure: 'Failed to save environment %s to %s',
+   EnvironmentDeploymentFailure: 'Failed to deploy from %s',
+   EnvironmentAlreadyExists: 'Environment %s already exists',
+   EnvironmentNotFoundInTheRegistry: 'Environment %s does not exist in the registry',
+   RegistrySearchFailed: 'Failed to search in %s',
+   EnvironmentPublishCollision: 'Environment %s already published',
+   EnvironmentPublishFailure: 'Failed to publish on %s',
+   EnvironmentCreateFailure: 'Failed to create %s'
+
+  class EnvironmentFile
+    def initialize(filename, docker_api = Docker)
+      @filename, @docker_api = filename, docker_api
+    end
+
+    def load!
+      begin
+        with_gzip_reader { |gz| Docker::Image.load(gz) }
+      rescue => msg
+        rbld_print.trace( msg )
+        raise EnvironmentLoadFailure, @filename
+      end
+    end
+
+    def save!(name, identity)
+      begin
+        with_gzip_writer do |gz|
+          Docker::Image.save_stream( identity ) { |chunk| gz.write chunk }
+        end
+      rescue => msg
+        rbld_print.trace( msg )
+        raise EnvironmentSaveFailure, [name, @filename]
+      end
+    end
+
+    private
+
+    def with_gzip_writer
+      begin
+        File.open(@filename, 'w') do |f|
+          gz = Zlib::GzipWriter.new(f)
+          begin
+            yield gz
+          ensure
+            gz.close
+          end
+        end
+      rescue
+        FileUtils::safe_unlink( @filename )
+        raise
+      end
+    end
+
+    def with_gzip_reader
+      Zlib::GzipReader.open( @filename ) do |gz|
+        begin
+          yield gz
+        ensure
+          gz.close
+        end
+      end
+    end
+  end
+
+  class DockerContext
+    def self.from_file(file)
+      base = %Q{
+        FROM scratch
+        ADD #{file} /
+      }
+
+      new( base, file )
+    end
+
+    def self.from_image(img)
+      base = %Q{
+        FROM #{img}
+      }
+
+      new( base )
+    end
+
+    def initialize(base, basefile = nil)
+      @base, @basefile = base, basefile
+    end
+
+    def prepare
+      tarfile_name = Dir::Tmpname.create('rbldctx') {}
+
+      rbld_log.info("Storing context in #{tarfile_name}")
+
+      File.open(tarfile_name, 'wb+') do |tarfile|
+        Gem::Package::TarWriter.new( tarfile ) do |tar|
+
+          files = bootstrap_file_pathnames
+          files << @basefile unless @basefile.nil?
+
+          files.each do |file_name|
+            tar.add_file(File.basename(file_name), 0640) do |t|
+              IO.copy_stream(file_name, t)
+            end
+          end
+
+          tar.add_file('Dockerfile', 0640) do |t|
+            t.write( dockerfile )
+          end
+
+        end
+      end
+
+      File.open(tarfile_name, 'r') { |f| yield f }
+    ensure
+      FileUtils::rm_f( tarfile_name )
+    end
+
+    private
+
+    def bootstrap_files
+      ["re-build-bootstrap-utils",
+       "re-build-entry-point",
+       "re-build-env-prepare",
+       "rebuild.rc"]
+    end
+
+    def bootstrap_file_pathnames
+      src_path = File.join( File.dirname( __FILE__ ), "bootstrap" )
+      src_path = File.expand_path( src_path )
+      bootstrap_files.map { |f| File.join( src_path, f ) }
+    end
+
+    def dockerfile
+      # sync after chmod is needed because of an AuFS problem described in:
+      # https://github.com/docker/docker/issues/9547
+      %Q{
+        #{@base}
+        LABEL re-build-environment=true
+        COPY #{bootstrap_files.join(' ')} /rebuild/
+        RUN chown root:root \
+              /rebuild/re-build-env-prepare \
+              /rebuild/re-build-bootstrap-utils \
+              /rebuild/rebuild.rc && \
+              chmod 700 \
+              /rebuild/re-build-entry-point \
+              /rebuild/re-build-env-prepare && \
+              sync && \
+              chmod 644 \
+              /rebuild/rebuild.rc \
+              /rebuild/re-build-bootstrap-utils && \
+              sync && \
+              /rebuild/re-build-env-prepare
+              ENTRYPOINT ["/rebuild/re-build-entry-point"]
+            }.squeeze(' ')
+    end
+
+    private_class_method :new
+  end
+
+  class API
+    extend Forwardable
+
+    def initialize(docker_api = Docker, cfg = Rebuild::Config.new)
+      @docker_api, @cfg = docker_api, cfg
+
+      tweak_excon
+      check_connectivity
+      @cache = PresentEnvironments.new
+    end
+
+    def remove!(env_name)
+      env = unmodified_env( env_name )
+      env.img.remove!
+      @cache.refresh!
+    end
+
+    def load!(filename)
+      EnvironmentFile.new( filename ).load!
+      # If image with the same name but another
+      # ID existed before load it becomes dangling
+      # and should be ditched
+      @cache.dangling.each(&:remove)
+      @cache.refresh!
+    end
+
+    def save(env_name, filename)
+      env = existing_env( env_name )
+      EnvironmentFile.new( filename ).save!(env_name, env.img.identity)
+    end
+
+    def search(env_name)
+      rbld_print.progress "Searching in #{@cfg.remote!}..."
+
+      begin
+        registry.search( env_name.name, env_name.tag )
+      rescue => msg
+        rbld_print.trace( msg )
+        raise RegistrySearchFailed, @cfg.remote!
+      end
+    end
+
+    def deploy!(env_name)
+      nonexisting_env(env_name)
+
+      raise EnvironmentNotFoundInTheRegistry, env_name.full \
+        if registry.search( env_name.name, env_name.tag ).empty?
+
+      rbld_print.progress "Deploying from #{@cfg.remote!}..."
+
+      begin
+       registry.deploy( env_name.name, env_name.tag ) do |img|
+         new_name = NameFactory.new(env_name).identity
+         img.tag( repo: new_name.name, tag: new_name.tag )
+       end
+      rescue => msg
+       rbld_print.trace( msg )
+       raise EnvironmentDeploymentFailure, @cfg.remote!
+      end
+
+      @cache.refresh!
+    end
+
+    def publish(env_name)
+      env = unmodified_env( env_name )
+
+      rbld_print.progress "Checking for collisions..."
+
+      raise EnvironmentPublishCollision, env_name \
+         unless registry.search( env_name.name, env_name.tag ).empty?
+
+      begin
+        rbld_print.progress "Publishing on #{@cfg.remote!}..."
+        registry.publish( env.name, env.tag, env.img.api_obj )
+      rescue => msg
+        rbld_print.trace( msg )
+        raise EnvironmentPublishFailure, @cfg.remote!
+      end
+    end
+
+    def run(env_name, cmd)
+      env = existing_env( env_name )
+      run_env_disposable( env, cmd )
+      @cache.refresh!
+      @errno
+    end
+
+    def modify!(env_name, cmd)
+      env = existing_env( env_name )
+
+      rbld_print.progress_start 'Initializing environment'
+
+      if env.modified?
+        rbld_log.info("Running container #{env.modification_container}")
+        rerun_modification_cont(env, cmd)
+      else
+        rbld_log.info("Running environment #{env.img}")
+        rbld_print.progress_end
+        run_env(env, cmd)
+      end
+      @cache.refresh!
+      @errno
+    end
+
+    def commit!(env_name, new_tag)
+      env = existing_env( env_name )
+
+      new_name = Rebuild::Utils::FullImageName.new( env_name.name, new_tag )
+      nonexisting_env(new_name)
+
+      if env.modified?
+        rbld_log.info("Committing container #{env.modification_container}")
+        rbld_print.progress "Creating new environment #{new_name}..."
+
+        names = NameFactory.new( new_name )
+        env.modification_container.flatten( names.identity )
+        env.rerun_img.remove! if env.rerun_img
+      else
+        raise NoChangesToCommit, env_name.full
+      end
+
+      @cache.refresh!
+    end
+
+    def checkout!(env_name)
+      env = existing_env( env_name )
+
+      if env.modified?
+        rbld_log.info("Removing container #{env.modification_container}")
+        env.modification_container.remove!
+      end
+
+      env.rerun_img.remove! if env.rerun_img
+      @cache.refresh!
+    end
+
+    def create!(base, basefile, env_name)
+      begin
+        nonexisting_env(env_name)
+
+        rbld_print.progress "Building environment..."
+
+        context = basefile.nil? ? DockerContext.from_image(base) \
+                                : DockerContext.from_file(basefile)
+
+        new_img = nil
+
+        context.prepare do |tar|
+          opts = { t: NameFactory.new(env_name).identity,
+                   rm: true }
+          new_img = Docker::Image.build_from_tar( tar, opts ) do |v|
+            begin
+              if ( log = JSON.parse( v ) ) && log.has_key?( "stream" )
+                rbld_print.raw_trace( log["stream"] )
+              end
+            rescue
+            end
+          end
+        end
+      rescue Docker::Error::DockerError => msg
+        new_img.remove( :force => true ) if new_img
+        rbld_print.trace( msg )
+        raise EnvironmentCreateFailure, "#{env_name.full}"
+      end
+
+      @cache.refresh!
+    end
+
+    def_delegator :@cache, :all, :environments
+
+    private
+
+    def tweak_excon
+      # docker-api use Excon to issue HTTP requests
+      # and default Excon timeouts which are 60 seconds
+      # apply to all docker-api actions.
+      # Some long-running actions like image build may
+      # take more than 1 minute so timeout needs to be
+      # increased
+      Excon.defaults[:write_timeout] = 600
+      Excon.defaults[:read_timeout] = 600
+    end
+
+    def check_connectivity
+      begin
+        @docker_api.validate_version!
+      rescue Docker::Error::VersionError => msg
+        raise UnsupportedDockerService, msg
+      end
+    end
+
+    def registry
+      @registry ||= Rebuild::Registry::API.new( @cfg.remote! )
+      @registry
+    end
+
+    def run_external(cmdline)
+      rbld_log.info("Executing external command #{cmdline}")
+      system( cmdline )
+      @errno = $?.exitstatus
+      rbld_log.info( "External command returned with code #{@errno}" )
+    end
+
+    def run_settings(env, cmd, opts = {})
+       %Q{ -i #{STDIN.tty? ? '-t' : ''}                               \
+           -v #{Dir.home}:#{Dir.home}                                 \
+           -e REBUILD_USER_ID=#{Process.uid}                          \
+           -e REBUILD_GROUP_ID=#{Process.gid}                         \
+           -e REBUILD_USER_NAME=#{Etc.getlogin}                       \
+           -e REBUILD_GROUP_NAME=#{Etc.getgrgid(Process.gid)[:name]}  \
+           -e REBUILD_USER_HOME=#{Dir.home}                           \
+           -e REBUILD_PWD=#{Dir.pwd}                                  \
+           --security-opt label:disable                               \
+           #{opts[:rerun] ? env.rerun_img.id : env.img.id}            \
+           "#{cmd.join(' ')}"                                         \
+       }
+    end
+
+    def run_env_disposable(env, cmd)
+      env.execution_container.remove! if env.execution_container
+      names = NameFactory.new(env)
+
+      cmdline = %Q{
+        docker run                           \
+             --rm                            \
+             --name #{names.running}         \
+             --hostname #{names.hostname}    \
+             #{run_settings( env, cmd )}     \
+      }
+
+      run_external( cmdline )
+    end
+
+    def run_env(env, cmd, opts = {})
+      names = NameFactory.new(env)
+
+      cmdline = %Q{
+        docker run                                     \
+               --name #{names.modified}                \
+               --hostname #{names.modified_hostname}   \
+               #{run_settings( env, cmd, opts )}       \
+      }
+
+      run_external( cmdline )
+    end
+
+    def rerun_modification_cont(env, cmd)
+      rbld_print.progress_tick
+
+      names = NameFactory.new( env )
+      new_img = env.modification_container.commit( names.rerun )
+
+      rbld_print.progress_tick
+
+      #Remove old re-run image in case it became dangling
+      @cache.dangling.each(&:remove)
+
+      rbld_print.progress_end
+
+      @cache.refresh!
+
+      run_env( @cache.get(env), cmd, rerun: true )
+    end
+
+    def existing_env(name)
+      env = @cache.get(name)
+      raise EnvironmentNotKnown, name.full unless env
+      env
+    end
+
+    def unmodified_env(name)
+      env = existing_env( name )
+      raise EnvironmentIsModified if env.modified?
+      env
+    end
+
+    def nonexisting_env(name)
+      raise EnvironmentAlreadyExists, name.full if @cache.get(name)
+    end
+  end
+end