vagrantup 1.0.7 → 1.1.0

data/lib/vagrant/provisioners/puppet.rb

@@ -1,176 +0,0 @@
-require "log4r"
-
-module Vagrant
-  module Provisioners
-    class PuppetError < Vagrant::Errors::VagrantError
-      error_namespace("vagrant.provisioners.puppet")
-    end
-
-    class Puppet < Base
-      class Config < Vagrant::Config::Base
-        attr_accessor :manifest_file
-        attr_accessor :manifests_path
-        attr_accessor :module_path
-        attr_accessor :pp_path
-        attr_accessor :options
-        attr_accessor :facter
-
-        def manifest_file; @manifest_file || "default.pp"; end
-        def manifests_path; @manifests_path || "manifests"; end
-        def pp_path; @pp_path || "/tmp/vagrant-puppet"; end
-        def options; @options ||= []; end
-        def facter; @facter ||= {}; end
-
-        # Returns the manifests path expanded relative to the root path of the
-        # environment.
-        def expanded_manifests_path(root_path)
-          Pathname.new(manifests_path).expand_path(root_path)
-        end
-
-        # Returns the module paths as an array of paths expanded relative to the
-        # root path.
-        def expanded_module_paths(root_path)
-          return [] if !module_path
-
-          # Get all the paths and expand them relative to the root path, returning
-          # the array of expanded paths
-          paths = module_path
-          paths = [paths] if !paths.is_a?(Array)
-          paths.map do |path|
-            Pathname.new(path).expand_path(root_path)
-          end
-        end
-
-        def validate(env, errors)
-          # Calculate the manifests and module paths based on env
-          this_expanded_manifests_path = expanded_manifests_path(env.root_path)
-          this_expanded_module_paths = expanded_module_paths(env.root_path)
-
-          # Manifests path/file validation
-          if !this_expanded_manifests_path.directory?
-            errors.add(I18n.t("vagrant.provisioners.puppet.manifests_path_missing",
-                              :path => this_expanded_manifests_path))
-          else
-            expanded_manifest_file = this_expanded_manifests_path.join(manifest_file)
-            if !expanded_manifest_file.file?
-              errors.add(I18n.t("vagrant.provisioners.puppet.manifest_missing",
-                                :manifest => expanded_manifest_file.to_s))
-            end
-          end
-
-          # Module paths validation
-          this_expanded_module_paths.each do |path|
-            if !path.directory?
-              errors.add(I18n.t("vagrant.provisioners.puppet.module_path_missing", :path => path))
-            end
-          end
-        end
-      end
-
-      def self.config_class
-        Config
-      end
-
-      def initialize(env, config)
-        super
-
-        @logger = Log4r::Logger.new("vagrant::provisioners::puppet")
-      end
-
-      def prepare
-        # Calculate the paths we're going to use based on the environment
-        @expanded_manifests_path = config.expanded_manifests_path(env[:root_path])
-        @expanded_module_paths   = config.expanded_module_paths(env[:root_path])
-        @manifest_file           = File.join(manifests_guest_path, config.manifest_file)
-
-        set_module_paths
-        share_manifests
-        share_module_paths
-      end
-
-      def provision!
-        # Check that the shared folders are properly shared
-        check = [manifests_guest_path]
-        @module_paths.each do |host_path, guest_path|
-          check << guest_path
-        end
-
-        verify_shared_folders(check)
-
-        # Verify Puppet is installed and run it
-        verify_binary("puppet")
-        run_puppet_client
-      end
-
-      def share_manifests
-        env[:vm].config.vm.share_folder("manifests", manifests_guest_path, @expanded_manifests_path)
-      end
-
-      def share_module_paths
-        count = 0
-        @module_paths.each do |from, to|
-          # Sorry for the cryptic key here, but VirtualBox has a strange limit on
-          # maximum size for it and its something small (around 10)
-          env[:vm].config.vm.share_folder("v-pp-m#{count}", to, from)
-          count += 1
-        end
-      end
-
-      def set_module_paths
-        @module_paths = []
-        @expanded_module_paths.each_with_index do |path, i|
-          @module_paths << [path, File.join(config.pp_path, "modules-#{i}")]
-        end
-      end
-
-      def manifests_guest_path
-        File.join(config.pp_path, "manifests")
-      end
-
-      def verify_binary(binary)
-        env[:vm].channel.sudo("which #{binary}",
-                              :error_class => PuppetError,
-                              :error_key => :not_detected,
-                              :binary => binary)
-      end
-
-      def run_puppet_client
-        options = [config.options].flatten
-        module_paths = @module_paths.map { |_, to| to }
-        options << "--modulepath '#{module_paths.join(':')}'" if !@module_paths.empty?
-        options << @manifest_file
-        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 = "cd #{manifests_guest_path} && #{facter}puppet apply #{options} --detailed-exitcodes || [ $? -eq 2 ]"
-
-        env[:ui].info I18n.t("vagrant.provisioners.puppet.running_puppet",
-                             :manifest => @manifest_file)
-
-        env[:vm].channel.sudo(command) do |type, data|
-          env[:ui].info(data.chomp, :prefix => false)
-        end
-      end
-
-      def verify_shared_folders(folders)
-        folders.each do |folder|
-          @logger.debug("Checking for shared folder: #{folder}")
-          if !env[:vm].channel.test("test -d #{folder}")
-            raise PuppetError, :missing_shared_folders
-          end
-        end
-      end
-    end
-  end
-end
-

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/vm.rb

