vagrant-fixed-ssh 1.0.7

data/lib/vagrant/action/vm/setup_package_files.rb

@@ -0,0 +1,54 @@
+require 'pathname'
+
+module Vagrant
+  module Action
+    module VM
+      # Sets up the mapping of files to copy into the package and verifies
+      # that the files can be properly copied.
+      class SetupPackageFiles
+        def initialize(app, env)
+          @app = app
+
+          env["package.include"] ||= []
+          env["package.vagrantfile"] ||= nil
+        end
+
+        def call(env)
+          files = {}
+          env["package.include"].each do |file|
+            source = Pathname.new(file)
+            dest   = nil
+
+            # If the source is relative then we add the file as-is to the include
+            # directory. Otherwise, we copy only the file into the root of the
+            # include directory. Kind of strange, but seems to match what people
+            # expect based on history.
+            if source.relative?
+              dest = source
+            else
+              dest = source.basename
+            end
+
+            # Assign the mapping
+            files[file] = dest
+          end
+
+          if env["package.vagrantfile"]
+            # Vagrantfiles are treated special and mapped to a specific file
+            files[env["package.vagrantfile"]] = "_Vagrantfile"
+          end
+
+          # Verify the mapping
+          files.each do |from, _|
+            raise Errors::PackageIncludeMissing, :file => from if !File.exist?(from)
+          end
+
+          # Save the mapping
+          env["package.files"] = files
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/share_folders.rb

@@ -0,0 +1,114 @@
+require 'pathname'
+
+require 'log4r'
+
+module Vagrant
+  module Action
+    module VM
+      class ShareFolders
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::share_folders")
+          @app    = app
+        end
+
+        def call(env)
+          @env = env
+
+          prepare_folders
+          create_metadata
+
+          @app.call(env)
+
+          mount_shared_folders
+        end
+
+        # This method returns an actual list of VirtualBox shared
+        # folders to create and their proper path.
+        def shared_folders
+          @env[:vm].config.vm.shared_folders.inject({}) do |acc, data|
+            key, value = data
+
+            next acc if value[:disabled]
+
+            # This to prevent overwriting the actual shared folders data
+            value = value.dup
+            acc[key] = value
+            acc
+          end
+        end
+
+        # Prepares the shared folders by verifying they exist and creating them
+        # if they don't.
+        def prepare_folders
+          shared_folders.each do |name, options|
+            hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
+
+            if !hostpath.directory? && options[:create]
+              # Host path doesn't exist, so let's create it.
+              @logger.debug("Host path doesn't exist, creating: #{hostpath}")
+
+              begin
+                hostpath.mkpath
+              rescue Errno::EACCES
+                raise Errors::SharedFolderCreateFailed, :path => hostpath.to_s
+              end
+            end
+          end
+        end
+
+        def create_metadata
+          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.creating")
+
+          folders = []
+          shared_folders.each do |name, data|
+            folders << {
+              :name => name,
+              :hostpath => File.expand_path(data[:hostpath], @env[:root_path]),
+              :transient => data[:transient]
+            }
+          end
+
+          @env[:vm].driver.share_folders(folders)
+        end
+
+        def mount_shared_folders
+          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.mounting")
+
+          # short guestpaths first, so we don't step on ourselves
+          folders = shared_folders.sort_by do |name, data|
+            if data[:guestpath]
+              data[:guestpath].length
+            else
+              # A long enough path to just do this at the end.
+              10000
+            end
+          end
+
+          # Go through each folder and mount
+          folders.each do |name, data|
+            if data[:guestpath]
+              # Guest path specified, so mount the folder to specified point
+              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
+                                    :name => name,
+                                    :guest_path => data[:guestpath]))
+
+              # Dup the data so we can pass it to the guest API
+              data = data.dup
+
+              # Calculate the owner and group
+              data[:owner] ||= @env[:vm].config.ssh.username
+              data[:group] ||= @env[:vm].config.ssh.username
+
+              # Mount the actual folder
+              @env[:vm].guest.mount_shared_folder(name, data[:guestpath], data)
+            else
+              # If no guest path is specified, then automounting is disabled
+              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
+                                    :name => name))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/suspend.rb

@@ -0,0 +1,20 @@
+module Vagrant
+  module Action
+    module VM
+      class Suspend
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:vm].state == :running
+            env[:ui].info I18n.t("vagrant.actions.vm.suspend.suspending")
+            env[:vm].driver.suspend
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/warden.rb

@@ -0,0 +1,92 @@
+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")
+      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
+          @logger.error("Error occurred: #{e}")
+          env["vagrant.error"] = e
+
+          # Something went horribly wrong. Start the rescue chain then
+          # reraise the exception to properly kick us out of limbo here.
+          begin_rescue(env)
+          raise
+        end
+      end
+
+      # Begins the recovery sequence for all middlewares which have run.
+      # It does this by calling `recover` (if it exists) on each middleware
+      # which has already run, in reverse order.
+      def begin_rescue(env)
+        @stack.each do |act|
+          if act.respond_to?(:recover)
+            @logger.info("Calling recover: #{act}")
+            act.recover(env)
+          end
+        end
+
+        # 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/lib/vagrant/box.rb

