rvagrant 0.8.7.dev

data/lib/vagrant/systems/solaris.rb

@@ -0,0 +1,67 @@
+module Vagrant
+  module Systems
+    # A general Vagrant system implementation for "solaris".
+    #
+    # Contributed by Blake Irvin <b.irvin@modcloth.com>
+    class Solaris < Base
+      # A custom config class which will be made accessible via `config.solaris`
+      # This is not necessary for all system implementers, of course. However,
+      # generally, Vagrant tries to make almost every aspect of its execution
+      # configurable, and this assists that goal.
+      class SolarisConfig < Vagrant::Config::Base
+        configures :solaris
+
+        attr_accessor :halt_timeout
+        attr_accessor :halt_check_interval
+        # This sets the command to use to execute items as a superuser. sudo is default
+        attr_accessor :suexec_cmd
+
+        def initialize
+          @halt_timeout = 30
+          @halt_check_interval = 1
+          @suexec_cmd = 'sudo'
+        end
+      end
+
+      # Here for whenever it may be used.
+      class SolarisError < Errors::VagrantError
+        error_namespace("vagrant.systems.solaris")
+      end
+
+      # There should be an exception raised if the line
+      #
+      #     vagrant::::profiles=Primary Administrator
+      #
+      # does not exist in /etc/user_attr. TODO
+      def halt
+        vm.env.ui.info I18n.t("vagrant.systems.solaris.attempting_halt")
+        vm.ssh.execute do |ssh|
+          ssh.exec!("#{vm.env.config.solaris.suexec_cmd} /usr/sbin/poweroff")
+        end
+
+        # Wait until the VM's state is actually powered off. If this doesn't
+        # occur within a reasonable amount of time (15 seconds by default),
+        # then simply return and allow Vagrant to kill the machine.
+        count = 0
+        while vm.vm.state != :powered_off
+          count += 1
+
+          return if count >= vm.env.config.solaris.halt_timeout
+          sleep vm.env.config.solaris.halt_check_interval
+        end
+      end
+
+      def mount_shared_folder(ssh, name, guestpath, owner, group)
+        # Create the shared folder
+        ssh.exec!("#{vm.env.config.solaris.suexec_cmd} mkdir -p #{guestpath}")
+
+        # Mount the folder with the proper owner/group
+        options = "-o uid=`id -u #{owner}`,gid=`id -g #{group}`"
+        ssh.exec!("#{vm.env.config.solaris.suexec_cmd} /sbin/mount -F vboxfs #{options} #{name} #{guestpath}")
+
+        # chown the folder to the proper owner/group
+        ssh.exec!("#{vm.env.config.solaris.suexec_cmd} chown `id -u #{owner}`:`id -g #{group}` #{guestpath}")
+      end
+    end
+  end
+end

data/lib/vagrant/systems/suse.rb

@@ -0,0 +1,9 @@
+module Vagrant
+  module Systems
+    class Suse < Redhat
+      def network_scripts_dir
+        '/etc/sysconfig/network/'
+      end 
+    end
+  end
+end

data/lib/vagrant/systems/ubuntu.rb

@@ -0,0 +1,17 @@
+require 'vagrant/systems/debian'
+
+module Vagrant
+  module Systems
+    class Ubuntu < Debian
+      def change_host_name(name)
+        vm.ssh.execute do |ssh|
+          if !ssh.test?("sudo hostname | grep '#{name}'")
+            ssh.exec!("sudo sed -i 's/.*$/#{name}/' /etc/hostname")
+            ssh.exec!("sudo sed -i 's@^\\(127[.]0[.]1[.]1[[:space:]]\\+\\)@\\1#{name} #{name.split('.')[0]} @' /etc/hosts")
+            ssh.exec!("sudo service hostname start")
+          end
+        end
+      end
+    end
+  end
+end

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,81 @@
+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].each do |method|
+      define_method(method) do |message|
+        # Log normal console messages
+        env.logger.info("ui") { message }
+      end
+    end
+
+    [:clear_line, :report_progress, :ask, :no?, :yes?].each do |method|
+      # By default do nothing, these aren't logged
+      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)
+            super(message)
+            opts ||= {}
+            opts[:new_line] = true if !opts.has_key?(:new_line)
+            @shell.say("\#{format_message(message, opts)}", #{color.inspect}, opts[:new_line])
+          end
+        CODE
+      end
+
+      [:ask, :no?, :yes?].each do |method|
+        class_eval <<-CODE
+          def #{method}(message, opts=nil)
+            super(message)
+            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
+
+        @shell.say(line, nil, false)
+      end
+
+      def clear_line
+        @shell.say(line_reset, 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 Util::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 :Counter,                   'vagrant/util/counter'
+    autoload :GlobLoader,                'vagrant/util/glob_loader'
+    autoload :HashWithIndifferentAccess, 'vagrant/util/hash_with_indifferent_access'
+    autoload :Platform,                  'vagrant/util/platform'
+    autoload :Retryable,                 'vagrant/util/retryable'
+    autoload :SafeExec,                  'vagrant/util/safe_exec'
+    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/counter.rb

@@ -0,0 +1,24 @@
+require 'thread'
+
+module Vagrant
+  module Util
+    # Atomic counter implementation. This is useful for incrementing
+    # a counter which is guaranteed to only be used once in its class.
+    module Counter
+      def get_and_update_counter(name=nil)
+        name ||= :global
+
+        mutex.synchronize do
+          @__counter ||= Hash.new(1)
+          result = @__counter[name]
+          @__counter[name] += 1
+          result
+        end
+      end
+
+      def mutex
+        @__counter_mutex ||= Mutex.new
+      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