vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/warden.rb

@@ -1,104 +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 IN action: #{action}")
-          @stack.unshift(action).first.call(env)
-          raise Errors::VagrantInterrupt if env[:interrupted]
-          @logger.info("Calling OUT action: #{action}")
-        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/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action.rb

@@ -1,72 +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 :BoxCheckOutdated, "vagrant/action/builtin/box_check_outdated"
-      autoload :BoxRemove, "vagrant/action/builtin/box_remove"
-      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 :HandleBox, "vagrant/action/builtin/handle_box"
-      autoload :HandleBoxUrl, "vagrant/action/builtin/handle_box_url"
-      autoload :HandleForwardedPortCollisions, "vagrant/action/builtin/handle_forwarded_port_collisions"
-      autoload :IsEnvSet, "vagrant/action/builtin/is_env_set"
-      autoload :IsState, "vagrant/action/builtin/is_state"
-      autoload :Lock, "vagrant/action/builtin/lock"
-      autoload :Message, "vagrant/action/builtin/message"
-      autoload :PrepareClone, "vagrant/action/builtin/prepare_clone"
-      autoload :Provision, "vagrant/action/builtin/provision"
-      autoload :ProvisionerCleanup, "vagrant/action/builtin/provisioner_cleanup"
-      autoload :SetHostname, "vagrant/action/builtin/set_hostname"
-      autoload :SSHExec, "vagrant/action/builtin/ssh_exec"
-      autoload :SSHRun,  "vagrant/action/builtin/ssh_run"
-      autoload :SyncedFolders, "vagrant/action/builtin/synced_folders"
-      autoload :SyncedFolderCleanup, "vagrant/action/builtin/synced_folder_cleanup"
-      autoload :WaitForCommunicator, "vagrant/action/builtin/wait_for_communicator"
-    end
-
-    module General
-      autoload :Package, 'vagrant/action/general/package'
-      autoload :PackageSetupFiles, 'vagrant/action/general/package_setup_files'
-      autoload :PackageSetupFolders, 'vagrant/action/general/package_setup_folders'
-    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
-
-    # This actions checks if a box is outdated in a given Vagrant
-    # environment for a single machine.
-    def self.action_box_outdated
-      Builder.new.tap do |b|
-        b.use Builtin::BoxCheckOutdated
-      end
-    end
-
-    # This is the action that will remove a box given a name (and optionally
-    # a provider). This middleware sequence is built-in to Vagrant. Plugins
-    # can hook into this like any other middleware sequence.
-    def self.action_box_remove
-      Builder.new.tap do |b|
-        b.use Builtin::BoxRemove
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/alias.rb

@@ -1,56 +0,0 @@
-require "vagrant/registry"
-
-module Vagrant
-  # This class imports and processes CLI aliases stored in ~/.vagrant.d/aliases
-  class Alias
-    def initialize(env)
-      @aliases = Registry.new
-      @env = env
-
-      if env.aliases_path.file?
-        env.aliases_path.readlines.each do |line|
-          # separate keyword-command pairs
-          keyword, command = interpret(line)
-
-          if keyword && command
-            register(keyword, command)
-          end
-        end
-      end
-    end
-
-    # This returns all the registered alias commands.
-    def commands
-      @aliases
-    end
-
-    # This interprets a raw line from the aliases file.
-    def interpret(line)
-      # is it a comment?
-      return nil if line.strip.start_with?("#")
-
-      keyword, command = line.split("=", 2).collect(&:strip)
-
-      # validate the keyword
-      if keyword.match(/\s/i)
-        raise Errors::AliasInvalidError, alias: line, message: "Alias keywords must not contain any whitespace."
-      end
-
-      [keyword, command]
-    end
-
-    # This registers an alias.
-    def register(keyword, command)
-      @aliases.register(keyword.to_sym) do
-        lambda do |args|
-          # directly execute shell commands
-          if command.start_with?("!")
-            return Util::SafeExec.exec "#{command[1..-1]} #{args.join(" ")}".strip
-          end
-
-          return CLI.new(command.split.concat(args), @env).execute
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/batch_action.rb

