vagrant-shell 0.2.9 → 0.2.11

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action/builtin/provision.rb

@@ -1,70 +0,0 @@
-require "log4r"
-
-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
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::action::builtin::provision")
-        end
-
-        def call(env)
-          # Check if we're even provisioning things.
-          enabled = true
-          enabled = env[:provision_enabled] if env.has_key?(:provision_enabled)
-
-          # This keeps track of a mapping between provisioner and type
-          type_map = {}
-
-          # Get all the configured provisioners
-          provisioners = env[:machine].config.vm.provisioners.map do |provisioner|
-            # Instantiate the provisioner
-            klass  = Vagrant.plugin("2").manager.provisioners[provisioner.name]
-            result = klass.new(env[:machine], provisioner.config)
-
-            # Store in the type map so that --provision-with works properly
-            type_map[result] = provisioner.name
-
-            # Return the result
-            result
-          end
-
-          # Ask the provisioners to modify the configuration if needed
-          provisioners.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
-            provisioners.each do |p|
-              next if env[:provision_types] && \
-                !env[:provision_types].include?(type_map[p])
-
-              run_provisioner(env, 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/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action/builtin/set_hostname.rb

@@ -1,27 +0,0 @@
-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/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action/builtin/ssh_exec.rb

@@ -1,42 +0,0 @@
-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/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action/builtin/ssh_run.rb

@@ -1,43 +0,0 @@
-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/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action/general/package.rb

@@ -1,103 +0,0 @@
-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

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action/hook.rb

@@ -1,107 +0,0 @@
-module Vagrant
-  module Action
-    # This class manages hooks into existing {Builder} stacks, and lets you
-    # add and remove middleware classes. This is the primary method by which
-    # plugins can hook into built-in middleware stacks.
-    class Hook
-      # This is a hash of the middleware to prepend to a certain
-      # other middleware.
-      #
-      # @return [Hash<Class, Array<Class>>]
-      attr_reader :before_hooks
-
-      # This is a hash of the middleware to append to a certain other
-      # middleware.
-      #
-      # @return [Hash<Class, Array<Class>>]
-      attr_reader :after_hooks
-
-      # This is a list of the hooks to just prepend to the beginning
-      #
-      # @return [Array<Class>]
-      attr_reader :prepend_hooks
-
-      # This is a list of the hooks to just append to the end
-      #
-      # @return [Array<Class>]
-      attr_reader :append_hooks
-
-      def initialize
-        @before_hooks  = Hash.new { |h, k| h[k] = [] }
-        @after_hooks   = Hash.new { |h, k| h[k] = [] }
-        @prepend_hooks = []
-        @append_hooks  = []
-      end
-
-      # Add a middleware before an existing middleware.
-      #
-      # @param [Class] existing The existing middleware.
-      # @param [Class] new The new middleware.
-      def before(existing, new, *args, &block)
-        @before_hooks[existing] << [new, args, block]
-      end
-
-      # Add a middleware after an existing middleware.
-      #
-      # @param [Class] existing The existing middleware.
-      # @param [Class] new The new middleware.
-      def after(existing, new, *args, &block)
-        @after_hooks[existing] << [new, args, block]
-      end
-
-      # Append a middleware to the end of the stack. Note that if the
-      # middleware sequence ends early, then the new middleware won't
-      # be run.
-      #
-      # @param [Class] new The middleware to append.
-      def append(new, *args, &block)
-        @append_hooks << [new, args, block]
-      end
-
-      # Prepend a middleware to the beginning of the stack.
-      #
-      # @param [Class] new The new middleware to prepend.
-      def prepend(new, *args, &block)
-        @prepend_hooks << [new, args, block]
-      end
-
-      # This applies the given hook to a builder. This should not be
-      # called directly.
-      #
-      # @param [Builder] builder
-      def apply(builder, options=nil)
-        options ||= {}
-
-        if !options[:no_prepend_or_append]
-          # Prepends first
-          @prepend_hooks.each do |klass, args, block|
-            builder.insert(0, klass, *args, &block)
-          end
-
-          # Appends
-          @append_hooks.each do |klass, args, block|
-            builder.use(klass, *args, &block)
-          end
-        end
-
-        # Before hooks
-        @before_hooks.each do |key, list|
-          next if !builder.index(key)
-
-          list.each do |klass, args, block|
-            builder.insert_before(key, klass, *args, &block)
-          end
-        end
-
-        # After hooks
-        @after_hooks.each do |key, list|
-          next if !builder.index(key)
-
-          list.each do |klass, args, block|
-            builder.insert_after(key, klass, *args, &block)
-          end
-        end
-      end
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action/runner.rb

@@ -1,69 +0,0 @@
-require 'log4r'
-
-require 'vagrant/action/hook'
-require 'vagrant/util/busy'
-
-# TODO:
-# * env.lock
-
-module Vagrant
-  module Action
-    class Runner
-      @@reported_interrupt = false
-
-      def initialize(globals=nil, &block)
-        @globals      = globals || {}
-        @lazy_globals = block
-        @logger       = Log4r::Logger.new("vagrant::action::runner")
-      end
-
-      def run(callable_id, options=nil)
-        callable = callable_id
-        callable = Builder.build(callable_id) if callable_id.kind_of?(Class)
-        raise ArgumentError, "Argument to run must be a callable object or registered action." if !callable || !callable.respond_to?(:call)
-
-        # Create the initial environment with the options given
-        environment = {}
-        environment.merge!(@globals)
-        environment.merge!(@lazy_globals.call) if @lazy_globals
-        environment.merge!(options || {})
-
-        # Setup the action hooks
-        hooks = Vagrant.plugin("2").manager.action_hooks(environment[:action_name])
-        if !hooks.empty?
-          @logger.info("Preparing hooks for middleware sequence...")
-          environment[:action_hooks] = hooks.map do |hook_proc|
-            Hook.new.tap do |h|
-              hook_proc.call(h)
-            end
-          end
-
-          @logger.info("#{environment[:action_hooks].length} hooks defined.")
-        end
-
-        # Run the action chain in a busy block, marking the environment as
-        # interrupted if a SIGINT occurs, and exiting cleanly once the
-        # chain has been run.
-        ui = environment[:ui] if environment.has_key?(:ui)
-        int_callback = lambda do
-          if environment[:interrupted]
-            ui.error I18n.t("vagrant.actions.runner.exit_immediately") if ui
-            abort
-          end
-
-          ui.warn I18n.t("vagrant.actions.runner.waiting_cleanup") if ui && !@@reported_interrupt
-          environment[:interrupted] = true
-          @@reported_interrupt = true
-        end
-
-        # We place a process lock around every action that is called
-        @logger.info("Running action: #{callable_id}")
-        Util::Busy.busy(int_callback) { callable.call(environment) }
-
-        # Return the environment in case there are things in there that
-        # the caller wants to use.
-        environment
-      end
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action/warden.rb

@@ -1,103 +0,0 @@
-require "log4r"
-
-module Vagrant
-  module Action
-    # The action warden is a middleware which injects itself between
-    # every other middleware, watching for exceptions which are raised
-    # and performing proper cleanup on every action by calling the `recover`
-    # method. The warden therefore allows middlewares to not worry about
-    # exceptional events, and by providing a simple callback, can clean up
-    # in any erroneous case.
-    #
-    # Warden will "just work" behind the scenes, and is not of particular
-    # interest except to those who are curious about the internal workings
-    # of Vagrant.
-    class Warden
-      attr_accessor :actions, :stack
-
-      def initialize(actions, env)
-        @stack      = []
-        @actions    = actions.map { |m| finalize_action(m, env) }
-        @logger     = Log4r::Logger.new("vagrant::action::warden")
-        @last_error = nil
-      end
-
-      def call(env)
-        return if @actions.empty?
-
-        begin
-          # Call the next middleware in the sequence, appending to the stack
-          # of "recoverable" middlewares in case something goes wrong!
-          raise Errors::VagrantInterrupt if env[:interrupted]
-          action = @actions.shift
-          @logger.info("Calling action: #{action}")
-          @stack.unshift(action).first.call(env)
-          raise Errors::VagrantInterrupt if env[:interrupted]
-        rescue SystemExit
-          # This means that an "exit" or "abort" was called. In these cases,
-          # we just exit immediately.
-          raise
-        rescue Exception => e
-          # We guard this so that the Warden only outputs this once for
-          # an exception that bubbles up.
-          if e != @last_error
-            @logger.error("Error occurred: #{e}")
-            @last_error = e
-          end
-
-          env["vagrant.error"] = e
-
-          # Something went horribly wrong. Start the rescue chain then
-          # reraise the exception to properly kick us out of limbo here.
-          recover(env)
-          raise
-        end
-      end
-
-      # We implement the recover method ourselves in case a Warden is
-      # embedded within another Warden. To recover, we just do our own
-      # recovery process on our stack.
-      def recover(env)
-        @logger.info("Beginning recovery process...")
-
-        @stack.each do |act|
-          if act.respond_to?(:recover)
-            @logger.info("Calling recover: #{act}")
-            act.recover(env)
-          end
-        end
-
-        @logger.info("Recovery complete.")
-
-        # Clear stack so that warden down the middleware chain doesn't
-        # rescue again.
-        @stack.clear
-      end
-
-      # A somewhat confusing function which simply initializes each
-      # middleware properly to call the next middleware in the sequence.
-      def finalize_action(action, env)
-        klass, args, block = action
-
-        # Default the arguments to an empty array. Otherwise in Ruby 1.8
-        # a `nil` args will actually pass `nil` into the class.
-        args ||= []
-
-        if klass.is_a?(Class)
-          # A action klass which is to be instantiated with the
-          # app, env, and any arguments given
-          klass.new(self, env, *args, &block)
-        elsif klass.respond_to?(:call)
-          # Make it a lambda which calls the item then forwards
-          # up the chain
-          lambda do |e|
-            klass.call(e)
-            self.call(e)
-          end
-        else
-          raise "Invalid action: #{action.inspect}"
-        end
-      end
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/action.rb

@@ -1,43 +0,0 @@
-require 'vagrant/action/builder'
-
-module Vagrant
-  module Action
-    autoload :Runner,      'vagrant/action/runner'
-    autoload :Warden,      'vagrant/action/warden'
-
-    # Builtin contains middleware classes that are shipped with Vagrant-core
-    # and are thus available to all plugins as a "standard library" of sorts.
-    module Builtin
-      autoload :BoxAdd,  "vagrant/action/builtin/box_add"
-      autoload :Call,    "vagrant/action/builtin/call"
-      autoload :Confirm, "vagrant/action/builtin/confirm"
-      autoload :ConfigValidate, "vagrant/action/builtin/config_validate"
-      autoload :DestroyConfirm, "vagrant/action/builtin/destroy_confirm"
-      autoload :EnvSet,  "vagrant/action/builtin/env_set"
-      autoload :GracefulHalt, "vagrant/action/builtin/graceful_halt"
-      autoload :HandleBoxUrl, "vagrant/action/builtin/handle_box_url"
-      autoload :HandleForwardedPortCollisions, "vagrant/action/builtin/handle_forwarded_port_collisions"
-      autoload :Lock, "vagrant/action/builtin/lock"
-      autoload :NFS, "vagrant/action/builtin/nfs"
-      autoload :Provision, "vagrant/action/builtin/provision"
-      autoload :SetHostname, "vagrant/action/builtin/set_hostname"
-      autoload :SSHExec, "vagrant/action/builtin/ssh_exec"
-      autoload :SSHRun,  "vagrant/action/builtin/ssh_run"
-    end
-
-    module General
-      autoload :Package,  'vagrant/action/general/package'
-    end
-
-    # This is the action that will add a box from a URL. This middleware
-    # sequence is built-in to Vagrant. Plugins can hook into this like any
-    # other middleware sequence. This is particularly useful for provider
-    # plugins, which can hook in to do things like verification of boxes
-    # that are downloaded.
-    def self.action_box_add
-      Builder.new.tap do |b|
-        b.use Builtin::BoxAdd
-      end
-    end
-  end
-end