tnargav 1.3.5 → 1.3.6

data/lib/vagrant/action/builtin/nfs.rb

@@ -0,0 +1,128 @@
+require 'fileutils'
+require 'pathname'
+require 'zlib'
+
+require "log4r"
+
+require 'vagrant/util/platform'
+
+module Vagrant
+  module Action
+    module Builtin
+      # This built-in middleware exports and mounts NFS shared folders.
+      #
+      # To use this middleware, two configuration parameters must be given
+      # via the environment hash:
+      #
+      #   - `:nfs_host_ip` - The IP of where to mount the NFS folder from.
+      #   - `:nfs_machine_ip` - The IP of the machine where the NFS folder
+      #     will be mounted.
+      #
+      class NFS
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::nfs")
+        end
+
+        def call(env)
+          # We forward things along first. We do everything on the tail
+          # end of the middleware call.
+          @app.call(env)
+
+          # Used by prepare_permission, so we need to save it
+          @env = env
+
+          folders = {}
+          env[:machine].config.vm.synced_folders.each do |id, opts|
+            # If this synced folder doesn't enable NFS, ignore it.
+            next if !opts[:nfs]
+
+            # Expand the host path, create it if we have to and
+            # store away the folder.
+            hostpath = Pathname.new(opts[:hostpath]).
+              expand_path(env[:root_path])
+
+            if !hostpath.directory? && opts[:create]
+              # Host path doesn't exist, so let's create it.
+              @logger.debug("Host path doesn't exist, creating: #{hostpath}")
+
+              begin
+                FileUtils.mkpath(hostpath)
+              rescue Errno::EACCES
+                raise Vagrant::Errors::SharedFolderCreateFailed,
+                  :path => hostpath.to_s
+              end
+            end
+
+            # Determine the real path by expanding symlinks and getting
+            # proper casing. We have to do this after creating it
+            # if it doesn't exist.
+            hostpath = hostpath.realpath
+            hostpath = Util::Platform.fs_real_path(hostpath)
+
+            # Set the hostpath back on the options and save it
+            opts[:hostpath] = hostpath.to_s
+            folders[id] = opts
+          end
+
+          if !folders.empty?
+            raise Errors::NFSNoHostIP if !env[:nfs_host_ip]
+            raise Errors::NFSNoGuestIP if !env[:nfs_machine_ip]
+
+            machine_ip = env[:nfs_machine_ip]
+            machine_ip = [machine_ip] if !machine_ip.is_a?(Array)
+
+            # Prepare the folder, this means setting up various options
+            # and such on the folder itself.
+            folders.each { |id, opts| prepare_folder(opts) }
+
+            # Export the folders
+            env[:ui].info I18n.t("vagrant.actions.vm.nfs.exporting")
+            env[:host].nfs_export(env[:machine].id, machine_ip, folders)
+
+            # Mount
+            env[:ui].info I18n.t("vagrant.actions.vm.nfs.mounting")
+
+            # Only mount folders that have a guest path specified.
+            mount_folders = {}
+            folders.each do |id, opts|
+              mount_folders[id] = opts.dup if opts[:guestpath]
+            end
+
+            # Mount them!
+            env[:machine].guest.capability(
+              :mount_nfs_folder, env[:nfs_host_ip], mount_folders)
+          end
+        end
+
+        protected
+
+        def prepare_folder(opts)
+          opts[:map_uid] = prepare_permission(:uid, opts)
+          opts[:map_gid] = prepare_permission(:gid, opts)
+          opts[:nfs_version] ||= 3
+
+          # We use a CRC32 to generate a 32-bit checksum so that the
+          # fsid is compatible with both old and new kernels.
+          opts[:uuid] = Zlib.crc32(opts[:hostpath]).to_s
+        end
+
+        # Prepares the UID/GID settings for a single folder.
+        def prepare_permission(perm, opts)
+          key = "map_#{perm}".to_sym
+          return nil if opts.has_key?(key) && opts[key].nil?
+
+          # The options on the hash get priority, then the default
+          # values
+          value = opts.has_key?(key) ? opts[key] : @env[:machine].config.nfs.send(key)
+          return value if value != :auto
+
+          # Get UID/GID from folder if we've made it this far
+          # (value == :auto)
+          stat = File.stat(opts[:hostpath])
+          return stat.send(perm)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/provision.rb

