linecook-gem 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: daf691a1760137d1407850c46df82f52f30ab117
+  data.tar.gz: 830e47b2c9d7267c1f362a62ed214b78512e2185
+SHA512:
+  metadata.gz: d5cbe11357a3fa8ea4bae785803da3548e2aebfc30d2a5616ea4403ffb6a3d9b5b349cf38b63129ee4698fa9f6fdaa3bf32a5ee4b431ee63dca6c0906c2b14cd
+  data.tar.gz: d51d2a394fdd2af2a07e9ba70aef43102f305dfadc9843da66f2bdc2bd5aed650673eb79a833a6b63a55ea8d79cab418e23bbb16a3e6bbd75c34549c9c816dbe

data/bin/linecook

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'linecook/cli'
+require 'benchmark'
+
+begin
+  ENV['THOR_DEBUG'] = '1'
+  etime = Benchmark.realtime { Linecook::CLI.start(ARGV) }
+  $stderr.puts "Completed in #{etime}s"
+rescue Thor::UndefinedCommandError, Thor::UnknownArgumentError, Thor::AmbiguousCommandError, Thor::InvocationError => e
+  $stderr.puts(e.message)
+  exit(64)
+rescue Thor::Error => e
+  $stderr.puts(e.message)
+  exit(1)
+end

data/lib/linecook/bake.rb

@@ -0,0 +1,49 @@
+require 'securerandom'
+
+require 'chef-provisioner'
+require 'chefdepartie'
+
+require 'linecook/build'
+
+module Linecook
+  module Baker
+    extend self
+
+    def bake
+      chef_config = setup
+      script = ChefProvisioner::Bootstrap.generate(
+        node_name: chef_config[:node_name],
+        chef_version: chef_config[:version] || nil,
+        first_boot: {
+          run_list: chef_config[:run_list]
+        }
+      )
+
+      puts "Establishing connection to build..."
+      build = Linecook::Build.new('test', 'ubuntu-base.squashfs')
+      build.start
+      build.ssh.forward(chef_port)
+      build.ssh.upload(script, '/tmp/chef_bootstrap')
+      build.ssh.run('sudo bash /tmp/chef_bootstrap')
+      build.ssh.stop_forwarding
+    end
+
+    private
+
+    def setup
+      ChefProvisioner::Config.setup(client: 'linecook', listen: 'localhost')
+      config = Linecook::Config.load_config
+
+      chef_config = config[:chef]
+      chef_config.merge!(node_name: "linecook-#{SecureRandom.uuid}",
+                         chef_server_url: ChefProvisioner::Config.server)
+      # FIXME: sort out cache copying here for concurrent builds of different refs
+      Chefdepartie.run(background: true, config: chef_config, cache: '/tmp/linecook-cache')
+      chef_config
+    end
+
+    def chef_port
+      ChefProvisioner::Config.server.split(':')[-1].to_i
+    end
+  end
+end

data/lib/linecook/build.rb

@@ -0,0 +1,21 @@
+require 'forwardable'
+require 'linecook/builder'
+
+module Linecook
+  class Build
+    extend Forwardable
+
+    def_instance_delegators :@container, :stop, :start, :ip, :info
+
+    def initialize(name, image)
+      Linecook::Builder.start
+      @name = name
+      @image = image
+      @container = Linecook::Lxc::Container.new(name: @name, image: @image, remote: Linecook::Builder.ssh)
+    end
+
+    def ssh
+      @ssh ||= Linecook::SSH.new(@container.ip, username: 'ubuntu', password: 'ubuntu', proxy: Linecook::Builder.ssh)
+    end
+  end
+end

data/lib/linecook/builder.rb

