vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/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.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.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/pushes/atlas/config.rb

@@ -1,148 +0,0 @@
-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.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/pushes/atlas/errors.rb

@@ -1,13 +0,0 @@
-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.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/pushes/atlas/locales/en.yml

@@ -1,22 +0,0 @@
-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.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/pushes/atlas/plugin.rb

@@ -1,35 +0,0 @@
-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.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/pushes/atlas/push.rb

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