vagrant 0.4.2 → 0.5.0

data/lib/vagrant/actions/vm/provision.rb

@@ -1,49 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Provision < Base
-        attr_reader :provisioner
-
-        def intialize(*args)
-          super
-
-          @provisioner = nil
-        end
-
-        def prepare
-          provisioner = @runner.env.config.vm.provisioner
-
-          if provisioner.nil?
-            logger.info("Provisioning not enabled, ignoring this step")
-            return
-          end
-
-          if provisioner.is_a?(Class)
-            @provisioner = provisioner.new(@runner)
-            raise ActionException.new(:provisioner_invalid_class) unless @provisioner.is_a?(Provisioners::Base)
-          elsif provisioner.is_a?(Symbol)
-            # We have a few hard coded provisioners for built-ins
-            mapping = {
-              :chef_solo    => Provisioners::ChefSolo,
-              :chef_server  => Provisioners::ChefServer
-            }
-
-            provisioner_klass = mapping[provisioner]
-            raise ActionException.new(:provisioner_unknown_type, :provisioner => provisioner.to_s) if provisioner_klass.nil?
-            @provisioner = provisioner_klass.new(@runner)
-          end
-
-          logger.info "Provisioning enabled with #{@provisioner.class}"
-          @provisioner.prepare
-        end
-
-        def execute!
-          if provisioner
-            logger.info "Beginning provisioning process..."
-            provisioner.provision!
-          end
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/actions/vm/reload.rb

@@ -1,17 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Reload < Base
-        def prepare
-          steps = [Customize, ForwardPorts, SharedFolders, Network, Boot]
-          steps.unshift(Halt) if @runner.vm.running?
-          steps << Provision if !@runner.env.config.vm.provisioner.nil?
-
-          steps.each do |action_klass|
-            @runner.add_action(action_klass)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/actions/vm/resume.rb

@@ -1,16 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Resume < Base
-        def execute!
-          if !@runner.vm.saved?
-            raise ActionException.new(:vm_not_suspended)
-          end
-
-          logger.info "Resuming suspended VM..."
-          @runner.start
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/actions/vm/start.rb

@@ -1,26 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Start < Base
-        def prepare
-          # Start is a "meta-action" so it really just queues up a bunch
-          # of other actions in its place:
-          steps = [Boot]
-          if !@runner.vm || !@runner.vm.saved?
-            steps.unshift([Customize, ForwardPorts, SharedFolders, Network])
-            steps << Provision if provision?
-          end
-
-          steps.flatten.each do |action_klass|
-            @runner.add_action(action_klass, options)
-          end
-        end
-
-        def provision?
-          enabled = options[:provision].nil? ? true : options[:provision]
-          !@runner.env.config.vm.provisioner.nil? && enabled
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/actions/vm/suspend.rb

@@ -1,16 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Suspend < Base
-        def execute!
-          if !@runner.vm.running?
-            raise ActionException.new(:vm_not_running_for_suspend)
-          end
-
-          logger.info "Saving VM state and suspending execution..."
-          @runner.vm.save_state
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/actions/vm/up.rb

@@ -1,53 +0,0 @@
-module Vagrant
-  module Actions
-    module VM
-      class Up < Base
-        def prepare
-          # If the dotfile is not a file, raise error
-          if File.exist?(@runner.env.dotfile_path) && !File.file?(@runner.env.dotfile_path)
-            raise ActionException.new(:dotfile_error, :env => @runner.env)
-          end
-
-          # Up is a "meta-action" so it really just queues up a bunch
-          # of other actions in its place:
-          steps = [Import, Start]
-          steps.insert(0, MoveHardDrive) if @runner.env.config.vm.hd_location
-
-          steps.each do |action_klass|
-            @runner.add_action(action_klass, options)
-          end
-        end
-
-        def after_import
-          update_dotfile
-          setup_mac_address
-          check_guest_additions
-        end
-
-        def update_dotfile
-          logger.info "Persisting the VM UUID (#{@runner.uuid})..."
-          @runner.env.update_dotfile
-        end
-
-        def setup_mac_address
-          logger.info "Matching MAC addresses..."
-          @runner.vm.network_adapters.first.mac_address = @runner.env.config.vm.base_mac
-          @runner.vm.save
-        end
-
-        def check_guest_additions
-          # Use the raw interface for now, while the virtualbox gem
-          # doesn't support guest properties (due to cross platform issues)
-          version = @runner.vm.interface.get_guest_property_value("/VirtualBox/GuestAdd/Version")
-          if version.empty?
-            logger.error Translator.t(:vm_additions_not_detected)
-          elsif version != VirtualBox.version
-            logger.error Translator.t(:vm_additions_version_mismatch,
-                                     :guest_additions_version => version,
-                                     :virtualbox_version => VirtualBox.version)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/busy.rb