@@ -0,0 +1,81 @@
+require 'forwardable'
+require 'sshkey'
+
+require 'linecook/lxc'
+require 'linecook/darwin_backend'
+require 'linecook/linux_backend'
+#
+# Linux builder:
+#  - just checks for a bridge interface
+#  - download live image, if not already
+#  - sets up lxc container using local lxc config
+#  - copies base image into builder container
+
+# OS X builder:
+#  - download live ISO
+#   - hdiutil
+#  - create cache loopback image
+#   - dd, based on config file.
+#  - start xhyve using gem
+#   - keep track of PID and IP
+#  - copy base image into xhyve cache
+
+# One linecook instance per build, but many linecook instances can share a single builder
+# FIXME: How to deal with concurrent builds on different branches / revisions?
+
+module Linecook
+  module Builder
+    extend self
+    extend Forwardable
+    BUILD_HOME = '/u/lxc'
+
+    def_instance_delegators :backend, :stop, :ip, :info, :running?
+
+    def backend
+      @backend ||= backend_for_platform
+    end
+
+    def start
+      return if running?
+      backend.start
+      setup_ssh
+    end
+
+    def ssh
+      config = Linecook::Config.load_config[:builder]
+      @ssh ||= SSH.new(ip, username: config[:username], password: config[:password])
+    end
+
+    def builds
+      ssh.test("[ -d #{BUILD_HOME} ]") ? ssh.capture("find  #{BUILD_HOME} -maxdepth 1 -mindepth 1 -type d -printf \"%f\n\"").delete(';').lines : []
+    end
+
+    def build_info
+      info = {}
+      builds.each do |build|
+        info[build] = Linecook::Build.new(build, nil).info
+      end
+      info
+    end
+
+    private
+
+    def setup_ssh
+      pubkey = SSHKey.new(File.read(File.expand_path("~/.ssh/id_rsa"))).ssh_public_key
+      config = Linecook::Config.load_config[:builder]
+      ssh.run("mkdir -p /home/#{config[:username]}/.ssh")
+      ssh.upload(pubkey, "/home/#{config[:username]}/.ssh/authorized_keys")
+    end
+
+    def backend_for_platform
+      case Config.platform
+      when 'linux'
+        LinuxBuilder.backend
+      when 'darwin'
+        OSXBuilder.backend
+      else
+        fail "Cannot find supported backend for #{Config.platform}"
+      end
+    end
+  end
+end

data/lib/linecook/cli.rb

@@ -0,0 +1,55 @@
+require 'thor'
+require 'linecook'
+
+class Builder < Thor
+  desc 'info', 'Show builder info'
+  def info
+    puts Linecook::Builder.info
+  end
+
+  desc 'start', 'Start the builder'
+  def start
+    Linecook::Builder.start
+  end
+
+  desc 'stop', 'Stop the builder'
+  def stop
+    Linecook::Builder.stop
+  end
+
+  desc 'ip', 'Show the external ip address of the builder'
+  def ip
+    puts Linecook::Builder.ip
+  end
+end
+
+class Build < Thor
+  desc 'list', 'Show all builds'
+  def list
+    puts Linecook::Builder.builds
+  end
+
+  desc 'info', 'Show build info' # FIXME: accept the build name
+  def info
+    puts Linecook::Builder.build_info
+  end
+end
+
+class Linecook::CLI < Thor
+  desc 'builder SUBCOMMAND', 'Manage builders'
+  subcommand 'builder', Builder
+
+  desc 'build SUBCOMMAND', 'Manage builds'
+  subcommand 'build', Build
+
+  desc 'bake', 'Bake a new image'
+  def bake
+    Linecook::Baker.bake
+  end
+
+  desc 'fetch IMAGE_NAME', 'Fetch an image by name'
+  method_options name: :string
+  def fetch(name)
+    Linecook::ImageFetcher.fetch(name)
+  end
+end

data/lib/linecook/config.rb

