vagrant 1.0.7 → 1.5.0

data/lib/vagrant/provisioners/puppet_server.rb

@@ -1,78 +0,0 @@
-module Vagrant
-  module Provisioners
-    class PuppetServerError < Vagrant::Errors::VagrantError
-      error_namespace("vagrant.provisioners.puppet_server")
-    end
-
-    class PuppetServer < Base
-      class Config < Vagrant::Config::Base
-        attr_accessor :puppet_server
-        attr_accessor :puppet_node
-        attr_accessor :options
-        attr_accessor :facter
-
-        def facter; @facter ||= {}; end
-        def puppet_server; @puppet_server || "puppet"; end
-        def options; @options ||= []; end
-      end
-
-      def self.config_class
-        Config
-      end
-
-      def provision!
-        verify_binary("puppet")
-        run_puppet_agent
-      end
-
-      def verify_binary(binary)
-        env[:vm].channel.sudo("which #{binary}",
-                              :error_class => PuppetServerError,
-                              :error_key => :not_detected,
-                              :binary => binary)
-      end
-
-      def run_puppet_agent
-        options = config.options
-        options = [options] if !options.is_a?(Array)
-
-        # Intelligently set the puppet node cert name based on certain
-        # external parameters.
-        cn = nil
-        if config.puppet_node
-          # If a node name is given, we use that directly for the certname
-          cn = config.puppet_node
-        elsif env[:vm].config.vm.host_name
-          # If a host name is given, we explicitly set the certname to
-          # nil so that the hostname becomes the cert name.
-          cn = nil
-        else
-          # Otherwise, we default to the name of the box.
-          cn = env[:vm].config.vm.box
-        end
-
-        # Add the certname option if there is one
-        options += ["--certname", cn] if cn
-        options = options.join(" ")
-
-        # Build up the custom facts if we have any
-        facter = ""
-        if !config.facter.empty?
-          facts = []
-          config.facter.each do |key, value|
-            facts << "FACTER_#{key}='#{value}'"
-          end
-
-          facter = "#{facts.join(" ")} "
-        end
-
-        command = "#{facter}puppet agent #{options} --server #{config.puppet_server} --detailed-exitcodes || [ $? -eq 2 ]"
-
-        env[:ui].info I18n.t("vagrant.provisioners.puppet_server.running_puppetd")
-        env[:vm].channel.sudo(command) do |type, data|
-          env[:ui].info(data.chomp, :prefix => false)
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/provisioners/shell.rb

@@ -1,103 +0,0 @@
-require 'tempfile'
-
-module Vagrant
-  module Provisioners
-    class Shell < Base
-      class Config < Vagrant::Config::Base
-        attr_accessor :inline
-        attr_accessor :path
-        attr_accessor :upload_path
-        attr_accessor :args
-
-        def initialize
-          @upload_path = "/tmp/vagrant-shell"
-        end
-
-        def validate(env, errors)
-          # Validate that the parameters are properly set
-          if path && inline
-            errors.add(I18n.t("vagrant.provisioners.shell.path_and_inline_set"))
-          elsif !path && !inline
-            errors.add(I18n.t("vagrant.provisioners.shell.no_path_or_inline"))
-          end
-
-          # Validate the existence of a script to upload
-          if path
-            expanded_path = Pathname.new(path).expand_path(env.root_path)
-            if !expanded_path.file?
-              errors.add(I18n.t("vagrant.provisioners.shell.path_invalid",
-                                :path => expanded_path))
-            end
-          end
-
-          # There needs to be a path to upload the script to
-          if !upload_path
-            errors.add(I18n.t("vagrant.provisioners.shell.upload_path_not_set"))
-          end
-
-          # If there are args and its not a string, that is a problem
-          if args && !args.is_a?(String)
-            errors.add(I18n.t("vagrant.provisioners.shell.args_not_string"))
-          end
-        end
-      end
-
-      def self.config_class
-        Config
-      end
-
-      # This method yields the path to a script to upload and execute
-      # on the remote server. This method will properly clean up the
-      # script file if needed.
-      def with_script_file
-        if config.path
-          # Just yield the path to that file...
-          yield Pathname.new(config.path).expand_path(env[:root_path])
-          return
-        end
-
-        # Otherwise we have an inline script, we need to Tempfile it,
-        # and handle it specially...
-        file = Tempfile.new('vagrant-shell')
-
-        # Unless you set binmode, on a Windows host the shell script will
-        # have CRLF line endings instead of LF line endings, causing havoc
-        # when the guest executes it
-        file.binmode
-
-        begin
-          file.write(config.inline)
-          file.fsync
-          file.close
-          yield file.path
-        ensure
-          file.close
-          file.unlink
-        end
-      end
-
-      def provision!
-        args = ""
-        args = " #{config.args}" if config.args
-        command = "chmod +x #{config.upload_path} && #{config.upload_path}#{args}"
-
-        with_script_file do |path|
-          # Upload the script to the VM
-          env[:vm].channel.upload(path.to_s, config.upload_path)
-
-          # Execute it with sudo
-          env[:vm].channel.sudo(command) do |type, data|
-            if [:stderr, :stdout].include?(type)
-              # Output the data with the proper color based on the stream.
-              color = type == :stdout ? :green : :red
-
-              # Note: Be sure to chomp the data to avoid the newlines that the
-              # Chef outputs.
-              env[:ui].info(data.chomp, :color => color, :prefix => false)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/registry.rb

