linecook-gem 0.6.10 → 0.7.0

data/lib/linecook-gem/provisioner/manager.rb

@@ -1,47 +0,0 @@
-require 'securerandom'
-require 'fileutils'
-
-require 'linecook-gem/builder/build'
-require 'linecook-gem/provisioner/chef-zero'
-require 'linecook-gem/provisioner/packer'
-
-module Linecook
-  module Baker
-    extend self
-
-    def bake(name: nil, tag: nil, id: nil, snapshot: nil, upload: nil, package: nil, build: nil, keep: nil, clean: nil)
-      build_agent = Linecook::Build.new(name, tag: tag, id: id, image: image(name))
-      resume = clean ? false : true
-      provider(name).provision(build_agent, name) if build
-      snapshot = build_agent.snapshot(save: true, resume: resume) if snapshot ||  upload || package
-      Linecook::ImageManager.upload(snapshot, type: build_agent.type) if upload || package
-      Linecook::Packager.package(snapshot, type: build_agent.type, ami: true) if package
-    rescue => e
-      puts e.message
-      puts e.backtrace
-      raise e
-    ensure
-      build_agent.stop(clean: clean) unless keep
-      build_agent.clean if clean
-      FileUtils.rm_f(snapshot) if clean && File.exists?(snapshot.to_s)
-    end
-
-  private
-
-    def image(name)
-      Linecook.config[:roles][name.to_sym][:image]
-    end
-
-    def provider(name)
-      provisioner = Linecook.config[:roles][name.to_sym][:provisioner] || Linecook.config[:provisioner][:default_provider]
-      case provisioner
-      when :chefzero
-        Linecook::Chef
-      when :packer
-        Linecook::Packer
-      else
-        fail "Unsupported provisioner #{provisioner}"
-      end
-    end
-  end
-end

data/lib/linecook-gem/provisioner/packer.rb

@@ -1,82 +0,0 @@
-require 'json'
-require 'tempfile'
-require 'mkmf'
-require 'fileutils'
-
-require 'linecook-gem/util/executor'
-
-
-module Linecook
-  module Packer
-    def self.provision(build, role)
-      Runner.new(build, role).run
-    end
-
-    class Runner
-      SOURCE_URL = 'https://releases.hashicorp.com/packer/'
-      PACKER_VERSION = '0.8.6'
-      PACKER_PATH = File.join(Linecook::Config::LINECOOK_HOME, 'bin', 'packer')
-
-      include Executor
-
-      def initialize(build, role)
-        role_config = Linecook.config[:roles][role.to_sym]
-        @packer = packer_path
-        @build = build
-        @template = role_config[:template_path]
-      end
-
-      def run
-        @build.start
-        packer_template = inject_builder
-        Tempfile.open('packer-linecook') do |template|
-          template.write(JSON.dump(packer_template))
-          template.flush
-          execute("#{@packer} build #{template.path}", sudo: false)
-        end
-      end
-
-    private
-
-      def packer_path
-        found = File.exists?(PACKER_PATH) ? PACKER_PATH : find_executable('packer')
-        path = if found
-          version = execute("#{found} --version", sudo: false, capture: true)
-          Gem::Version.new(version) >= Gem::Version.new(PACKER_VERSION) ? found : nil
-        end
-
-        path ||= get_packer
-      end
-
-      def get_packer
-        puts "packer too old (<#{PACKER_VERSION}) or not present, getting latest packer"
-        arch = 1.size == 8 ? 'amd64' : '386'
-        path = File.join(File.dirname(PACKER_PATH), 'packer.zip')
-        url = File.join(SOURCE_URL, PACKER_VERSION, "packer_#{PACKER_VERSION}_#{Linecook::Config.platform}_#{arch}.zip")
-        Linecook::Downloader.download(url, path)
-        Linecook::Downloader.unzip(path)
-        PACKER_PATH
-      end
-
-      def inject_builder
-        packer_template = JSON.load(File.read(@template)).symbolize_keys
-        packer_template.merge(builders: null_builder)
-      end
-
-      def null_builder
-        [ communicator.merge(type: 'null') ]
-      end
-
-      def communicator
-        {
-          ssh_host: @build.ssh.hostname,
-          ssh_username: @build.ssh.username,
-          ssh_private_key_file: @build.ssh.keyfile,
-          ssh_bastion_host: Linecook::Builder.ssh.hostname,
-          ssh_bastion_username: Linecook::Builder.ssh.username,
-          ssh_bastion_private_key_file: Linecook::Builder.ssh.keyfile,
-        }
-      end
-    end
-  end
-end

data/lib/linecook-gem/util/config.rb