@@ -0,0 +1,68 @@
+require 'yaml'
+require 'fileutils'
+
+require 'xhyve'
+
+module Linecook
+  module Config
+    extend self
+    attr_reader :config
+
+    CONFIG_PATH = File.join(Dir.pwd, 'linecook.yml').freeze # File.expand_path('../../../config/config.yml', __FILE__)
+    LINECOOK_HOME = File.expand_path('~/.linecook').freeze
+    DEFAULT_CONFIG_PATH = File.join(LINECOOK_HOME, 'config.yml').freeze
+    DEFAULT_CONFIG = {
+      builder: {
+        image: :live_image,
+        name: 'builder',
+        home: '/u/lxc',
+        username: 'ubuntu',
+        password: 'ubuntu'
+      },
+      images: {
+        live_iso: 'livesys.iso',
+        live_image: 'livesys.squashfs',
+        base_image: 'ubuntu-base.squashfs'
+      }
+    }
+
+    def setup
+      FileUtils.mkdir_p(LINECOOK_HOME)
+      File.write(DEFAULT_CONFIG_PATH, YAML.dump(DEFAULT_CONFIG)) unless File.exist?(DEFAULT_CONFIG_PATH)
+      check_perms if platform == 'darwin'
+    end
+
+    def check_perms
+      fix_perms if (File.stat(Xhyve::BINARY_PATH).uid != 0 || !File.stat(Xhyve::BINARY_PATH).setuid?)
+    end
+
+    def fix_perms
+      puts "Xhyve requires root until https://github.com/mist64/xhyve/issues/60 is resolved\nPlease enter your sudo password to setuid on the xhyve binary"
+      system("sudo chown root #{Xhyve::BINARY_PATH}")
+      system("sudo chmod +s #{Xhyve::BINARY_PATH}")
+    end
+
+    def load_config
+      @config ||= begin
+        config = YAML.load(File.read(DEFAULT_CONFIG_PATH)) if File.exist?(DEFAULT_CONFIG_PATH)
+        config.merge!(YAML.load(File.read(CONFIG_PATH))) if File.exist?(CONFIG_PATH)
+        # fail "Cookbook path not provided or doesn't exist" unless (config[:chef][:cookbook_path] && Dir.exists?(config[:chef][:cookbook_path]))
+        # fail "Databag secret not provided or doesn't exist" unless (config[:chef][:encrypted_data_bag_secret] && File.exists?(config[:chef][:encrypted_data_bag_secret]))
+        (config || {}).deep_symbolize_keys
+      end
+    end
+
+    def platform
+      case RbConfig::CONFIG['host_os'].downcase
+      when /linux/
+        'linux'
+      when /darwin/
+        'darwin'
+      else
+        fail 'Linux and OS X are the only supported systems'
+      end
+    end
+
+    setup
+  end
+end

data/lib/linecook/darwin_backend.rb

