vagrant-unbundled 1.8.4.2 → 1.8.5.1

data/plugins/guests/funtoo/plugin.rb

@@ -6,17 +6,12 @@ module VagrantPlugins
       name "Funtoo guest"
       description "Funtoo guest support."
 
-      guest("funtoo", "linux") do
-        require File.expand_path("../guest", __FILE__)
+      guest(:funtoo, :gentoo) do
+        require_relative "guest"
         Guest
       end
 
-      guest_capability("funtoo", "change_host_name") do
-        require_relative "cap/change_host_name"
-        Cap::ChangeHostName
-      end
-
-      guest_capability("funtoo", "configure_networks") do
+      guest_capability(:funtoo, :configure_networks) do
         require_relative "cap/configure_networks"
         Cap::ConfigureNetworks
       end

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

@@ -3,12 +3,27 @@ module VagrantPlugins
     module Cap
       class ChangeHostName
         def self.change_host_name(machine, name)
-          machine.communicate.tap do |comm|
-            if !comm.test("sudo hostname --fqdn | grep '#{name}'")
-              comm.sudo("echo 'hostname=#{name.split('.')[0]}' > /etc/conf.d/hostname")
-              comm.sudo("sed -i 's@^\\(127[.]0[.]0[.]1[[:space:]]\\+\\)@\\1#{name} #{name.split('.')[0]} @' /etc/hosts")
-              comm.sudo("hostname #{name.split('.')[0]}")
-            end
+          comm = machine.communicate
+
+          if !comm.test("hostname -f | grep '^#{name}$'", sudo: false)
+            basename = name.split(".", 2)[0]
+            comm.sudo <<-EOH.gsub(/^ {14}/, "")
+              set -e
+
+              # Set the hostname
+              hostname '#{basename}'
+              echo "hostname=#{basename}" > /etc/conf.d/hostname
+
+              # Remove comments and blank lines from /etc/hosts
+              sed -i'' -e 's/#.*$//' /etc/hosts
+              sed -i'' -e '/^$/d' /etc/hosts
+
+              # Prepend ourselves to /etc/hosts
+              grep -w '#{name}' /etc/hosts || {
+                echo -e '127.0.0.1\\t#{name}\\t#{basename}' | cat - /etc/hosts > /tmp/tmp-hosts
+                mv /tmp/tmp-hosts /etc/hosts
+              }
+            EOH
           end
         end
       end

data/plugins/guests/gentoo/cap/configure_networks.rb

@@ -9,34 +9,43 @@ module VagrantPlugins
         include Vagrant::Util
 
         def self.configure_networks(machine, networks)
-          machine.communicate.tap do |comm|
-            # Remove any previous host only network additions to the interface file
-            comm.sudo("sed -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/conf.d/net > /tmp/vagrant-network-interfaces")
-            comm.sudo("cat /tmp/vagrant-network-interfaces > /etc/conf.d/net")
-            comm.sudo("rm -f /tmp/vagrant-network-interfaces")
-
-            # Configure each network interface
-            networks.each do |network|
-              entry = TemplateRenderer.render("guests/gentoo/network_#{network[:type]}",
-                                              options: network)
-
-              # Upload the entry to a temporary location
-              Tempfile.open("vagrant-gentoo-configure-networks") do |f|
-                f.binmode
-                f.write(entry)
-                f.fsync
-                f.close
-                comm.upload(f.path, "/tmp/vagrant-network-entry")
-              end
-
-              # Configure the interface
-              comm.sudo("ln -fs /etc/init.d/net.lo /etc/init.d/net.eth#{network[:interface]}")
-              comm.sudo("/etc/init.d/net.eth#{network[:interface]} stop")
-              comm.sudo("cat /tmp/vagrant-network-entry >> /etc/conf.d/net")
-              comm.sudo("rm -f /tmp/vagrant-network-entry")
-              comm.sudo("/etc/init.d/net.eth#{network[:interface]} start")
+          comm = machine.communicate
+
+          commands   = []
+          interfaces = machine.guest.capability(:network_interfaces, "/bin/ip")
+
+          # Remove any previous network additions to the configuration file.
+          commands << "sed -i'' -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/conf.d/net"
+
+          networks.each_with_index do |network, i|
+            network[:device] = interfaces[network[:interface]]
+
+            entry = TemplateRenderer.render("guests/gentoo/network_#{network[:type]}",
+              options: network,
+            )
+
+            remote_path = "/tmp/vagrant-network-#{network[:device]}-#{Time.now.to_i}-#{i}"
+
+            Tempfile.open("vagrant-gentoo-configure-networks") do |f|
+              f.binmode
+              f.write(entry)
+              f.fsync
+              f.close
+              comm.upload(f.path, remote_path)
             end
