tenderloin 0.2.0

data/lib/tenderloin/config.rb

@@ -0,0 +1,144 @@
+module Tenderloin
+  def self.config
+    Config.config
+  end
+
+  class Config
+    @config = nil
+    @config_runners = []
+
+    class << self
+      def reset!
+        @config = nil
+        config_runners.clear
+      end
+
+      def config
+        @config ||= Config::Top.new
+      end
+
+      def config_runners
+        @config_runners ||= []
+      end
+
+      def run(&block)
+        config_runners << block
+      end
+
+      def execute!
+        config_runners.each do |block|
+          block.call(config)
+        end
+
+        config.loaded!
+      end
+    end
+  end
+
+  class Config
+    class Base
+      def [](key)
+        send(key)
+      end
+
+      def to_json
+        instance_variables_hash.to_json
+      end
+
+      def instance_variables_hash
+        instance_variables.inject({}) do |acc, iv|
+          acc[iv.to_s[1..-1].to_sym] = instance_variable_get(iv)
+          acc
+        end
+      end
+    end
+
+    class SSHConfig < Base
+      attr_accessor :username
+      attr_accessor :password
+      attr_accessor :host
+      attr_accessor :max_tries
+      attr_accessor :timeout
+    end
+
+    class VMConfig < Base
+      attr_accessor :box
+      attr_accessor :box_vmx
+      attr_accessor :project_directory
+      attr_accessor :hd_location
+
+
+      def initialize
+      end
+
+      def hd_location=(val)
+        raise Exception.new "disk_storage must be set to a directory" unless File.directory?(val)
+        @hd_location=val
+      end
+
+      def base
+        File.expand_path(@base)
+      end
+    end
+
+    class PackageConfig < Base
+      attr_accessor :name
+      attr_accessor :extension
+    end
+
+    class ChefConfig < Base
+      attr_accessor :cookbooks_path
+      attr_accessor :provisioning_path
+      attr_accessor :json
+      attr_accessor :enabled
+
+      def initialize
+        @enabled = false
+      end
+
+      def to_json
+        # Overridden so that the 'json' key could be removed, since its just
+        # merged into the config anyways
+        data = instance_variables_hash
+        data.delete(:json)
+        data.to_json
+      end
+    end
+
+    class TenderloinConfig < Base
+      attr_accessor :dotfile_name
+      attr_accessor :log_output
+      attr_accessor :home
+
+      def home
+        File.expand_path(@home)
+      end
+    end
+
+    class Top < Base
+      attr_reader :package
+      attr_reader :ssh
+      attr_reader :vm
+      attr_reader :chef
+      attr_reader :tenderloin
+
+      def initialize
+        @ssh = SSHConfig.new
+        @vm = VMConfig.new
+        @chef = ChefConfig.new
+        @tenderloin = TenderloinConfig.new
+        @package = PackageConfig.new
+
+        @loaded = false
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def loaded!
+        @loaded = true
+      end
+    end
+  end
+end

data/lib/tenderloin/downloaders/base.rb

@@ -0,0 +1,13 @@
+module Tenderloin
+  module Downloaders
+    # Represents a base class for a downloader. A downloader handles
+    # downloading a box file to a temporary file.
+    class Base
+      include Tenderloin::Util
+
+      # Downloads the source file to the destination file. It is up to
+      # implementors of this class to handle the logic.
+      def download!(source_url, destination_file); end
+    end
+  end
+end

data/lib/tenderloin/downloaders/file.rb

@@ -0,0 +1,21 @@
+module Tenderloin
+  module Downloaders
+    # "Downloads" a file to a temporary file. Basically, this downloader
+    # simply does a file copy.
+    class File < Base
+      BUFFERSIZE = 1048576 # 1 MB
+
+      def download!(source_url, destination_file)
+        # For now we read the contents of one into a buffer
+        # and copy it into the other. In the future, we should do
+        # a system-level file copy (FileUtils.cp).
+        open(source_url) do |f|
+          loop do
+            break if f.eof?
+            destination_file.write(f.read(BUFFERSIZE))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tenderloin/downloaders/http.rb

@@ -0,0 +1,47 @@
+module Tenderloin
+  module Downloaders
+    # Downloads a file from an HTTP URL to a temporary file. This
+    # downloader reports its progress to stdout while downloading.
+    class HTTP < Base
+      # ANSI escape code to clear lines from cursor to end of line
+      CL_RESET = "\r\e[0K"
+
+      def download!(source_url, destination_file)
+        Net::HTTP.get_response(URI.parse(source_url)) do |response|
+          total = response.content_length
+          progress = 0
+          segment_count = 0
+
+          response.read_body do |segment|
+            # Report the progress out
+            progress += segment.length
+            segment_count += 1
+
+            # Progress reporting is limited to every 25 segments just so
+            # we're not constantly updating
+            if segment_count % 25 == 0
+              report_progress(progress, total)
+              segment_count = 0
+            end
+
+            # Store the segment
+            destination_file.write(segment)
+          end
+        end
+
+        complete_progress
+      end
+
+      def report_progress(progress, total)
+        percent = (progress.to_f / total.to_f) * 100
+        print "#{CL_RESET}Download Progress: #{percent.to_i}% (#{progress} / #{total})"
+        $stdout.flush
+      end
+
+      def complete_progress
+        # Just clear the line back out
+        print "#{CL_RESET}"
+      end
+    end
+  end
+end