@@ -0,0 +1,96 @@
+require 'securerandom'
+require 'linecook/image'
+# FIXME: read config values from config file
+
+module Linecook
+  module OSXBuilder
+    extend self
+    def backend
+      XhyveBackend.new
+    end
+  end
+
+  class XhyveBackend
+    RUN_SPEC_PATH = File.join(Linecook::Config::LINECOOK_HOME, 'xhyve.yml').freeze
+    LINUX_CMDLINE = 'boot=live root=/dev/ram0 live-media=initramfs console=ttyS1,115200 console=tty0 net.ifnames=0 biosdevname=0'.freeze
+
+    attr_reader :ip
+    def initialize
+      spec = load_run_spec
+      @pid = spec[:pid]
+      @ip = spec[:ip]
+      @uuid = spec[:uuid]
+    end
+
+    def info
+      {ip: @ip, pid: @pid, uuid: @uuid}
+    end
+
+    def start
+      launch_guest unless running?
+    end
+
+    def stop
+      return false unless @pid
+      Process.kill('KILL', @pid)
+      @ip = nil
+      @pid = nil
+      save_run_spec
+    end
+
+    def running?
+      return false unless @pid
+      (true if Process.kill(0, @pid) rescue false)
+    end
+
+  private
+
+    def launch_guest
+      get_iso
+      boot_path = File.join(mount_iso, 'BOOT')
+      puts "Starting xhyve guest..."
+      @uuid ||= SecureRandom.uuid
+      guest = Xhyve::Guest.new(
+          kernel: File.join(boot_path, 'VMLINUZ'),
+          initrd: File.join(boot_path, 'INITRD'),
+          cmdline: LINUX_CMDLINE,   # boot flags to linux
+          #blockdevs: 'loop.img',     # path to img files to use as block devs # FIXME
+          uuid: @uuid,
+          serial: 'com2',
+          memory: '4G', # FIXME
+          processors: 1,             # number of processors #FIXME
+          networking: true,          # Enable networking? (requires sudo)
+          acpi: true,                 # set up acpi? (required for clean shutdown)
+          )
+      guest.start
+      puts "Started with #{guest.mac}... waiting for network"
+      @ip = guest.ip
+      @pid = guest.pid
+      unless @ip
+        @guest.kill
+        fail 'Could not acquire ip' 
+      end
+      puts "Network acquired, IP is #{@ip}"
+      save_run_spec
+      # wait_ssh # FIXME: we need to wait until SSH is actually up or we will sometimes timeout
+    end
+
+    # get and mount the iso
+    def get_iso
+      image = Linecook::Config.load_config[:images][:live_iso]
+      @image_path = Linecook::ImageFetcher.fetch(image)
+    end
+
+    def mount_iso
+      `hdiutil mount #{@image_path}`.strip.split(/\s+/).last
+    end
+
+    def save_run_spec
+      File.write(RUN_SPEC_PATH, YAML.dump(info))
+    end
+
+    def load_run_spec
+      File.exists?(RUN_SPEC_PATH) ? YAML.load(File.read(RUN_SPEC_PATH)) : {}
+    end
+  end
+end

data/lib/linecook/image.rb

@@ -0,0 +1,51 @@
+require 'open-uri'
+require 'fileutils'
+require 'digest'
+
+require 'octokit'
+require 'ruby-progressbar'
+
+module Linecook
+  module ImageFetcher
+    extend self
+
+    def fetch(name, upgrade:false)
+      dir = File.join(Config::LINECOOK_HOME, 'images')
+      path = File.join(dir, name)
+      download(image(name)[:browser_download_url], path) unless File.exist?(path) || upgrade
+      path
+    end
+
+    private
+
+    def client
+      @client ||= Octokit::Client.new
+    end
+
+    def source
+      @source ||= (Config.load_config['source_repo'] || 'dalehamel/lxb')
+    end
+
+    def latest
+      client.releases(source).sort_by { |r| r[:published_at] }.last
+    end
+
+    def image(name)
+      latest[:assets].find { |a| a[:name] =~ /#{name}/ }
+    end
+
+    def download(url, path)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'w') do |f|
+        pbar = ProgressBar.create(title: File.basename(path), total: nil)
+        IO.copy_stream(open(url,
+                            content_length_proc: lambda do|t|
+                              pbar.total = t if t && 0 < t
+                            end,
+                            progress_proc: lambda do|s|
+                              pbar.progress = s
+                            end), f)
+      end
+    end
+  end
+end

data/lib/linecook/linux_backend.rb

@@ -0,0 +1,21 @@
+module Linecook
+  module LinuxBuilder
+    extend self
+    LXC_MIN_VERSION = '1.0.7'
+
+    def backend
+      check_lxc_version
+      config = Linecook::Config.load_config[:builder]
+      images = Linecook::Config.load_config[:images]
+      Linecook::Lxc::Container.new(name: config[:name], home: config[:home], image: images[config[:image]])
+    end
+
+    private
+
+    # FIXME: move to dependency check during initial setup if on linux
+    def check_lxc_version
+      version = `lxc-info --version`
+      fail "lxc too old (<#{LXC_MIN_VERSION}) or not present" unless Gem::Version.new(version) >= Gem::Version.new(LXC_MIN_VERSION)
+    end
+  end
+end

data/lib/linecook/lxc.rb