@@ -0,0 +1,44 @@
+module Vagrant
+  # Represents a "box," which is simply a packaged vagrant environment.
+  # Boxes are simply `tar` files which contain an exported VirtualBox
+  # virtual machine, at the least. They are created with `vagrant package`
+  # and may contain additional files if specified by the creator. This
+  # class serves to help manage these boxes, although most of the logic
+  # is kicked out to middlewares.
+  class Box
+    # The name of the box.
+    attr_reader :name
+
+    # The directory where this box is stored
+    attr_reader :directory
+
+    # Creates a new box instance. Given an optional `name` parameter,
+    # newly created instance will have that name, otherwise it defaults
+    # to `nil`.
+    #
+    # **Note:** This method does not actually _create_ the box, but merely
+    # returns a new, abstract representation of it. To add a box, see {#add}.
+    def initialize(name, directory, action_runner)
+      @name          = name
+      @directory     = directory
+      @action_runner = action_runner
+    end
+
+    # Begins the process of destroying this box. This cannot be undone!
+    def destroy
+      @action_runner.run(:box_remove, { :box_name => @name, :box_directory => @directory })
+    end
+
+    # Begins sequence to repackage this box.
+    def repackage(options=nil)
+      @action_runner.run(:box_repackage, { :box_name => @name, :box_directory => @directory })
+    end
+
+    # Implemented for comparison with other boxes. Comparison is implemented
+    # by simply comparing name.
+    def <=>(other)
+      return super if !other.is_a?(self.class)
+      name <=> other.name
+    end
+  end
+end

data/lib/vagrant/box_collection.rb

@@ -0,0 +1,58 @@
+require 'forwardable'
+
+module Vagrant
+  # Represents a collection of boxes, providing helpful methods for
+  # finding boxes.
+  class BoxCollection
+    include Enumerable
+    extend Forwardable
+    def_delegators :@boxes, :length, :each
+
+    # The directory that the boxes are being searched for.
+    attr_reader :directory
+
+    # Initializes the class to search for boxes in the given directory.
+    def initialize(directory, action_runner)
+      @directory     = directory
+      @boxes         = []
+      @action_runner = action_runner
+
+      reload!
+    end
+
+    # Find a box in the collection by the given name. The name must
+    # be a string, for now.
+    def find(name)
+      @boxes.each do |box|
+        return box if box.name == name
+      end
+
+      nil
+    end
+
+    # Adds a box to this collection with the given name and located
+    # at the given URL.
+    def add(name, url)
+      raise Errors::BoxAlreadyExists, :name => name if find(name)
+
+      @action_runner.run(:box_add,
+                         :box_name => name,
+                         :box_url => url,
+                         :box_directory => @directory.join(name))
+    end
+
+    # Loads the list of all boxes from the source. This modifies the
+    # current array.
+    def reload!
+      @boxes.clear
+
+      Dir.open(@directory) do |dir|
+        dir.each do |d|
+          next if d == "." || d == ".." || !@directory.join(d).directory?
+          @boxes << Box.new(d, @directory.join(d), @action_runner)
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant/cli.rb

@@ -0,0 +1,76 @@
+require 'log4r'
+require 'optparse'
+
+module Vagrant
+  # Manages the command line interface to Vagrant.
+  class CLI < Command::Base
+    def initialize(argv, env)
+      super
+
+      @logger = Log4r::Logger.new("vagrant::cli")
+      @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+      @logger.info("CLI: #{@main_args.inspect} #{@sub_command.inspect} #{@sub_args.inspect}")
+    end
+
+    def execute
+      if @main_args.include?("-v") || @main_args.include?("--version")
+        # Version short-circuits the whole thing. Just print
+        # the version and exit.
+        @env.ui.info(I18n.t("vagrant.commands.version.output",
+                            :version => Vagrant::VERSION),
+                     :prefix => false)
+
+        return 0
+      elsif @main_args.include?("-h") || @main_args.include?("--help")
+        # Help is next in short-circuiting everything. Print
+        # the help and exit.
+        help
+        return 0
+      end
+
+      # If we reached this far then we must have a subcommand. If not,
+      # then we also just print the help and exit.
+      command_class = Vagrant.commands.get(@sub_command.to_sym) if @sub_command
+      if !command_class || !@sub_command
+        help
+        return 0
+      end
+      @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+      # Initialize and execute the command class, returning the exit status.
+      result = command_class.new(@sub_args, @env).execute
+      result = 0 if !result.is_a?(Fixnum)
+      return result
+    end
+
+    # This prints out the help for the CLI.
+    def help
+      # We use the optionparser for this. Its just easier. We don't use
+      # an optionparser above because I don't think the performance hits
+      # of creating a whole object are worth checking only a couple flags.
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: vagrant [-v] [-h] command [<args>]"
+        opts.separator ""
+        opts.on("-v", "--version", "Print the version and exit.")
+        opts.on("-h", "--help", "Print this help.")
+        opts.separator ""
+        opts.separator "Available subcommands:"
+
+        # Add the available subcommands as separators in order to print them
+        # out as well.
+        keys = []
+        Vagrant.commands.each { |key, value| keys << key.to_s }
+
+        keys.sort.each do |key|
+          opts.separator "     #{key}"
+        end
+
+        opts.separator ""
+        opts.separator "For help on any individual command run `vagrant COMMAND -h`"
+      end
+
+      @env.ui.info(opts.help, :prefix => false)
+    end
+  end
+end