@@ -1,52 +0,0 @@
-module Vagrant
-  # Register components in a single location that can be queried.
-  #
-  # This allows certain components (such as guest systems, configuration
-  # pieces, etc.) to be registered and queried.
-  class Registry
-    def initialize
-      @actions = {}
-      @results_cache = {}
-    end
-
-    # Register a callable by key.
-    #
-    # The callable should be given in a block which will be lazily evaluated
-    # when the action is needed.
-    #
-    # If an action by the given name already exists then it will be
-    # overwritten.
-    def register(key, value=nil, &block)
-      block = lambda { value } if value
-      @actions[key] = block
-    end
-
-    # Get an action by the given key.
-    #
-    # This will evaluate the block given to `register` and return the resulting
-    # action stack.
-    def get(key)
-      return nil if !@actions.has_key?(key)
-      return @results_cache[key] if @results_cache.has_key?(key)
-      @results_cache[key] = @actions[key].call
-    end
-    alias :[] :get
-
-    # Iterate over the keyspace.
-    def each(&block)
-      @actions.each do |key, _|
-        yield key, get(key)
-      end
-    end
-
-    # Converts this registry to a hash
-    def to_hash
-      result = {}
-      self.each do |key, value|
-        result[key] = value
-      end
-
-      result
-    end
-  end
-end

data/lib/vagrant/ssh.rb