@@ -0,0 +1,261 @@
+require 'linecook/ssh'
+require 'linecook/image'
+require 'linecook/config'
+require 'tempfile'
+require 'ipaddress'
+
+module Linecook
+  module Lxc
+    class Container
+      attr_reader :config
+      def initialize(name: 'linecook', home: '/u/lxc', image: nil, remote: :local)
+        @remote = remote == :local ? false : remote
+        config = { utsname: name, rootfs: File.join(home, name, 'rootfs') }
+        config.merge!(network: { type: 'veth', flags: 'up', link: 'lxcbr0' }) # FIXME
+        @config = Linecook::Lxc::Config.generate(config) # FIXME read link from config
+        @source_image = image || Linecook::Config.load_config[:images][:base_image]
+        @name = name
+        @home = home
+      end
+
+      def start
+        setup_image
+        setup_dirs
+        mount_all
+        write_config
+        execute("lxc-start #{container_str} -d")
+        # wait_running # FIXME - poll until it's running, or we can reach a race condition
+        # Don't start a cgmanager if we're already in a container
+        execute('[ -f /etc/init/cgmanager.conf ] && sudo status cgmanager | grep -q running && sudo stop cgmanager || true') if lxc?
+        setup_bridge unless @remote
+        wait_ssh
+        unmount unless running?
+      end
+
+      def stop
+        setup_dirs
+        execute("lxc-stop #{container_str} -k")
+        unmount
+      end
+
+      def ip
+        attempts = 10
+        attempt = 0
+        until info[:ip] || attempt >= attempts
+          attempt += 1
+          sleep(1)
+        end
+        info[:ip].is_a?(Array) ? info[:ip].find { |ip| bridge_network.include?(IPAddress(ip)) } : info[:ip]
+      end
+
+      def running?
+        info[:state] == 'RUNNING'
+      end
+
+      def pid
+        info[:pid]
+      end
+
+      def info
+        @info = {}
+        capture("lxc-info #{container_str}").lines.each do |line|
+          k, v = line.strip.split(/:\s+/)
+          key = k.downcase.to_sym
+          @info[key] = @info[key] ? [@info[key]].flatten << v : v
+        end
+        @info
+      end
+
+      private
+
+      def wait_ssh
+        running = false
+        max_attempts = 60
+        attempts = 0
+        until running || attempts > max_attempts
+          break if capture("lxc-attach -n #{@name} -P #{@home} status ssh") =~ /running/
+          attempts += 1
+          sleep(1)
+        end
+      end
+
+      def lxc?
+        namespaces = capture('cat /proc/1/cgroup').lines.map{ |l| l.strip.split(':').last }.uniq
+        namespaces.length != 1 || namespaces.first != '/'
+      end
+
+      def setup_dirs
+        @lower_dir = tmpdir(label: 'lower')
+        @upper_base = tmpdir(label: 'upper')
+        @upper_dir = File.join(@upper_base, '/upper')
+        @work_dir = File.join(@upper_base, '/work')
+        @overlay = File.join(@home, @name, '/rootfs')
+        @socket_dirs = []
+        (Linecook::Config.load_config[:socket_dirs] ||[]).each{ |sock| @socket_dirs << File.join(@overlay, sock) }
+      end
+
+      def write_config
+        path = if @remote
+                 @remote.upload(@config, '/tmp/lxc-config')
+                 '/tmp/lxc-config'
+               else
+                 file = Tempfile.new('lxc-config')
+                 file.write(@config)
+                 file.close
+                 file.path
+        end
+        execute("mv #{path} #{File.join(@home, @name, 'config')}")
+      end
+
+      def mount_all
+        # Prepare an overlayfs
+        execute("mkdir -p #{@overlay}")
+        execute("mkdir -p #{@lower_dir}")
+        execute("mkdir -p #{@upper_base}")
+        mount(@image_path, @lower_dir, options: '-o loop')
+        mount('tmpfs', @upper_base, type: '-t tmpfs', options:'-o noatime') # FIXME: - don't always be tmpfs
+        execute("mkdir -p #{@work_dir}")
+        execute("mkdir -p #{@upper_dir}")
+        mount('overlay', @overlay, type: '-t overlay', options: "-o lowerdir=#{@lower_dir},upperdir=#{@upper_dir},workdir=#{@work_dir}")
+        # Overlayfs doesn't support unix domain sockets
+        @socket_dirs.each do |sock|
+          execute("mkdir -p #{sock}")
+          mount('tmpfs', sock, type: '-t tmpfs', options:'-o noatime')
+        end
+      end
+
+      def mount(source, dest, type: '', options:'')
+        execute("grep -q #{dest} /etc/mtab || sudo mount #{type} #{options} #{source} #{dest}")
+      end
+
+      def unmount
+        @socket_dirs.each { |sock| execute("umount #{sock}") }
+        execute("umount #{@overlay}")
+        execute("umount #{@upper_base}")
+        execute("umount #{@lower_dir}")
+        execute("rmdir #{@lower_dir}")
+        execute("rmdir #{@upper_base}")
+      end
+
+      def bridge_network
+        broad_ip = Socket.getifaddrs.find do |a|
+          a.name == 'lxcbr0' && a.broadaddr && a.broadaddr.afamily == 2 && !a.broadaddr.inspect_sockaddr.start_with?('169.254')
+        end.broadaddr.inspect_sockaddr
+        IPAddress("#{broad_ip.to_s}/24")
+      end
+
+      def setup_bridge
+        bridge_config = <<-eos
+auto lo
+iface lo inet loopback
+
+auto lxcbr0
+iface lxcbr0 inet dhcp
+  bridge_ports eth0
+  bridge_fd 0
+  bridge_maxwait 0
+eos
+        interfaces = Tempfile.new('interfaces')
+        interfaces.write(bridge_config)
+        interfaces.close
+        execute("mv #{interfaces.path} #{File.join(@home, @name, 'rootfs', 'etc', 'network', 'interfaces')}")
+
+        execute("lxc-attach -n #{@name} -P #{@home} ifup lxcbr0")
+      end
+
+
+      def setup_image
+        @source_path = Linecook::ImageFetcher.fetch(@source_image)
+        if @remote
+          dest = "#{File.basename(@source_path)}"
+          @remote.upload(@source_path, dest) unless @remote.test("[ -f #{dest} ]")
+          @image_path = dest
+        else
+          @image_path = @source_path
+        end
+      end
+
+      def tmpdir(label: 'tmp')
+        "/tmp/#{@name}-#{label}"
+      end
+
+      def container_str
+        "-n #{@name} -P #{@home}"
+      end
+
+      def capture(command, sudo: true)
+        execute(command, sudo: sudo, capture: true)
+      end
+
+      def execute(command, sudo: true, capture: false)
+        command = "sudo #{command}" if sudo
+        if @remote
+          if capture
+            return @remote.capture(command)
+          else
+            @remote.run(command)
+          end
+        else
+          if capture
+            return `#{command}`
+          else
+            system(command)
+          end
+        end
+      end
+    end
+
+    module Config
+      extend self
+      DEFAULT_LXC_CONFIG = {
+        include: '/usr/share/lxc/config/ubuntu.common.conf',
+        aa_profile: 'lxc-container-default-with-nesting',
+        arch: 'x86.64',
+        utsname: 'linecook',
+        rootfs: '/u/lxc/linecook/rootfs',
+        network: {
+          type: 'veth',
+          flags: 'up',
+          link: 'br0'
+        },
+        mount: {
+          auto: 'cgroup'
+        },
+        cgroup: {
+          devices: {
+            allow: [
+              'b 7:* rwm',
+              'c 10:237 rwm'
+            ]
+          }
+        }
+      }.freeze
+
+      def generate(**kwargs)
+        cfg = []
+        flatten(DEFAULT_LXC_CONFIG.merge(kwargs || {})).each do |k, v|
+          [v].flatten.each do |val|
+            cfg << "lxc.#{k}=#{val}"
+          end
+        end
+        cfg.join("\n")
+      end
+
+      private
+
+      def flatten(hash)
+        flattened = {}
+        hash.each do |k, v|
+          if v.is_a?(Hash)
+            flatten(v).each do |key, val|
+              flattened["#{k}.#{key}"] = val
+            end
+          else
+            flattened[k] = v
+          end
+        end
+        flattened
+      end
+    end
+  end
+end

