vagrant 0.1.0

data/lib/vagrant/downloaders/base.rb

@@ -0,0 +1,13 @@
+module Vagrant
+  module Downloaders
+    # Represents a base class for a downloader. A downloader handles
+    # downloading a box file to a temporary file.
+    class Base
+      include Vagrant::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/vagrant/downloaders/file.rb

@@ -0,0 +1,21 @@
+module Vagrant
+  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/vagrant/downloaders/http.rb

@@ -0,0 +1,47 @@
+module Vagrant
+  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/vagrant/env.rb

@@ -0,0 +1,140 @@
+module Vagrant
+  class Env
+    ROOTFILE_NAME = "Vagrantfile"
+    HOME_SUBDIRS = ["tmp", "boxes"]
+
+    # Initialize class variables used
+    @@persisted_vm = nil
+    @@root_path = nil
+    @@box = nil
+
+    extend Vagrant::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, Vagrant.config.vagrant.dotfile_name); end
+      def home_path; File.expand_path(Vagrant.config.vagrant.home); end
+      def tmp_path; File.join(home_path, "tmp"); end
+      def boxes_path; File.join(home_path, "boxes"); end
+
+      def load!(opts={})
+        load_root_path!(Pathname.new(Dir.pwd), opts)
+        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, ROOTFILE_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(Vagrant.config.vagrant.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!
+        @@box = Box.find(Vagrant.config.vm.box) if Vagrant.config.vm.box
+
+        if @@box
+          logger.info("Reloading configuration to account for loaded box...")
+          load_config!
+        end
+      end
+
+      def load_vm!
+        return unless root_path
+
+        File.open(dotfile_path) do |f|
+          @@persisted_vm = Vagrant::VM.find(f.read)
+        end
+      rescue Errno::ENOENT
+        @@persisted_vm = nil
+      end
+
+      def persist_vm(vm)
+        File.open(dotfile_path, 'w+') do |f|
+          f.write(vm.uuid)
+        end
+      end
+
+      def load_root_path!(path=Pathname.new(Dir.pwd), opts={})
+        if path.to_s == '/'
+          return false if opts[:suppress_errors]
+          error_and_exit(<<-msg)
+A `#{ROOTFILE_NAME}` was not found! This file is required for vagrant to run
+since it describes the expected environment that vagrant is supposed
+to manage. Please create a #{ROOTFILE_NAME} and place it in your project
+root.
+msg
+          return
+        end
+
+        file = "#{path}/#{ROOTFILE_NAME}"
+        if File.exist?(file)
+          @@root_path = path.to_s
+          return true
+        end
+
+        load_root_path!(path.parent, opts)
+      end
+
+      def require_box
+        if !box
+          if !Vagrant.config.vm.box
+            error_and_exit(<<-msg)
+No base box was specified! A base box is required as a staring point
+for every vagrant virtual machine. Please specify one in your Vagrantfile
+using `config.vm.box`
+msg
+          else
+            error_and_exit(<<-msg)
+Specified box `#{Vagrant.config.vm.box}` does not exist!
+
+The box must be added through the `vagrant box add` command. Please view
+the documentation associated with the command for more information.
+msg
+          end
+        end
+      end
+
+      def require_persisted_vm
+        if !persisted_vm
+          error_and_exit(<<-error)
+The task you're trying to run requires that the vagrant environment
+already be created, but unfortunately this vagrant still appears to
+have no box! You can setup the environment by setting up your
+#{ROOTFILE_NAME} and running `vagrant up`
+error
+          return
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ssh.rb

@@ -0,0 +1,43 @@
+module Vagrant
+  class SSH
+    SCRIPT = File.join(File.dirname(__FILE__), '..', '..', 'script', 'vagrant-ssh-expect.sh')
+
+    class << self
+      def connect(opts={})
+        options = {}
+        [:host, :password, :username].each do |param|
+          options[param] = opts[param] || Vagrant.config.ssh.send(param)
+        end
+
+        Kernel.exec "#{SCRIPT} #{options[:username]} #{options[:password]} #{options[:host]} #{port(opts)}".strip
+      end
+
+      def execute
+        Net::SSH.start(Vagrant.config.ssh.host, Vagrant.config[:ssh][:username], :port => port, :password => Vagrant.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?
+        Net::SSH.start(Vagrant.config.ssh.host, Vagrant.config.ssh.username, :port => port, :password => Vagrant.config.ssh.password, :timeout => 5) do |ssh|
+          return true
+        end
+
+        false
+      rescue Errno::ECONNREFUSED, Net::SSH::Disconnect
+        false
+      end
+
+      def port(opts={})
+        opts[:port] || Vagrant.config.vm.forwarded_ports[Vagrant.config.ssh.forwarded_port_key][:hostport]
+      end
+    end
+  end
+end

data/lib/vagrant/util.rb

@@ -0,0 +1,45 @@
+module Vagrant
+  module Util
+    def self.included(base)
+      base.extend Vagrant::Util
+    end
+
+    def error_and_exit(error)
+      abort <<-error
+=====================================================================
+Vagrant 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 Vagrant.config.loaded?
+          @@singleton_logger ||= Vagrant::Logger.new(Vagrant.config.vagrant.log_output)
+        else
+          Vagrant::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')}] Vagrant: #{msg}\n"
+    end
+  end
+end
+

data/lib/vagrant/vm.rb

@@ -0,0 +1,57 @@
+module Vagrant
+  class VM < Actions::Runner
+    include Vagrant::Util
+
+    attr_accessor :vm
+    attr_accessor :from
+
+    class << self
+      # Finds a virtual machine by a given UUID and either returns
+      # a Vagrant::VM object or returns nil.
+      def find(uuid)
+        vm = VirtualBox::VM.find(uuid)
+        return nil if vm.nil?
+        new(vm)
+      end
+    end
+
+    def initialize(vm=nil)
+      @vm = 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 start
+      return if @vm.running?
+
+      actions = [Actions::VM::ForwardPorts, Actions::VM::SharedFolders, Actions::VM::Start]
+      actions.each do |action|
+        add_action(action)
+      end
+
+      execute!
+    end
+
+    def destroy
+      execute!(Actions::VM::Down)
+    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/script/vagrant-ssh-expect.sh

@@ -0,0 +1,22 @@
+#!/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
+
+expect "*password: " {
+  send "$password\r"
+} timeout {
+  send_user "Error connecting"
+}
+
+interact

data/templates/Vagrantfile

@@ -0,0 +1,8 @@
+Vagrant::Config.run do |config|
+  # All Vagrant configuration is done here. For a detailed explanation
+  # and listing of configuration options, please check the documentation
+  # online.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "base"
+end

data/test/test_helper.rb

@@ -0,0 +1,91 @@
+begin
+  require File.expand_path('../.bundle/environment', __FILE__)
+rescue LoadError
+  # Fallback on doing the resolve at runtime.
+  require "rubygems"
+  require "bundler"
+  Bundler.setup
+end
+
+# ruby-debug, not necessary, but useful if we have it
+begin
+  require 'ruby-debug'
+rescue LoadError; end
+
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'vagrant')
+require 'contest'
+require 'mocha'
+
+class Test::Unit::TestCase
+  # Clears the previous config and sets up the new config
+  def mock_config
+    Vagrant::Config.instance_variable_set(:@config_runners, nil)
+    Vagrant::Config.instance_variable_set(:@config, nil)
+
+    Vagrant::Config.run do |config|
+      config.vagrant.dotfile_name = ".hobo"
+
+      config.ssh.username = "foo"
+      config.ssh.password = "bar"
+      config.ssh.host = "baz"
+      config.ssh.forwarded_port_key = "ssh"
+      config.ssh.max_tries = 10
+
+      config.vm.box = "foo"
+      config.vm.box_ovf = "box.ovf"
+      config.vm.base_mac = "42"
+      config.vm.project_directory = "/hobo"
+      config.vm.disk_image_format = 'VMDK'
+      config.vm.forward_port("ssh", 22, 2222)
+
+      config.package.name = 'vagrant'
+      config.package.extension = '.box'
+
+      config.chef.cookbooks_path = "cookbooks"
+      config.chef.provisioning_path = "/tmp/hobo-chef"
+      config.chef.json = {
+        :recipes => ["hobo_main"]
+      }
+
+      config.vagrant.home = '~/.home'
+    end
+
+    if block_given?
+      Vagrant::Config.run do |config|
+        yield config
+      end
+    end
+
+    if block_given?
+      Vagrant::Config.run do |config|
+        yield config
+      end
+    end
+
+    Vagrant::Config.execute!
+  end
+
+  # Sets up the mocks and instantiates an action for testing
+  def mock_action(action_klass, *args)
+    vm = mock("vboxvm")
+    mock_vm = mock("vm")
+    action = action_klass.new(mock_vm, *args)
+
+    mock_vm.stubs(:vm).returns(vm)
+    mock_vm.stubs(:vm=)
+    mock_vm.stubs(:invoke_callback)
+    mock_vm.stubs(:invoke_around_callback).yields
+    mock_vm.stubs(:actions).returns([action])
+
+    [mock_vm, vm, action]
+  end
+
+  # Sets up the mocks and stubs for a downloader
+  def mock_downloader(downloader_klass)
+    tempfile = mock("tempfile")
+    tempfile.stubs(:write)
+
+    [downloader_klass.new, tempfile]
+  end
+end