@@ -1,79 +0,0 @@
-module Vagrant
-  def self.busy?
-    Busy.busy?
-  end
-
-  def self.busy(&block)
-    Busy.busy(&block)
-  end
-
-  class Busy
-    extend Vagrant::Util
-
-    @@busy = false
-    @@mutex = Mutex.new
-    @@trap_thread = nil
-
-    class << self
-      def busy?
-        @@busy
-      end
-
-      def busy=(val)
-        @@busy = val
-      end
-
-      def busy(&block)
-        @@mutex.synchronize do
-          begin
-            Signal.trap("INT") { wait_for_not_busy }
-            Busy.busy = true
-            block.call
-          ensure
-            # In the case an exception is thrown, make sure we restore
-            # busy back to some sane state.
-            Busy.busy = false
-
-            # Make sure that the trap thread completes, if it is running
-            trap_thread.join if trap_thread
-
-            # And restore the INT trap to the default
-            Signal.trap("INT", "DEFAULT")
-          end
-        end
-      end
-
-      def wait_for_not_busy(sleeptime=5)
-        if @@trap_thread
-          # logger.info "Exiting vagrant immediately!"
-          Thread.kill(@@trap_thread)
-          abort
-          return # for tests
-        end
-
-        @@trap_thread ||= Thread.new do
-          # Wait while the app is busy
-          loop do
-            break unless busy?
-            # logger.info "Waiting for vagrant to clean itself up..."
-            sleep sleeptime
-          end
-
-          # Exit out of the entire script
-          # logger.info "Exiting vagrant..."
-          exit
-        end
-      end
-
-      # Used for testing
-      def reset_trap_thread!
-        @@trap_thread = nil
-      end
-
-      # Returns the trap thread
-      def trap_thread
-        @@trap_thread
-      end
-    end
-  end
-end

data/lib/vagrant/resource_logger.rb

@@ -1,126 +0,0 @@
-require 'thread'
-
-module Vagrant
-  # Represents a logger for a specific resource within Vagrant. Each
-  # logger should be initialized and set to represent a single
-  # resource. Each logged message will then appear in the following
-  # format:
-  #
-  #     [resource] message
-  #
-  # This class is thread safe. The backing class which actually does
-  # all the logging IO is protected.
-  #
-  # This class also handles progress meters of multiple resources and
-  # handles all the proper interleaving and console updating to
-  # display the progress meters in a way which doesn't conflict with
-  # other incoming log messages.
-  class ResourceLogger
-    @@singleton_logger = nil
-    @@progress_reporters = nil
-    @@writer_lock = Mutex.new
-
-    # The resource which this logger represents.
-    attr_reader :resource
-
-    # The environment that this logger is part of
-    attr_reader :env
-
-    # The backing logger which actually handles the IO. This logger
-    # should be a subclass of the standard library Logger, in general.
-    # IMPORTANT: This logger must be thread-safe.
-    attr_reader :logger
-
-    class << self
-      # Returns a singleton logger. If one has not yet be
-      # instantiated, then the given environment will be used to
-      # create a new logger.
-      def singleton_logger(env=nil)
-        if env && env.config && env.config.loaded?
-          @@singleton_logger ||= Util::PlainLogger.new(env.config.vagrant.log_output)
-        else
-          Util::PlainLogger.new(nil)
-        end
-      end
-
-      # Resets the singleton logger (only used for testing).
-      def reset_singleton_logger!
-        @@singleton_logger = nil
-      end
-
-      # Returns the progress parts array which contains the various
-      # progress reporters.
-      def progress_reporters
-        @@progress_reporters ||= {}
-      end
-    end
-
-    def initialize(resource, env)
-      @resource = resource
-      @env = env
-      @logger = self.class.singleton_logger(env)
-    end
-
-    [:debug, :info, :error, :fatal].each do |method|
-      define_method(method) do |message|
-        @@writer_lock.synchronize do
-          # We clear the line in case progress reports have been going
-          # out.
-          print(cl_reset)
-          logger.send(method, "[#{resource}] #{message}")
-        end
-
-        # Once again flush the progress reporters since we probably
-        # cleared any existing ones.
-        flush_progress
-      end
-    end
-
-    # Sets a progress report for the resource that this logger
-    # represents. This progress report is interleaved within the output.
-    def report_progress(progress, total, show_parts=true)
-      # Simply add the progress reporter to the list of progress
-      # reporters
-      self.class.progress_reporters[resource] = {
-        :progress => progress,
-        :total => total,
-        :show_parts => show_parts
-      }
-
-      # And force an update to occur
-      flush_progress
-    end
-
-    # Clears the progress report for this resource
-    def clear_progress
-      self.class.progress_reporters.delete(resource)
-    end
-
-    def flush_progress
-      # Don't do anything if there are no progress reporters
-      return if self.class.progress_reporters.length <= 0
-
-      @@writer_lock.synchronize do
-        reports = []
-
-        # First generate all the report percentages and output
-        self.class.progress_reporters.each do |name, data|
-          percent = (data[:progress].to_f / data[:total].to_f) * 100
-          line = "#{name}: #{percent.to_i}%"
-          line << " (#{data[:progress]} / #{data[:total]})" if data[:show_parts]
-          reports << line
-        end
-
-        # Output it to stdout
-        print "#{cl_reset}[progress] #{reports.join(" ")}"
-        $stdout.flush
-      end
-    end
-
-    def cl_reset
-      reset = "\r"
-      reset += "\e[0K" unless Mario::Platform.windows?
-      reset
-    end
-  end
-end

