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

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-1ee58c40e3f5/plugins/commands/ssh_config/command.rb

@@ -0,0 +1,73 @@
+require 'optparse'
+
+require "vagrant/util/safe_puts"
+require "vagrant/util/platform"
+
+module VagrantPlugins
+  module CommandSSHConfig
+    class Command < Vagrant.plugin("2", :command)
+      include Vagrant::Util::SafePuts
+
+      def self.synopsis
+        "outputs OpenSSH valid configuration to connect to the machine"
+      end
+
+      def convert_win_paths(paths)
+        paths.map! { |path| Vagrant::Util::Platform.format_windows_path(path, :disable_unc) }
+      end
+
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant ssh-config [options] [name|id]"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("--host NAME", "Name the host for the config") do |h|
+            options[:host] = h
+          end
+        end
+
+        argv = parse_options(opts)
+        return if !argv
+
+        with_target_vms(argv) do |machine|
+          ssh_info = machine.ssh_info
+          raise Vagrant::Errors::SSHNotReady if ssh_info.nil?
+
+          if Vagrant::Util::Platform.windows?
+            ssh_info[:private_key_path] = convert_win_paths(ssh_info[:private_key_path])
+          end
+
+          variables = {
+            host_key: options[:host] || machine.name || "vagrant",
+            ssh_host: ssh_info[:host],
+            ssh_port: ssh_info[:port],
+            ssh_user: ssh_info[:username],
+            keys_only: ssh_info[:keys_only],
+            paranoid: ssh_info[:paranoid],
+            private_key_path: ssh_info[:private_key_path],
+            log_level: ssh_info[:log_level],
+            forward_agent: ssh_info[:forward_agent],
+            forward_x11:   ssh_info[:forward_x11],
+            proxy_command: ssh_info[:proxy_command],
+            ssh_command:   ssh_info[:ssh_command],
+            forward_env:   ssh_info[:forward_env],
+          }
+
+          # Render the template and output directly to STDOUT
+          template = "commands/ssh_config/config"
+          config   = Vagrant::Util::TemplateRenderer.render(template, variables)
+          machine.ui.machine("ssh-config", config)
+          safe_puts(config)
+          safe_puts
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-1ee58c40e3f5/plugins/commands/up/command.rb

@@ -0,0 +1,193 @@
+require 'optparse'
+require 'set'
+
+require "vagrant"
+
+require File.expand_path("../start_mixins", __FILE__)
+
+module VagrantPlugins
+  module CommandUp
+    class Command < Vagrant.plugin("2", :command)
+      include StartMixins
+
+      def self.synopsis
+        "starts and provisions the vagrant environment"
+      end
+
+      def execute
+        options = {}
+        options[:destroy_on_error] = true
+        options[:install_provider] = true
+        options[:parallel] = true
+        options[:provision_ignore_sentinel] = false
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant up [options] [name|id]"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          build_start_options(o, options)
+
+          o.on("--[no-]destroy-on-error",
+               "Destroy machine if any fatal error happens (default to true)") do |destroy|
+            options[:destroy_on_error] = destroy
+          end
+
+          o.on("--[no-]parallel",
+               "Enable or disable parallelism if provider supports it") do |parallel|
+            options[:parallel] = parallel
+          end
+
+          o.on("--provider PROVIDER", String,
+               "Back the machine with a specific provider") do |provider|
+            options[:provider] = provider
+          end
+
+          o.on("--[no-]install-provider",
+               "If possible, install the provider if it isn't installed") do |p|
+            options[:install_provider] = p
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        # Validate the provisioners
+        validate_provisioner_flags!(options, argv)
+
+        # Go over each VM and bring it up
+        @logger.debug("'Up' each target VM...")
+
+        # Get the names of the machines we want to bring up
+        names = argv
+        if names.empty?
+          autostart = false
+          @env.vagrantfile.machine_names_and_options.each do |n, o|
+            autostart = true if o.key?(:autostart)
+            o[:autostart] = true if !o.key?(:autostart)
+            names << n.to_s if o[:autostart]
+          end
+
+          # If we have an autostart key but no names, it means that
+          # all machines are autostart: false and we don't start anything.
+          names = nil if autostart && names.empty?
+        end
+
+        # Build up the batch job of what we'll do
+        machines = []
+        if names
+          # To prevent vagrant from attempting to validate a global vms config
+          # (which doesn't exist within the local dir) when attempting to
+          # install a machines provider, this check below will disable the
+          # install_providers function if a user gives us a machine id instead
+          # of the machines name.
+          machine_names = []
+          with_target_vms(names, provider: options[:provider]){|m| machine_names << m.name }
+          options[:install_provider] = false if !(machine_names - names).empty?
+
+          # If we're installing providers, then do that. We don't
+          # parallelize this step because it is likely the same provider
+          # anyways.
+          if options[:install_provider]
+            install_providers(names, provider: options[:provider])
+          end
+
+          @env.batch(options[:parallel]) do |batch|
+            with_target_vms(names, provider: options[:provider]) do |machine|
+              @env.ui.info(I18n.t(
+                "vagrant.commands.up.upping",
+                name: machine.name,
+                provider: machine.provider_name))
+
+              machines << machine
+
+              batch.action(machine, :up, options)
+            end
+          end
+        end
+
+        if machines.empty?
+          @env.ui.info(I18n.t("vagrant.up_no_machines"))
+          return 0
+        end
+
+        # Output the post-up messages that we have, if any
+        machines.each do |m|
+          next if !m.config.vm.post_up_message
+          next if m.config.vm.post_up_message == ""
+
+          # Add a newline to separate things.
+          @env.ui.info("", prefix: false)
+
+          m.ui.success(I18n.t(
+            "vagrant.post_up_message",
+            name: m.name.to_s,
+            message: m.config.vm.post_up_message))
+        end
+
+        # Success, exit status 0
+        0
+      end
+
+      protected
+
+      def install_providers(names, provider: nil)
+        # First create a set of all the providers we need to check for.
+        # Most likely this will be a set of one.
+        providers = Set.new
+        with_target_vms(names, provider: provider) do |machine|
+          # Check if we have this machine in the index
+          entry    = @env.machine_index.get(machine.name.to_s)
+
+          # Get the provider for this machine. This logic isn't completely
+          # straightforward. If we have a forced provider, we always use
+          # that no matter what. If we have an entry in the index (meaning
+          # the machine may be created), we use that provider no matter
+          # what since that will be used by the core. If we have none, then
+          # we ask the Vagrant env what the default provider would be and use
+          # that.
+          #
+          # Note that this logic is a bit redundant if we have "provider"
+          # set but I think its probably cleaner to put this logic in one
+          # place.
+          p = provider
+          p = entry.provider.to_sym if !p && entry
+          p = @env.default_provider(
+            machine: machine.name.to_sym, check_usable: false) if !p
+
+          # Add it to the set
+          providers.add(p)
+        end
+
+        # Go through and determine if we can install the providers
+        providers.delete_if do |name|
+          !@env.can_install_provider?(name)
+        end
+
+        # Install the providers if we have to
+        providers.each do |name|
+          # Find the provider. Ignore if we can't find it, this error
+          # will pop up later in the process.
+          parts = Vagrant.plugin("2").manager.providers[name]
+          next if !parts
+
+          # If the provider is already installed, then our work here is done
+          cls = parts[0]
+          next if cls.installed?
+
+          # Some human-friendly output
+          ui = Vagrant::UI::Prefixed.new(@env.ui, "")
+          ui.output(I18n.t(
+            "vagrant.installing_provider",
+            provider: name.to_s))
+          ui.detail(I18n.t("vagrant.installing_provider_detail"))
+
+          # Install the provider
+          @env.install_provider(name)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-1ee58c40e3f5/plugins/commands/validate/command.rb

