tnargav 1.2.2

data/plugins/commands/init/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandInit
+    class Plugin < Vagrant.plugin("2")
+      name "init command"
+      description <<-DESC
+      The `init` command sets up your working directory to be a
+      Vagrant-managed environment.
+      DESC
+
+      command("init") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/package/command.rb

@@ -0,0 +1,83 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandPackage
+    class Command < Vagrant.plugin("2", :command)
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant package [vm-name] [--base name] [--output name.box]"
+          o.separator "                       [--include one,two,three] [--vagrantfile file]"
+
+          o.separator ""
+
+          o.on("--base NAME", "Name of a VM in virtualbox to package as a base box") do |b|
+            options[:base] = b
+          end
+
+          o.on("--output NAME", "Name of the file to output") do |output|
+            options[:output] = output
+          end
+
+          o.on("--include x,y,z", Array, "Additional files to package with the box.") do |i|
+            options[:include] = i
+          end
+
+          o.on("--vagrantfile file", "Vagrantfile to package with the box.") do |v|
+            options[:vagrantfile] = v
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("package options: #{options.inspect}")
+        if options[:base]
+          package_base(options)
+        else
+          package_target(argv[0], options)
+        end
+
+        # Success, exit status 0
+        0
+      end
+
+      protected
+
+      def package_base(options)
+        # XXX: This whole thing is hardcoded and very temporary. The whole
+        # `vagrant package --base` process is deprecated for something much
+        # better in the future. We just hardcode this to keep VirtualBox working
+        # for now.
+        provider = Vagrant.plugin("2").manager.providers[:virtualbox]
+        vm = Vagrant::Machine.new(
+          options[:base],
+          :virtualbox, provider[0], nil, provider[1],
+          @env.config_global,
+          nil, nil,
+          @env, true)
+        @logger.debug("Packaging base VM: #{vm.name}")
+        package_vm(vm, options)
+      end
+
+      def package_target(name, options)
+        with_target_vms(name, :single_target => true) do |vm|
+          @logger.debug("Packaging VM: #{vm.name}")
+          package_vm(vm, options)
+        end
+      end
+
+      def package_vm(vm, options)
+        opts = options.inject({}) do |acc, data|
+          k,v = data
+          acc["package.#{k}"] = v
+          acc
+        end
+
+        vm.action(:package, opts)
+      end
+    end
+  end
+end