+
+            commands << <<-EOH.gsub(/^ {14}/, '')
+              ln -sf /etc/init.d/net.lo /etc/init.d/net.#{network[:device]}
+              /etc/init.d/net.#{network[:device]} stop || true
+
+              cat '#{remote_path}' >> /etc/conf.d/net
+              rm -f '#{remote_path}'
+
+              /etc/init.d/net.#{network[:device]} start
+            EOH
           end
+
+          comm.sudo(commands.join("\n"))
         end
       end
     end

data/plugins/guests/gentoo/plugin.rb

@@ -6,17 +6,17 @@ module VagrantPlugins
       name "Gentoo guest"
       description "Gentoo guest support."
 
-      guest("gentoo", "linux") do
-        require File.expand_path("../guest", __FILE__)
+      guest(:gentoo, :linux) do
+        require_relative "guest"
         Guest
       end
 
-      guest_capability("gentoo", "change_host_name") do
+      guest_capability(:gentoo, :change_host_name) do
         require_relative "cap/change_host_name"
         Cap::ChangeHostName
       end
 
-      guest_capability("gentoo", "configure_networks") do
+      guest_capability(:gentoo, :configure_networks) do
         require_relative "cap/configure_networks"
         Cap::ConfigureNetworks
       end

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

@@ -6,13 +6,12 @@ module VagrantPlugins
           comm = machine.communicate
 
           possible.each do |ip|
-            command = "ping -c1 -w1 -W1 #{ip}"
-            if comm.test(command)
+            if comm.test("ping -c1 -w1 -W1 #{ip}")
               return ip
             end
           end
 
-          nil
+          return nil
         end
       end
     end

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

@@ -1,12 +1,17 @@
+require "shellwords"
+
+require "vagrant/util/retryable"
+
 module VagrantPlugins
   module GuestLinux
     module Cap
       class MountVirtualBoxSharedFolder
+        extend Vagrant::Util::Retryable
+
         def self.mount_virtualbox_shared_folder(machine, name, guestpath, options)
-          expanded_guest_path = machine.guest.capability(
-            :shell_expand_guest_path, guestpath)
+          guest_path = Shellwords.escape(guestpath)
 
-          mount_commands = []
+          mount_commands = ["set -e"]
 
           if options[:owner].is_a? Integer
             mount_uid = options[:owner]
@@ -25,73 +30,54 @@ module VagrantPlugins
           # First mount command uses getent to get the group
           mount_options = "-o uid=#{mount_uid},gid=#{mount_gid}"
           mount_options += ",#{options[:mount_options].join(",")}" if options[:mount_options]
-          mount_commands << "mount -t vboxsf #{mount_options} #{name} #{expanded_guest_path}"
+          mount_commands << "mount -t vboxsf #{mount_options} #{name} #{guest_path}"
 
           # Second mount command uses the old style `id -g`
           mount_options = "-o uid=#{mount_uid},gid=#{mount_gid_old}"
           mount_options += ",#{options[:mount_options].join(",")}" if options[:mount_options]
-          mount_commands << "mount -t vboxsf #{mount_options} #{name} #{expanded_guest_path}"
+          mount_commands << "mount -t vboxsf #{mount_options} #{name} #{guest_path}"
 
           # Create the guest path if it doesn't exist
-          machine.communicate.sudo("mkdir -p #{expanded_guest_path}")
+          machine.communicate.sudo("mkdir -p #{guest_path}")
 
           # Attempt to mount the folder. We retry here a few times because
           # it can fail early on.