@@ -0,0 +1,79 @@
+require "log4r"
+
+require_relative "mixin_provisioners"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class will run the configured provisioners against the
+      # machine.
+      #
+      # This action should be placed BEFORE the machine is booted so it
+      # can do some setup, and then run again (on the return path) against
+      # a running machine.
+      class Provision
+        include MixinProvisioners
+
+        def initialize(app, env)
+          @app             = app
+          @logger          = Log4r::Logger.new("vagrant::action::builtin::provision")
+        end
+
+        def call(env)
+          @env = env
+
+          # Check if we're even provisioning things.
+          enabled = true
+
+          # Check if we already provisioned, and if so, disable the rest
+          ignore_sentinel = true
+          ignore_sentinel = env[:provision_ignore_sentinel] if env.has_key?(:provision_ignore_sentinel)
+          if !ignore_sentinel
+            @logger.info("Checking provisioner sentinel if we should run...")
+            sentinel = env[:machine].data_dir.join("action_provision")
+            if sentinel.file?
+              @logger.info("Sentinel found! Not provisioning.")
+              enabled = false
+            else
+              @logger.info("Sentinel not found.")
+              sentinel.open("w") do |f|
+                f.write(Time.now.to_i.to_s)
+              end
+            end
+          end
+
+          # If we explicitly specified, take that value.
+          enabled = env[:provision_enabled] if env.has_key?(:provision_enabled)
+
+          # Ask the provisioners to modify the configuration if needed
+          provisioner_instances.each do |p|
+            p.configure(env[:machine].config)
+          end
+
+          # Continue, we need the VM to be booted.
+          @app.call(env)
+
+          # Actually provision if we enabled it
+          if enabled
+            provisioner_instances.each do |p|
+              next if env[:provision_types] && \
+                !env[:provision_types].include?(provisioner_type_map[p])
+
+              run_provisioner(env, provisioner_type_map[p].to_s, p)
+            end
+          end
+        end
+
+        # This is pulled out into a seperate method so that users can
+        # subclass and implement custom behavior if they'd like around
+        # this step.
+        def run_provisioner(env, name, p)
+          env[:ui].info(I18n.t("vagrant.actions.vm.provision.beginning",
+                               :provisioner => name))
+
+          p.provision
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/provisioner_cleanup.rb

@@ -0,0 +1,35 @@
+require "log4r"
+
+require_relative "mixin_provisioners"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This action will run the cleanup methods on provisioners and should
+      # be used as part of any Destroy action.
+      class ProvisionerCleanup
+        include MixinProvisioners
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::provision_cleanup")
+        end
+
+        def call(env)
+          @env = env
+
+          # Ask the provisioners to modify the configuration if needed
+          provisioner_instances.each do |p|
+            env[:ui].info(I18n.t(
+              "vagrant.provisioner_cleanup",
+              name: provisioner_type_map[p].to_s))
+            p.cleanup
+          end
+
+          # Continue, we need the VM to be booted.
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/set_hostname.rb

@@ -0,0 +1,27 @@
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This middleware sets the hostname of the guest according to the
+      # "vm.hostname" configuration parameter if it is set. This middleware
+      # should be placed such that the after the @app.call, a booted machine
+      # is available (this generally means BEFORE the boot middleware).
+      class SetHostname
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+
+          hostname = env[:machine].config.vm.hostname
+          if !hostname.nil?
+            env[:ui].info I18n.t("vagrant.actions.vm.hostname.setting")
+            env[:machine].guest.capability(:change_host_name, hostname)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/ssh_exec.rb

