vagrant-packet 0.1.2 → 0.1.3

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

@@ -1,135 +0,0 @@
-require "log4r"
-
-require 'vagrant/util/platform'
-
-require_relative "mixin_synced_folders"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This middleware will setup the synced folders for the machine using
-      # the appropriate synced folder plugin.
-      class SyncedFolders
-        include MixinSyncedFolders
-
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::action::builtin::synced_folders")
-        end
-
-        def call(env)
-          opts = {
-            cached: !!env[:synced_folders_cached],
-            config: env[:synced_folders_config],
-          }
-
-          @logger.info("SyncedFolders loading from cache: #{opts[:cached]}")
-          folders = synced_folders(env[:machine], **opts)
-          original_folders = folders
-
-          folders.each do |impl_name, fs|
-            @logger.info("Synced Folder Implementation: #{impl_name}")
-
-            fs.each do |id, data|
-              # Log every implementation and their paths
-              @logger.info("  - #{id}: #{data[:hostpath]} => #{data[:guestpath]}")
-            end
-          end
-
-          # Go through each folder and make sure to create it if
-          # it does not exist on host
-          folders.each do |_, fs|
-            fs.each do |id, data|
-              next if data[:hostpath_exact]
-
-              data[:hostpath] = File.expand_path(
-                data[:hostpath], env[:root_path])
-
-              # Expand the symlink if this is a path that exists
-              if File.file?(data[:hostpath])
-                data[:hostpath] = File.realpath(data[:hostpath])
-              end
-
-              # Create the hostpath if it doesn't exist and we've been told to
-              if !File.directory?(data[:hostpath]) && data[:create]
-                @logger.info("Creating shared folder host directory: #{data[:hostpath]}")
-                begin
-                  Pathname.new(data[:hostpath]).mkpath
-                rescue Errno::EACCES
-                  raise Vagrant::Errors::SharedFolderCreateFailed,
-                    path: data[:hostpath]
-                end
-              end
-
-              if File.directory?(data[:hostpath])
-                data[:hostpath] = File.realpath(data[:hostpath])
-                data[:hostpath] = Util::Platform.fs_real_path(data[:hostpath]).to_s
-              end
-            end
-          end
-
-          # Build up the instances of the synced folders. We do this once
-          # so that they can store state.
-          folders = folders.map do |impl_name, fs|
-            instance = plugins[impl_name.to_sym][0].new
-            [instance, impl_name, fs]
-          end
-
-          # Go through each folder and prepare the folders
-          folders.each do |impl, impl_name, fs|
-            if !env[:synced_folders_disable]
-              @logger.info("Invoking synced folder prepare for: #{impl_name}")
-              impl.prepare(env[:machine], fs, impl_opts(impl_name, env))
-            end
-          end
-
-          # Continue, we need the VM to be booted.
-          @app.call(env)
-
-          # Once booted, setup the folder contents
-          folders.each do |impl, impl_name, fs|
-            if !env[:synced_folders_disable]
-              @logger.info("Invoking synced folder enable: #{impl_name}")
-              impl.enable(env[:machine], fs, impl_opts(impl_name, env))
-              next
-            end
-
-            # We're disabling synced folders
-            to_disable = {}
-            fs.each do |id, data|
-              next if !env[:synced_folders_disable].include?(id)
-              to_disable[id] = data
-            end
-
-            @logger.info("Invoking synced folder disable: #{impl_name}")
-            to_disable.each do |id, _|
-              @logger.info("  - Disabling: #{id}")
-            end
-            impl.disable(env[:machine], to_disable, impl_opts(impl_name, env))
-          end
-
-          # If we disabled folders, we have to delete some from the
-          # save, so we load the entire cached thing, and delete them.
-          if env[:synced_folders_disable]
-            all = synced_folders(env[:machine], cached: true)
-            all.each do |impl, fs|
-              fs.keys.each do |id|
-                if env[:synced_folders_disable].include?(id)
-                  fs.delete(id)
-                end
-              end
-            end
-
-            save_synced_folders(env[:machine], all)
-          else
-            save_opts = { merge: true }
-            save_opts[:vagrantfile] = true if !opts[:config]
-
-            # Save the synced folders
-            save_synced_folders(env[:machine], original_folders, **save_opts)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-module Vagrant
-  module Action
-    module Builtin
-      # This waits for the communicator to be ready for a set amount of
-      # time.
-      class WaitForCommunicator
-        def initialize(app, env, states=nil)
-          @app    = app
-          @states = states
-        end
-
-        def call(env)
-          # Wait for ready in a thread so that we can continually check
-          # for interrupts.
-          ready_thr = Thread.new do
-            Thread.current[:result] = env[:machine].communicate.wait_for_ready(
-              env[:machine].config.vm.boot_timeout)
-          end
-
-          # Start a thread that verifies the VM stays in a good state.
-          states_thr = Thread.new do
-            Thread.current[:result] = true
-
-            # Otherwise, periodically verify the VM isn't in a bad state.
-            while true
-              state = env[:machine].state.id
-
-              # Used to report invalid states
-              Thread.current[:last_known_state] = state
-
-              # Check if we have the proper state so we can break out
-              if @states && !@states.include?(state)
-                Thread.current[:result] = false
-                break
-              end
-
-              # Sleep a bit so we don't hit 100% CPU constantly.
-              sleep 1
-            end
-          end
-
-          # Wait for a result or an interrupt
-          env[:ui].output(I18n.t("vagrant.boot_waiting"))
-          while ready_thr.alive? && states_thr.alive?
-            sleep 1
-            return if env[:interrupted]
-          end
-
-          # Join so that they can raise exceptions if there were any
-          ready_thr.join if !ready_thr.alive?
-          states_thr.join if !states_thr.alive?
-
-          # If it went into a bad state, then raise an error
-          if !states_thr[:result]
-            raise Errors::VMBootBadState,
-              valid: @states.join(", "),
-              invalid: states_thr[:last_known_state]
-          end
-
-          # If it didn't boot, raise an error
-          if !ready_thr[:result]
-            raise Errors::VMBootTimeout
-          end
-
-          env[:ui].output(I18n.t("vagrant.boot_completed"))
-
-          # Make sure our threads are all killed
-          ready_thr.kill
-          states_thr.kill
-
-          @app.call(env)
-        ensure
-          ready_thr.kill
-          states_thr.kill
-        end
-      end
-    end
-  end
-end

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