data/lib/vagrant/util/error_helper.rb

@@ -1,13 +0,0 @@
-module Vagrant
-  module Util
-    def error_and_exit(key, data = {})
-      abort <<-error
-=====================================================================
-Vagrant experienced an error!
-
-#{Translator.t(key, data).chomp}
-=====================================================================
-error
-    end
-  end
-end

data/lib/vagrant/util/output_helper.rb

@@ -1,9 +0,0 @@
-module Vagrant
-  module Util
-    def wrap_output
-      puts "====================================================================="
-      yield
-      puts "====================================================================="
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,149 +0,0 @@
-begin
-  require File.expand_path('../.bundle/environment', __FILE__)
-rescue LoadError
-  # Fallback on doing the resolve at runtime.
-  require "rubygems"
-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
-  # Mocks an environment, setting it up with the given config.
-  def mock_environment
-    environment = Vagrant::Environment.new
-
-    Vagrant::Config.reset!(environment)
-
-    Vagrant::Config.run do |config|
-      config.vagrant.home = '~/.home'
-      config.vagrant.dotfile_name = ".vagrant"
-      config.vagrant.log_output = nil
-
-      config.ssh.username = "foo"
-      config.ssh.host = "baz"
-      config.ssh.port = 22
-      config.ssh.forwarded_port_key = "ssh"
-      config.ssh.max_tries = 10
-      config.ssh.timeout = 10
-      config.ssh.private_key_path = '~/foo'
-
-      config.vm.box = "foo"
-      config.vm.box_ovf = "box.ovf"
-      config.vm.base_mac = "42"
-      config.vm.disk_image_format = 'VMDK'
-      config.vm.forward_port("ssh", 22, 2222)
-      config.vm.shared_folder_uid = nil
-      config.vm.shared_folder_gid = nil
-      config.vm.system = :linux
-      config.vm.share_folder("v-root", "/vagrant", ".")
-
-      config.package.name = 'vagrant'
-      config.package.extension = '.box'
-
-      # Unison
-      config.unison.folder_suffix = ".sync"
-      config.unison.log_file = "foo-%s"
-
-      # Chef
-      config.chef.chef_server_url = "http://localhost:4000"
-      config.chef.validation_key_path = "validation.pem"
-      config.chef.client_key_path = "/zoo/foo/bar.pem"
-      config.chef.node_name = "baz"
-      config.chef.cookbooks_path = "cookbooks"
-      config.chef.provisioning_path = "/tmp/vagrant-chef"
-      config.chef.log_level = :info
-      config.chef.json = {
-        :recipes => ["vagrant_main"]
-      }
-    end
-
-    if block_given?
-      Vagrant::Config.run do |config|
-        yield config
-      end
-    end
-
-    config = Vagrant::Config.execute!
-
-    environment.instance_variable_set(:@config, config)
-
-    # Setup the logger. We create it then reset it so that subsequent
-    # calls will recreate it for us.
-    environment.load_logger!
-    environment.logger.class.reset_singleton_logger!
-    environment.logger.stubs(:flush_progress)
-    environment.logger.stubs(:cl_reset).returns("")
-
-    environment
-  end
-
-  # Sets up the mocks for a VM
-  def mock_vm(env=nil)
-    env ||= mock_environment
-    vm = Vagrant::VM.new
-    vm.stubs(:env).returns(env)
-    vm.stubs(:ssh).returns(Vagrant::SSH.new(vm.env))
-    vm
-  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)
-    stub_default_action_dependecies(action)
-
-    mock_vm.stubs(:name).returns("foo")
-    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.stubs(:env).returns(mock_environment)
-    mock_vm.env.stubs(:logger).returns(quiet_logger("mock"))
-
-    mock_ssh = Vagrant::SSH.new(mock_vm.env)
-    mock_ssh.stubs(:execute)
-
-    mock_vm.stubs(:ssh).returns(mock_ssh)
-
-    vm.stubs(:env).returns(mock_vm.env)
-
-    [mock_vm, vm, action]
-  end
-
-  # Returns a resource logger which is safe for tests
-  def quiet_logger(resource, env=nil)
-    logger = Vagrant::ResourceLogger.new(resource, env)
-    logger.stubs(:flush_progress)
-    logger.stubs(:cl_reset).returns("")
-    logger
-  end
-
-  # Returns a linux system
-  def linux_system(vm)
-    Vagrant::Systems::Linux.new(vm)
-  end
-
-  def stub_default_action_dependecies(mock)
-    mock.stubs(:precedes).returns([])
-    mock.stubs(:follows).returns([])
-  end
-
-  # Sets up the mocks and stubs for a downloader
-  def mock_downloader(downloader_klass)
-    tempfile = mock("tempfile")
-    tempfile.stubs(:write)
-
-    [downloader_klass.new(mock_environment), tempfile]
-  end
-end
-