data/plugins/commands/package/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandPackage
+    class Plugin < Vagrant.plugin("2")
+      name "package command"
+      description <<-DESC
+      The `package` command will take a previously existing Vagrant
+      environment and package it into a box file.
+      DESC
+
+      command("package") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      class BundlerCheck
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Bundler sets up its own custom gem load paths such that our
+          # own gems are never loaded. Therefore, give an error if a user
+          # tries to install gems while within a Bundler-managed environment.
+          if defined?(Bundler)
+            require 'bundler/shared_helpers'
+            if Bundler::SharedHelpers.in_bundle?
+              raise Vagrant::Errors::GemCommandInBundler
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require "rubygems"
+require "rubygems/dependency_installer"
+
+require "log4r"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      # This action takes the `:plugin_name` variable in the environment
+      # and installs it using the RubyGems API.
+      class InstallGem
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::plugins::plugincommand::installgem")
+        end
+
+        def call(env)
+          plugin_name = env[:plugin_name]
+          prerelease  = env[:plugin_prerelease]
+          version     = env[:plugin_version]
+
+          # Install the gem
+          plugin_name_label = plugin_name
+          plugin_name_label += ' --prerelease' if prerelease
+          plugin_name_label += " --version '#{version}'" if version
+          env[:ui].info(I18n.t("vagrant.commands.plugin.installing",
+                               :name => plugin_name_label))
+          installed_gems = env[:gem_helper].with_environment do
+            # Override the list of sources by the ones set as a parameter if given
+            if env[:plugin_sources]
+              @logger.info("Custom plugin sources: #{env[:plugin_sources]}")
+              Gem.sources = env[:plugin_sources]
+            end
+
+            installer = Gem::DependencyInstaller.new(:document => [], :prerelease => prerelease)
+
+            begin
+              installer.install(plugin_name, version)
+            rescue Gem::GemNotFoundException
+              raise Vagrant::Errors::PluginInstallNotFound,
+                :name => plugin_name
+            end
+          end
+
+          # The plugin spec is the last installed gem since RubyGems
+          # currently always installed the requested gem last.
+          @logger.debug("Installed #{installed_gems.length} gems.")
+          plugin_spec = installed_gems.last
+
+          # Store the installed name so we can uninstall it if things go
+          # wrong.
+          @installed_plugin_name = plugin_spec.name
+
+          # Mark that we installed the gem
+          @logger.info("Adding the plugin to the state file...")
+          env[:plugin_state_file].add_plugin(plugin_spec.name)
+
+          # Tell the user
+          env[:ui].success(I18n.t("vagrant.commands.plugin.installed",
+                                  :name => plugin_spec.name,
+                                  :version => plugin_spec.version.to_s))
+
+          # Continue
+          @app.call(env)
+        end
+
+        def recover(env)
+          # If any error happens, we uninstall it and remove it from
+          # the state file. We can only do this if we successfully installed
+          # the gem in the first place.
+          if @installed_plugin_name
+            new_env = env.dup
+            new_env.delete(:interrupted)
+            new_env[:plugin_name] = @installed_plugin_name
+            new_env[:action_runner].run(Action.action_uninstall, new_env)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require "fileutils"
+require "pathname"
+require "rubygems"
+require "set"
+
+require "log4r"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      # This middleware licenses a plugin by copying the license file to
+      # the proper place.
+      class LicensePlugin
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::plugins::plugincommand::license")
+        end
+
+        def call(env)
+          # Get the list of installed plugins according to the state file
+          installed = Set.new(env[:plugin_state_file].installed_plugins)
+
+          # If the plugin we're trying to license doesn't exist in the
+          # state file, then it is an error.
+          if !installed.include?(env[:plugin_name])
+            raise Vagrant::Errors::PluginNotFound, :name => env[:plugin_name]
+          end
+
+          # Verify the license file exists
+          license_file = Pathname.new(env[:plugin_license_path])
+          if !license_file.file?
+            raise Vagrant::Errors::PluginInstallLicenseNotFound,
+              :name => env[:plugin_name],
+              :path => license_file.to_s
+          end
+
+          # Copy it in.
+          final_path = env[:home_path].join("license-#{env[:plugin_name]}.lic")
+          @logger.info("Copying license from: #{license_file}")
+          @logger.info("Copying license to: #{final_path}")
+          env[:ui].info(I18n.t("vagrant.commands.plugin.installing_license",
+                               :name => env[:plugin_name]))
+          FileUtils.cp(license_file, final_path)
+
+          # Installed!
+          env[:ui].success(I18n.t("vagrant.commands.plugin.installed_license",
+                                 :name => env[:plugin_name]))
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require "pathname"
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Action
+      # This middleware sequence will install a plugin.
+      def self.action_install
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use BundlerCheck
+          b.use InstallGem
+          b.use PruneGems
+        end
+      end
+
+      # This middleware sequence licenses paid addons.
+      def self.action_license
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use BundlerCheck
+          b.use LicensePlugin
+        end
+      end
+
+      # This middleware sequence will list all installed plugins.
+      def self.action_list
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use BundlerCheck
+          b.use ListPlugins
+        end
+      end
+
+      # This middleware sequence will uninstall a plugin.
+      def self.action_uninstall
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use BundlerCheck
+          b.use UninstallPlugin
+          b.use PruneGems
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :BundlerCheck, action_root.join("bundler_check")
+      autoload :InstallGem, action_root.join("install_gem")
+      autoload :LicensePlugin, action_root.join("license_plugin")
+      autoload :ListPlugins, action_root.join("list_plugins")
+      autoload :PruneGems, action_root.join("prune_gems")
+      autoload :UninstallPlugin, action_root.join("uninstall_plugin")
+    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,58 @@
+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
+
+            o.on("--plugin-prerelease",
+                 "Allow prerelease versions of this plugin.") do |plugin_prerelease|
+              options[:plugin_prerelease] = plugin_prerelease
+            end
+
+            o.on("--plugin-source PLUGIN_SOURCE", String,
+                 "Add a RubyGems repository source") do |plugin_source|
+              options[:plugin_sources] ||= []
+              options[:plugin_sources] << plugin_source
+            end
+
+            o.on("--plugin-version PLUGIN_VERSION", String,
+                 "Install a specific version of the plugin") do |plugin_version|
+              options[:plugin_version] = plugin_version
+            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_prerelease  => options[:plugin_prerelease],
+            :plugin_version     => options[:plugin_version],
+            :plugin_sources     => options[:plugin_sources],
+            :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