@@ -1,204 +0,0 @@
-require 'fileutils'
-require "pathname"
-
-require 'vagrant/util/safe_chdir'
-require 'vagrant/util/subprocess'
-require 'vagrant/util/presence'
-
-module Vagrant
-  module Action
-    module General
-      # A general packaging (tar) middleware. Given the following options,
-      # it will do the right thing:
-      #
-      #   * package.output - The filename of the outputted package.
-      #   * package.include - An array of files to include in the package.
-      #   * package.directory - The directory which contains the contents to
-      #       compress into the package.
-      #
-      # This middleware always produces the final file in the current working
-      # directory (FileUtils.pwd)
-      class Package
-        include Util
-
-        # Perform sanity validations that the provided output filepath is sane.
-        # In particular, this function validates:
-        #
-        #   - The output path is a regular file (not a directory or symlink)
-        #   - No file currently exists at the given path
-        #   - A directory of package files was actually provided (internal)
-        #
-        # @param [String] output path to the output file
-        # @param [String] directory path to a directory containing the files
-        def self.validate!(output, directory)
-          filename = File.basename(output.to_s)
-          output   = fullpath(output)
-
-          if File.directory?(output)
-            raise Vagrant::Errors::PackageOutputDirectory
-          end
-
-          if File.exist?(output)
-            raise Vagrant::Errors::PackageOutputExists, filename: filename
-          end
-
-          if !Vagrant::Util::Presence.present?(directory) || !File.directory?(directory)
-            raise Vagrant::Errors::PackageRequiresDirectory
-          end
-        end
-
-        # Calculate the full path of the given path, relative to the current
-        # working directory (where the command was run).
-        #
-        # @param [String] output the relative path
-        def self.fullpath(output)
-          File.expand_path(output, Dir.pwd)
-        end
-
-        # The path to the final output file.
-        # @return [String]
-        attr_reader :fullpath
-
-        def initialize(app, env)
-          @app = app
-
-          env["package.files"]  ||= {}
-          env["package.output"] ||= "package.box"
-
-          @fullpath = self.class.fullpath(env["package.output"])
-        end
-
-        def call(env)
-          @env = env
-
-          self.class.validate!(env["package.output"], env["package.directory"])
-
-          package_with_folder_path if env["package.output"].include?(File::SEPARATOR)
-
-          raise Errors::PackageOutputDirectory if File.directory?(fullpath)
-
-          @app.call(env)
-
-          @env[:ui].info I18n.t("vagrant.actions.general.package.compressing", fullpath: fullpath)
-          copy_include_files
-          setup_private_key
-          compress
-        end
-
-        def package_with_folder_path
-          folder_path = File.expand_path("..", @fullpath)
-          create_box_folder(folder_path) unless File.directory?(folder_path)
-        end
-
-        def create_box_folder(folder_path)
-          @env[:ui].info(I18n.t("vagrant.actions.general.package.box_folder", folder_path: folder_path))
-          FileUtils.mkdir_p(folder_path)
-        end
-
-        def recover(env)
-          @env = env
-
-          # There are certain exceptions that we don't delete the file for.
-          ignore_exc = [Errors::PackageOutputDirectory, Errors::PackageOutputExists]
-          ignore_exc.each do |exc|
-            return if env["vagrant.error"].is_a?(exc)
-          end
-
-          # Cleanup any packaged files if the packaging failed at some point.
-          File.delete(fullpath) if File.exist?(fullpath)
-        end
-
-        # This method copies the include files (passed in via command line)
-        # to the temporary directory so they are included in a sub-folder within
-        # the actual box
-        def copy_include_files
-          include_directory = Pathname.new(@env["package.directory"]).join("include")
-
-          @env["package.files"].each do |from, dest|
-            # We place the file in the include directory
-            to = include_directory.join(dest)
-
-            @env[:ui].info I18n.t("vagrant.actions.general.package.packaging", file: from)
-            FileUtils.mkdir_p(to.parent)
-
-            # Copy directory contents recursively.
-            if File.directory?(from)
-              FileUtils.cp_r(Dir.glob(from), to.parent, preserve: true)
-            else
-              FileUtils.cp(from, to, preserve: true)
-            end
-          end
-        rescue Errno::EEXIST => e
-          raise if !e.to_s.include?("symlink")
-
-          # The directory contains symlinks. Show a nicer error.
-          raise Errors::PackageIncludeSymlink
-        end
-
-        # Compress the exported file into a package
-        def compress
-          # Get the output path. We have to do this up here so that the
-          # pwd returns the proper thing.
-          output_path = fullpath.to_s
-
-          # Switch into that directory and package everything up
-          Util::SafeChdir.safe_chdir(@env["package.directory"]) do
-            # Find all the files in our current directory and tar it up!
-            files = Dir.glob(File.join(".", "*"))
-
-            # Package!
-            Util::Subprocess.execute("bsdtar", "-czf", output_path, *files)
-          end
-        end
-
-        # This will copy the generated private key into the box and use
-        # it for SSH by default. We have to do this because we now generate
-        # random keypairs on boot, so packaged boxes would stop working
-        # without this.
-        def setup_private_key
-          # If we don't have machine, we do nothing (weird)
-          return if !@env[:machine]
-
-          # If we don't have a data dir, we also do nothing (base package)
-          return if !@env[:machine].data_dir
-
-          # If we don't have a generated private key, we do nothing
-          path = @env[:machine].data_dir.join("private_key")
-          if !path.file?
-            # If we have a private key that was copied into this box,
-            # then we copy that. This is a bit of a heuristic and can be a
-            # security risk if the key is named the correct thing, but
-            # we'll take that risk for dev environments.
-            (@env[:machine].config.ssh.private_key_path || []).each do |p|
-              # If we have the correctly named key, copy it
-              if File.basename(p) == "vagrant_private_key"
-                path = Pathname.new(p)
-                break
-              end
-            end
-          end
-
-          # If we still have no matching key, do nothing
-          return if !path.file?
-
-          # Copy it into our box directory
-          dir = Pathname.new(@env["package.directory"])
-          new_path = dir.join("vagrant_private_key")
-          FileUtils.cp(path, new_path)
-
-          # Append it to the Vagrantfile (or create a Vagrantfile)
-          vf_path = dir.join("Vagrantfile")
-          mode = "w+"
-          mode = "a" if vf_path.file?
-          vf_path.open(mode) do |f|
-            f.binmode
-            f.puts
-            f.puts %Q[Vagrant.configure("2") do |config|]
-            f.puts %Q[  config.ssh.private_key_path = File.expand_path("../vagrant_private_key", __FILE__)]
-            f.puts %Q[end]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-module Vagrant
-  module Action
-    module General
-      class PackageSetupFiles
-        def initialize(app, env)
-          @app = app
-
-          env["package.include"] ||= []
-          env["package.vagrantfile"] ||= nil
-        end
-
-        def call(env)
-          files = {}
-          env["package.include"].each do |file|
-            source = Pathname.new(file)
-            dest   = nil
-
-            # If the source is relative then we add the file as-is to the include
-            # directory. Otherwise, we copy only the file into the root of the
-            # include directory. Kind of strange, but seems to match what people
-            # expect based on history.
-            if source.relative?
-              dest = source
-            else
-              dest = source.basename
-            end
-
-            # Assign the mapping
-            files[file] = dest
-          end
-
-          if env["package.vagrantfile"]
-            # Vagrantfiles are treated special and mapped to a specific file
-            files[env["package.vagrantfile"]] = "_Vagrantfile"
-          end
-
-          # Verify the mapping
-          files.each do |from, _|
-            raise Vagrant::Errors::PackageIncludeMissing,
-                  file: from if !File.exist?(from)
-          end
-
-          # Save the mapping
-          env["package.files"] = files
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-require "fileutils"
-require_relative "package"
-
-module Vagrant
-  module Action
-    module General
-      class PackageSetupFolders
-        include Vagrant::Util::Presence
-
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          env["package.output"] ||= "package.box"
-          env["package.directory"] ||= Dir.mktmpdir("vagrant-package-", env[:tmp_path])
-
-          # Match up a couple environmental variables so that the other parts of
-          # Vagrant will do the right thing.
-          env["export.temp_dir"] = env["package.directory"]
-
-          Vagrant::Action::General::Package.validate!(
-              env["package.output"], env["package.directory"])
-
-          @app.call(env)
-        end
-
-        def recover(env)
-          dir = env["package.directory"]
-          if File.exist?(dir)
-            FileUtils.rm_rf(dir)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,107 +0,0 @@
-module Vagrant
-  module Action
-    # This class manages hooks into existing {Builder} stacks, and lets you
-    # add and remove middleware classes. This is the primary method by which
-    # plugins can hook into built-in middleware stacks.
-    class Hook
-      # This is a hash of the middleware to prepend to a certain
-      # other middleware.
-      #
-      # @return [Hash<Class, Array<Class>>]
-      attr_reader :before_hooks
-
-      # This is a hash of the middleware to append to a certain other
-      # middleware.
-      #
-      # @return [Hash<Class, Array<Class>>]
-      attr_reader :after_hooks
-
-      # This is a list of the hooks to just prepend to the beginning
-      #
-      # @return [Array<Class>]
-      attr_reader :prepend_hooks
-
-      # This is a list of the hooks to just append to the end
-      #
-      # @return [Array<Class>]
-      attr_reader :append_hooks
-
-      def initialize
-        @before_hooks  = Hash.new { |h, k| h[k] = [] }
-        @after_hooks   = Hash.new { |h, k| h[k] = [] }
-        @prepend_hooks = []
-        @append_hooks  = []
-      end
-
-      # Add a middleware before an existing middleware.
-      #
-      # @param [Class] existing The existing middleware.
-      # @param [Class] new The new middleware.
-      def before(existing, new, *args, &block)
-        @before_hooks[existing] << [new, args, block]
-      end
-
-      # Add a middleware after an existing middleware.
-      #
-      # @param [Class] existing The existing middleware.
-      # @param [Class] new The new middleware.
-      def after(existing, new, *args, &block)
-        @after_hooks[existing] << [new, args, block]
-      end
-
-      # Append a middleware to the end of the stack. Note that if the
-      # middleware sequence ends early, then the new middleware won't
-      # be run.
-      #
-      # @param [Class] new The middleware to append.
-      def append(new, *args, &block)
-        @append_hooks << [new, args, block]
-      end
-
-      # Prepend a middleware to the beginning of the stack.
-      #
-      # @param [Class] new The new middleware to prepend.
-      def prepend(new, *args, &block)
-        @prepend_hooks << [new, args, block]
-      end
-
-      # This applies the given hook to a builder. This should not be
-      # called directly.
-      #
-      # @param [Builder] builder
-      def apply(builder, options=nil)
-        options ||= {}
-
-        if !options[:no_prepend_or_append]
-          # Prepends first
-          @prepend_hooks.each do |klass, args, block|
-            builder.insert(0, klass, *args, &block)
-          end
-
-          # Appends
-          @append_hooks.each do |klass, args, block|
-            builder.use(klass, *args, &block)
-          end
-        end
-
-        # Before hooks
-        @before_hooks.each do |key, list|
-          next if !builder.index(key)
-
-          list.each do |klass, args, block|
-            builder.insert_before(key, klass, *args, &block)
-          end
-        end
-
-        # After hooks
-        @after_hooks.each do |key, list|
-          next if !builder.index(key)
-
-          list.each do |klass, args, block|
-            builder.insert_after(key, klass, *args, &block)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-require 'log4r'
-
-require 'vagrant/action/hook'
-require 'vagrant/util/busy'
-
-module Vagrant
-  module Action
-    class Runner
-      @@reported_interrupt = false
-
-      def initialize(globals=nil, &block)
-        @globals      = globals || {}
-        @lazy_globals = block
-        @logger       = Log4r::Logger.new("vagrant::action::runner")
-      end
-
-      def run(callable_id, options=nil)
-        callable = callable_id
-        if !callable.kind_of?(Builder)
-          if callable_id.kind_of?(Class) || callable_id.respond_to?(:call)
-            callable = Builder.build(callable_id)
-          end
-        end
-
-        if !callable || !callable.respond_to?(:call)
-          raise ArgumentError,
-            "Argument to run must be a callable object or registered action."
-        end
-
-        # Create the initial environment with the options given
-        environment = {}
-        environment.merge!(@globals)
-        environment.merge!(@lazy_globals.call) if @lazy_globals
-        environment.merge!(options || {})
-
-        # Setup the action hooks
-        hooks = Vagrant.plugin("2").manager.action_hooks(environment[:action_name])
-        if !hooks.empty?
-          @logger.info("Preparing hooks for middleware sequence...")
-          environment[:action_hooks] = hooks.map do |hook_proc|
-            Hook.new.tap do |h|
-              hook_proc.call(h)
-            end
-          end
-
-          @logger.info("#{environment[:action_hooks].length} hooks defined.")
-        end
-
-        # Run the action chain in a busy block, marking the environment as
-        # interrupted if a SIGINT occurs, and exiting cleanly once the
-        # chain has been run.
-        ui = environment[:ui] if environment.key?(:ui)
-        int_callback = lambda do
-          if environment[:interrupted]
-            ui.error I18n.t("vagrant.actions.runner.exit_immediately") if ui
-            abort
-          end
-
-          ui.warn I18n.t("vagrant.actions.runner.waiting_cleanup") if ui && !@@reported_interrupt
-          environment[:interrupted] = true
-          @@reported_interrupt = true
-        end
-
-        # We place a process lock around every action that is called
-        @logger.info("Running action: #{environment[:action_name]} #{callable_id}")
-        Util::Busy.busy(int_callback) { callable.call(environment) }
-
-        # Return the environment in case there are things in there that
-        # the caller wants to use.
-        environment
-      end
-    end
-  end
-end