vagrant-aws-detiber 0.7.2.pre.2

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

@@ -0,0 +1,295 @@
+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.detail(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 = 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-419afb4dcffe/plugins/pushes/atlas/config.rb

@@ -0,0 +1,148 @@
+module VagrantPlugins
+  module AtlasPush
+    class Config < Vagrant.plugin("2", :config)
+      # The address of the Atlas server to upload to. By default this will
+      # be the public Atlas server.
+      #
+      # @return [String]
+      attr_accessor :address
+
+      # The Atlas token to use. If the user has run `vagrant login`, this will
+      # use that token. If the environment variable `ATLAS_TOKEN` is set, the
+      # uploader will use this value. By default, this is nil.
+      #
+      # @return [String, nil]
+      attr_accessor :token
+
+      # The name of the application to push to. This will be created (with
+      # user confirmation) if it doesn't already exist.
+      #
+      # @return [String]
+      attr_accessor :app
+
+      # The base directory with file contents to upload. By default this
+      # is the same directory as the Vagrantfile, but you can specify this
+      # if you have a `src` folder or `bin` folder or some other folder
+      # you want to upload.
+      #
+      # @return [String]
+      attr_accessor :dir
+
+      # Lists of files to include/exclude in what is uploaded. Exclude is
+      # always the last run filter, so if a file is matched in both include
+      # and exclude, it will be excluded.
+      #
+      # The value of the array elements should be a simple file glob relative
+      # to the directory being packaged.
+      #
+      # @return [Array<String>]
+      attr_accessor :includes
+      attr_accessor :excludes
+
+      # If set to true, Vagrant will automatically use VCS data to determine
+      # the files to upload. As a caveat: uncommitted changes will not be
+      # deployed.
+      #
+      # @return [Boolean]
+      attr_accessor :vcs
+
+      # The path to the uploader binary to shell out to. This usually
+      # is only set for debugging/development. If not set, the uploader
+      # will be looked for within the Vagrant installer dir followed by
+      # the PATH.
+      #
+      # @return [String]
+      attr_accessor :uploader_path
+
+      def initialize
+        @address = UNSET_VALUE
+        @token = UNSET_VALUE
+        @app = UNSET_VALUE
+        @dir = UNSET_VALUE
+        @vcs = UNSET_VALUE
+        @includes = []
+        @excludes = []
+        @uploader_path = UNSET_VALUE
+      end
+
+      def merge(other)
+        super.tap do |result|
+          result.includes = self.includes.dup.concat(other.includes).uniq
+          result.excludes = self.excludes.dup.concat(other.excludes).uniq
+        end
+      end
+
+      def finalize!
+        @address = nil if @address == UNSET_VALUE
+        @token = nil if @token == UNSET_VALUE
+        @token = ENV["ATLAS_TOKEN"] if !@token && ENV["ATLAS_TOKEN"] != ""
+        @app = nil if @app == UNSET_VALUE
+        @dir = "." if @dir == UNSET_VALUE
+        @uploader_path = nil if @uploader_path == UNSET_VALUE
+        @vcs = true if @vcs == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        if missing?(@token)
+          token = token_from_vagrant_login(machine.env)
+          if missing?(token)
+            errors << I18n.t("atlas_push.errors.missing_token")
+          else
+            @token = token
+          end
+        end
+
+        if missing?(@app)
+          errors << I18n.t("atlas_push.errors.missing_attribute",
+            attribute: "app",
+          )
+        end
+
+        if missing?(@dir)
+          errors << I18n.t("atlas_push.errors.missing_attribute",
+            attribute: "dir",
+          )
+        end
+
+        { "Atlas push" => errors }
+      end
+
+      # Add the filepath to the list of includes
+      # @param [String] filepath
+      def include(filepath)
+        @includes << filepath
+      end
+      alias_method :include=, :include
+
+      # Add the filepath to the list of excludes
+      # @param [String] filepath
+      def exclude(filepath)
+        @excludes << filepath
+      end
+      alias_method :exclude=, :exclude
+
+      private
+
+      # Determine if the given string is "missing" (blank)
+      # @return [true, false]
+      def missing?(obj)
+        obj.to_s.strip.empty?
+      end
+
+      # Attempt to load the token from disk using the vagrant-login plugin. If
+      # the constant is not defined, that means the user is operating in some
+      # bespoke and unsupported Ruby environment.
+      #
+      # @param [Vagrant::Environment] env
+      #
+      # @return [String, nil]
+      #   the token, or nil if it does not exist
+      def token_from_vagrant_login(env)
+        client = VagrantPlugins::LoginCommand::Client.new(env)
+        client.token
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/pushes/atlas/errors.rb

@@ -0,0 +1,13 @@
+module VagrantPlugins
+  module AtlasPush
+    module Errors
+      class Error < Vagrant::Errors::VagrantError
+        error_namespace("atlas_push.errors")
+      end
+
+      class UploaderNotFound < Error
+        error_key(:uploader_not_found)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/pushes/atlas/locales/en.yml

@@ -0,0 +1,22 @@
+en:
+  atlas_push:
+    errors:
+      missing_attribute: |-
+        Missing required attribute '%{attribute}'. The Vagrant Atlas Push plugin
+        requires you set this attribute. Please set this attribute in your
+        Vagrantfile, for example:
+
+            config.push.define "atlas" do |push|
+              push.%{attribute} = "..."
+            end
+      missing_token: |-
+        Missing required configuration parameter 'token'. This is required for
+        Vagrant to securely communicate with your Atlas account.
+
+        To generate an access token, run 'vagrant login'.
+      uploader_not_found: |-
+        Vagrant was unable to find the Atlas uploader CLI. If your Vagrantfile
+        specifies the path explicitly with "uploader_path", then make sure that
+        path is valid. Otherwise, make sure that you have a valid install of
+        Vagrant. If you installed Vagrant outside of the official installers,
+        the "atlas-upload" binary must exist on your PATH.

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/pushes/atlas/plugin.rb

@@ -0,0 +1,35 @@
+require "vagrant"
+
+module VagrantPlugins
+  module AtlasPush
+    autoload :Errors, File.expand_path("../errors", __FILE__)
+
+    class Plugin < Vagrant.plugin("2")
+      name "atlas"
+      description <<-DESC
+      Deploy using HashiCorp's Atlas service.
+      DESC
+
+      config(:atlas, :push) do
+        require_relative "config"
+        init!
+        Config
+      end
+
+      push(:atlas) do
+        require_relative "push"
+        init!
+        Push
+      end
+
+      protected
+
+      def self.init!
+        return if defined?(@_init)
+        I18n.load_path << File.expand_path("../locales/en.yml", __FILE__)
+        I18n.reload!
+        @_init = true
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/pushes/atlas/push.rb

@@ -0,0 +1,84 @@
+require "vagrant/util/safe_exec"
+require "vagrant/util/subprocess"
+require "vagrant/util/which"
+
+module VagrantPlugins
+  module AtlasPush
+    class Push < Vagrant.plugin("2", :push)
+      UPLOADER_BIN = "atlas-upload".freeze
+
+      def push
+        uploader = self.uploader_path
+
+        # If we didn't find the uploader binary it is a critical error
+        raise Errors::UploaderNotFound if !uploader
+
+        # We found it. Build up the command and the args.
+        execute(uploader)
+        return 0
+      end
+
+      # Executes the uploader with the proper flags based on the configuration.
+      # This function shouldn't return since it will exec, but might return
+      # if we're on a system that doesn't support exec, so handle that properly.
+      def execute(uploader)
+        cmd = []
+        cmd << "-debug" if !Vagrant.log_level.nil?
+        cmd << "-vcs" if config.vcs
+        cmd += config.includes.map { |v| ["-include", v] }
+        cmd += config.excludes.map { |v| ["-exclude", v] }
+        cmd += metadata.map { |k,v| ["-metadata", "#{k}=#{v}"] }
+        cmd += ["-address", config.address] if config.address
+        cmd += ["-token", config.token] if config.token
+        cmd << config.app
+        cmd << File.expand_path(config.dir, env.root_path)
+        Vagrant::Util::SafeExec.exec(uploader, *cmd.flatten)
+      end
+
+      # This returns the path to the uploader binary, or nil if it can't
+      # be found.
+      #
+      # @return [String]
+      def uploader_path
+        # Determine the uploader path
+        if uploader = config.uploader_path
+          return uploader
+        end
+
+        if Vagrant.in_installer?
+          path = File.join(
+            Vagrant.installer_embedded_dir, "bin", UPLOADER_BIN)
+          return path if File.file?(path)
+        end
+
+        return Vagrant::Util::Which.which(UPLOADER_BIN)
+      end
+
+      # The metadata command for this push.
+      #
+      # @return [Array<String>]
+      def metadata
+        box     = env.vagrantfile.config.vm.box
+        box_url = env.vagrantfile.config.vm.box_url
+
+        result = {}
+
+        if !box.nil? && !box.empty?
+          result["box"] = box
+        end
+
+        if !box_url.nil? && !box_url.empty?
+          result["box_url"] = Array(box_url).first
+        end
+
+        return result
+      end
+
+      include Vagrant::Util::CommandDeprecation::Complete
+
+      def deprecation_command_name
+        "push (atlas strategy)"
+      end
+    end
+  end
+end