vagrantup 1.0.7 → 1.1.0

data/plugins/commands/plugin/action/list_plugins.rb

@@ -0,0 +1,54 @@
+require "rubygems"
+require "set"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      # This middleware lists all the installed plugins.
+      #
+      # This is a bit more complicated than simply listing installed
+      # gems or what is in the state file as installed. Instead, this
+      # actually compares installed gems with what the state file claims
+      # is installed, and outputs the appropriate truly installed
+      # plugins.
+      class ListPlugins
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Get the list of installed plugins according to the state file
+          installed = Set.new(env[:plugin_state_file].installed_plugins)
+
+          # Go through the plugins installed in this environment and
+          # get the latest version of each.
+          installed_map = {}
+          env[:gem_helper].with_environment do
+            Gem::Specification.find_all.each do |spec|
+              # Ignore specs that aren't in our installed list
+              next if !installed.include?(spec.name)
+
+              # If we already have a newer version in our list of installed,
+              # then ignore it
+              next if installed_map.has_key?(spec.name) &&
+                installed_map[spec.name].version >= spec.version
+
+              installed_map[spec.name] = spec
+            end
+          end
+
+          # Output!
+          if installed_map.empty?
+            env[:ui].info(I18n.t("vagrant.commands.plugin.no_plugins"))
+          else
+            installed_map.values.each do |spec|
+              env[:ui].info "#{spec.name} (#{spec.version})"
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/action/prune_gems.rb

@@ -0,0 +1,149 @@
+require "rubygems"
+require "rubygems/user_interaction"
+require "rubygems/uninstaller"
+require "set"
+
+require "log4r"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      # This class prunes any unnecessary gems from the Vagrant-managed
+      # gem folder. This keeps the gem folder to the absolute minimum set
+      # of required gems and doesn't let it blow up out of control.
+      #
+      # A high-level description of how this works:
+      #
+      #   1. Get the list of installed plugins. Vagrant maintains this
+      #     list on its own.
+      #   2. Get the list of installed RubyGems.
+      #   3. Find the latest version of each RubyGem that matches an installed
+      #      plugin. These are our root RubyGems that must be installed.
+      #   4. Go through each root and mark all dependencies recursively as
+      #      necessary.
+      #   5. Set subtraction between all gems and necessary gems yields a
+      #      list of gems that aren't needed. Uninstall them.
+      #
+      class PruneGems
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::plugins::plugincommand::prune")
+        end
+
+        def call(env)
+          @logger.info("Pruning gems...")
+
+          # Get the list of installed plugins according to the state file
+          installed = Set.new(env[:plugin_state_file].installed_plugins)
+
+          # Get the actual specifications of installed gems
+          all_specs = env[:gem_helper].with_environment do
+            result = []
+            Gem::Specification.find_all { |s| result << s }
+            result
+          end
+
+          # The list of specs to prune initially starts out as all of them
+          all_specs = Set.new(all_specs)
+
+          # Go through each spec and find the latest version of the installed
+          # gems, since we want to keep those.
+          installed_specs = {}
+
+          @logger.debug("Collecting installed plugin gems...")
+          all_specs.each do |spec|
+            # If this isn't a spec that we claim is installed, skip it
+            next if !installed.include?(spec.name)
+
+            # If it is already in the specs, then we need to make sure we
+            # have the latest version.
+            if installed_specs.has_key?(spec.name)
+              if installed_specs[spec.name].version > spec.version
+                next
+              end
+            end
+
+            @logger.debug(" -- #{spec.name} (#{spec.version})")
+            installed_specs[spec.name] = spec
+          end
+
+          # Recursive dependency checker to keep all dependencies and remove
+          # all non-crucial gems from the prune list.
+          good_specs = Set.new
+          to_check   = installed_specs.values
+
+          while true
+            # If we're out of gems to check then we break out
+            break if to_check.empty?
+
+            # Get a random (first) element to check
+            spec = to_check.shift
+
+            # If we already checked this, then do the next one
+            next if good_specs.include?(spec)
+
+            # Find all the dependencies and add the latest compliant gem
+            # to the `to_check` list.
+            if spec.dependencies.length > 0
+              @logger.debug("Finding dependencies for '#{spec.name}' to mark as good...")
+              spec.dependencies.each do |dep|
+                # Ignore non-runtime dependencies
+                next if dep.type != :runtime
+                @logger.debug("Searching for: '#{dep.name}'")
+
+                latest_matching = nil
+
+                all_specs.each do |prune_spec|
+                  if dep =~ prune_spec
+                    # If we have a matching one already and this one isn't newer
+                    # then we ditch it.
+                    next if latest_matching &&
+                      prune_spec.version <= latest_matching.version
+
+                    latest_matching = prune_spec
+                  end
+                end
+
+                if latest_matching.nil?
+                  @logger.error("Missing dependency for '#{spec.name}': #{dep.name}")
+                  next
+                end
+
+                @logger.debug("Latest matching dep: '#{latest_matching.name}' (#{latest_matching.version})")
+                to_check << latest_matching
+              end
+            end
+
+            # Add ito the list of checked things so we don't accidentally
+            # re-check it
+            good_specs.add(spec)
+          end
+
+          # Figure out the gems we need to prune
+          prune_specs = all_specs - good_specs
+          @logger.debug("Gems to prune: #{prune_specs.inspect}")
+          @logger.info("Pruning #{prune_specs.length} gems.")
+
+          if prune_specs.length > 0
+            env[:gem_helper].with_environment do
+              prune_specs.each do |prune_spec|
+                uninstaller = Gem::Uninstaller.new(prune_spec.name, {
+                  :all         => true,
+                  :executables => true,
+                  :force       => true,
+                  :ignore      => true,
+                  :version     => prune_spec.version.version
+                })
+
+                @logger.info("Uninstalling: #{prune_spec.name} (#{prune_spec.version})")
+                uninstaller.uninstall
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/action/uninstall_plugin.rb

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      # This middleware uninstalls a plugin by simply removing it from
+      # the state file. Running a {PruneGems} after should properly remove
+      # it from the gem index.
+      class UninstallPlugin
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Remove it!
+          env[:ui].info(I18n.t("vagrant.commands.plugin.uninstalling",
+                               :name => env[:plugin_name]))
+          env[:plugin_state_file].remove_plugin(env[:plugin_name])
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/command/base.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module CommandPlugin
+    module Command
+      class Base < Vagrant.plugin("2", :command)
+        # This is a helper for executing an action sequence with the proper
+        # environment hash setup so that the plugin specific helpers are
+        # in.
+        #
+        # @param [Object] callable the Middleware callable
+        # @param [Hash] env Extra environment hash that is merged in.
+        def action(callable, env=nil)
+          env = {
+            :gem_helper => GemHelper.new(@env.gems_path),
+            :plugin_state_file => StateFile.new(@env.home_path.join("plugins.json"))
+          }.merge(env || {})
+
+          @env.action_runner.run(callable, env)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/command/install.rb