@@ -1,165 +0,0 @@
-require 'thread'
-
-require "log4r"
-
-module Vagrant
-  # This class executes multiple actions as a single batch, parallelizing
-  # the action calls if possible.
-  class BatchAction
-    def initialize(allow_parallel=true)
-      @actions          = []
-      @allow_parallel   = allow_parallel
-      @logger           = Log4r::Logger.new("vagrant::batch_action")
-    end
-
-    # Add an action to the batch of actions that will be run.
-    #
-    # This will **not** run the action now. The action will be run
-    # when {#run} is called.
-    #
-    # @param [Machine] machine The machine to run the action on
-    # @param [Symbol] action The action to run
-    # @param [Hash] options Any additional options to send in.
-    def action(machine, action, options=nil)
-      @actions << [machine, action, options]
-    end
-
-    # Custom runs a custom proc against a machine.
-    #
-    # @param [Machine] machine The machine to run against.
-    def custom(machine, &block)
-      @actions << [machine, block, nil]
-    end
-
-    # Run all the queued up actions, parallelizing if possible.
-    #
-    # This will parallelize if and only if the provider of every machine
-    # supports parallelization and parallelization is possible from
-    # initialization of the class.
-    def run
-      par = false
-
-      if @allow_parallel
-        par = true
-        @logger.info("Enabling parallelization by default.")
-      end
-
-      if par
-        @actions.each do |machine, _, _|
-          if !machine.provider_options[:parallel]
-            @logger.info("Disabling parallelization because provider doesn't support it: #{machine.provider_name}")
-            par = false
-            break
-          end
-        end
-      end
-
-      if par && @actions.length <= 1
-        @logger.info("Disabling parallelization because only executing one action")
-        par = false
-      end
-
-      @logger.info("Batch action will parallelize: #{par.inspect}")
-
-      threads = []
-      @actions.each do |machine, action, options|
-        @logger.info("Starting action: #{machine} #{action} #{options}")
-
-        # Create the new thread to run our action. This is basically just
-        # calling the action but also contains some error handling in it
-        # as well.
-        thread = Thread.new do
-          Thread.current[:error] = nil
-
-          # Record our pid when we started in order to figure out if
-          # we've forked...
-          start_pid = Process.pid
-
-          begin
-            if action.is_a?(Proc)
-              action.call(machine)
-            else
-              machine.send(:action, action, options)
-            end
-          rescue Exception => e
-            # If we're not parallelizing, then raise the error. We also
-            # don't raise the error if we've forked, because it'll hang
-            # the process.
-            raise if !par && Process.pid == start_pid
-
-            # Store the exception that will be processed later
-            Thread.current[:error] = e
-
-            # We can only do the things below if we do not fork, otherwise
-            # it'll hang the process.
-            if Process.pid == start_pid
-              # Let the user know that this process had an error early
-              # so that they see it while other things are happening.
-              machine.ui.error(I18n.t("vagrant.general.batch_notify_error"))
-            end
-          end
-
-          # If we forked during the process run, we need to do a hard
-          # exit here. Ruby's fork only copies the running process (which
-          # would be us), so if we return from this thread, it results
-          # in a zombie Ruby process.
-          if Process.pid != start_pid
-            # We forked.
-
-            exit_status = true
-            if Thread.current[:error]
-              # We had an error, print the stack trace and exit immediately.
-              exit_status = false
-              error = Thread.current[:error]
-              @logger.error(error.inspect)
-              @logger.error(error.message)
-              @logger.error(error.backtrace.join("\n"))
-            end
-
-            Process.exit!(exit_status)
-          end
-        end
-
-        # Set some attributes on the thread for later
-        thread[:machine] = machine
-
-        if !par
-          thread.join(THREAD_MAX_JOIN_TIMEOUT) while thread.alive?
-        end
-        threads << thread
-      end
-
-      errors = []
-
-      threads.each do |thread|
-        # Wait for the thread to complete
-        thread.join(THREAD_MAX_JOIN_TIMEOUT) while thread.alive?
-
-        # If the thread had an error, then store the error to show later
-        if thread[:error]
-          e = thread[:error]
-          # If the error isn't a Vagrant error, then store the backtrace
-          # as well.
-          if !thread[:error].is_a?(Errors::VagrantError)
-            e       = thread[:error]
-            message = e.message
-            message += "\n"
-            message += "\n#{e.backtrace.join("\n")}"
-
-            errors << I18n.t("vagrant.general.batch_unexpected_error",
-                             machine: thread[:machine].name,
-                             message: message)
-          else
-            errors << I18n.t("vagrant.general.batch_vagrant_error",
-                             machine: thread[:machine].name,
-                             message: thread[:error].message)
-          end
-        end
-      end
-
-      if !errors.empty?
-        raise Errors::BatchMultiError, message: errors.join("\n\n")
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/box.rb