@@ -1,195 +0,0 @@
-require 'log4r'
-
-module Vagrant
-  class VM
-    include Vagrant::Util
-
-    attr_reader :uuid
-    attr_reader :env
-    attr_reader :name
-    attr_reader :vm
-    attr_reader :box
-    attr_reader :config
-    attr_reader :driver
-
-    def initialize(name, env, config, opts=nil)
-      @logger = Log4r::Logger.new("vagrant::vm")
-
-      @name   = name
-      @vm     = nil
-      @env    = env
-      @config = config
-      @box    = env.boxes.find(config.vm.box)
-
-      opts ||= {}
-      if opts[:base]
-        # The name is the ID we use.
-        @uuid = name
-      else
-        # Load the UUID if its saved.
-        active = env.local_data[:active] || {}
-        @uuid = active[@name.to_s]
-      end
-
-      # Reload ourselves to get the state
-      reload!
-
-      # Load the associated guest.
-      load_guest!
-      @loaded_guest_distro = false
-    end
-
-    # Loads the guest associated with the VM. The guest class is
-    # responsible for OS-specific functionality. More information
-    # can be found by reading the documentation on {Vagrant::Guest::Base}.
-    #
-    # **This method should never be called manually.**
-    def load_guest!(guest=nil)
-      guest ||= config.vm.guest
-      @logger.info("Loading guest: #{guest}")
-
-      if guest.is_a?(Class)
-        raise Errors::VMGuestError, :_key => :invalid_class, :guest => guest.to_s if !(guest <= Guest::Base)
-        @guest = guest.new(self)
-      elsif guest.is_a?(Symbol)
-        guest_klass = Vagrant.guests.get(guest)
-        raise Errors::VMGuestError, :_key => :unknown_type, :guest => guest.to_s if !guest_klass
-        @guest = guest_klass.new(self)
-      else
-        raise Errors::VMGuestError, :unspecified
-      end
-    end
-
-    # Returns a channel object to communicate with the virtual
-    # machine.
-    def channel
-      @channel ||= Communication::SSH.new(self)
-    end
-
-    # Returns the guest for this VM, loading the distro of the system if
-    # we can.
-    def guest
-      if !@loaded_guest_distro && state == :running
-        # Load the guest distro for the first time
-        result = @guest.distro_dispatch
-        load_guest!(result)
-        @loaded_guest_distro = true
-      end
-
-      @guest
-    end
-
-    # Access the {Vagrant::SSH} object associated with this VM, which
-    # is used to get SSH credentials with the virtual machine.
-    def ssh
-      @ssh ||= SSH.new(self)
-    end
-
-    # Returns the state of the VM as a symbol.
-    #
-    # @return [Symbol]
-    def state
-      return :not_created if !@uuid
-      state = @driver.read_state
-      return :not_created if !state
-      return state
-    end
-
-    # Returns a boolean true if the VM has been created, otherwise
-    # returns false.
-    #
-    # @return [Boolean]
-    def created?
-      state != :not_created
-    end
-
-    # Sets the currently active VM for this VM. If the VM is a valid,
-    # created virtual machine, then it will also update the local data
-    # to persist the VM. Otherwise, it will remove itself from the
-    # local data (if it exists).
-    def uuid=(value)
-      env.local_data[:active] ||= {}
-      if value
-        env.local_data[:active][name.to_s] = value
-      else
-        env.local_data[:active].delete(name.to_s)
-      end
-
-      # Commit the local data so that the next time vagrant is initialized,
-      # it realizes the VM exists
-      env.local_data.commit
-
-      # Store the uuid and reload the instance
-      @uuid = value
-      reload!
-    end
-
-    def reload!
-      begin
-        @driver = Driver::VirtualBox.new(@uuid)
-      rescue Driver::VirtualBox::VMNotFound
-        # Clear the UUID since this VM doesn't exist.
-        @uuid = nil
-
-        # Reset the driver. This shouldn't raise a VMNotFound since we won't
-        # feed it a UUID.
-        @driver = Driver::VirtualBox.new
-      end
-    end
-
-    def package(options=nil)
-      run_action(:package, { "validate" => false }.merge(options || {}))
-    end
-
-    def up(options=nil)
-      run_action(:up, options)
-    end
-
-    def start(options=nil)
-      return if state == :running
-      return resume if state == :saved
-
-      run_action(:start, options)
-    end
-
-    def halt(options=nil)
-      run_action(:halt, options)
-    end
-
-    def reload(options=nil)
-      run_action(:reload, options)
-    end
-
-    def provision
-      run_action(:provision)
-    end
-
-    def destroy
-      run_action(:destroy)
-    end
-
-    def suspend
-      run_action(:suspend)
-    end
-
-    def resume
-      run_action(:resume)
-    end
-
-    def ui
-      return @_ui if defined?(@_ui)
-      @_ui = @env.ui.dup
-      @_ui.resource = @name
-      @_ui
-    end
-
-    def run_action(name, options=nil)
-      options = {
-        :vm => self,
-        :ui => ui
-      }.merge(options || {})
-
-      env.action_runner.run(name, options)
-    end
-  end
-end