vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/plugin/v2/push.rb

@@ -1,27 +0,0 @@
-module Vagrant
-  module Plugin
-    module V2
-      class Push
-        attr_reader :env
-        attr_reader :config
-
-        # Initializes the pusher with the given environment the push
-        # configuration.
-        #
-        # @param [Environment] env
-        # @param [Object] config Push configuration
-        def initialize(env, config)
-          @env     = env
-          @config  = config
-        end
-
-        # This is the method called when the actual pushing should be
-        # done.
-        #
-        # No return value is expected.
-        def push
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/plugin/v2/synced_folder.rb

@@ -1,60 +0,0 @@
-module Vagrant
-  module Plugin
-    module V2
-      # This is the base class for a synced folder implementation.
-      class SyncedFolder
-        # This is called early when the synced folder is set to determine
-        # if this implementation can be used for this machine. This should
-        # return true or false.
-        #
-        # @param [Machine] machine
-        # @param [Boolean] raise_error If true, should raise an exception
-        #   if it isn't usable.
-        # @return [Boolean]
-        def usable?(machine, raise_error=false)
-        end
-
-        # DEPRECATED: This will be removed.
-        #
-        # @deprecated
-        def prepare(machine, folders, opts)
-        end
-
-        # This is called after the machine is booted and after networks
-        # are setup.
-        #
-        # This might be called with new folders while the machine is running.
-        # If so, then this should add only those folders without removing
-        # any existing ones.
-        #
-        # No return value.
-        def enable(machine, folders, opts)
-        end
-
-        # This is called to remove the synced folders from a running
-        # machine.
-        #
-        # This is not guaranteed to be called, but this should be implemented
-        # by every synced folder implementation.
-        #
-        # @param [Machine] machine The machine to modify.
-        # @param [Hash] folders The folders to remove. This will not contain
-        #   any folders that should remain.
-        # @param [Hash] opts Any options for the synced folders.
-        def disable(machine, folders, opts)
-        end
-
-        # This is called after destroying the machine during a
-        # `vagrant destroy` and also prior to syncing folders during
-        # a `vagrant up`.
-        #
-        # No return value.
-        #
-        # @param [Machine] machine
-        # @param [Hash] opts
-        def cleanup(machine, opts)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/plugin/v2/trigger.rb