@@ -1,126 +0,0 @@
-require 'log4r'
-
-require 'vagrant/util/file_mode'
-require 'vagrant/util/platform'
-require 'vagrant/util/safe_exec'
-
-module Vagrant
-  # Manages SSH connection information as well as allows opening an
-  # SSH connection.
-  class SSH
-    include Util::SafeExec
-
-    def initialize(vm)
-      @vm     = vm
-      @logger = Log4r::Logger.new("vagrant::ssh")
-    end
-
-    # Returns a hash of information necessary for accessing this
-    # virtual machine via SSH.
-    #
-    # @return [Hash]
-    def info
-      results = {
-        :host          => @vm.config.ssh.host,
-        :port          => @vm.config.ssh.port || @vm.driver.ssh_port(@vm.config.ssh.guest_port),
-        :username      => @vm.config.ssh.username,
-        :forward_agent => @vm.config.ssh.forward_agent,
-        :forward_x11   => @vm.config.ssh.forward_x11
-      }
-
-      # This can happen if no port is set and for some reason Vagrant
-      # can't detect an SSH port.
-      raise Errors::SSHPortNotDetected if !results[:port]
-
-      # Determine the private key path, which is either set by the
-      # configuration or uses just the built-in insecure key.
-      pk_path = @vm.config.ssh.private_key_path || @vm.env.default_private_key_path
-      results[:private_key_path] = File.expand_path(pk_path, @vm.env.root_path)
-
-      # We need to check and fix the private key permissions
-      # to make sure that SSH gets a key with 0600 perms.
-      check_key_permissions(results[:private_key_path])
-
-      # Return the results
-      return results
-    end
-
-    # Connects to the environment's virtual machine, replacing the ruby
-    # process with an SSH process.
-    #
-    # @param [Hash] opts Options hash
-    # @options opts [Boolean] :plain_mode If True, doesn't authenticate with
-    #   the machine, only connects, allowing the user to connect.
-    def exec(opts={})
-      # Get the SSH information and cache it here
-      ssh_info = info
-
-      if Util::Platform.windows?
-        raise Errors::SSHUnavailableWindows, :host => ssh_info[:host],
-                                             :port => ssh_info[:port],
-                                             :username => ssh_info[:username],
-                                             :key_path => ssh_info[:private_key_path]
-      end
-
-      raise Errors::SSHUnavailable if !Kernel.system("which ssh > /dev/null 2>&1")
-
-      # If plain mode is enabled then we don't do any authentication (we don't
-      # set a user or an identity file)
-      plain_mode = opts[:plain_mode]
-
-      options = {}
-      options[:host] = ssh_info[:host]
-      options[:port] = ssh_info[:port]
-      options[:username] = ssh_info[:username]
-      options[:private_key_path] = ssh_info[:private_key_path]
-
-      # Command line options
-      command_options = ["-p", options[:port].to_s, "-o", "UserKnownHostsFile=/dev/null",
-                         "-o", "StrictHostKeyChecking=no", "-o", "LogLevel=ERROR"]
-
-      # Solaris/OpenSolaris/Illumos uses SunSSH which doesn't support the IdentitiesOnly option
-      command_options += ["-o", "IdentitiesOnly=yes"] unless Util::Platform.solaris?
-
-      command_options += ["-i", options[:private_key_path]] if !plain_mode
-      command_options += ["-o", "ForwardAgent=yes"] if ssh_info[:forward_agent]
-
-      # If there are extra options, then we append those
-      command_options.concat(opts[:extra_args]) if opts[:extra_args]
-
-      if ssh_info[:forward_x11]
-        # Both are required so that no warnings are shown regarding X11
-        command_options += ["-o", "ForwardX11=yes"]
-        command_options += ["-o", "ForwardX11Trusted=yes"]
-      end
-
-      host_string = options[:host]
-      host_string = "#{options[:username]}@#{host_string}" if !plain_mode
-      command_options << host_string
-      @logger.info("Invoking SSH: #{command_options.inspect}")
-      safe_exec("ssh", *command_options)
-    end
-
-    # Checks the file permissions for a private key, resetting them
-    # if needed.
-    def check_key_permissions(key_path)
-      # Windows systems don't have this issue
-      return if Util::Platform.windows?
-
-      @logger.debug("Checking key permissions: #{key_path}")
-      stat = File.stat(key_path)
-
-      if stat.owned? && Util::FileMode.from_octal(stat.mode) != "600"
-        @logger.info("Attempting to correct key permissions to 0600")
-        File.chmod(0600, key_path)
-
-        if Util::FileMode.from_octal(stat.mode) != "600"
-          raise Errors::SSHKeyBadPermissions, :key_path => key_path
-        end
-      end
-    rescue Errno::EPERM
-      # This shouldn't happen since we verified we own the file, but
-      # it is possible in theory, so we raise an error.
-      raise Errors::SSHKeyBadPermissions, :key_path => key_path
-    end
-  end
-end

data/lib/vagrant/test_helpers.rb

@@ -1,154 +0,0 @@
-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
-      # duplicate the Vagrant::Environment ui and get the default vm object
-      # for the new action environment from the first pair in the vms list
-      opts = {:ui => v_env.ui.dup, :vm => v_env.vms.first.last}
-      app = lambda { |env| }
-      env = Vagrant::Action::Environment.new(opts)
-      env["vagrant.test"] = true
-      [app, env]
-    end
-
-    # Utility method for capturing output streams.
-    # @example Evaluate the output
-    #   output = capture(:stdout){ env.cli("foo") }
-    #   assert_equal "bar", output
-    # @example Silence the output
-    #   silence(:stdout){ env.cli("init") }
-    # @param [:stdout, :stderr] stream The stream to capture
-    # @yieldreturn String
-    # @see https://github.com/wycats/thor/blob/master/spec/spec_helper.rb
-    def capture(stream)
-      begin
-        stream = stream.to_s
-        eval "$#{stream} = StringIO.new"
-        yield
-        result = eval("$#{stream}").string
-      ensure
-        eval("$#{stream} = #{stream.upcase}")
-      end
-
-      result
-    end
-    alias :silence :capture
-
-    #------------------------------------------------------------
-    # 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