vagrant-aws-detiber 0.7.2.pre.2

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/mixin_synced_folders.rb

@@ -0,0 +1,260 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/prepare_clone.rb

@@ -0,0 +1,38 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/provision.rb

@@ -0,0 +1,143 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/provisioner_cleanup.rb

@@ -0,0 +1,54 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/set_hostname.rb

@@ -0,0 +1,27 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/ssh_exec.rb

@@ -0,0 +1,44 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/ssh_run.rb

@@ -0,0 +1,63 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/lib/vagrant/action/builtin/synced_folder_cleanup.rb

@@ -0,0 +1,33 @@
+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