data/lib/tenderloin/env.rb

@@ -0,0 +1,156 @@
+module Tenderloin
+  class Env
+    BOXFILE_NAME = "Tenderfile"
+    HOME_SUBDIRS = ["tmp", "boxes"]
+
+    # Initialize class variables used
+    @@persisted_vm = nil
+    @@root_path = nil
+    @@box = nil
+
+    extend Tenderloin::Util
+
+    class << self
+      def box; @@box; end
+      def persisted_vm; @@persisted_vm; end
+      def root_path; @@root_path; end
+      def dotfile_path
+        File.join(root_path, $ROOTFILE_NAME + ".loinstate")
+      end
+      def home_path; File.expand_path(Tenderloin.config.tenderloin.home); end
+      def tmp_path; File.join(home_path, "tmp"); end
+      def boxes_path; File.join(home_path, "boxes"); end
+      def vms_path; File.join(home_path, "vms"); end
+
+      def load!
+        load_root_path!
+        load_config!
+        load_home_directory!
+        load_box!
+        load_vm!
+      end
+
+      def load_config!
+        # Prepare load paths for config files
+        load_paths = [File.join(PROJECT_ROOT, "config", "default.rb")]
+        load_paths << File.join(box.directory, BOXFILE_NAME) if box
+        load_paths << File.join(root_path, $ROOTFILE_NAME) if root_path
+
+        # Then clear out the old data
+        Config.reset!
+
+        load_paths.each do |path|
+          logger.info "Loading config from #{path}..."
+          load path if File.exist?(path)
+        end
+
+        # Execute the configurations
+        Config.execute!
+      end
+
+      def load_home_directory!
+        home_dir = File.expand_path(Tenderloin.config.tenderloin.home)
+
+        dirs = HOME_SUBDIRS.collect { |path| File.join(home_dir, path) }
+        dirs.unshift(home_dir)
+
+        dirs.each do |dir|
+          next if File.directory?(dir)
+
+          logger.info "Creating home directory since it doesn't exist: #{dir}"
+          FileUtils.mkdir_p(dir)
+        end
+      end
+
+      def load_box!
+        return unless root_path
+
+        @@box = Box.find(Tenderloin.config.vm.box) if Tenderloin.config.vm.box
+
+        if @@box
+          logger.info("Reloading configuration to account for loaded box...")
+          load_config!
+        end
+      end
+
+      def load_vm!
+        return if !root_path || !File.file?(dotfile_path)
+
+        File.open(dotfile_path) do |f|
+          @@persisted_vm = Tenderloin::VM.find(f.read)
+        end
+      rescue Errno::ENOENT
+        @@persisted_vm = nil
+      end
+
+      def persist_vm(vm_id)
+        File.open(dotfile_path, 'w+') do |f|
+          f.write(vm_id)
+        end
+      end
+
+      def load_root_path!(path=nil)
+        path ||= Pathname.new(Dir.pwd)
+
+        # Stop if we're at the root. 2nd regex matches windows drives
+        # such as C:. and Z:. Portability of this check will need to be
+        # researched.
+        return false if path.to_s == '/' || path.to_s =~ /^[A-Z]:\.$/
+
+        file = "#{path}/#{$ROOTFILE_NAME}"
+        if File.exist?(file)
+          @@root_path = path.to_s
+          return true
+        end
+
+        load_root_path!(path.parent)
+      end
+
+      def require_root_path
+        if !root_path
+          error_and_exit(<<-msg)
+A `#{$ROOTFILE_NAME}` was not found! This file is required for tenderloin to run
+since it describes the expected environment that tenderloin is supposed
+to manage. Please create a #{$ROOTFILE_NAME} and place it in your project
+root.
+msg
+        end
+      end
+
+      def require_box
+        require_root_path
+
+        if !box
+          if !Tenderloin.config.vm.box
+            error_and_exit(<<-msg)
+No base box was specified! A base box is required as a staring point
+for every tenderloin virtual machine. Please specify one in your Tenderfile
+using `config.vm.box`
+msg
+          else
+            error_and_exit(<<-msg)
+Specified box `#{Tenderloin.config.vm.box}` does not exist!
+
+The box must be added through the `tenderloin box add` command. Please view
+the documentation associated with the command for more information.
+msg
+          end
+        end
+      end
+
+      def require_persisted_vm
+        require_root_path
+
+        if !persisted_vm
+          error_and_exit(<<-error)
+The task you're trying to run requires that the tenderloin environment
+already be created, but unfortunately this tenderloin still appears to
+have no box! You can setup the environment by setting up your
+#{$ROOTFILE_NAME} and running `tenderloin up`
+error
+          return
+        end
+      end
+    end
+  end
+end