@@ -1,242 +0,0 @@
-require 'fileutils'
-require 'log4r'
-require 'shellwords'
-
-require Vagrant.source_root.join("plugins/provisioners/shell/provisioner")
-require "vagrant/util/subprocess"
-require "vagrant/util/platform"
-require "vagrant/util/powershell"
-
-module Vagrant
-  module Plugin
-    module V2
-      class Trigger
-        # @return [Kernel_V2::Config::Trigger]
-        attr_reader :config
-
-        # This class is responsible for setting up basic triggers that were
-        # defined inside a Vagrantfile.
-        #
-        # @param [Vagrant::Environment] env Vagrant environment
-        # @param [Kernel_V2::TriggerConfig] config Trigger configuration
-        # @param [Vagrant::Machine] machine Active Machine
-        def initialize(env, config, machine)
-          @env        = env
-          @config     = config
-          @machine    = machine
-
-          @logger = Log4r::Logger.new("vagrant::trigger::#{self.class.to_s.downcase}")
-        end
-
-        # Fires all triggers, if any are defined for the action and guest
-        #
-        # @param [Symbol] action Vagrant command to fire trigger on
-        # @param [Symbol] stage :before or :after
-        # @param [String] guest_name The guest that invoked firing the triggers
-        def fire_triggers(action, stage, guest_name)
-          # get all triggers matching action
-          triggers = []
-          if stage == :before
-            triggers = config.before_triggers.select do |t|
-              t.command == action || (t.command == :all && !t.ignore.include?(action))
-            end
-          elsif stage == :after
-            triggers = config.after_triggers.select do |t|
-              t.command == action || (t.command == :all && !t.ignore.include?(action))
-            end
-          else
-            raise Errors::TriggersNoStageGiven,
-              action: action,
-              stage: stage,
-              guest_name: guest_name
-          end
-
-          triggers = filter_triggers(triggers, guest_name)
-
-          if !triggers.empty?
-            @logger.info("Firing trigger for action #{action} on guest #{guest_name}")
-            @machine.ui.info(I18n.t("vagrant.trigger.start", stage: stage, action: action))
-            fire(triggers, guest_name)
-          end
-        end
-
-        protected
-
-        #-------------------------------------------------------------------
-        # Internal methods, don't call these.
-        #-------------------------------------------------------------------
-
-        # Filters triggers to be fired based on configured restraints
-        #
-        # @param [Array] triggers An array of triggers to be filtered
-        # @param [String] guest_name The name of the current guest
-        # @return [Array] The filtered array of triggers
-        def filter_triggers(triggers, guest_name)
-          # look for only_on trigger constraint and if it doesn't match guest
-          # name, throw it away also be sure to preserve order
-          filter = triggers.dup
-
-          filter.each do |trigger|
-            index = nil
-            match = false
-            if trigger.only_on
-              trigger.only_on.each do |o|
-                if o.match(guest_name)
-                  # trigger matches on current guest, so we're fine to use it
-                  match = true
-                  break
-                end
-              end
-              # no matches found, so don't use trigger for guest
-              index = triggers.index(trigger) unless match == true
-            end
-
-            if index
-              @logger.debug("Trigger #{trigger.id} will be ignored for #{guest_name}")
-              triggers.delete_at(index)
-            end
-          end
-
-          return triggers
-        end
-
-        # Fires off all triggers in the given array
-        #
-        # @param [Array] triggers An array of triggers to be fired
-        def fire(triggers, guest_name)
-          # ensure on_error is respected by exiting or continuing
-
-          triggers.each do |trigger|
-            @logger.debug("Running trigger #{trigger.id}...")
-
-            if trigger.name
-              @machine.ui.info(I18n.t("vagrant.trigger.fire_with_name",
-                                      name: trigger.name))
-            else
-              @machine.ui.info(I18n.t("vagrant.trigger.fire"))
-            end
-
-            if trigger.info
-              info(trigger.info)
-            end
-
-            if trigger.warn
-              warn(trigger.warn)
-            end
-
-            if trigger.run
-              run(trigger.run, trigger.on_error)
-            end
-
-            if trigger.run_remote
-              run_remote(trigger.run_remote, trigger.on_error)
-            end
-          end
-        end
-
-        # Prints the given message at info level for a trigger
-        #
-        # @param [String] message The string to be printed
-        def info(message)
-          @machine.ui.info(message)
-        end
-
-        # Prints the given message at warn level for a trigger
-        #
-        # @param [String] message The string to be printed
-        def warn(message)
-          @machine.ui.warn(message)
-        end
-
-        # Runs a script on a guest
-        #
-        # @param [Provisioners::Shell::Config] config A Shell provisioner config
-        def run(config, on_error)
-          if config.inline
-            cmd = Shellwords.split(config.inline)
-
-            @machine.ui.detail(I18n.t("vagrant.trigger.run.inline", command: config.inline))
-          else
-            cmd = File.expand_path(config.path, @env.root_path)
-            cmd << " #{config.args.join(' ' )}" if config.args
-            cmd = Shellwords.split(cmd)
-
-            @machine.ui.detail(I18n.t("vagrant.trigger.run.script", path: config.path))
-          end
-
-          # Pick an execution method to run the script or inline string with
-          # Default to Subprocess::Execute
-          exec_method = Vagrant::Util::Subprocess.method(:execute)
-
-          if Vagrant::Util::Platform.windows?
-            if config.inline
-              exec_method = Vagrant::Util::PowerShell.method(:execute_inline)
-            else
-              exec_method = Vagrant::Util::PowerShell.method(:execute)
-            end
-          end
-
-          begin
-            result = exec_method.call(*cmd, :notify => [:stdout, :stderr]) do |type,data|
-              options = {}
-              case type
-              when :stdout
-                options[:color] = :green if !config.keep_color
-              when :stderr
-                options[:color] = :red if !config.keep_color
-              end
-
-              @machine.ui.detail(data, options)
-            end
-          rescue => e
-            @machine.ui.error(I18n.t("vagrant.errors.triggers_run_fail"))
-            @machine.ui.error(e.message)
-
-            if on_error == :halt
-              @logger.debug("Trigger run encountered an error. Halting on error...")
-              raise e
-            else
-              @logger.debug("Trigger run encountered an error. Continuing on anyway...")
-              @machine.ui.warn(I18n.t("vagrant.trigger.on_error_continue"))
-            end
-          end
-        end
-
-        # Runs a script on the guest
-        #
-        # @param [ShellProvisioner/Config] config A Shell provisioner config
-        def run_remote(config, on_error)
-          unless @machine.state.id == :running
-            if on_error == :halt
-              raise Errors::TriggersGuestNotRunning,
-                machine_name: @machine.name,
-                state: @machine.state.id
-            else
-              @machine.ui.error(I18n.t("vagrant.errors.triggers_guest_not_running",
-                                        machine_name: @machine.name,
-                                        state: @machine.state.id))
-              @machine.ui.warn(I18n.t("vagrant.trigger.on_error_continue"))
-              return
-            end
-          end
-
-          prov = VagrantPlugins::Shell::Provisioner.new(@machine, config)
-
-          begin
-            prov.provision
-          rescue => e
-            @machine.ui.error(I18n.t("vagrant.errors.triggers_run_fail"))
-
-            if on_error == :halt
-              @logger.debug("Trigger run encountered an error. Halting on error...")
-              raise e
-            else
-              @logger.debug("Trigger run encountered an error. Continuing on anyway...")
-              @machine.ui.error(e.message)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/plugin/v2.rb