@@ -1,198 +0,0 @@
-require 'fileutils'
-require "tempfile"
-
-require "json"
-require "log4r"
-
-require "vagrant/box_metadata"
-require "vagrant/util/downloader"
-require "vagrant/util/platform"
-require "vagrant/util/safe_chdir"
-require "vagrant/util/subprocess"
-
-module Vagrant
-  # Represents a "box," which is a package Vagrant environment that is used
-  # as a base image when creating a new guest machine.
-  class Box
-    include Comparable
-
-    # The box name. This is the logical name used when adding the box.
-    #
-    # @return [String]
-    attr_reader :name
-
-    # This is the provider that this box is built for.
-    #
-    # @return [Symbol]
-    attr_reader :provider
-
-    # The version of this box.
-    #
-    # @return [String]
-    attr_reader :version
-
-    # This is the directory on disk where this box exists.
-    #
-    # @return [Pathname]
-    attr_reader :directory
-
-    # This is the metadata for the box. This is read from the "metadata.json"
-    # file that all boxes require.
-    #
-    # @return [Hash]
-    attr_reader :metadata
-
-    # This is the URL to the version info and other metadata for this
-    # box.
-    #
-    # @return [String]
-    attr_reader :metadata_url
-
-    # This is used to initialize a box.
-    #
-    # @param [String] name Logical name of the box.
-    # @param [Symbol] provider The provider that this box implements.
-    # @param [Pathname] directory The directory where this box exists on
-    #   disk.
-    def initialize(name, provider, version, directory, **opts)
-      @name      = name
-      @version   = version
-      @provider  = provider
-      @directory = directory
-      @metadata_url = opts[:metadata_url]
-
-      metadata_file = directory.join("metadata.json")
-      raise Errors::BoxMetadataFileNotFound, name: @name if !metadata_file.file?
-
-      begin
-        @metadata = JSON.parse(directory.join("metadata.json").read)
-      rescue JSON::ParserError
-        raise Errors::BoxMetadataCorrupted, name: @name
-      end
-
-      @logger = Log4r::Logger.new("vagrant::box")
-    end
-
-    # This deletes the box. This is NOT undoable.
-    def destroy!
-      # Delete the directory to delete the box.
-      FileUtils.rm_r(@directory)
-
-      # Just return true always
-      true
-    rescue Errno::ENOENT
-      # This means the directory didn't exist. Not a problem.
-      return true
-    end
-
-    # Checks if this box is in use according to the given machine
-    # index and returns the entries that appear to be using the box.
-    #
-    # The entries returned, if any, are not tested for validity
-    # with {MachineIndex::Entry#valid?}, so the caller should do that
-    # if the caller cares.
-    #
-    # @param [MachineIndex] index
-    # @return [Array<MachineIndex::Entry>]
-    def in_use?(index)
-      results = []
-      index.each do |entry|
-        box_data = entry.extra_data["box"]
-        next if !box_data
-
-        # If all the data matches, record it
-        if box_data["name"] == self.name &&
-          box_data["provider"] == self.provider.to_s &&
-          box_data["version"] == self.version.to_s
-          results << entry
-        end
-      end
-
-      return nil if results.empty?
-      results
-    end
-
-    # Loads the metadata URL and returns the latest metadata associated
-    # with this box.
-    #
-    # @param [Hash] download_options Options to pass to the downloader.
-    # @return [BoxMetadata]
-    def load_metadata(**download_options)
-      tf = Tempfile.new("vagrant-load-metadata")
-      tf.close
-
-      url = @metadata_url
-      if File.file?(url) || url !~ /^[a-z0-9]+:.*$/i
-        url = File.expand_path(url)
-        url = Util::Platform.cygwin_windows_path(url)
-        url = "file:#{url}"
-      end
-
-      opts = { headers: ["Accept: application/json"] }.merge(download_options)
-      Util::Downloader.new(url, tf.path, **opts).download!
-      BoxMetadata.new(File.open(tf.path, "r"))
-    rescue Errors::DownloaderError => e
-      raise Errors::BoxMetadataDownloadError,
-        message: e.extra_data[:message]
-    ensure
-      tf.unlink if tf
-    end
-
-    # Checks if the box has an update and returns the metadata, version,
-    # and provider. If the box doesn't have an update that satisfies the
-    # constraints, it will return nil.
-    #
-    # This will potentially make a network call if it has to load the
-    # metadata from the network.
-    #
-    # @param [String] version Version constraints the update must
-    #   satisfy. If nil, the version constrain defaults to being a
-    #   larger version than this box.
-    # @return [Array]
-    def has_update?(version=nil, download_options: {})
-      if !@metadata_url
-        raise Errors::BoxUpdateNoMetadata, name: @name
-      end
-
-      version += ", " if version
-      version ||= ""
-      version += "> #{@version}"
-      md      = self.load_metadata(download_options)
-      newer   = md.version(version, provider: @provider)
-      return nil if !newer
-
-      [md, newer, newer.provider(@provider)]
-    end
-
-    # This repackages this box and outputs it to the given path.
-    #
-    # @param [Pathname] path The full path (filename included) of where
-    #   to output this box.
-    # @return [Boolean] true if this succeeds.
-    def repackage(path)
-      @logger.debug("Repackaging box '#{@name}' to: #{path}")
-
-      Util::SafeChdir.safe_chdir(@directory) do
-        # Find all the files in our current directory and tar it up!
-        files = Dir.glob(File.join(".", "**", "*")).select { |f| File.file?(f) }
-
-        # Package!
-        Util::Subprocess.execute("bsdtar", "-czf", path.to_s, *files)
-      end
-
-      @logger.info("Repackaged box '#{@name}' successfully: #{path}")
-
-      true
-    end
-
-    # Implemented for comparison with other boxes. Comparison is
-    # implemented by comparing names and providers.
-    def <=>(other)
-      return super if !other.is_a?(self.class)
-
-      # Comparison is done by composing the name and provider
-      "#{@name}-#{@version}-#{@provider}" <=>
-      "#{other.name}-#{other.version}-#{other.provider}"
-    end
-  end
-end