data/lib/linecook/ssh.rb

@@ -0,0 +1,128 @@
+require 'sshkit'
+require 'sshkit/dsl'
+require 'net/ssh'
+require 'net/ssh/proxy/command'
+
+require 'linecook/config'
+
+module Linecook
+  class SSHKit::Formatter::Linecook < SSHKit::Formatter::Pretty
+    def write_command(command)
+      log_command_start(command) unless command.started?
+      log_command_stdout(command) unless command.stdout.empty?
+      log_command_stderr(command) unless command.stderr.empty?
+      log_command_finished(command) if command.finished?
+    end
+
+    def log_command_start(command)
+      print(command, 'run'.colorize(:green), command.to_s.colorize(:yellow))
+    end
+
+    def log_command_stdout(command)
+      command.stdout.lines.each do |line|
+        print(command, 'out'.colorize(:green), line)
+      end
+      command.stdout = ''
+    end
+
+    def log_command_stderr(command)
+      command.stderr.lines.each do |line|
+        print(command, 'err'.colorize(:yellow), line)
+      end
+      command.stderr = ''
+    end
+
+    def log_command_finished(command)
+      if command.failure?
+        print(command, 'failed'.colorize(:red), "with status #{command.exit_status} #{command.to_s.colorize(:yellow)} in #{sprintf('%5.3f seconds', command.runtime)}")
+      else
+        print(command, 'done'.colorize(:green), "#{command.to_s.colorize(:yellow)} in #{sprintf('%5.3f seconds', command.runtime)}")
+      end
+    end
+
+    def print(command, state, message)
+      line = "[#{command.host.to_s.colorize(:blue)}][#{state}] #{message}"
+      line << "\n" unless line.end_with?("\n")
+      original_output << line
+    end
+  end
+
+  class SSH
+
+    attr_reader :username, :hostname
+    def initialize(hostname, username: 'ubuntu', password: nil, proxy: nil)
+      @username = username
+      @password = password
+      @hostname = hostname
+      @proxy = proxy_command(proxy) if proxy
+    end
+
+    def forward(local, remote:nil)
+      remote ||= local
+      opts = { password: @password }
+      opts.merge!({ proxy: @proxy }) if @proxy
+      @session = Net::SSH.start(@hostname, @username, opts)
+      @session.forward.remote(local, '127.0.0.1', remote)
+      # Block to ensure it's open
+      @session.loop { !@session.forward.active_remotes.include?([remote, '127.0.0.1']) }
+      @keep_forwarding = true
+      @forward = Thread.new do
+        @session.loop(0.1) { @keep_forwarding }
+      end
+    end
+
+    def stop_forwarding
+      @keep_forwarding = false
+      @forward.join
+      @session.close unless @session.closed?
+    end
+
+    def test(check)
+      result = nil
+      on linecook_host do |_host|
+        result = test(check)
+      end
+      result
+    end
+
+    def run(command)
+      on linecook_host do |_host|
+        execute(command)
+      end
+    end
+
+    def capture(command)
+      output = nil
+      on linecook_host do |_host|
+        output = capture(command)
+      end
+      output
+    end
+
+    def upload(data, path)
+      on linecook_host do |_host|
+        contents = File.exist?(data) ? data : StringIO.new(data)
+        upload! contents, path
+      end
+    end
+
+    private
+
+    def linecook_host
+      @host ||= begin
+
+        host = SSHKit::Host.new(user: @username, hostname: @hostname)
+        host.password = @password if @password
+        host.ssh_options = { proxy: @proxy } if @proxy
+        host
+      end
+    end
+
+    def proxy_command(proxy)
+      ssh_command = "ssh #{proxy.username}@#{proxy.hostname} nc %h %p"
+      Net::SSH::Proxy::Command.new(ssh_command)
+    end
+  end
+end
+
+SSHKit.config.output = SSHKit::Formatter::Linecook.new($stdout)