@@ -1,25 +0,0 @@
-require "log4r"
-
-# We don't autoload components because if we're loading anything in the
-# V2 namespace anyways, then we're going to need the Components class.
-require "vagrant/plugin/v2/components"
-require "vagrant/plugin/v2/errors"
-
-module Vagrant
-  module Plugin
-    module V2
-      autoload :Command, "vagrant/plugin/v2/command"
-      autoload :Communicator, "vagrant/plugin/v2/communicator"
-      autoload :Config, "vagrant/plugin/v2/config"
-      autoload :Guest,  "vagrant/plugin/v2/guest"
-      autoload :Host,   "vagrant/plugin/v2/host"
-      autoload :Manager, "vagrant/plugin/v2/manager"
-      autoload :Plugin, "vagrant/plugin/v2/plugin"
-      autoload :Provider, "vagrant/plugin/v2/provider"
-      autoload :Push, "vagrant/plugin/v2/push"
-      autoload :Provisioner, "vagrant/plugin/v2/provisioner"
-      autoload :SyncedFolder, "vagrant/plugin/v2/synced_folder"
-      autoload :Trigger, "vagrant/plugin/v2/trigger"
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/plugin.rb

@@ -1,8 +0,0 @@
-module Vagrant
-  module Plugin
-    autoload :V1,        "vagrant/plugin/v1"
-    autoload :V2,        "vagrant/plugin/v2"
-    autoload :Manager,   "vagrant/plugin/manager"
-    autoload :StateFile, "vagrant/plugin/state_file"
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/registry.rb

@@ -1,101 +0,0 @@
-module Vagrant
-  # Register components in a single location that can be queried.
-  #
-  # This allows certain components (such as guest systems, configuration
-  # pieces, etc.) to be registered and queried, lazily.
-  class Registry
-    def initialize
-      @items = {}
-      @results_cache = {}
-    end
-
-    # Register a key with a lazy-loaded value.
-    #
-    # If a key with the given name already exists, it is overwritten.
-    def register(key, &block)
-      raise ArgumentError, "block required" if !block_given?
-      @items[key] = block
-    end
-
-    # Get a value by the given key.
-    #
-    # This will evaluate the block given to `register` and return the
-    # resulting value.
-    def get(key)
-      return nil if !@items.key?(key)
-      return @results_cache[key] if @results_cache.key?(key)
-      @results_cache[key] = @items[key].call
-    end
-    alias :[] :get
-
-    # Checks if the given key is registered with the registry.
-    #
-    # @return [Boolean]
-    def key?(key)
-      @items.key?(key)
-    end
-    alias_method :has_key?, :key?
-
-    # Returns an array populated with the keys of this object.
-    #
-    # @return [Array]
-    def keys
-      @items.keys
-    end
-
-    # Iterate over the keyspace.
-    def each(&block)
-      @items.each do |key, _|
-        yield key, get(key)
-      end
-    end
-
-    # Return the number of elements in this registry.
-    #
-    # @return [Integer]
-    def length
-      @items.keys.length
-    end
-    alias_method :size, :length
-
-    # Checks if this registry has any items.
-    #
-    # @return [Boolean]
-    def empty?
-      @items.keys.empty?
-    end
-
-    # Merge one registry with another and return a completely new
-    # registry. Note that the result cache is completely busted, so
-    # any gets on the new registry will result in a cache miss.
-    def merge(other)
-      self.class.new.tap do |result|
-        result.merge!(self)
-        result.merge!(other)
-      end
-    end
-
-    # Like #{merge} but merges into self.
-    def merge!(other)
-      @items.merge!(other.__internal_state[:items])
-      self
-    end
-
-    # Converts this registry to a hash
-    def to_hash
-      result = {}
-      self.each do |key, value|
-        result[key] = value
-      end
-
-      result
-    end
-
-    def __internal_state
-      {
-        items: @items,
-        results_cache: @results_cache
-      }
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/shared_helpers.rb

