vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/mixin_synced_folders.rb

@@ -1,260 +0,0 @@
-require "json"
-require "set"
-
-require 'vagrant/util/scoped_hash_override'
-
-module Vagrant
-  module Action
-    module Builtin
-      module MixinSyncedFolders
-        include Vagrant::Util::ScopedHashOverride
-
-        # This goes over all the registered synced folder types and returns
-        # the highest priority implementation that is usable for this machine.
-        def default_synced_folder_type(machine, plugins)
-          ordered = []
-
-          # First turn the plugins into an array
-          plugins.each do |key, data|
-            impl     = data[0]
-            priority = data[1]
-
-            ordered << [priority, key, impl]
-          end
-
-          # Order the plugins by priority. Higher is tried before lower.
-          ordered = ordered.sort { |a, b| b[0] <=> a[0] }
-
-          allowed_types = machine.config.vm.allowed_synced_folder_types
-          if allowed_types
-            ordered = allowed_types.map do |type|
-              ordered.find do |_, key, impl|
-                key == type
-              end
-            end.compact
-          end
-
-          # Find the proper implementation
-          ordered.each do |_, key, impl|
-            return key if impl.new.usable?(machine)
-          end
-
-          return nil
-        end
-
-        # This finds the options in the env that are set for a given
-        # synced folder type.
-        def impl_opts(name, env)
-          {}.tap do |result|
-            env.each do |k, v|
-              if k.to_s.start_with?("#{name}_")
-                # While I generally don't like the 'rescue' syntax,
-                # we do this to just fall back to the default value
-                # if it isn't dup-able.
-                k = k.dup rescue k
-                v = v.dup rescue v
-
-                result[k] = v
-              end
-            end
-          end
-        end
-
-        # This returns the available synced folder implementations. This
-        # is a separate method so that it can be easily stubbed by tests.
-        def plugins
-          @plugins ||= Vagrant.plugin("2").manager.synced_folders
-        end
-
-        # This saves the synced folders data to the machine data directory.
-        # They can then be retrieved again with `synced_folders` by passing
-        # the `cached` option to it.
-        #
-        # @param [Machine] machine The machine that the folders belong to
-        # @param [Hash] folders The result from a {#synced_folders} call.
-        def save_synced_folders(machine, folders, **opts)
-          if opts[:merge]
-            existing = cached_synced_folders(machine)
-            if existing
-              if opts[:vagrantfile]
-                # Go through and find any cached that were from the
-                # Vagrantfile itself. We remove those if it was requested.
-                existing.each do |impl, fs|
-                  fs.each do |id, data|
-                    fs.delete(id) if data[:__vagrantfile]
-                  end
-                end
-              end
-
-              folders.each do |impl, fs|
-                existing[impl] ||= {}
-                fs.each do |id, data|
-                  existing[impl][id] = data
-                end
-              end
-
-              folders = existing
-            end
-          end
-
-          machine.data_dir.join("synced_folders").open("w") do |f|
-            f.write(JSON.dump(folders))
-          end
-        end
-
-        # This returns the set of shared folders that should be done for
-        # this machine. It returns the folders in a hash keyed by the
-        # implementation class for the synced folders.
-        #
-        # @return [Hash<Symbol, Hash<String, Hash>>]
-        def synced_folders(machine, **opts)
-          return cached_synced_folders(machine) if opts[:cached]
-
-          config = opts[:config]
-          root   = false
-          if !config
-            config = machine.config.vm
-            root   = true
-          end
-
-          config_folders = config.synced_folders
-          folders = {}
-
-          # Determine all the synced folders as well as the implementation
-          # they're going to use.
-          config_folders.each do |id, data|
-            # Ignore disabled synced folders
-            next if data[:disabled]
-
-            impl = ""
-            impl = data[:type].to_sym if data[:type] && !data[:type].empty?
-
-            if impl != ""
-              impl_class = plugins[impl]
-              if !impl_class
-                # This should never happen because configuration validation
-                # should catch this case. But we put this here as an assert
-                raise "Internal error. Report this as a bug. Invalid: #{data[:type]}"
-              end
-
-              if !opts[:disable_usable_check]
-                if !impl_class[0].new.usable?(machine, true)
-                  # Verify that explicitly defined shared folder types are
-                  # actually usable.
-                  raise Errors::SyncedFolderUnusable, type: data[:type].to_s
-                end
-              end
-            end
-
-            # Get the data to store
-            data = data.dup
-            if root
-              # If these are the root synced folders (attached directly)
-              # to the Vagrantfile, then we mark it as such.
-              data[:__vagrantfile] = true
-            end
-
-            # Keep track of this shared folder by the implementation.
-            folders[impl] ||= {}
-            folders[impl][id] = data
-          end
-
-          # If we have folders with the "default" key, then determine the
-          # most appropriate implementation for this.
-          if folders.key?("") && !folders[""].empty?
-            default_impl = default_synced_folder_type(machine, plugins)
-            if !default_impl
-              types = plugins.to_hash.keys.map { |t| t.to_s }.sort.join(", ")
-              raise Errors::NoDefaultSyncedFolderImpl, types: types
-            end
-
-            folders[default_impl] ||= {}
-            folders[default_impl].merge!(folders[""])
-            folders.delete("")
-          end
-
-          # Apply the scoped hash overrides to get the options
-          folders.dup.each do |impl_name, fs|
-            new_fs = {}
-            fs.each do |id, data|
-              id         = data[:id] if data[:id]
-              new_fs[id] = scoped_hash_override(data, impl_name)
-            end
-
-            folders[impl_name] = new_fs
-          end
-
-          return folders
-        end
-
-        # This finds the difference between two lists of synced folder
-        # definitions.
-        #
-        # This will return a hash with three keys: "added", "removed",
-        # and "modified". These will contain a set of IDs of folders
-        # that were added, removed, or modified, respectively.
-        #
-        # The parameters should be results from the {#synced_folders} call.
-        #
-        # @return [hash]
-        def synced_folders_diff(one, two)
-          existing_ids = {}
-          one.each do |impl, fs|
-            fs.each do |id, data|
-              existing_ids[id] = data
-            end
-          end
-
-          result = Hash.new { |h, k| h[k] = Set.new }
-          two.each do |impl, fs|
-            fs.each do |id, data|
-              existing = existing_ids.delete(id)
-              if !existing
-                result[:added] << id
-                next
-              end
-
-              # Exists, so we have to compare the host and guestpath, which
-              # is most important...
-              if existing[:hostpath] != data[:hostpath] ||
-                existing[:guestpath] != data[:guestpath]
-                result[:modified] << id
-              end
-            end
-          end
-
-          existing_ids.each do |k, _|
-            result[:removed] << k
-          end
-
-          result
-        end
-
-        protected
-
-        def cached_synced_folders(machine)
-          JSON.parse(machine.data_dir.join("synced_folders").read).tap do |r|
-            # We have to do all sorts of things to make the proper things
-            # symbols and
-            r.keys.each do |k|
-              r[k].each do |ik, v|
-                v.keys.each do |vk|
-                  v[vk.to_sym] = v[vk]
-                  v.delete(vk)
-                end
-              end
-
-              r[k.to_sym] = r[k]
-              r.delete(k)
-            end
-          end
-        rescue Errno::ENOENT
-          # If the file doesn't exist, we probably just have a machine created
-          # by a version of Vagrant that didn't cache shared folders. Report no
-          # shared folders to be safe.
-          return {}
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/prepare_clone.rb