data/lib/tenderloin/fusion_vm.rb

@@ -0,0 +1,85 @@
+module Tenderloin
+  class FusionVM
+    VMRUN = "/Applications/VMware\\ Fusion.app/Contents/Library/vmrun"
+
+    def initialize(vmx)
+      @vmx = vmx
+    end
+
+    def run(cmd, opts='')
+      retrycount = 0
+      while true
+        res = `#{VMRUN} #{cmd} #{@vmx} #{opts}`
+        if $? == 0
+          return res
+        else
+          if res =~ /VMware Tools are not running/
+            sleep 1; next unless retrycount > 10
+          end
+          raise "Error running vmrun command #{cmd}: " + res
+        end
+      end
+    end
+
+    def start_fusion
+      # Ensure fusion is running.
+      `if [[ -z $(pgrep 'VMware Fusion') ]]; then open /Applications/VMware\\ Fusion.app ; sleep 5 ; fi`
+    end
+
+    def running?()
+      `#{VMRUN} list | grep "#{@vmx}"`
+      $? == 0 ? true : false
+    end
+
+    def start(opts = {})
+      gui_opt = opts[:headless] == true ? "nogui" : "gui"
+      run('start', gui_opt)
+    end
+
+    def stop(opts = {})
+      hard_opt = opts[:force] == true ? "hard" : "soft"
+      run 'stop', hard_opt
+    end
+
+    def delete()
+      run 'deleteVM'
+    end
+
+    def get_guest_var(var)
+      run 'readVariable', 'guestVar ' + var
+    end
+
+    def ip
+      ip = get_guest_var('ip').strip
+      unless ip =~ /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/
+        mac_address = VMXFile.load(@vmx)["ethernet0.generatedAddress"]
+        ip = dhcp_leases[mac_address]
+      end
+      ip
+    end
+
+    def enable_shared_folders
+      run 'enableSharedFolders'
+    end
+
+    def share_folder(name, hostpath)
+      run 'addSharedFolder', "#{name} #{hostpath}"
+    end
+
+    def dhcp_leases
+      mac_ip = {}
+      curLeaseIp = nil
+      Dir['/var/db/vmware/vmnet-dhcpd*.leases'].each do |f|
+        File.open(f).each do |line|
+          case line
+          when /lease (.*) \{/
+            curLeaseIp = $1
+          when /hardware ethernet (.*);/
+            mac_ip[$1] = curLeaseIp
+          end
+        end
+      end
+      mac_ip
+    end
+  end
+end

data/lib/tenderloin/ssh.rb

@@ -0,0 +1,49 @@
+module Tenderloin
+  class SSH
+    SCRIPT = File.join(File.dirname(__FILE__), '..', '..', 'script', 'tenderloin-ssh-expect.sh')
+
+    class << self
+      def connect(opts={})
+        options = {}
+        [:host, :password, :username].each do |param|
+          options[param] = opts[param] || Tenderloin.config.ssh.send(param)
+        end
+
+        Kernel.exec "#{SCRIPT} #{options[:username]} #{options[:password]} #{options[:host]} #{port(opts)}".strip
+      end
+
+      def execute(ip)
+        Net::SSH.start(ip, Tenderloin.config[:ssh][:username], :port => port, :password => Tenderloin.config[:ssh][:password]) do |ssh|
+          yield ssh
+        end
+      end
+
+      def upload!(from, to)
+        execute do |ssh|
+          scp = Net::SCP.new(ssh)
+          scp.upload!(from, to)
+        end
+      end
+
+      def up?(ip)
+        check_thread = Thread.new do
+          begin
+            Thread.current[:result] = false
+            Net::SSH.start(ip, Tenderloin.config.ssh.username, :port => port, :password => Tenderloin.config.ssh.password, :timeout => Tenderloin.config.ssh.timeout) do |ssh|
+              Thread.current[:result] = true
+            end
+          rescue Errno::ECONNREFUSED, Net::SSH::Disconnect
+            # False, its defaulted above
+          end
+        end
+
+        check_thread.join(Tenderloin.config.ssh.timeout)
+        return check_thread[:result]
+      end
+
+      def port(opts={})
+        opts[:port] || 22
+      end
+    end
+  end
+end

data/lib/tenderloin/util.rb

@@ -0,0 +1,51 @@
+module Tenderloin
+  module Util
+    def self.included(base)
+      base.extend Tenderloin::Util
+    end
+
+    def wrap_output
+      puts "====================================================================="
+      yield
+      puts "====================================================================="
+    end
+
+    def error_and_exit(error)
+      abort <<-error
+=====================================================================
+Tenderloin experienced an error!
+
+#{error.chomp}
+=====================================================================
+error
+    end
+
+    def logger
+      Logger.singleton_logger
+    end
+  end
+
+  class Logger < ::Logger
+    @@singleton_logger = nil
+
+    class << self
+      def singleton_logger
+        # TODO: Buffer messages until config is loaded, then output them?
+        if Tenderloin.config.loaded?
+          @@singleton_logger ||= Tenderloin::Logger.new(Tenderloin.config.tenderloin.log_output)
+        else
+          Tenderloin::Logger.new(nil)
+        end
+      end
+
+      def reset_logger!
+        @@singleton_logger = nil
+      end
+    end
+
+    def format_message(level, time, progname, msg)
+      "[#{level} #{time.strftime('%m-%d-%Y %X')}] Tenderloin: #{msg}\n"
+    end
+  end
+end
+

data/lib/tenderloin/vm.rb

@@ -0,0 +1,63 @@
+module Tenderloin
+  class VM < Actions::Runner
+    include Tenderloin::Util
+
+    attr_accessor :vm_id
+    attr_accessor :from
+
+    class << self
+      # Finds a virtual machine by a given UUID and either returns
+      # a Tenderloin::VM object or returns nil.
+      def find(uuid)
+        # TODO - just validate the existence - there's no 'loading' needed
+        new(uuid) if File.exists? File.join(Tenderloin::Env.vms_path, uuid, uuid + ".vmx")
+      end
+    end
+
+    def initialize(vm=nil)
+      @vm_id = vm
+    end
+
+    def package(out_path, include_files=[])
+      add_action(Actions::VM::Export)
+      add_action(Actions::VM::Package, out_path, include_files)
+      execute!
+    end
+
+    def vmx_path
+      File.join(Tenderloin::Env.vms_path, @vm_id, @vm_id + ".vmx")
+    end
+
+    def fusion_vm
+      @fusion_vm ||= FusionVM.new(vmx_path) if vmx_path
+    end
+
+    def start
+      return if running?
+
+      execute!(Actions::VM::Start)
+    end
+
+    def running?
+      fusion_vm.running?
+    end
+
+    def destroy
+      execute!(Actions::VM::Destroy)
+    end
+
+    def suspend
+      execute!(Actions::VM::Suspend)
+    end
+
+    def resume
+      execute!(Actions::VM::Resume)
+    end
+
+    def saved?
+      @vm.saved?
+    end
+
+    def powered_off?; @vm.powered_off? end
+  end
+end

data/lib/tenderloin/vmx_file.rb

@@ -0,0 +1,28 @@
+module Tenderloin
+  class VMXFile
+
+    def self.load(filename)
+      data = {}
+      File.open(filename).each do |line|
+        parts = line.split('=')
+        data[parts[0].strip] = parts[1].strip.gsub!(/^"(.*?)"$/,'\1')
+      end
+      data
+    end
+
+    def self.write(filename, data)
+      File.open(filename, 'w') do |f|
+        data.each do |k,v|
+          f.puts "#{k} = \"#{v}\""
+        end
+      end
+    end
+
+    def self.with_vmx_data(filename, &block)
+      data = load(filename)
+      block.call(data)
+      write(filename, data)
+    end
+
+  end
+end

data/lib/tenderloin.rb

@@ -0,0 +1,14 @@
+libdir = File.dirname(__FILE__)
+$:.unshift(libdir)
+PROJECT_ROOT = File.join(libdir, '..') unless defined?(PROJECT_ROOT)
+
+# The libs which must be loaded prior to the rest
+%w{tempfile open-uri json pathname logger uri net/http net/ssh archive/tar/minitar
+  net/scp fileutils tenderloin/util tenderloin/actions/base tenderloin/downloaders/base tenderloin/actions/runner}.each do |f|
+  require f
+end
+
+# Glob require the rest
+Dir[File.join(PROJECT_ROOT, "lib", "tenderloin", "**", "*.rb")].each do |f|
+  require f
+end

data/script/tenderloin-ssh-expect.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/expect
+
+set uname [lrange $argv 0 0]
+set password [lrange $argv 1 1]
+set host [lrange $argv 2 2]
+set port [lrange $argv 3 3]
+
+if { $port != "" } {
+  set port_option "-p $port"
+} else {
+  set port_option ""
+}
+
+spawn ssh $port_option -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no $uname@$host
+
+set timeout 30
+expect "*password: " {
+  send "$password\r"
+} timeout {
+  send_user "Error connecting"
+}
+
+interact