@@ -0,0 +1,42 @@
+require "pathname"
+
+require "vagrant/util/ssh"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class will exec into a full fledged SSH console into the
+      # remote machine. This middleware assumes that the VM is running and
+      # ready for SSH, and uses the {Machine#ssh_info} method to retrieve
+      # SSH information necessary to connect.
+      #
+      # Note: If there are any middleware after `SSHExec`, they will **not**
+      # run, since exec replaces the currently running process.
+      class SSHExec
+        # For quick access to the `SSH` class.
+        include Vagrant::Util
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Grab the SSH info from the machine
+          info = env[:machine].ssh_info
+
+          # If the result is nil, then the machine is telling us that it is
+          # not yet ready for SSH, so we raise this exception.
+          raise Errors::SSHNotReady if info.nil?
+
+          if info[:private_key_path]
+            # Check the SSH key permissions
+            SSH.check_key_permissions(Pathname.new(info[:private_key_path]))
+          end
+
+          # Exec!
+          SSH.exec(info, env[:ssh_opts])
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/ssh_run.rb

@@ -0,0 +1,43 @@
+require "log4r"
+
+module Vagrant
+  module Action
+    module Builtin
+      # This class will run a single command on the remote machine and will
+      # mirror the output to the UI. The resulting exit status of the command
+      # will exist in the `:ssh_run_exit_status` key in the environment.
+      class SSHRun
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::action::builtin::ssh_run")
+        end
+
+        def call(env)
+          command = env[:ssh_run_command]
+
+          @logger.debug("Executing command: #{command}")
+          exit_status = 0
+          exit_status = env[:machine].communicate.execute(command, :error_check => false) do |type, data|
+            # Determine the proper channel to send the output onto depending
+            # on the type of data we are receiving.
+            channel = type == :stdout ? :out : :error
+
+            # Print the output as it comes in, but don't prefix it and don't
+            # force a new line so that the output is properly preserved however
+            # it may be formatted.
+            env[:ui].info(data.to_s,
+                          :prefix => false,
+                          :new_line => false,
+                          :channel => channel)
+          end
+
+          # Set the exit status on a known environmental variable
+          env[:ssh_run_exit_status] = exit_status
+
+          # Call the next middleware
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin/wait_for_communicator.rb

@@ -0,0 +1,84 @@
+module Vagrant
+  module Action
+    module Builtin
+      # This waits for the communicator to be ready for a set amount of
+      # time.
+      class WaitForCommunicator
+        def initialize(app, env, states=nil)
+          @app    = app
+          @states = states
+        end
+
+        def call(env)
+          # Wait for ready in a thread so that we can continually check
+          # for interrupts.
+          ready_thr = Thread.new do
+            Thread.current[:result] = env[:machine].communicate.wait_for_ready(
+              env[:machine].config.vm.boot_timeout)
+          end
+
+          # Start a thread that verifies the VM stays in a good state.
+          states_thr = Thread.new do
+            Thread.current[:result] = true
+
+            # If we aren't caring about states, just basically put this
+            # thread to sleep because it'll get killed later.
+            if !@states
+              while true
+                sleep 300
+              end
+
+              next
+            end
+
+            # Otherwise, periodically verify the VM isn't in a bad state.
+            while true
+              state = env[:machine].provider.state.id
+
+              # Used to report invalid states
+              Thread.current[:last_known_state] = state
+
+              # Check if we have the proper state so we can break out
+              if !@states.include?(state)
+                Thread.current[:result] = false
+                break
+              end
+
+              # Sleep a bit so we don't hit 100% CPU constantly.
+              sleep 1
+            end
+          end
+
+          # Wait for a result or an interrupt
+          env[:ui].info I18n.t("vagrant.boot_waiting")
+          while ready_thr.alive? && states_thr.alive?
+            return if env[:interrupted]
+          end
+
+          # If it went into a bad state, then raise an error
+          if !states_thr[:result]
+            raise Errors::VMBootBadState,
+              valid: @states.join(", "),
+              invalid: states_thr[:last_known_state]
+          end
+
+          # If it didn't boot, raise an error
+          if !ready_thr[:result]
+            raise Errors::VMBootTimeout
+          end
+
+          env[:ui].info I18n.t("vagrant.boot_completed")
+
+          # Make sure our threads are all killed
+          ready_thr.kill
+          states_thr.kill
+
+          @app.call(env)
+        ensure
+          ready_thr.kill
+          states_thr.kill
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/general/package.rb