-          attempts = 0
-          while true
-            success = true
-
-            stderr = ""
-            mount_commands.each do |command|
-              no_such_device = false
-              stderr = ""
-              status = machine.communicate.sudo(command, error_check: false) do |type, data|
-                if type == :stderr
-                  no_such_device = true if data =~ /No such device/i
-                  stderr += data.to_s
-                end
-              end
-
-              success = status == 0 && !no_such_device
-              break if success
-            end
-
-            break if success
-
-            attempts += 1
-            if attempts > 10
-              raise Vagrant::Errors::LinuxMountFailed,
-                command: mount_commands.join("\n"),
-                output: stderr
-            end
-
-            sleep(2*attempts)
+          command = mount_commands.join("\n")
+          stderr = ""
+          retryable(on: Vagrant::Errors::VirtualBoxMountFailed, tries: 3, sleep: 5) do
+            machine.communicate.sudo(command,
+              error_class: Vagrant::Errors::VirtualBoxMountFailed,
+              error_key: :virtualbox_mount_failed,
+              command: command,
+              output: stderr,
+            ) { |type, data| stderr = data if type == :stderr }
           end
 
           # Chown the directory to the proper user. We skip this if the
           # mount options contained a readonly flag, because it won't work.
           if !options[:mount_options] || !options[:mount_options].include?("ro")
             chown_commands = []
-            chown_commands << "chown #{mount_uid}:#{mount_gid} #{expanded_guest_path}"
-            chown_commands << "chown #{mount_uid}:#{mount_gid_old} #{expanded_guest_path}"
+            chown_commands << "chown #{mount_uid}:#{mount_gid} #{guest_path}"
+            chown_commands << "chown #{mount_uid}:#{mount_gid_old} #{guest_path}"
 
             exit_status = machine.communicate.sudo(chown_commands[0], error_check: false)
             machine.communicate.sudo(chown_commands[1]) if exit_status != 0
           end
 
           # Emit an upstart event if we can
-          machine.communicate.sudo <<-SCRIPT
-if command -v /sbin/init && /sbin/init --version | grep upstart; then
-  /sbin/initctl emit --no-wait vagrant-mounted MOUNTPOINT='#{expanded_guest_path}'
-fi
-SCRIPT
+          machine.communicate.sudo <<-EOH.gsub(/^ {12}/, "")
+            if command -v /sbin/init && /sbin/init --version | grep upstart; then
+              /sbin/initctl emit --no-wait vagrant-mounted MOUNTPOINT=#{guest_path}
+            fi
+          EOH
         end
 
         def self.unmount_virtualbox_shared_folder(machine, guestpath, options)
-          result = machine.communicate.sudo(
-            "umount #{guestpath}", error_check: false)
+          guest_path = Shellwords.escape(guestpath)
+
+          result = machine.communicate.sudo("umount #{guest_path}", error_check: false)
           if result == 0