data/lib/linecook/version.rb

@@ -0,0 +1,3 @@
+module Linecook
+  VERSION = '0.0.1'
+end

data/lib/linecook.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+
+require 'active_support/all'
+require 'linecook/version'
+require 'linecook/config'
+require 'linecook/build'
+require 'linecook/bake'
+require 'linecook/image'

data/man/LINECOOK.1

@@ -0,0 +1,59 @@
+.TH LINECOOK 1 "December 2015" Unix "User Manuals"
+.SH NAME
+.PP
+linecook \- system image builder
+.SH SYNOPSIS
+.PP
+linecook help [\fB\fCCOMMAND\fR]\- for specific command help
+.SH DESCRIPTION
+.PP
+Linecook 
+.SH CONFIGURATION
+.PP
+Describe config file here once it's been determined
+.SH FILES
+.TP
+\fI\&./linecook.yml\fP
+Local config file. Gets deep merged over the system config file. If not explicitly specified, found from current directory if exists.
+.TP
+\fI~/linecook/config.yml\fP
+The system wide configuration file, base or 'common' configuration. Other configurations get deep merged on top of this.
+.SH DEPENDENCIES
+.PP
+Ruby 2.0 or greater, gem, and bundler.
+.PP
+Does not work and will never work on Windows.
+.SS Linux
+.PP
+Only tested on Gentoo and Ubuntu
+.RS
+.IP \(bu 2
+lxc >= 1.0.7
+.IP \(bu 2
+brutils
+.IP \(bu 2
+dnsmasq
+.IP \(bu 2
+iptables with masquerade support
+.IP \(bu 2
+Linux 3.19 or greater with support for cgroups, and netfilter as described by lxc and iptables for NAT.
+.RE
+.SS OS X
+.RS
+.IP \(bu 2
+OS X 10.10 or later (Hypervisor.framework required for Xhyve)
+.RE
+.SH QUIRKS
+.RS
+.IP \(bu 2
+Overlayfs doesn't support unix domain sockets (yet), so anything using a unix domain socket outside of the /run tree should do manually symlink to /run.
+.IP \(bu 2
+Config file will allow you to explicitly mount tmpfs over things that don't do /run if you need to create unix domain sockets
+.RE
+.SH BUGS
+.PP
+Report bugs against github.com/dalehamel/linecook
+.SH AUTHOR
+.PP
+Dale Hamel 
+\[la]dale.hamel@srvthe.net\[ra]

metadata

@@ -0,0 +1,242 @@
+--- !ruby/object:Gem::Specification
+name: linecook-gem
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dale Hamel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: xhyve-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+- !ruby/object:Gem::Dependency
+  name: sshkit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.7.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.7.1
+- !ruby/object:Gem::Dependency
+  name: sshkey
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+- !ruby/object:Gem::Dependency
+  name: octokit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: chefdepartie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+- !ruby/object:Gem::Dependency
+  name: chef-provisioner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.7.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.7.5
+- !ruby/object:Gem::Dependency
+  name: ipaddress
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: md2man
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+description: Build and snapshot a system image for distribution, CI, or both using
+  real chef cookbooks and a fake server.
+email: dale.hamel@srvthe.net
+executables:
+- linecook
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/linecook
+- lib/linecook.rb
+- lib/linecook/bake.rb
+- lib/linecook/build.rb
+- lib/linecook/builder.rb
+- lib/linecook/cli.rb
+- lib/linecook/config.rb
+- lib/linecook/darwin_backend.rb
+- lib/linecook/image.rb
+- lib/linecook/linux_backend.rb
+- lib/linecook/lxc.rb
+- lib/linecook/ssh.rb
+- lib/linecook/version.rb
+- man/LINECOOK.1
+homepage: http://rubygems.org/gems/linecook
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Build system images using chef zero, LXC, and packer
+test_files: []
+has_rdoc: