vagrant-unbundled 2.1.4.0 → 2.2.0.0

data/plugins/commands/winrm/command.rb

@@ -0,0 +1,69 @@
+require 'optparse'
+
+require "vagrant/util/safe_puts"
+
+module VagrantPlugins
+  module CommandWinRM
+    class Command < Vagrant.plugin("2", :command)
+      include Vagrant::Util::SafePuts
+
+      def self.synopsis
+        "executes commands on a machine via WinRM"
+      end
+
+      def execute
+        options = {
+          command: [],
+          shell: :powershell
+        }
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant winrm [options] [name|id]"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("-c", "--command COMMAND", "Execute a WinRM command directly") do |c|
+            options[:command] << c
+          end
+
+          o.on("-e", "--elevated", "Run with elevated credentials") do |e|
+            options[:elevated] = true
+          end
+
+          o.on("-s", "--shell SHELL", [:powershell, :cmd], "Use specified shell (powershell, cmd)") do |s|
+            options[:shell] = s
+          end
+        end
+
+        argv = parse_options(opts)
+        return if !argv
+
+        with_target_vms(argv, single_target: true) do |machine|
+          if machine.config.vm.communicator != :winrm
+            raise Vagrant::Errors::WinRMInvalidCommunicator
+          end
+
+          opts = {
+            shell: options[:shell],
+            elevated: !!options[:elevated]
+          }
+
+          options[:command].each do |cmd|
+            begin
+              machine.communicate.execute(cmd, opts) do |type, data|
+                io = type == :stderr ? $stderr : $stdout
+                safe_puts(data, io: io, printer: :print)
+              end
+            rescue VagrantPlugins::CommunicatorWinRM::Errors::WinRMBadExitStatus
+              return 1
+            end
+          end
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/winrm/plugin.rb

@@ -0,0 +1,17 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandWinRM
+    class Plugin < Vagrant.plugin("2")
+      name "winrm command"
+      description <<-DESC
+      The `winrm` command executes commands on a machine via WinRM
+      DESC
+
+      command("winrm") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/winrm_config/command.rb

@@ -0,0 +1,125 @@
+require 'optparse'
+require "vagrant/util/safe_puts"
+require_relative "../../communicators/winrm/helper"
+
+module VagrantPlugins
+  module CommandWinRMConfig
+    class Command < Vagrant.plugin("2", :command)
+      include Vagrant::Util::SafePuts
+
+      def self.synopsis
+        "outputs WinRM 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 winrm-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|
+          winrm_info = CommunicatorWinRM::Helper.winrm_info(machine)
+          raise Vagrant::Errors::WinRMNotRead if winrm_info.nil?
+
+          rdp_info = get_rdp_info(machine) || {}
+
+          variables = {
+            host_key: options[:host] || machine.name || "vagrant",
+            rdp_host: rdp_info[:host] || winrm_info[:host],
+            rdp_port: rdp_info[:port],
+            rdp_user: rdp_info[:username],
+            rdp_pass: rdp_info[:password],
+            winrm_host: winrm_info[:host],
+            winrm_port: winrm_info[:port],
+            winrm_user: machine.config.winrm.username,
+            winrm_password: machine.config.winrm.password
+          }
+
+          template = "commands/winrm_config/config"
+          config = Vagrant::Util::TemplateRenderer.render(template, variables)
+          machine.ui.machine("winrm-config", config)
+          safe_puts(config)
+          safe_puts
+        end
+
+        # Success, exit status 0
+        0
+      end
+
+      protected
+
+      # Generate RDP information for machine
+      #
+      # @param [Vagrant::Machine] machine Guest machine
+      # @return [Hash, nil]
+      def get_rdp_info(machine)
+        rdp_info = {}
+        if machine.provider.capability?(:rdp_info)
+          rdp_info = machine.provider.capability(:rdp_info)
+          rdp_info ||= {}
+        end
+
+        ssh_info = machine.ssh_info || {}
+
+        if !rdp_info[:username]
+          username = ssh_info[:username]
+          if machine.config.vm.communicator == :winrm
+            username = machine.config.winrm.username
+          end
+          rdp_info[:username] = username
+        end
+
+        if !rdp_info[:password]
+          password = ssh_info[:password]
+          if machine.config.vm.communicator == :winrm
+            password = machine.config.winrm.password
+          end
+          rdp_info[:password] = password
+        end
+
+        rdp_info[:host] ||= ssh_info[:host]
+        rdp_info[:port] ||= machine.config.rdp.port
+        rdp_info[:username] ||= machine.config.rdp.username
+
+        if rdp_info[:host] == "127.0.0.1"
+          # We need to find a forwarded port...
+          search_port = machine.config.rdp.search_port
+          ports       = nil
+          if machine.provider.capability?(:forwarded_ports)
+            ports = machine.provider.capability(:forwarded_ports)
+          else
+            ports = {}.tap do |result|
+              machine.config.vm.networks.each do |type, netopts|
+                next if type != :forwarded_port
+                next if !netopts[:host]
+                result[netopts[:host]] = netopts[:guest]
+              end
+            end
+          end
+
+          ports = ports.invert
+          port  = ports[search_port]
+          rdp_info[:port] = port
+          return nil if !port
+        end
+
+        rdp_info
+      end
+    end
+  end
+end

