nixme-vagrant 0.7.2

data/lib/vagrant/test_helpers.rb

@@ -0,0 +1,128 @@
+module Vagrant
+  # Test helpers provided by Vagrant to allow for plugin developers
+  # to write automated tests for their code. This module simply provides
+  # methods which can be included into any test framework (`test/unit`,
+  # RSpec, Shoulda, etc.)
+  module TestHelpers
+    #------------------------------------------------------------
+    # Environment creation helpers
+    #------------------------------------------------------------
+    # Creates a "vagrant_app" directory in the test tmp folder
+    # which can be used for creating test Vagrant environments.
+    # Returns the root directory of the app. This typically doesn't need
+    # to be called directly unless you're setting up a custom application.
+    # See the examples for common use cases.
+    def vagrant_app(*path)
+      root = tmp_path.join("vagrant_app")
+      FileUtils.rm_rf(root)
+      FileUtils.mkdir_p(root)
+      root.join(*path)
+    end
+
+    # Creates a Vagrantfile with the given contents in the given
+    # app directory. If no app directory is specified, then a default
+    # Vagrant app is used.
+    def vagrantfile(*args)
+      path = args.shift.join("Vagrantfile") if Pathname === args.first
+      path ||= vagrant_app("Vagrantfile")
+
+      # Create this box so that it exists
+      vagrant_box("base")
+
+      str  = args.shift || ""
+      File.open(path.to_s, "w") do |f|
+        f.puts "ENV['VAGRANT_HOME'] = '#{home_path}'"
+        f.puts "Vagrant::Config.run do |config|"
+        f.puts "config.vm.base_mac = 'foo' if !config.vm.base_mac"
+        f.puts "config.vm.box = 'base'"
+        f.puts str
+        f.puts "end"
+      end
+
+      path.parent
+    end
+
+    # Creates and _loads_ a Vagrant environment at the given path.
+    # If no path is given, then a default {#vagrantfile} is used.
+    def vagrant_env(*args)
+      path = args.shift if Pathname === args.first
+      path ||= vagrantfile
+      Vagrant::Environment.new(:cwd => path).load!
+    end
+
+    # Creates the folder to contain a vagrant box. This allows for
+    # "fake" boxes to be made with the specified name.
+    #
+    # @param [String] name
+    # @return [Pathname]
+    def vagrant_box(name)
+      result = boxes_path.join(name)
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Returns an instantiated downloader with a mocked tempfile
+    # which can be passed into it.
+    #
+    # @param [Class] klass The downloader class
+    # @return [Array] Returns an array of `downloader` `tempfile`
+    def vagrant_mock_downloader(klass)
+      tempfile = mock("tempfile")
+      tempfile.stubs(:write)
+
+      _, env = action_env
+      [klass.new(env), tempfile]
+    end
+
+    # Returns a blank app (callable) and action environment with the
+    # given vagrant environment. This allows for testing of middlewares.
+    def action_env(v_env = nil)
+      v_env ||= vagrant_env
+      app = lambda { |env| }
+      env = Vagrant::Action::Environment.new(v_env)
+      env["vagrant.test"] = true
+      [app, env]
+    end
+
+    #------------------------------------------------------------
+    # Path helpers
+    #------------------------------------------------------------
+    # Path to the tmp directory for the tests.
+    #
+    # @return [Pathname]
+    def tmp_path
+      result = Vagrant.source_root.join("test", "tmp")
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Path to the "home" directory for the tests
+    #
+    # @return [Pathname]
+    def home_path
+      result = tmp_path.join("home")
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Path to the boxes directory in the home directory
+    #
+    # @return [Pathname]
+    def boxes_path
+      result = home_path.join("boxes")
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Cleans all the test temp paths, which includes the boxes path,
+    # home path, etc. This allows for cleaning between tests.
+    def clean_paths
+      FileUtils.rm_rf(tmp_path)
+
+      # Call these methods only to rebuild the directories
+      tmp_path
+      home_path
+      boxes_path
+    end
+  end
+end

data/lib/vagrant/ui.rb