@@ -0,0 +1,31 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandValidate
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "validates the Vagrantfile"
+      end
+
+      def execute
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant validate"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        # Validate the configuration of all machines
+        with_target_vms() do |machine|
+          machine.action_raw(:config_validate, Vagrant::Action::Builtin::ConfigValidate)
+        end
+
+        @env.ui.info(I18n.t("vagrant.commands.validate.success"))
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-1ee58c40e3f5/plugins/communicators/winrm/shell.rb

@@ -0,0 +1,221 @@
+require "timeout"
+
+require "log4r"
+
+require "vagrant/util/retryable"
+require "vagrant/util/silence_warnings"
+
+Vagrant::Util::SilenceWarnings.silence! do
+  require "winrm"
+end
+
+require "winrm-elevated"
+require "winrm-fs"
+
+module VagrantPlugins
+  module CommunicatorWinRM
+    class WinRMShell
+      include Vagrant::Util::Retryable
+
+      # These are the exceptions that we retry because they represent
+      # errors that are generally fixed from a retry and don't
+      # necessarily represent immediate failure cases.
+      @@exceptions_to_retry_on = [
+        HTTPClient::KeepAliveDisconnected,
+        WinRM::WinRMHTTPTransportError,
+        WinRM::WinRMAuthorizationError,
+        WinRM::WinRMWSManFault,
+        Errno::EACCES,
+        Errno::EADDRINUSE,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::ENETUNREACH,
+        Errno::EHOSTUNREACH,
+        Timeout::Error
+      ]
+
+      attr_reader :logger
+      attr_reader :host
+      attr_reader :port
+      attr_reader :username
+      attr_reader :password
+      attr_reader :execution_time_limit
+      attr_reader :config
+
+      def initialize(host, port, config)
+        @logger = Log4r::Logger.new("vagrant::communication::winrmshell")
+        @logger.debug("initializing WinRMShell")
+
+        @host                  = host
+        @port                  = port
+        @username              = config.username
+        @password              = config.password
+        @execution_time_limit  = config.execution_time_limit
+        @config                = config
+      end
+
+      def powershell(command, opts = {}, &block)
+        connection.shell(:powershell) do |shell|
+          execute_with_rescue(shell, command, &block)
+        end
+      end
+
+      def cmd(command, opts = {}, &block)
+        shell_opts = {}
+        shell_opts[:codepage] = @config.codepage if @config.codepage
+        connection.shell(:cmd, shell_opts) do |shell|
+          execute_with_rescue(shell, command, &block)
+        end
+      end
+
+      def elevated(command, opts = {}, &block)
+        connection.shell(:elevated) do |shell|
+          shell.interactive_logon = opts[:interactive] || false
+          execute_with_rescue(shell, command, &block)
+        end
+      end
+
+      def wql(query, opts = {}, &block)
+        retryable(tries: @config.max_tries, on: @@exceptions_to_retry_on, sleep: @config.retry_delay) do
+          connection.run_wql(query)
+        end
+      rescue => e
+        raise_winrm_exception(e, "run_wql", query)
+      end
+
+      # @param from [Array<String>, String] a single path or folder, or an
+      #        array of paths and folders to upload to the guest
+      # @param to [String] a path or folder on the guest to upload to
+      # @return [FixNum] Total size transfered from host to guest
+      def upload(from, to)
+        file_manager = WinRM::FS::FileManager.new(connection)
+        if from.is_a?(Array)
+          # Preserve return FixNum of bytes transfered
+          return_bytes = 0
+          from.each do |file|
+            return_bytes += file_manager.upload(file, to)
+          end
+          return return_bytes
+        else
+          file_manager.upload(from, to)
+        end
+      end
+
+      def download(from, to)
+        file_manager = WinRM::FS::FileManager.new(connection)
+        file_manager.download(from, to)
+      end
+
+      protected
+
+      def execute_with_rescue(shell, command, &block)
+        handle_output(shell, command, &block)
+      rescue => e
+        raise_winrm_exception(e, shell.class.name.split("::").last, command)
+      end
+
+      def handle_output(shell, command, &block)
+        output = shell.run(command) do |out, err|
+          block.call(:stdout, out) if block_given? && out
+          block.call(:stderr, err) if block_given? && err
+        end
+
+        @logger.debug("Output: #{output.inspect}")
+
+        # Verify that we didn't get a parser error, and if so we should
+        # set the exit code to 1. Parse errors return exit code 0 so we
+        # need to do this.
+        if output.exitcode == 0
+          if output.stderr.include?("ParserError")
+            @logger.warn("Detected ParserError, setting exit code to 1")
+            output.exitcode = 1
+          end
+        end
+
+        return output
+      end
+
+      def raise_winrm_exception(exception, shell = nil, command = nil)
+        case exception
+        when WinRM::WinRMAuthorizationError
+          raise Errors::AuthenticationFailed,
+              user: @config.username,
+              password: @config.password,
+              endpoint: endpoint,
+              message: exception.message
+        when WinRM::WinRMHTTPTransportError
+          raise Errors::ExecutionError,
+            shell: shell,
+            command: command,
+            message: exception.message
+        when OpenSSL::SSL::SSLError
+          raise Errors::SSLError, message: exception.message
+        when HTTPClient::TimeoutError
+          raise Errors::ConnectionTimeout, message: exception.message
+        when Errno::ETIMEDOUT
+          raise Errors::ConnectionTimeout
+          # This is raised if the connection timed out
+        when Errno::ECONNREFUSED
+          # This is raised if we failed to connect the max amount of times
+          raise Errors::ConnectionRefused
+        when Errno::ECONNRESET
+          # This is raised if we failed to connect the max number of times
+          # due to an ECONNRESET.
+          raise Errors::ConnectionReset
+        when Errno::EHOSTDOWN
+          # This is raised if we get an ICMP DestinationUnknown error.
+          raise Errors::HostDown
+        when Errno::EHOSTUNREACH
+          # This is raised if we can't work out how to route traffic.
+          raise Errors::NoRoute
+        else
+          raise Errors::ExecutionError,
+            shell: shell,
+            command: command,
+            message: exception.message
+        end
+      end
+
+      def new_connection
+        @logger.info("Attempting to connect to WinRM...")
+        @logger.info("  - Host: #{@host}")
+        @logger.info("  - Port: #{@port}")
+        @logger.info("  - Username: #{@config.username}")
+        @logger.info("  - Transport: #{@config.transport}")
+
+        client = ::WinRM::Connection.new(endpoint_options)
+        client.logger = @logger
+        client
+      end
+
+      def connection
+        @connection ||= new_connection
+      end
+
+      def endpoint
+        case @config.transport.to_sym
+        when :ssl
+          "https://#{@host}:#{@port}/wsman"
+        when :plaintext, :negotiate
+          "http://#{@host}:#{@port}/wsman"
+        else
+          raise Errors::WinRMInvalidTransport, transport: @config.transport
+        end
+      end
+
+      def endpoint_options
+        { endpoint: endpoint,
+          transport: @config.transport,
+          operation_timeout: @config.timeout,
+          user: @username,
+          password: @password,
+          host: @host,
+          port: @port,
+          basic_auth_only: @config.basic_auth_only,
+          no_ssl_peer_verification: !@config.ssl_peer_verification,
+          retry_delay: @config.retry_delay,
+          retry_limit: @config.max_tries }
+      end
+    end #WinShell class
+  end
+end