@@ -1,38 +0,0 @@
-require "log4r"
-
-module Vagrant
-  module Action
-    module Builtin
-      class PrepareClone
-        def initialize(app, env)
-          @app = app
-          @logger = Log4r::Logger.new("vagrant::action::vm::prepare_clone")
-        end
-
-        def call(env)
-          # If we aren't cloning, then do nothing
-          if !env[:machine].config.vm.clone
-            return @app.call(env)
-          end
-
-          # We need to get the machine ID from this Vagrant environment
-          clone_env = env[:machine].env.environment(
-            env[:machine].config.vm.clone)
-          raise Errors::CloneNotFound if !clone_env.root_path
-
-          # Get the machine itself
-          clone_machine = clone_env.machine(
-            clone_env.primary_machine_name, env[:machine].provider_name)
-          raise Errors::CloneMachineNotFound if !clone_machine.id
-
-          # Set the ID of the master so we know what to clone from
-          env[:clone_id] = clone_machine.id
-          env[:clone_machine] = clone_machine
-
-          # Continue
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/provision.rb

@@ -1,143 +0,0 @@
-require "log4r"
-
-require_relative "mixin_provisioners"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This class will run the configured provisioners against the
-      # machine.
-      #
-      # This action should be placed BEFORE the machine is booted so it
-      # can do some setup, and then run again (on the return path) against
-      # a running machine.
-      class Provision
-        include MixinProvisioners
-
-        def initialize(app, env)
-          @app             = app
-          @logger          = Log4r::Logger.new("vagrant::action::builtin::provision")
-        end
-
-        def call(env)
-          @env = env
-
-          # Tracks whether we were configured to provision
-          config_enabled = true
-          config_enabled = env[:provision_enabled] if env.key?(:provision_enabled)
-
-          # Check if we already provisioned, and if so, disable the rest
-          provision_enabled = true
-
-          ignore_sentinel = true
-          if env.key?(:provision_ignore_sentinel)
-            ignore_sentinel = env[:provision_ignore_sentinel]
-          end
-          if ignore_sentinel
-            @logger.info("Ignoring sentinel check, forcing provision")
-          end
-
-          @logger.info("Checking provisioner sentinel file...")
-          sentinel_path = env[:machine].data_dir.join("action_provision")
-          update_sentinel = false
-          if sentinel_path.file?
-            # The sentinel file is in the format of "version:data" so that
-            # we can remain backwards compatible with previous sentinels.
-            # Versions so far:
-            #
-            #   Vagrant < 1.5.0: A timestamp. The weakness here was that
-            #     if it wasn't cleaned up, it would incorrectly not provision
-            #     new machines.
-            #
-            #   Vagrant >= 1.5.0: "1.5:ID", where ID is the machine ID.
-            #     We compare both so we know whether it is a new machine.
-            #
-            contents = sentinel_path.read.chomp
-            parts    = contents.split(":", 2)
-
-            if parts.length == 1
-              @logger.info("Old-style sentinel found! Not provisioning.")
-              provision_enabled = false if !ignore_sentinel
-              update_sentinel = true
-            elsif parts[0] == "1.5" && parts[1] == env[:machine].id.to_s
-              @logger.info("Sentinel found! Not provisioning.")
-              provision_enabled = false if !ignore_sentinel
-            else
-              @logger.info("Sentinel found with another machine ID. Removing.")
-              sentinel_path.unlink
-            end
-          end
-
-          # Store the value so that other actions can use it
-          env[:provision_enabled] = provision_enabled if !env.key?(:provision_enabled)
-
-          # Ask the provisioners to modify the configuration if needed
-          provisioner_instances(env).each do |p, _|
-            p.configure(env[:machine].config)
-          end
-
-          # Continue, we need the VM to be booted.
-          @app.call(env)
-
-          # If we're configured to not provision, notify the user and stop
-          if !config_enabled
-            env[:ui].info(I18n.t("vagrant.actions.vm.provision.disabled_by_config"))
-            return
-          end
-
-          # If we're not provisioning because of the sentinel, tell the user
-          # but continue trying for the "always" provisioners
-          if !provision_enabled
-            env[:ui].info(I18n.t("vagrant.actions.vm.provision.disabled_by_sentinel"))
-          end
-
-          # Write the sentinel if we have to
-          if update_sentinel || !sentinel_path.file?
-            @logger.info("Writing provisioning sentinel so we don't provision again")
-            sentinel_path.open("w") do |f|
-              f.write("1.5:#{env[:machine].id}")
-            end
-          end
-
-          type_map = provisioner_type_map(env)
-          provisioner_instances(env).each do |p, options|
-            type_name = type_map[p]
-
-            if options[:run] == :never
-              next if env[:provision_types].nil? || !env[:provision_types].include?(options[:name])
-            else
-              next if env[:provision_types] && \
-                !env[:provision_types].include?(type_name) && \
-                !env[:provision_types].include?(options[:name])
-
-              # Don't run if sentinel is around and we're not always running
-              next if !provision_enabled && options[:run] != :always
-            end
-
-            name = type_name
-            if options[:name]
-              name = "#{options[:name]} (#{type_name})"
-            end
-
-            env[:ui].info(I18n.t(
-              "vagrant.actions.vm.provision.beginning",
-              provisioner: name))
-
-            env[:hook].call(:provisioner_run, env.merge(
-              callable: method(:run_provisioner),
-              provisioner: p,
-              provisioner_name: type_name,
-            ))
-          end
-        end
-
-        # This is pulled out into a separate method so that users can
-        # subclass and implement custom behavior if they'd like to work around
-        # this step.
-        def run_provisioner(env)
-          env[:provisioner].provision
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/provisioner_cleanup.rb