@@ -0,0 +1,39 @@
+require 'optparse'
+
+require_relative "base"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Command
+      class Install < Base
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant plugin install <name> [-h]"
+            o.separator ""
+
+            o.on("--entry-point NAME", String,
+                 "The name of the entry point file for loading the plugin.") do |entry_point|
+              options[:entry_point] = entry_point
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 1
+
+          # Install the gem
+          action(Action.action_install, {
+            :plugin_entry_point => options[:entry_point],
+            :plugin_name        => argv[0]
+          })
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/command/license.rb

@@ -0,0 +1,31 @@
+require 'optparse'
+
+require_relative "base"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Command
+      class License < Base
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant plugin license <name> <license-file> [-h]"
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 2
+
+          # License the plugin
+          action(Action.action_license, {
+            :plugin_license_path => argv[1],
+            :plugin_name         => argv[0]
+          })
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/command/list.rb

@@ -0,0 +1,28 @@
+require 'optparse'
+
+require_relative "base"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Command
+      class List < Base
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant plugin list [-h]"
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length > 0
+
+          # List the installed plugins
+          action(Action.action_list)
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/command/root.rb

@@ -0,0 +1,75 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandPlugin
+    module Command
+      class Root < Vagrant.plugin("2", :command)
+        def initialize(argv, env)
+          super
+
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+          @subcommands.register(:install) do
+            require_relative "install"
+            Install
+          end
+
+          @subcommands.register(:license) do
+            require_relative "license"
+            License
+          end
+
+          @subcommands.register(:list) do
+            require_relative "list"
+            List
+          end
+
+          @subcommands.register(:uninstall) do
+            require_relative "uninstall"
+            Uninstall
+          end
+        end
+
+        def execute
+          if @main_args.include?("-h") || @main_args.include?("--help")
+            # Print the help for all the sub-commands.
+            return help
+          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 = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help if !command_class || !@sub_command
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+
+        # Prints the help out for this command
+        def help
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant plugin <command> [<args>]"
+            o.separator ""
+            o.separator "Available subcommands:"
+
+            # Add the available subcommands as separators in order to print them
+            # out as well.
+            keys = []
+            @subcommands.each { |key, value| keys << key.to_s }
+
+            keys.sort.each do |key|
+              o.separator "     #{key}"
+            end
+
+            o.separator ""
+            o.separator "For help on any individual command run `vagrant plugin COMMAND -h`"
+          end
+
+          @env.ui.info(opts.help, :prefix => false)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/command/uninstall.rb

@@ -0,0 +1,28 @@
+require 'optparse'
+
+require_relative "base"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Command
+      class Uninstall < Base
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant plugin uninstall <name> [-h]"
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 1
+
+          # Uninstall the gem
+          action(Action.action_uninstall, :plugin_name => argv[0])
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end