-            machine.communicate.sudo("rmdir #{guestpath}", error_check: false)
+            machine.communicate.sudo("rmdir #{guest_path}", error_check: false)
           end
         end
       end

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module GuestLinux
+    module Cap
+      class NetworkInterfaces
+        # Get network interfaces as a list. The result will be something like:
+        #
+        #   eth0\nenp0s8\nenp0s9
+        #
+        # @return [Array<String>]
+        def self.network_interfaces(machine, path = "/sbin/ip")
+          s = ""
+          machine.communicate.sudo("#{path} -o -0 addr | grep -v LOOPBACK | awk '{print $2}' | sed 's/://'") do |type, data|
+            s << data if type == :stdout
+          end
+          s.split("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require "vagrant/util/retryable"
+
+module VagrantPlugins
+  module GuestLinux
+    module Cap
+      class NFS
+        extend Vagrant::Util::Retryable
+
+        def self.nfs_client_installed(machine)
+          machine.communicate.test("test -x /sbin/mount.nfs")
+        end
+
+        def self.mount_nfs_folder(machine, ip, folders)
+          comm = machine.communicate
+
+          folders.each do |name, opts|
+            # Mount each folder separately so we can retry.
+            commands = ["set -e"]
+
+            # Shellescape the paths in case they do not have special characters.
+            guest_path = Shellwords.escape(opts[:guestpath])
+            host_path  = Shellwords.escape(opts[:hostpath])
+
+            # Build the list of mount options.
+            mount_opts =  []
+            mount_opts << "vers=#{opts[:nfs_version]}" if opts[:nfs_version]
+            mount_opts << "udp" if opts[:nfs_udp]
+            if opts[:mount_options]
+              mount_opts = mount_opts + opts[:mount_options].dup
+            end
+            mount_opts = mount_opts.join(",")
+
+            # Make the directory on the guest.
+            commands << "mkdir -p #{guest_path}"
+
+            # Perform the mount operation.
+            commands << "mount -o #{mount_opts} #{ip}:#{host_path} #{guest_path}"
+
+            # Emit a mount event
+            commands << <<-EOH.gsub(/^ {14}/, '')
+              if command -v /sbin/init && /sbin/init --version | grep upstart; then
+                /sbin/initctl emit --no-wait vagrant-mounted MOUNTPOINT=#{guest_path}
+              fi
+            EOH
+
+            # Run the command, raising a specific error.
+            retryable(on: Vagrant::Errors::NFSMountFailed, tries: 3, sleep: 5) do
+              machine.communicate.sudo(commands.join("\n"),
+                error_class: Vagrant::Errors::NFSMountFailed,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require "tempfile"
+
+require "vagrant/util/shell_quote"
+
+module VagrantPlugins
+  module GuestLinux
+    module Cap
+      class PublicKey
+        def self.insert_public_key(machine, contents)
+          comm = machine.communicate
+          contents = contents.strip << "\n"
+
+          remote_path = "/tmp/vagrant-insert-pubkey-#{Time.now.to_i}"
+          Tempfile.open("vagrant-linux-insert-public-key") do |f|
+            f.binmode
+            f.write(contents)
+            f.fsync
+            f.close
+            comm.upload(f.path, remote_path)
+          end
+
+          # Use execute (not sudo) because we want to execute this as the SSH
+          # user (which is "vagrant" by default).
+          comm.execute <<-EOH.gsub(/^ {12}/, "")
+            set -e
+
+            mkdir -p ~/.ssh
+            chmod 0700 ~/.ssh
+            cat '#{remote_path}' >> ~/.ssh/authorized_keys
+            chmod 0600 ~/.ssh/authorized_keys
+
+            rm -f '#{remote_path}'
+          EOH
+        end
+
+        def self.remove_public_key(machine, contents)
+          comm = machine.communicate
+          contents = contents.strip << "\n"
+
+          remote_path = "/tmp/vagrant-remove-pubkey-#{Time.now.to_i}"
+          Tempfile.open("vagrant-bsd-remove-public-key") do |f|
+            f.binmode
+            f.write(contents)
+            f.fsync
+            f.close
+            comm.upload(f.path, remote_path)
+          end
+
+          # Use execute (not sudo) because we want to execute this as the SSH
+          # user (which is "vagrant" by default).
+          comm.execute <<-EOH.sub(/^ {12}/, "")
+            set -e
+
+            if test -f ~/.ssh/authorized_keys; then
+              grep -v -x -f '#{remote_path}' ~/.ssh/authorized_keys > ~/.ssh/authorized_keys.tmp
+              mv ~/.ssh/authorized_keys.tmp ~/.ssh/authorized_keys
+            fi
+
+            rm -f '#{remote_path}'
+          EOH
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+require "shellwords"
+
 module VagrantPlugins
   module GuestLinux
     module Cap
@@ -11,9 +13,8 @@ module VagrantPlugins
         end
 
         def self.rsync_pre(machine, opts)
-          machine.communicate.tap do |comm|
-            comm.sudo("mkdir -p '#{opts[:guestpath]}'")
-          end
+          guest_path = Shellwords.escape(opts[:guestpath])
+          machine.communicate.sudo("mkdir -p #{guest_path}")
         end
 
         def self.rsync_post(machine, opts)
@@ -21,8 +22,10 @@ module VagrantPlugins
             return
           end
 
+          guest_path = Shellwords.escape(opts[:guestpath])
+
           machine.communicate.sudo(
-            "find '#{opts[:guestpath]}' " +
+            "find #{guest_path} " +
             "'!' -type l -a " +
             "'(' ! -user #{opts[:owner]} -or ! -group #{opts[:group]} ')' -print0 | " +
             "xargs -0 -r chown #{opts[:owner]}:#{opts[:group]}")