@@ -1,54 +0,0 @@
-require "log4r"
-
-require_relative "mixin_provisioners"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This action will run the cleanup methods on provisioners and should
-      # be used as part of any Destroy action.
-      class ProvisionerCleanup
-        include MixinProvisioners
-
-        def initialize(app, env, place=nil)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::action::builtin::provision_cleanup")
-
-          place ||= :after
-          @place = place.to_sym
-        end
-
-        def call(env)
-          do_cleanup(env) if @place == :before
-
-          # Continue, we need the VM to be booted.
-          @app.call(env)
-
-          do_cleanup(env) if @place == :after
-        end
-
-        def do_cleanup(env)
-          type_map = provisioner_type_map(env)
-
-          # Ask the provisioners to modify the configuration if needed
-          provisioner_instances(env).each do |p, _|
-            name = type_map[p].to_s
-
-            # Check if the subclass defined a cleanup method. The parent
-            # provisioning class defines a `cleanup` method, so we cannot use
-            # `respond_to?` here. Instead, we have to check if _this_ instance
-            # defines a cleanup task.
-            if p.public_methods(false).include?(:cleanup)
-              env[:ui].info(I18n.t("vagrant.provisioner_cleanup",
-                name: name,
-              ))
-              p.cleanup
-            else
-              @logger.debug("Skipping cleanup tasks for `#{name}' - not defined")
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/set_hostname.rb

