vagrant-aws-mkubenka 0.7.2.pre.14 → 0.7.2.pre.16

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/provisioners/shell/provisioner.rb

@@ -1,295 +0,0 @@
-require "pathname"
-require "tempfile"
-
-require "vagrant/util/downloader"
-require "vagrant/util/retryable"
-
-module VagrantPlugins
-  module Shell
-    class Provisioner < Vagrant.plugin("2", :provisioner)
-      include Vagrant::Util::Retryable
-
-      def provision
-        args = ""
-        if config.args.is_a?(String)
-          args = " #{config.args.to_s}"
-        elsif config.args.is_a?(Array)
-          args = config.args.map { |a| quote_and_escape(a) }
-          args = " #{args.join(" ")}"
-        end
-
-        case @machine.config.vm.communicator
-        when :winrm
-          provision_winrm(args)
-        when :winssh
-          provision_winssh(args)
-        else
-          provision_ssh(args)
-        end
-      end
-
-      protected
-
-      # This handles outputting the communication data back to the UI
-      def handle_comm(type, data)
-        if [:stderr, :stdout].include?(type)
-          # Output the data with the proper color based on the stream.
-          color = type == :stdout ? :green : :red
-
-          # Clear out the newline since we add one
-          data = data.chomp
-          return if data.empty?
-
-          options = {}
-          options[:color] = color if !config.keep_color
-
-          @machine.ui.info(data.chomp, options)
-        end
-      end
-
-      # This is the provision method called if SSH is what is running
-      # on the remote end, which assumes a POSIX-style host.
-      def provision_ssh(args)
-        env = config.env.map { |k,v| "#{k}=#{quote_and_escape(v.to_s)}" }
-        env = env.join(" ")
-
-        command =  "chmod +x '#{config.upload_path}'"
-        command << " &&"
-        command << " #{env}" if !env.empty?
-        command << " #{config.upload_path}#{args}"
-
-        with_script_file do |path|
-          # Upload the script to the machine
-          @machine.communicate.tap do |comm|
-            # Reset upload path permissions for the current ssh user
-            info = nil
-            retryable(on: Vagrant::Errors::SSHNotReady, tries: 3, sleep: 2) do
-              info = @machine.ssh_info
-              raise Vagrant::Errors::SSHNotReady if info.nil?
-            end
-
-            user = info[:username]
-            comm.sudo("chown -R #{user} #{config.upload_path}",
-                      error_check: false)
-
-            comm.upload(path.to_s, config.upload_path)
-
-            if config.name
-              @machine.ui.detail(I18n.t("vagrant.provisioners.shell.running",
-                                      script: "script: #{config.name}"))
-            elsif config.path
-              @machine.ui.detail(I18n.t("vagrant.provisioners.shell.running",
-                                      script: path.to_s))
-            else
-              @machine.ui.detail(I18n.t("vagrant.provisioners.shell.running",
-                                      script: "inline script"))
-            end
-
-            # Execute it with sudo
-            comm.execute(
-              command,
-              sudo: config.privileged,
-              error_key: :ssh_bad_exit_status_muted
-            ) do |type, data|
-              handle_comm(type, data)
-            end
-          end
-        end
-      end
-
-      # This is the provision method called if Windows OpenSSH is what is running
-      # on the remote end, which assumes a non-POSIX-style host.
-      def provision_winssh(args)
-        with_script_file do |path|
-          # Upload the script to the machine
-          @machine.communicate.tap do |comm|
-            env = config.env.map{|k,v| comm.generate_environment_export(k, v)}.join
-            upload_path = config.upload_path.to_s
-            if File.extname(upload_path).empty?
-              remote_ext = @machine.config.winssh.shell == "powershell" ? "ps1" : "bat"
-              upload_path << ".#{remote_ext}"
-            end
-            if remote_ext == "ps1"
-              # Copy powershell_args from configuration
-              shell_args = config.powershell_args
-              # For PowerShell scripts bypass the execution policy unless already specified
-              shell_args += " -ExecutionPolicy Bypass" if config.powershell_args !~ /[-\/]ExecutionPolicy/i
-              # CLIXML output is kinda useless, especially on non-windows hosts
-              shell_args += " -OutputFormat Text" if config.powershell_args !~ /[-\/]OutputFormat/i
-              command = "#{env}\npowershell #{shell_args} #{upload_path}#{args}"
-            else
-              command = "#{env}\n#{upload_path}#{args}"
-            end
-
-            # Reset upload path permissions for the current ssh user
-            info = nil
-            retryable(on: Vagrant::Errors::SSHNotReady, tries: 3, sleep: 2) do
-              info = @machine.ssh_info
-              raise Vagrant::Errors::SSHNotReady if info.nil?
-            end
-
-            comm.upload(path.to_s, upload_path)
-
-            if config.name
-              @machine.ui.detail(I18n.t("vagrant.provisioners.shell.running",
-                                      script: "script: #{config.name}"))
-            elsif config.path
-              @machine.ui.detail(I18n.t("vagrant.provisioners.shell.running",
-                                      script: path.to_s))
-            else
-              @machine.ui.detail(I18n.t("vagrant.provisioners.shell.running",
-                                      script: "inline script"))
-            end
-
-            # Execute it with sudo
-            comm.execute(
-              command,
-              sudo: config.privileged,
-              error_key: :ssh_bad_exit_status_muted
-            ) do |type, data|
-              handle_comm(type, data)
-            end
-          end
-        end
-      end
-
-      # This provisions using WinRM, which assumes a PowerShell
-      # console on the other side.
-      def provision_winrm(args)
-        if @machine.guest.capability?(:wait_for_reboot)
-          @machine.guest.capability(:wait_for_reboot)
-        end
-
-        with_script_file do |path|
-          @machine.communicate.tap do |comm|
-            # Make sure that the upload path has an extension, since
-            # having an extension is critical for Windows execution
-            upload_path = config.upload_path.to_s
-            if File.extname(upload_path) == ""
-              upload_path += File.extname(path.to_s)
-            end
-
-            # Upload it
-            comm.upload(path.to_s, upload_path)
-
-            # Build the environment
-            env = config.env.map { |k,v| "$env:#{k} = #{quote_and_escape(v.to_s)}" }
-            env = env.join("; ")
-
-            # Calculate the path that we'll be executing
-            exec_path = upload_path
-            exec_path.gsub!('/', '\\')
-            exec_path = "c:#{exec_path}" if exec_path.start_with?("\\")
-
-            # Copy powershell_args from configuration
-            shell_args = config.powershell_args
-
-            # For PowerShell scripts bypass the execution policy unless already specified
-            shell_args += " -ExecutionPolicy Bypass" if config.powershell_args !~ /[-\/]ExecutionPolicy/i
-
-            # CLIXML output is kinda useless, especially on non-windows hosts
-            shell_args += " -OutputFormat Text" if config.powershell_args !~ /[-\/]OutputFormat/i
-
-            command = "\"#{exec_path}\"#{args}"
-            if File.extname(exec_path).downcase == ".ps1"
-              command = "powershell #{shell_args.to_s} -file #{command}"
-            else
-              command = "cmd /q /c #{command}"
-            end
-
-            # Append the environment
-            if !env.empty?
-              command = "#{env}; #{command}"
-            end
-
-            if config.name
-              @machine.ui.detail(I18n.t("vagrant.provisioners.shell.running",
-                                      script: "script: #{config.name}"))
-            elsif config.path
-              @machine.ui.detail(I18n.t("vagrant.provisioners.shell.runningas",
-                                      local: config.path.to_s, remote: exec_path))
-            else
-              @machine.ui.detail(I18n.t("vagrant.provisioners.shell.running",
-                                      script: "inline PowerShell script"))
-            end
-
-            # Execute it with sudo
-            comm.sudo(command, { elevated: config.privileged, interactive: config.powershell_elevated_interactive }) do |type, data|
-              handle_comm(type, data)
-            end
-          end
-        end
-      end
-
-      # Quote and escape strings for shell execution, thanks to Capistrano.
-      def quote_and_escape(text, quote = '"')
-        "#{quote}#{text.gsub(/#{quote}/) { |m| "#{m}\\#{m}#{m}" }}#{quote}"
-      end
-
-      # This method yields the path to a script to upload and execute
-      # on the remote server. This method will properly clean up the
-      # script file if needed.
-      def with_script_file
-        ext    = nil
-        script = nil
-
-        if config.remote?
-          download_path = @machine.env.tmp_path.join(
-            "#{@machine.id}-remote-script")
-          download_path.delete if download_path.file?
-
-          begin
-            Vagrant::Util::Downloader.new(
-              config.path,
-              download_path,
-              md5: config.md5,
-              sha1: config.sha1
-            ).download!
-            ext    = File.extname(config.path)
-            script = download_path.read
-          ensure
-            download_path.delete if download_path.file?
-          end
-        elsif config.path
-          # Just yield the path to that file...
-          root_path = @machine.env.root_path
-          ext    = File.extname(config.path)
-          script = Pathname.new(config.path).expand_path(root_path).read
-        else
-          # The script is just the inline code...
-          ext    = ".ps1"
-          script = config.inline
-        end
-
-        # Replace Windows line endings with Unix ones unless binary file
-        # or we're running on Windows.
-        if !config.binary && @machine.config.vm.communicator != :winrm
-          begin
-            script.gsub!(/\r\n?$/, "\n")
-          rescue ArgumentError
-            script = script.force_encoding("ASCII-8BIT").gsub(/\r\n?$/, "\n")
-          end
-        end
-
-        # Otherwise we have an inline script, we need to Tempfile it,
-        # and handle it specially...
-        file = Tempfile.new(['vagrant-shell', ext])
-
-        # Unless you set binmode, on a Windows host the shell script will
-        # have CRLF line endings instead of LF line endings, causing havoc
-        # when the guest executes it. This fixes [GH-1181].
-        file.binmode
-
-        begin
-          file.write(script)
-          file.fsync
-          file.close
-          yield file.path
-        ensure
-          file.close
-          file.unlink
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/synced_folders/rsync/command/rsync_auto.rb