@@ -0,0 +1,103 @@
+require 'fileutils'
+
+require 'vagrant/util/safe_chdir'
+require 'vagrant/util/subprocess'
+
+module Vagrant
+  module Action
+    module General
+      # A general packaging (tar) middleware. Given the following options,
+      # it will do the right thing:
+      #
+      #   * package.output - The filename of the outputted package.
+      #   * package.include - An array of files to include in the package.
+      #   * package.directory - The directory which contains the contents to
+      #       compress into the package.
+      #
+      # This middleware always produces the final file in the current working
+      # directory (FileUtils.pwd)
+      class Package
+        include Util
+
+        def initialize(app, env)
+          @app = app
+
+          env["package.files"]  ||= {}
+          env["package.output"] ||= env[:global_config].package.name
+        end
+
+        def call(env)
+          @env = env
+
+          raise Errors::PackageOutputDirectory if File.directory?(tar_path)
+          raise Errors::PackageOutputExists if File.exist?(tar_path)
+          raise Errors::PackageRequiresDirectory if !env["package.directory"] ||
+            !File.directory?(env["package.directory"])
+
+          compress
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          # There are certain exceptions that we don't delete the file for.
+          ignore_exc = [Errors::PackageOutputDirectory, Errors::PackageOutputExists]
+          ignore_exc.each do |exc|
+            return if env["vagrant.error"].is_a?(exc)
+          end
+
+          # Cleanup any packaged files if the packaging failed at some point.
+          File.delete(tar_path) if File.exist?(tar_path)
+        end
+
+        # This method copies the include files (passed in via command line)
+        # to the temporary directory so they are included in a sub-folder within
+        # the actual box
+        def copy_include_files
+          include_directory = Pathname.new(@env["package.directory"]).join("include")
+
+          @env["package.files"].each do |from, dest|
+            # We place the file in the include directory
+            to = include_directory.join(dest)
+
+            @env[:ui].info I18n.t("vagrant.actions.general.package.packaging", :file => from)
+            FileUtils.mkdir_p(to.parent)
+
+            # Copy direcotry contents recursively.
+            if File.directory?(from)
+              FileUtils.cp_r(Dir.glob(from), to.parent, :preserve => true)
+            else
+              FileUtils.cp(from, to, :preserve => true)
+            end
+          end
+        end
+
+        # Compress the exported file into a package
+        def compress
+          @env[:ui].info I18n.t("vagrant.actions.general.package.compressing", :tar_path => tar_path)
+
+          # Copy over the included files
+          copy_include_files
+
+          # Get the output path. We have to do this up here so that the
+          # pwd returns the proper thing.
+          output_path = tar_path.to_s
+
+          # Switch into that directory and package everything up
+          Util::SafeChdir.safe_chdir(@env["package.directory"]) do
+            # Find all the files in our current directory and tar it up!
+            files = Dir.glob(File.join(".", "**", "*"))
+
+            # Package!
+            Util::Subprocess.execute("bsdtar", "-czf", output_path, *files)
+          end
+        end
+
+        # Path to the final box output file
+        def tar_path
+          File.expand_path(@env["package.output"], FileUtils.pwd)
+        end
+      end
+    end
+  end
+end