data/plugins/commands/winrm_config/plugin.rb

@@ -0,0 +1,17 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandWinRMConfig
+    class Plugin < Vagrant.plugin("2")
+      name "winrm-config command"
+      description <<-DESC
+      The `winrm-config` command dumps WinRM configuration information
+      DESC
+
+      command("winrm-config") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/guests/bsd/cap/file_system.rb

@@ -0,0 +1,77 @@
+module VagrantPlugins
+  module GuestBSD
+    module Cap
+      class FileSystem
+        # Create a temporary file or directory on the guest
+        #
+        # @param [Vagrant::Machine] machine Vagrant guest machine
+        # @param [Hash] opts Path options
+        # @return [String] path to temporary file or directory
+        def self.create_tmp_path(machine, opts)
+          template = "vagrant"
+          cmd = ["mktemp"]
+          if opts[:type] == :directory
+            cmd << "-d"
+          end
+          cmd << "-t"
+          cmd << template
+          tmp_path = ""
+          machine.communicate.execute(cmd.join(" ")) do |type, data|
+            if type == :stdout
+              tmp_path << data
+            end
+          end
+          tmp_path.strip
+        end
+
+        # Decompress tgz file on guest to given location
+        #
+        # @param [Vagrant::Machine] machine Vagrant guest machine
+        # @param [String] compressed_file Path to compressed file on guest
+        # @param [String] destination Path for decompressed files on guest
+        def self.decompress_tgz(machine, compressed_file, destination, opts={})
+          comm = machine.communicate
+          extract_dir = create_tmp_path(machine, type: :directory)
+          cmds = []
+          if opts[:type] == :directory
+            cmds << "mkdir -p '#{destination}'"
+          else
+            cmds << "mkdir -p '#{File.dirname(destination)}'"
+          end
+          cmds += [
+            "tar -C '#{extract_dir}' -xzf '#{compressed_file}'",
+            "mv '#{extract_dir}'/* '#{destination}'",
+            "rm -f '#{compressed_file}'",
+            "rm -rf '#{extract_dir}'"
+          ]
+          cmds.each{ |cmd| comm.execute(cmd) }
+          true
+        end
+
+        # Decompress zip file on guest to given location
+        #
+        # @param [Vagrant::Machine] machine Vagrant guest machine
+        # @param [String] compressed_file Path to compressed file on guest
+        # @param [String] destination Path for decompressed files on guest
+        def self.decompress_zip(machine, compressed_file, destination, opts={})
+          comm = machine.communicate
+          extract_dir = create_tmp_path(machine, type: :directory)
+          cmds = []
+          if opts[:type] == :directory
+            cmds << "mkdir -p '#{destination}'"
+          else
+            cmds << "mkdir -p '#{File.dirname(destination)}'"
+          end
+          cmds += [
+            "unzip '#{compressed_file}' -d '#{extract_dir}'",
+            "mv '#{extract_dir}'/* '#{destination}'",
+            "rm -f '#{compressed_file}'",
+            "rm -rf '#{extract_dir}'"
+          ]
+          cmds.each{ |cmd| comm.execute(cmd) }
+          true
+        end
+      end
+    end
+  end
+end

data/plugins/guests/bsd/plugin.rb

@@ -11,6 +11,21 @@ module VagrantPlugins
         Guest
       end
 
+      guest_capability(:bsd, :create_tmp_path) do
+        require_relative "cap/file_system"
+        Cap::FileSystem
+      end
+
+      guest_capability(:bsd, :decompress_tgz) do
+        require_relative "cap/file_system"
+        Cap::FileSystem
+      end
+
+      guest_capability(:bsd, :decompress_zip) do
+        require_relative "cap/file_system"
+        Cap::FileSystem
+      end
+
       guest_capability(:bsd, :halt) do
         require_relative "cap/halt"
         Cap::Halt

data/plugins/guests/linux/cap/file_system.rb

@@ -0,0 +1,79 @@
+module VagrantPlugins
+  module GuestLinux
+    module Cap
+      class FileSystem
+        # Create a temporary file or directory on the guest
+        #
+        # @param [Vagrant::Machine] machine Vagrant guest machine
+        # @param [Hash] opts Path options
+        # @return [String] path to temporary file or directory
+        def self.create_tmp_path(machine, opts)
+          template = "vagrant-XXXXXX"
+          if opts[:extension]
+            template << opts[:extension].to_s
+          end
+          cmd = ["mktemp", "--tmpdir"]
+          if opts[:type] == :directory
+            cmd << "-d"
+          end
+          cmd << template
+          tmp_path = ""
+          machine.communicate.execute(cmd.join(" ")) do |type, data|
+            if type == :stdout
+              tmp_path << data
+            end
+          end
+          tmp_path.strip
+        end
+
+        # Decompress tgz file on guest to given location
+        #
+        # @param [Vagrant::Machine] machine Vagrant guest machine
+        # @param [String] compressed_file Path to compressed file on guest
+        # @param [String] destination Path for decompressed files on guest
+        def self.decompress_tgz(machine, compressed_file, destination, opts={})
+          comm = machine.communicate
+          extract_dir = create_tmp_path(machine, type: :directory)
+          cmds = []
+          if opts[:type] == :directory
+            cmds << "mkdir -p '#{destination}'"
+          else
+            cmds << "mkdir -p '#{File.dirname(destination)}'"
+          end
+          cmds += [
+            "tar -C '#{extract_dir}' -xzf '#{compressed_file}'",
+            "mv '#{extract_dir}'/* '#{destination}'",
+            "rm -f '#{compressed_file}'",
+            "rm -rf '#{extract_dir}'"
+          ]
+          cmds.each{ |cmd| comm.execute(cmd) }
+          true
+        end
+
+        # Decompress zip file on guest to given location
+        #
+        # @param [Vagrant::Machine] machine Vagrant guest machine
+        # @param [String] compressed_file Path to compressed file on guest
+        # @param [String] destination Path for decompressed files on guest
+        def self.decompress_zip(machine, compressed_file, destination, opts={})
+          comm = machine.communicate
+          extract_dir = create_tmp_path(machine, type: :directory)
+          cmds = []
+          if opts[:type] == :directory
+            cmds << "mkdir -p '#{destination}'"
+          else
+            cmds << "mkdir -p '#{File.dirname(destination)}'"
+          end
+          cmds += [
+            "unzip '#{compressed_file}' -d '#{extract_dir}'",
+            "mv '#{extract_dir}'/* '#{destination}'",
+            "rm -f '#{compressed_file}'",
+            "rm -rf '#{extract_dir}'"
+          ]
+          cmds.each{ |cmd| comm.execute(cmd) }
+          true
+        end
+      end
+    end
+  end
+end

data/plugins/guests/linux/cap/network_interfaces.rb