@@ -1,208 +0,0 @@
-require "log4r"
-require 'optparse'
-require "thread"
-
-require "vagrant/action/builtin/mixin_synced_folders"
-require "vagrant/util/busy"
-require "vagrant/util/platform"
-
-require_relative "../helper"
-
-# This is to avoid a bug in nio 1.0.0. Remove around nio 1.0.1
-if Vagrant::Util::Platform.windows?
-  ENV["NIO4R_PURE"] = "1"
-end
-
-require "listen"
-
-module VagrantPlugins
-  module SyncedFolderRSync
-    module Command
-      class RsyncAuto < Vagrant.plugin("2", :command)
-        include Vagrant::Action::Builtin::MixinSyncedFolders
-
-        def self.synopsis
-          "syncs rsync synced folders automatically when files change"
-        end
-
-        def execute
-          @logger = Log4r::Logger.new("vagrant::commands::rsync-auto")
-
-          options = {}
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant rsync-auto [vm-name]"
-            o.separator ""
-            o.separator "Options:"
-            o.separator ""
-
-            o.on("--[no-]poll", "Force polling filesystem (slow)") do |poll|
-              options[:poll] = poll
-            end
-          end
-
-          # Parse the options and return if we don't have any target.
-          argv = parse_options(opts)
-          return if !argv
-
-          # Build up the paths that we need to listen to.
-          paths = {}
-          ignores = []
-          with_target_vms(argv) do |machine|
-            if machine.provider.capability?(:proxy_machine)
-              proxy = machine.provider.capability(:proxy_machine)
-              if proxy
-                machine.ui.warn(I18n.t(
-                  "vagrant.rsync_proxy_machine",
-                  name: machine.name.to_s,
-                  provider: machine.provider_name.to_s))
-
-                machine = proxy
-              end
-            end
-
-            cached = synced_folders(machine, cached: true)
-            fresh  = synced_folders(machine)
-            diff   = synced_folders_diff(cached, fresh)
-            if !diff[:added].empty?
-              machine.ui.warn(I18n.t("vagrant.rsync_auto_new_folders"))
-            end
-
-            folders = cached[:rsync]
-            next if !folders || folders.empty?
-
-            # Get the SSH info for this machine so we can do an initial
-            # sync to the VM.
-            ssh_info = machine.ssh_info
-            if ssh_info
-              machine.ui.info(I18n.t("vagrant.rsync_auto_initial"))
-              folders.each do |id, folder_opts|
-                RsyncHelper.rsync_single(machine, ssh_info, folder_opts)
-              end
-            end
-
-            folders.each do |id, folder_opts|
-              # If we marked this folder to not auto sync, then
-              # don't do it.
-              next if folder_opts.key?(:auto) && !folder_opts[:auto]
-
-              hostpath = folder_opts[:hostpath]
-              hostpath = File.expand_path(hostpath, machine.env.root_path)
-              paths[hostpath] ||= []
-              paths[hostpath] << {
-                id: id,
-                machine: machine,
-                opts:    folder_opts,
-              }
-
-              if folder_opts[:exclude]
-                Array(folder_opts[:exclude]).each do |pattern|
-                  ignores << RsyncHelper.exclude_to_regexp(hostpath, pattern.to_s)
-                end
-              end
-            end
-          end
-
-          # Exit immediately if there is nothing to watch
-          if paths.empty?
-            @env.ui.info(I18n.t("vagrant.rsync_auto_no_paths"))
-            return 1
-          end
-
-          # Output to the user what paths we'll be watching
-          paths.keys.sort.each do |path|
-            paths[path].each do |path_opts|
-              path_opts[:machine].ui.info(I18n.t(
-                "vagrant.rsync_auto_path",
-                path: path.to_s,
-              ))
-            end
-          end
-
-          @logger.info("Listening to paths: #{paths.keys.sort.inspect}")
-          @logger.info("Ignoring #{ignores.length} paths:")
-          ignores.each do |ignore|
-            @logger.info("  -- #{ignore.to_s}")
-          end
-          @logger.info("Listening via: #{Listen::Adapter.select.inspect}")
-          callback = method(:callback).to_proc.curry[paths]
-          listopts = { ignore: ignores, force_polling: !!options[:poll] }
-          listener = Listen.to(*paths.keys, listopts, &callback)
-
-          # Create the callback that lets us know when we've been interrupted
-          queue    = Queue.new
-          callback = lambda do
-            # This needs to execute in another thread because Thread
-            # synchronization can't happen in a trap context.
-            Thread.new { queue << true }
-          end
-
-          # Run the listener in a busy block so that we can cleanly
-          # exit once we receive an interrupt.
-          Vagrant::Util::Busy.busy(callback) do
-            listener.start
-            queue.pop
-            listener.stop if listener.state != :stopped
-          end
-
-          0
-        end
-
-        # This is the callback that is called when any changes happen
-        def callback(paths, modified, added, removed)
-          @logger.info("File change callback called!")
-          @logger.info("  - Modified: #{modified.inspect}")
-          @logger.info("  - Added: #{added.inspect}")
-          @logger.info("  - Removed: #{removed.inspect}")
-
-          tosync = []
-          paths.each do |hostpath, folders|
-            # Find out if this path should be synced
-            found = catch(:done) do
-              [modified, added, removed].each do |changed|
-                changed.each do |listenpath|
-                  throw :done, true if listenpath.start_with?(hostpath)
-                end
-              end
-
-              # Make sure to return false if all else fails so that we
-              # don't sync to this machine.
-              false
-            end
-
-            # If it should be synced, store it for later
-            tosync << folders if found
-          end
-
-          # Sync all the folders that need to be synced
-          tosync.each do |folders|
-            folders.each do |opts|
-              # Reload so we get the latest ID
-              opts[:machine].reload
-              if !opts[:machine].id || opts[:machine].id == ""
-                # Skip since we can't get SSH info without an ID
-                next
-              end
-
-              ssh_info = opts[:machine].ssh_info
-              begin
-                start = Time.now
-                RsyncHelper.rsync_single(opts[:machine], ssh_info, opts[:opts])
-                finish = Time.now
-                @logger.info("Time spent in rsync: #{finish-start} (in seconds)")
-              rescue Vagrant::Errors::MachineGuestNotReady
-                # Error communicating to the machine, probably a reload or
-                # halt is happening. Just notify the user but don't fail out.
-                opts[:machine].ui.error(I18n.t(
-                  "vagrant.rsync_communicator_not_ready_callback"))
-              rescue Vagrant::Errors::RSyncError => e
-                # Error executing rsync, so show an error
-                opts[:machine].ui.error(I18n.t(
-                  "vagrant.rsync_auto_rsync_error", message: e.to_s))
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end