@@ -0,0 +1,69 @@
+require 'mario'
+
+module Vagrant
+  # Vagrant UIs handle communication with the outside world (typically
+  # through a shell). They must respond to the typically logger methods
+  # of `warn`, `error`, `info`, and `confirm`.
+  class UI
+    attr_accessor :env
+
+    def initialize(env)
+      @env = env
+    end
+
+    [:warn, :error, :info, :confirm, :say_with_vm, :report_progress, :ask, :no?, :yes?].each do |method|
+      # By default these methods don't do anything. A silent UI.
+      define_method(method) { |*args| }
+    end
+
+    # A shell UI, which uses a `Thor::Shell` object to talk with
+    # a terminal.
+    class Shell < UI
+      def initialize(env, shell)
+        super(env)
+
+        @shell = shell
+      end
+
+      [[:warn, :yellow], [:error, :red], [:info, nil], [:confirm, :green]].each do |method, color|
+        class_eval <<-CODE
+          def #{method}(message, opts=nil)
+            @shell.say("\#{line_reset}\#{format_message(message, opts)}", #{color.inspect})
+          end
+        CODE
+      end
+
+      [:ask, :no?, :yes?].each do |method|
+        class_eval <<-CODE
+          def #{method}(message, opts=nil)
+            opts ||= {}
+            @shell.send(#{method.inspect}, format_message(message, opts), opts[:color])
+          end
+        CODE
+      end
+
+      def report_progress(progress, total, show_parts=true)
+        percent = (progress.to_f / total.to_f) * 100
+        line = "Progress: #{percent.to_i}%"
+        line << " (#{progress} / #{total})" if show_parts
+        line = "#{line_reset}#{line}"
+
+        @shell.say(line, nil, false)
+      end
+
+      protected
+
+      def format_message(message, opts=nil)
+        opts = { :prefix => true }.merge(opts || {})
+        message = "[#{env.resource}] #{message}" if opts[:prefix]
+        message
+      end
+
+      def line_reset
+        reset = "\r"
+        reset += "\e[0K" unless Mario::Platform.windows?
+        reset
+      end
+    end
+  end
+end

data/lib/vagrant/util.rb

@@ -0,0 +1,13 @@
+module Vagrant
+  module Util
+    autoload :Busy,                      'vagrant/util/busy'
+    autoload :GlobLoader,                'vagrant/util/glob_loader'
+    autoload :HashWithIndifferentAccess, 'vagrant/util/hash_with_indifferent_access'
+    autoload :PlainLogger,               'vagrant/util/plain_logger'
+    autoload :Platform,                  'vagrant/util/platform'
+    autoload :ResourceLogger,            'vagrant/util/resource_logger'
+    autoload :Retryable,                 'vagrant/util/retryable'
+    autoload :StackedProcRunner,         'vagrant/util/stacked_proc_runner'
+    autoload :TemplateRenderer,          'vagrant/util/template_renderer'
+  end
+end

data/lib/vagrant/util/busy.rb

@@ -0,0 +1,59 @@
+module Vagrant
+  module Util
+    # Utility class which allows blocks of code to be marked as "busy"
+    # with a specified interrupt handler. During busy areas of code, it
+    # is often undesirable for SIGINTs to immediately kill the application.
+    # This class is a helper to cleanly register callbacks to handle this
+    # situation.
+    class Busy
+      @@registered = []
+      @@mutex = Mutex.new
+
+      class << self
+        # Mark a given block of code as a "busy" block of code, which will
+        # register a SIGINT handler for the duration of the block. When a
+        # SIGINT occurs, the `sig_callback` proc will be called. It is up
+        # to the callback to behave properly and exit the application.
+        def busy(sig_callback)
+          register(sig_callback)
+          yield
+        ensure
+          unregister(sig_callback)
+        end
+
+        # Registers a SIGINT handler. This typically is called from {busy}.
+        # Callbacks are only registered once, so calling this multiple times
+        # with the same callback has no consequence.
+        def register(sig_callback)
+          @@mutex.synchronize do
+            registered << sig_callback
+            registered.uniq!
+
+            # Register the handler if this is our first callback.
+            Signal.trap("INT") { fire_callbacks } if registered.length == 1
+          end
+        end
+
+        # Unregisters a SIGINT handler.
+        def unregister(sig_callback)
+          @@mutex.synchronize do
+            registered.delete(sig_callback)
+
+            # Remove the signal trap if no more registered callbacks exist
+            Signal.trap("INT", "DEFAULT") if registered.empty?
+          end
+        end
+
+        # Fires all the registered callbacks.
+        def fire_callbacks
+          registered.each { |r| r.call }
+        end
+
+        # Helper method to get access to the class variable. This is mostly
+        # exposed for tests. This shouldn't be mucked with directly, since it's
+        # structure may change at any time.
+        def registered; @@registered; end
+      end
+    end
+  end
+end

data/lib/vagrant/util/hash_with_indifferent_access.rb

@@ -0,0 +1,63 @@
+module Vagrant
+  module Util
+    # A hash with indifferent access. Mostly taken from Thor/Rails (thanks).
+    # Normally I'm not a fan of using an indifferent access hash since Symbols
+    # are basically memory leaks in Ruby, but since Vagrant is typically a quick
+    # one-off binary run and it doesn't use too many hash keys where this is
+    # used, the effect should be minimal.
+    #
+    #   hash[:foo]  #=> 'bar'
+    #   hash['foo'] #=> 'bar'
+    #
+    class HashWithIndifferentAccess < ::Hash
+      def initialize(hash={}, &block)
+        super(&block)
+
+        hash.each do |key, value|
+          self[convert_key(key)] = value
+        end
+      end
+
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def values_at(*indices)
+        indices.collect { |key| self[convert_key(key)] }
+      end
+
+      def merge(other)
+        dup.merge!(other)
+      end
+
+      def merge!(other)
+        other.each do |key, value|
+          self[convert_key(key)] = value
+        end
+        self
+      end
+
+      def key?(key)
+        super(convert_key(key))
+      end
+
+      alias_method :include?, :key?
+      alias_method :has_key?, :key?
+      alias_method :member?, :key?
+
+      protected
+
+      def convert_key(key)
+        key.is_a?(Symbol) ? key.to_s : key
+      end
+    end
+  end
+end

data/lib/vagrant/util/plain_logger.rb

@@ -0,0 +1,25 @@
+require 'logger'
+
+module Vagrant
+  module Util
+    # Subclass of the standard library logger which has no format on
+    # its own. The message sent to the logger is outputted as-is.
+    class PlainLogger < ::Logger
+      # This is the method which is called for all debug, info, error,
+      # etc. methods by the logger. This is overriden to verify that
+      # the output is always flushed.
+      #
+      # Logger by default syncs all log devices but this just verifies
+      # it is truly flushed.
+      def add(*args)
+        super
+        @logdev.dev.flush if @logdev
+      end
+
+      def format_message(level, time, progname, msg)
+        # We do no formatting, its up to the user
+        "#{msg}\n"
+      end
+    end
+  end
+end

data/lib/vagrant/util/platform.rb

@@ -0,0 +1,58 @@
+require 'rbconfig'
+require 'mario'
+
+module Vagrant
+  module Util
+    # This class just contains some platform checking code.
+    class Platform
+      class << self
+        def tiger?
+          platform.include?("darwin8")
+        end
+
+        def leopard?
+          platform.include?("darwin9")
+        end
+
+        [:darwin, :bsd, :linux].each do |type|
+          define_method("#{type}?") do
+            platform.include?(type.to_s)
+          end
+        end
+
+        def windows?
+          %W[mingw mswin].each do |text|
+            return true if platform.include?(text)
+          end
+
+          false
+        end
+
+        # Returns boolean noting whether this is a 64-bit CPU. This
+        # is not 100% accurate and there could easily be false negatives.
+        #
+        # @return [Boolean]
+        def bit64?
+          ["x86_64", "amd64"].include?(RbConfig::CONFIG["host_cpu"])
+        end
+
+        # Returns boolean noting whether this is a 32-bit CPU. This
+        # can easily throw false positives since it relies on {#bit64?}.
+        #
+        # @return [Boolean]
+        def bit32?
+          !bit64?
+        end
+
+        def tar_file_options
+          # create, write only, fail if the file exists, binary if windows
+          File::WRONLY|File::EXCL|File::CREAT|(Mario::Platform.windows? ? File::BINARY : 0)
+        end
+
+        def platform
+          RbConfig::CONFIG["host_os"].downcase
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/resource_logger.rb

@@ -0,0 +1,63 @@
+require 'thread'
+
+module Vagrant
+  module Util
+    # 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.
+    class ResourceLogger
+      @@singleton_logger = 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)
+          return PlainLogger.new(nil) if !env.loaded?
+
+          @@singleton_logger ||= begin
+            file = env.log_path.join("#{Time.now.to_i}.log")
+            PlainLogger.new(file)
+          end
+        end
+
+        # Resets the singleton logger (only used for testing).
+        def reset_singleton_logger!
+          @@singleton_logger = nil
+        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
+            logger.send(method, "[#{resource}] #{message}")
+          end
+        end
+      end
+    end
+  end
+end