@@ -19,6 +19,7 @@ module VagrantPlugins
           machine.communicate.sudo("#{path} -o -0 addr | grep -v LOOPBACK | awk '{print $2}' | sed 's/://'") do |type, data|
             s << data if type == :stdout
           end
+
           # In some cases net devices may be added to the guest and will not
           # properly show up when using `ip`. This pulls any device information
           # that can be found in /proc and adds it to the list of interfaces
@@ -26,7 +27,17 @@ module VagrantPlugins
           machine.communicate.sudo("cat /proc/net/dev | grep -E '^[a-z0-9 ]+:' | awk '{print $1}' | sed 's/://'", error_check: false) do |type, data|
             s << data if type == :stdout
           end
-          ifaces = s.split("\n")
+
+          # Collect all loopback interfaces
+          los = ""
+          machine.communicate.sudo("#{path} -o -0 addr | grep LOOPBACK | awk '{print $2}' | sed 's/://'") do |type, data|
+            los << data if type == :stdout
+          end
+          loifaces = los.split("\n")
+          @@logger.debug("loopback interfaces: #{loifaces.inspect}")
+
+          ifaces = s.split("\n").reject { |x| x.empty? or loifaces.include?(x) }
+
           @@logger.debug("Unsorted list: #{ifaces.inspect}")
           # Break out integers from strings and sort the arrays to provide
           # a natural sort for the interface names
@@ -34,7 +45,7 @@ module VagrantPlugins
           #  as expected. This is generally seen with veth* devices, and proper ordering
           #  is currently not required
           ifaces = ifaces.map do |iface|
-            iface.scan(/(.+?)(\d+)/).flatten.map do |iface_part|
+            iface.scan(/(.+?)(\d+)?/).flatten.map do |iface_part|
               if iface_part.to_i.to_s == iface_part
                 iface_part.to_i
               else

data/plugins/guests/linux/plugin.rb

@@ -16,6 +16,21 @@ module VagrantPlugins
         Cap::ChooseAddressableIPAddr
       end
 
+      guest_capability(:linux, :create_tmp_path) do
+        require_relative "cap/file_system"
+        Cap::FileSystem
+      end
+
+      guest_capability(:linux, :decompress_tgz) do
+        require_relative "cap/file_system"
+        Cap::FileSystem
+      end
+
+      guest_capability(:linux, :decompress_zip) do
+        require_relative "cap/file_system"
+        Cap::FileSystem
+      end
+
       guest_capability(:linux, :halt) do
         require_relative "cap/halt"
         Cap::Halt

data/plugins/guests/redhat/cap/change_host_name.rb

@@ -2,6 +2,9 @@ module VagrantPlugins
   module GuestRedHat
     module Cap
       class ChangeHostName
+
+        extend Vagrant::Util::GuestInspection::Linux
+
         def self.change_host_name(machine, name)
           comm = machine.communicate
 
@@ -10,27 +13,32 @@ module VagrantPlugins
             comm.sudo <<-EOH.gsub(/^ {14}/, '')
               # Update sysconfig
               sed -i 's/\\(HOSTNAME=\\).*/\\1#{name}/' /etc/sysconfig/network
-
               # Update DNS
               sed -i 's/\\(DHCP_HOSTNAME=\\).*/\\1\"#{basename}\"/' /etc/sysconfig/network-scripts/ifcfg-*
-
               # Set the hostname - use hostnamectl if available
               echo '#{name}' > /etc/hostname
-              if command -v hostnamectl; then
-                hostnamectl set-hostname --static '#{name}'
-                hostnamectl set-hostname --transient '#{name}'
-              else
-                hostname -F /etc/hostname
-              fi
-
-              # Prepend ourselves to /etc/hosts
               grep -w '#{name}' /etc/hosts || {
                 sed -i'' '1i 127.0.0.1\\t#{name}\\t#{basename}' /etc/hosts
               }
-
-              # Restart network
-              service network restart
             EOH