@@ -1,134 +0,0 @@
-require 'yaml'
-require 'json'
-require 'fileutils'
-
-require 'xhyve'
-
-module Linecook
-  def self.config
-    config = Config.load_config
-    config
-  end
-
-  module Config
-    extend self
-    attr_reader :config
-
-    LXC_MIN_VERSION = '1.1.4'
-    CONFIG_PATH = File.join(Dir.pwd, 'linecook.yml').freeze # File.expand_path('../../../config/config.yml', __FILE__)
-    SECRETS_PATH = File.join(Dir.pwd, 'secrets.ejson').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'
-      },
-      provisioner: {
-        default_provider: :chefzero,
-        default_image: :base_image,
-        chefzero: {
-          audit: true
-        }
-      },
-      image: {
-        provider: {
-          public: :github,
-          private: :s3,
-        },
-        images: {
-          live_iso: {
-            name: 'livesys.iso',
-            profile: :public,
-          },
-          live_image: {
-            name: 'livesys.squashfs',
-            profile: :public,
-          },
-          base_image: {
-            name: 'ubuntu-base.squashfs',
-            profile: :public,
-          }
-        }
-      },
-      packager: {
-        provider: :ebs,
-        ebs: {
-          hvm: true,
-          size: 10,
-          region: 'us-east-1',
-          copy_regions: [],
-          account_ids: []
-        }
-      },
-      roles: {
-      }
-    }
-
-    def secrets
-      @secrets ||= begin
-        secrets_path = ENV['LINECOOK_SECRETS_PATH'] || SECRETS_PATH
-        if File.exists?(secrets_path)
-          ejson_path = File.join(Gem::Specification.find_by_name('ejson').gem_dir, 'build', "#{Linecook::Config.platform}-amd64", 'ejson' )
-          command = "#{ejson_path} decrypt #{secrets_path}"
-          secrets = JSON.load(`sudo #{command}`)
-          secrets.deep_symbolize_keys
-        else
-          {}
-        end
-      end
-    end
-
-    def load_config
-      @config ||= begin
-        config_path = ENV['LINECOOK_CONFIG_PATH'] || CONFIG_PATH
-        config = YAML.load(File.read(DEFAULT_CONFIG_PATH)) if File.exist?(DEFAULT_CONFIG_PATH)
-        config.deep_merge!(YAML.load(File.read(config_path))) if File.exist?(config_path)
-        (config || {}).deep_symbolize_keys!
-        config.deep_merge!(secrets)
-      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
-
-  private
-
-    def setup
-      FileUtils.mkdir_p(LINECOOK_HOME)
-      config = {}
-      config.merge!(YAML.load(File.read(DEFAULT_CONFIG_PATH))) if File.exist?(DEFAULT_CONFIG_PATH)
-      File.write(DEFAULT_CONFIG_PATH, YAML.dump(DEFAULT_CONFIG.deep_merge(config)))
-      check_perms if platform == 'darwin'
-      check_lxc if platform == 'linux'
-    end
-
-    def check_lxc
-      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
-
-    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
-
-    setup
-  end
-end

data/lib/linecook-gem/util/executor.rb

@@ -1,33 +0,0 @@
-module Linecook
-  module Executor
-    def capture(command, sudo: true)
-      execute(command, sudo: sudo, capture: true)
-    end
-
-    def test(check)
-      if @remote
-        return @remote.test(check)
-      else
-        `#{check}`
-        return $?.exitstatus == 0
-      end
-    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
-end

data/lib/linecook-gem/util/ssh.rb

@@ -1,190 +0,0 @@
-require 'openssl'
-
-require 'sshkit'
-require 'sshkit/dsl'
-require 'net/ssh'
-require 'net/ssh/proxy/command'
-
-require 'linecook-gem/util/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
-    MAX_RETRIES = 5
-    attr_reader :username, :password, :hostname, :keyfile
-
-    def self.private_key
-      userkey = File.expand_path("~/.ssh/id_rsa")
-      dedicated_key = File.join(Linecook::Config::LINECOOK_HOME, 'linecook_ssh.pem')
-      unless File.exists?(dedicated_key)
-        File.write(dedicated_key, SSHKey.generate.private_key)
-        FileUtils.chmod(0600, dedicated_key)
-      end
-      File.exists?(userkey) ? userkey : dedicated_key
-    end
-
-    def self.public_key(keyfile: nil)
-      SSHKey.new(File.read(keyfile || private_key)).ssh_public_key
-    end
-
-    # Generate a fingerprint for an SSHv2 key used by amazon, yes, this is ugly
-    def self.sshv2_fingerprint(key)
-      _, blob = key.split(/ /)
-      blob = blob.unpack("m*").first
-      reader = Net::SSH::Buffer.new(blob)
-      k=reader.read_key
-      OpenSSL::Digest.new('md5',k.to_der).hexdigest.scan(/../).join(":")
-    end
-
-    def initialize(hostname, username: 'ubuntu', password: nil, keyfile: nil, proxy: nil, setup: true)
-      @username = username
-      @password = password
-      @hostname = hostname
-      @keyfile = keyfile
-      @proxy = proxy_command(proxy) if proxy
-      wait_for_connection
-      setup_ssh_key if @keyfile && setup
-    end
-
-    def forward(local, remote:nil)
-      remote ||= local
-      opts = { password: @password, paranoid: Net::SSH::Verifiers::Null.new }
-      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
-
-    def download(path, local: nil)
-      on linecook_host do |_host|
-        download! path, local || File.basename(path)
-      end
-    end
-
-    private
-
-    def wait_for_connection
-      puts "Waiting for SSH connection"
-      attempts = 0
-      while attempts < MAX_RETRIES
-        begin
-          run("echo connected")
-          return
-        rescue SSHKit::Runner::ExecuteError
-          puts "Retrying SSH connection"
-          sleep(5)
-          attempts += 1
-        end
-      end
-    end
-
-    def setup_ssh_key
-      pubkey = Linecook::SSH.public_key(keyfile: @keyfile)
-      config = Linecook.config[:builder]
-      run("mkdir -p /home/#{config[:username]}/.ssh")
-      upload(pubkey, "/home/#{config[:username]}/.ssh/authorized_keys")
-    end
-
-
-    def linecook_host
-      @host ||= begin
-        host = SSHKit::Host.new(user: @username, hostname: @hostname)
-        host.password = @password if @password
-        opts = {paranoid: Net::SSH::Verifiers::Null.new}
-        opts.merge!({ proxy: @proxy }) if @proxy
-        opts.merge!({ keys: [@keyfile], auth_methods: %w(publickey password) }) if @keyfile
-        host.ssh_options = opts
-        host
-      end
-    end
-
-    def proxy_command(proxy)
-      ssh_command = "ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no #{"-i #{@keyfile}" if @keyfile} #{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)