@@ -1,27 +0,0 @@
-require "log4r"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This middleware sets the hostname of the guest according to the
-      # "vm.hostname" configuration parameter if it is set. This middleware
-      # should be placed such that the after the @app.call, a booted machine
-      # is available (this generally means BEFORE the boot middleware).
-      class SetHostname
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          @app.call(env)
-
-          hostname = env[:machine].config.vm.hostname
-          if !hostname.nil?
-            env[:ui].info I18n.t("vagrant.actions.vm.hostname.setting")
-            env[:machine].guest.capability(:change_host_name, hostname)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/ssh_exec.rb

@@ -1,44 +0,0 @@
-require "pathname"
-
-require "vagrant/util/ssh"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This class will exec into a full fledged SSH console into the
-      # remote machine. This middleware assumes that the VM is running and
-      # ready for SSH, and uses the {Machine#ssh_info} method to retrieve
-      # SSH information necessary to connect.
-      #
-      # Note: If there are any middleware after `SSHExec`, they will **not**
-      # run, since exec replaces the currently running process.
-      class SSHExec
-        # For quick access to the `SSH` class.
-        include Vagrant::Util
-
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          # Grab the SSH info from the machine or the environment
-          info = env[:ssh_info]
-          info ||= env[:machine].ssh_info
-
-          # If the result is nil, then the machine is telling us that it is
-          # not yet ready for SSH, so we raise this exception.
-          raise Errors::SSHNotReady if info.nil?
-
-          info[:private_key_path] ||= []
-
-          if info[:private_key_path].empty? && info[:password]
-            env[:ui].warn(I18n.t("vagrant.ssh_exec_password"))
-          end
-
-          # Exec!
-          SSH.exec(info, env[:ssh_opts])
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/ssh_run.rb

@@ -1,63 +0,0 @@
-require "log4r"
-
-require "vagrant/util/platform"
-require "vagrant/util/ssh"
-require "vagrant/util/shell_quote"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This class will run a single command on the remote machine and will
-      # mirror the output to the UI. The resulting exit status of the command
-      # will exist in the `:ssh_run_exit_status` key in the environment.
-      class SSHRun
-        # For quick access to the `SSH` class.
-        include Vagrant::Util
-
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::action::builtin::ssh_run")
-        end
-
-        def call(env)
-          # Grab the SSH info from the machine or the environment
-          info = env[:ssh_info]
-          info ||= env[:machine].ssh_info
-
-          # If the result is nil, then the machine is telling us that it is
-          # not yet ready for SSH, so we raise this exception.
-          raise Errors::SSHNotReady if info.nil?
-
-          info[:private_key_path] ||= []
-
-          if info[:keys_only] && info[:private_key_path].empty?
-            raise Errors::SSHRunRequiresKeys
-          end
-
-          # Get the command and wrap it in a login shell
-          command = ShellQuote.escape(env[:ssh_run_command], "'")
-          command = "#{env[:machine].config.ssh.shell} -c '#{command}'"
-
-          # Execute!
-          opts = env[:ssh_opts] || {}
-          opts[:extra_args] ||= []
-
-          # Allow the user to specify a tty or non-tty manually, but if they
-          # don't then we default to a TTY
-          if !opts[:extra_args].include?("-t") &&
-              !opts[:extra_args].include?("-T") &&
-              env[:tty]
-            opts[:extra_args] << "-t"
-          end
-
-          opts[:extra_args] << command
-          opts[:subprocess] = true
-          env[:ssh_run_exit_status] = Util::SSH.exec(info, opts)
-
-          # Call the next middleware
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/action/builtin/synced_folder_cleanup.rb

@@ -1,33 +0,0 @@
-require "log4r"
-
-require_relative "mixin_synced_folders"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This middleware will run cleanup tasks for synced folders using
-      # the appropriate synced folder plugin.
-      class SyncedFolderCleanup
-        include MixinSyncedFolders
-
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::action::builtin::synced_folder_cleanup")
-        end
-
-        def call(env)
-          folders = synced_folders(env[:machine])
-
-          # Go through each folder and do cleanup
-          folders.each_key do |impl_name|
-            @logger.info("Invoking synced folder cleanup for: #{impl_name}")
-            plugins[impl_name.to_sym][0].new.cleanup(
-              env[:machine], impl_opts(impl_name, env))
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end