+
+            if hostnamectl?(comm)
+              comm.sudo("hostnamectl set-hostname --static '#{name}' ; " \
+                "hostnamectl set-hostname --transient '#{name}'")
+            else
+              comm.sudo("hostname -F /etc/hostname")
+            end
+
+            restart_command = "service network restart"
+
+            if systemd?(comm)
+              if systemd_networkd?(comm)
+                restart_command = "systemctl restart systemd-networkd.service"
+              elsif systemd_controlled?(comm, "NetworkManager.service")
+                restart_command = "systemctl restart NetworkManager.service"
+              end
+            end
+            comm.sudo(restart_command)
           end
         end
       end

data/plugins/guests/solaris/cap/file_system.rb

@@ -0,0 +1,77 @@
+module VagrantPlugins
+  module GuestSolaris
+    module Cap
+      class FileSystem
+        # Create a temporary file or directory on the guest
+        #
+        # @param [Vagrant::Machine] machine Vagrant guest machine
+        # @param [Hash] opts Path options
+        # @return [String] path to temporary file or directory
+        def self.create_tmp_path(machine, opts)
+          template = "vagrant-XXXXXX"
+          cmd = ["mktemp"]
+          if opts[:type] == :directory
+            cmd << "-d"
+          end
+          cmd << "-t"
+          cmd << template
+          tmp_path = ""
+          machine.communicate.execute(cmd.join(" ")) do |type, data|
+            if type == :stdout
+              tmp_path << data
+            end
+          end
+          tmp_path.strip
+        end
+
+        # Decompress tgz file on guest to given location
+        #
+        # @param [Vagrant::Machine] machine Vagrant guest machine
+        # @param [String] compressed_file Path to compressed file on guest
+        # @param [String] destination Path for decompressed files on guest
+        def self.decompress_tgz(machine, compressed_file, destination, opts={})
+          comm = machine.communicate
+          extract_dir = create_tmp_path(machine, type: :directory)
+          cmds = []
+          if opts[:type] == :directory
+            cmds << "mkdir -p '#{destination}'"
+          else
+            cmds << "mkdir -p '#{File.dirname(destination)}'"
+          end
+          cmds += [
+            "tar xzf '#{compressed_file}' -C '#{extract_dir}'",
+            "mv '#{extract_dir}'/* '#{destination}'",
+            "rm -f '#{compressed_file}'",
+            "rm -rf '#{extract_dir}'"
+          ]
+          cmds.each{ |cmd| comm.execute(cmd) }
+          true
+        end
+
+        # Decompress zip file on guest to given location
+        #
+        # @param [Vagrant::Machine] machine Vagrant guest machine
+        # @param [String] compressed_file Path to compressed file on guest
+        # @param [String] destination Path for decompressed files on guest
+        def self.decompress_zip(machine, compressed_file, destination, opts={})
+          comm = machine.communicate
+          extract_dir = create_tmp_path(machine, type: :directory)
+          cmds = []
+          if opts[:type] == :directory
+            cmds << "mkdir -p '#{destination}'"
+          else
+            cmds << "mkdir -p '#{File.dirname(destination)}'"
+          end
+          cmds += [
+            "unzip '#{compressed_file}' -d '#{extract_dir}'",
+            "mv '#{extract_dir}'/* '#{destination}'",
+            "rm -f '#{compressed_file}'",
+            "rm -rf '#{extract_dir}'"
+          ]
+          cmds.each{ |cmd| comm.execute(cmd) }
+          true
+        end
+      end
+    end
+  end
+end

data/plugins/guests/solaris/plugin.rb

@@ -16,6 +16,21 @@ module VagrantPlugins
         Guest
       end
 
+      guest_capability(:solaris, :create_tmp_path) do
+        require_relative "cap/file_system"
+        Cap::FileSystem
+      end
+
+      guest_capability(:solaris, :decompress_tgz) do
+        require_relative "cap/file_system"
+        Cap::FileSystem
+      end
+
+      guest_capability(:solaris, :decompress_zip) do
+        require_relative "cap/file_system"
+        Cap::FileSystem
+      end
+
       guest_capability(:solaris, :change_host_name) do
         require_relative "cap/change_host_name"
         Cap::ChangeHostName