@@ -1,169 +0,0 @@
-require "pathname"
-require "tempfile"
-require "thread"
-
-module Vagrant
-  @@global_lock = Mutex.new
-
-  # This is the default endpoint of the Vagrant Cloud in
-  # use. API calls will be made to this for various functions
-  # of Vagrant that may require remote access.
-  #
-  # @return [String]
-  DEFAULT_SERVER_URL = "https://vagrantcloud.com".freeze
-
-  # Max number of seconds to wait for joining an active thread.
-  #
-  # @return [Integer]
-  # @note This is not the maximum time for a thread to complete.
-  THREAD_MAX_JOIN_TIMEOUT = 60
-
-  # This holds a global lock for the duration of the block. This should
-  # be invoked around anything that is modifying process state (such as
-  # environmental variables).
-  def self.global_lock
-    @@global_lock.synchronize do
-      return yield
-    end
-  end
-
-  # This returns a true/false showing whether we're running from the
-  # environment setup by the Vagrant installers.
-  #
-  # @return [Boolean]
-  def self.in_installer?
-    !!ENV["VAGRANT_INSTALLER_ENV"]
-  end
-
-  # Returns the path to the embedded directory of the Vagrant installer,
-  # if there is one (if we're running in an installer).
-  #
-  # @return [String]
-  def self.installer_embedded_dir
-    return nil if !Vagrant.in_installer?
-    ENV["VAGRANT_INSTALLER_EMBEDDED_DIR"]
-  end
-
-  # Should the plugin system be initialized
-  #
-  # @return [Boolean]
-  def self.plugins_init?
-    !ENV['VAGRANT_DISABLE_PLUGIN_INIT']
-  end
-
-  # This returns whether or not 3rd party plugins should and can be loaded.
-  #
-  # @return [Boolean]
-  def self.plugins_enabled?
-    !ENV["VAGRANT_NO_PLUGINS"]
-  end
-
-  # Whether or not super quiet mode is enabled. This is ill-advised.
-  #
-  # @return [Boolean]
-  def self.very_quiet?
-    !!ENV["VAGRANT_I_KNOW_WHAT_IM_DOING_PLEASE_BE_QUIET"]
-  end
-
-  # The current log level for Vagrant
-  #
-  # @return [String]
-  def self.log_level
-    ENV["VAGRANT_LOG"]
-  end
-
-  # Returns the URL prefix to the server.
-  #
-  # @return [String]
-  def self.server_url(config_server_url=nil)
-    result = ENV["VAGRANT_SERVER_URL"]
-    result = config_server_url if result == "" or result == nil
-    result || DEFAULT_SERVER_URL
-  end
-
-  # The source root is the path to the root directory of the Vagrant source.
-  #
-  # @return [Pathname]
-  def self.source_root
-    @source_root ||= Pathname.new(File.expand_path('../../../', __FILE__))
-  end
-
-  # This returns the path to the ~/.vagrant.d folder where Vagrant's
-  # per-user state is stored.
-  #
-  # @return [Pathname]
-  def self.user_data_path
-    # Use user specified env var if available
-    path = ENV["VAGRANT_HOME"]
-
-    # On Windows, we default to the USERPROFILE directory if it
-    # is available. This is more compatible with Cygwin and sharing
-    # the home directory across shells.
-    if !path && ENV["USERPROFILE"]
-      path = "#{ENV["USERPROFILE"]}/.vagrant.d"
-    end
-
-    # Fallback to the default
-    path ||= "~/.vagrant.d"
-
-    Pathname.new(path).expand_path
-  end
-
-  # This returns true/false if the running version of Vagrant is
-  # a pre-release version (development)
-  #
-  # @return [Boolean]
-  def self.prerelease?
-    Gem::Version.new(Vagrant::VERSION).prerelease?
-  end
-
-  # This allows control over dependency resolution when installing
-  # plugins into vagrant. When true, dependency libraries that Vagrant
-  # core relies upon will be hard constraints.
-  #
-  # @return [Boolean]
-  def self.strict_dependency_enforcement
-    if ENV["VAGRANT_DISABLE_STRICT_DEPENDENCY_ENFORCEMENT"]
-      false
-    else
-      true
-    end
-  end
-
-  # Use Ruby Resolv in place of libc
-  #
-  # @return [boolean] enabled or not
-  def self.enable_resolv_replace
-    if ENV["VAGRANT_ENABLE_RESOLV_REPLACE"]
-      if !ENV["VAGRANT_DISABLE_RESOLV_REPLACE"]
-        begin
-          require "resolv-replace"
-          true
-        rescue
-          false
-        end
-      else
-        false
-      end
-    end
-  end
-
-  # Set the global logger
-  #
-  # @param log Logger
-  # @return [Logger]
-  def self.global_logger=(log)
-    @_global_logger = log
-  end
-
-  # Get the global logger instance
-  #
-  # @return [Logger]
-  def self.global_logger
-    if @_global_logger.nil?
-      require "log4r"
-      @_global_logger = Log4r::Logger.new("vagrant::global")
-    end
-    @_global_logger
-  end
-end