Merge pull request #6983 from posita/vagrant-provider-support-2741

Vagrantfile

@@ -27,14 +27,46 @@ $minion_ips = $num_minion.times.collect { |n| $minion_ip_base + "#{n+3}" }
 # Determine the OS platform to use
 $kube_os = ENV['KUBERNETES_OS'] || "fedora"
 
-# Check if we already have kube box
-$kube_box_url = ENV['KUBERNETES_BOX_URL'] || "http://opscode-vm-bento.s3.amazonaws.com/vagrant/virtualbox/opscode_fedora-20_chef-provisionerless.box"
-
-# OS platform to box information
-$kube_box = {
-  "fedora" => {
-    "name" => "fedora20",
-    "box_url" => $kube_box_url 
+# To override the vagrant provider, use (e.g.):
+#   KUBERNETES_PROVIDER=vagrant VAGRANT_DEFAULT_PROVIDER=... .../cluster/kube-up.sh
+# To override the box, use (e.g.):
+#   KUBERNETES_PROVIDER=vagrant KUBERNETES_BOX_NAME=... .../cluster/kube-up.sh
+# You can specify a box version:
+#   KUBERNETES_PROVIDER=vagrant KUBERNETES_BOX_NAME=... KUBERNETES_BOX_VERSION=... .../cluster/kube-up.sh
+# You can specify a box location:
+#   KUBERNETES_PROVIDER=vagrant KUBERNETES_BOX_NAME=... KUBERNETES_BOX_URL=... .../cluster/kube-up.sh
+# KUBERNETES_BOX_URL and KUBERNETES_BOX_VERSION will be ignored unless
+# KUBERNETES_BOX_NAME is set
+
+# Default OS platform to provider/box information
+$kube_provider_boxes = {
+  :parallels => {
+    'fedora' => {
+      # :box_url and :box_version are optional (and mutually exclusive);
+      # if :box_url is omitted the box will be retrieved by :box_name (and
+      # :box_version if provided) from
+      # http://atlas.hashicorp.com/boxes/search (formerly
+      # http://vagrantcloud.com/); this allows you override :box_name with
+      # your own value so long as you provide :box_url; for example, the
+      # "official" name of this box is "rickard-von-essen/
+      # opscode_fedora-20", but by providing the URL and our own name, we
+      # make it appear as yet another provider under the "kube-fedora20"
+      # box
+      :box_name => 'kube-fedora20',
+      :box_url => 'https://atlas.hashicorp.com/rickard-von-essen/boxes/opscode_fedora-20/versions/0.4.0/providers/parallels.box'
+    }
+  },
+  :virtualbox => {
+    'fedora' => {
+      :box_name => 'kube-fedora20',
+      :box_url => 'http://opscode-vm-bento.s3.amazonaws.com/vagrant/virtualbox/opscode_fedora-20_chef-provisionerless.box'
+    }
+  },
+  :vmware_desktop => {
+    'fedora' => {
+      :box_name => 'kube-fedora20',
+      :box_url => 'http://opscode-vm-bento.s3.amazonaws.com/vagrant/vmware/opscode_fedora-20-i386_chef-provisionerless.box'
+    }
   }
 }
 
@@ -54,16 +86,88 @@ end
 # In Fedora VM, tmpfs device is mapped to /tmp.  tmpfs is given 50% of RAM allocation.
 # When doing Salt provisioning, we copy approximately 200MB of content in /tmp before anything else happens.
 # This causes problems if anything else was in /tmp or the other directories that are bound to tmpfs device (i.e /run, etc.)
-$vm_mem = (ENV['KUBERNETES_MEMORY'] || 1024).to_i
+$vm_master_mem = (ENV['KUBERNETES_MASTER_MEMORY'] || ENV['KUBERNETES_MEMORY'] || 1024).to_i
+$vm_minion_mem = (ENV['KUBERNETES_MINION_MEMORY'] || ENV['KUBERNETES_MEMORY'] || 1024).to_i
 
 Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
-  def customize_vm(config)
-    config.vm.box = $kube_box[$kube_os]["name"]
-    config.vm.box_url = $kube_box[$kube_os]["box_url"]
+  def setvmboxandurl(config, provider)
+    if ENV['KUBERNETES_BOX_NAME'] then
+      config.vm.box = ENV['KUBERNETES_BOX_NAME']
 
-    config.vm.provider :virtualbox do |v|
-      v.customize ["modifyvm", :id, "--memory", $vm_mem]
-      v.customize ["modifyvm", :id, "--cpus", $vm_cpus]
+      if ENV['KUBERNETES_BOX_URL'] then
+        config.vm.box_url = ENV['KUBERNETES_BOX_URL']
+      end
+
+      if ENV['KUBERNETES_BOX_VERSION'] then
+        config.vm.box_version = ENV['KUBERNETES_BOX_VERSION']
+      end
+    else
+      config.vm.box = $kube_provider_boxes[provider][$kube_os][:box_name]
+
+      if $kube_provider_boxes[provider][$kube_os][:box_url] then
+        config.vm.box_url = $kube_provider_boxes[provider][$kube_os][:box_url]
+      end
+
+      if $kube_provider_boxes[provider][$kube_os][:box_version] then
+        config.vm.box_version = $kube_provider_boxes[provider][$kube_os][:box_version]
+      end
+    end
+  end
+
+  def customize_vm(config, vm_mem)
+    # Try VMWare Fusion first (see
+    # https://docs.vagrantup.com/v2/providers/basic_usage.html)
+    config.vm.provider :vmware_fusion do |v, override|
+      setvmboxandurl(override, :vmware_desktop)
+      v.vmx['memsize'] = vm_mem
+      v.vmx['numvcpus'] = $vm_cpus
+    end
+
+    # Then try VMWare Workstation
+    config.vm.provider :vmware_workstation do |v, override|
+      setvmboxandurl(override, :vmware_desktop)
+      v.vmx['memsize'] = vm_mem
+      v.vmx['numvcpus'] = $vm_cpus
+    end
+
+    # Then try Parallels
+    config.vm.provider :parallels do |v, override|
+      setvmboxandurl(override, :parallels)
+      v.memory = vm_mem # v.customize ['set', :id, '--memsize', vm_mem]
+      v.cpus = $vm_cpus # v.customize ['set', :id, '--cpus', $vm_cpus]
+
+      # Don't attempt to update the Parallels tools on the image (this can
+      # be done manually if necessary)
+      v.update_guest_tools = false # v.customize ['set', :id, '--tools-autoupdate', 'off']
+
+      # Set up Parallels folder sharing to behave like VirtualBox (i.e.,
+      # mount the current directory as /vagrant and that's it)
+      v.customize ['set', :id, '--shf-guest', 'off']
+      v.customize ['set', :id, '--shf-guest-automount', 'off']
+      v.customize ['set', :id, '--shf-host', 'on']
+
+      # Remove all auto-mounted "shared folders"; the result seems to
+      # persist between runs (i.e., vagrant halt && vagrant up)
+      override.vm.provision :shell, :inline => (%q{
+        set -ex
+        if [ -d /media/psf ]; then
+          for i in /media/psf/*; do
+            if [ -d "${i}" ]; then
+              umount "${i}" || true
+              rmdir -v "${i}"
+            fi
+          done
+          rmdir -v /media/psf
+        fi
+        exit
+      }).strip
+    end
+
+    # Finally, fall back to VirtualBox
+    config.vm.provider :virtualbox do |v, override|
+      setvmboxandurl(override, :virtualbox)
+      v.memory = vm_mem # v.customize ["modifyvm", :id, "--memory", vm_mem]
+      v.cpus = $vm_cpus # v.customize ["modifyvm", :id, "--cpus", $vm_cpus]
 
       # Use faster paravirtualized networking
       v.customize ["modifyvm", :id, "--nictype1", "virtio"]
@@ -73,7 +177,7 @@ Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
 
   # Kubernetes master
   config.vm.define "master" do |c|
-    customize_vm c
+    customize_vm c, $vm_master_mem
     if ENV['KUBE_TEMP'] then
       script = "#{ENV['KUBE_TEMP']}/master-start.sh"
       c.vm.provision "shell", run: "always", path: script
@@ -84,17 +188,20 @@ Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
 
   # Kubernetes minion
   $num_minion.times do |n|
-    config.vm.define "minion-#{n+1}" do |minion|
-      customize_vm minion
+    minion_vm_name = "minion-#{n+1}"
+    minion_prefix = ENV['INSTANCE_PREFIX'] || 'kubernetes' # must mirror default in cluster/vagrant/config-default.sh
+    minion_hostname = "#{minion_prefix}-#{minion_vm_name}"
+
+    config.vm.define minion_vm_name do |minion|
+      customize_vm minion, $vm_minion_mem
 
-      minion_index = n+1
       minion_ip = $minion_ips[n]
       if ENV['KUBE_TEMP'] then
         script = "#{ENV['KUBE_TEMP']}/minion-start-#{n}.sh"
         minion.vm.provision "shell", run: "always", path: script
       end
       minion.vm.network "private_network", ip: "#{minion_ip}"
-      minion.vm.hostname = "#{ENV['INSTANCE_PREFIX']}-minion-#{minion_index}"
+      minion.vm.hostname = minion_hostname
     end
   end
 end

cluster/vagrant/util.sh

@@ -33,13 +33,62 @@ function detect-minions {
 # Verify prereqs on host machine  Also sets exports USING_KUBE_SCRIPTS=true so
 # that our Vagrantfile doesn't error out.
 function verify-prereqs {
-  for x in vagrant VBoxManage; do
+  for x in vagrant; do
     if ! which "$x" >/dev/null; then
       echo "Can't find $x in PATH, please fix and retry."
       exit 1
     fi
   done
 
+  local vagrant_plugins=$(vagrant plugin list | sed '-es% .*$%%' '-es%  *% %g' | tr ' ' $'\n')
+  local providers=(
+      # Format is:
+      #   provider_ctl_executable vagrant_provider_name vagrant_provider_plugin_re
+      # either provider_ctl_executable or vagrant_provider_plugin_re can
+      # be blank (i.e., '') if none is needed by Vagrant (see, e.g.,
+      # virtualbox entry)
+      vmrun vmware_fusion vagrant-vmware-fusion
+      vmrun vmware_workstation vagrant-vmware-workstation
+      prlctl parallels vagrant-parallels
+      VBoxManage virtualbox ''
+  )
+  local provider_found=''
+  local provider_bin
+  local provider_name
+  local provider_plugin_re
+
+  while [ "${#providers[@]}" -gt 0 ]; do
+    provider_bin=${providers[0]}
+    provider_name=${providers[1]}
+    provider_plugin_re=${providers[2]}
+    providers=("${providers[@]:3}")
+
+    # If the provider is explicitly set, look only for that provider
+    if [ -n "${VAGRANT_DEFAULT_PROVIDER:-}" ] \
+        && [ "${VAGRANT_DEFAULT_PROVIDER}" != "${provider_name}" ]; then
+      continue
+    fi
+
+    if ([ -z "${provider_bin}" ] \
+          || which "${provider_bin}" >/dev/null 2>&1) \
+        && ([ -z "${provider_plugin_re}" ] \
+          || [ -n "$(echo "${vagrant_plugins}" | grep -E "^${provider_plugin_re}$")" ]); then
+      provider_found="${provider_name}"
+      # Stop after finding the first viable provider
+      break
+    fi
+  done
+
+  if [ -z "${provider_found}" ]; then
+    if [ -n "${VAGRANT_DEFAULT_PROVIDER}" ]; then
+      echo "Can't find the necessary components for the ${VAGRANT_DEFAULT_PROVIDER} vagrant provider, please fix and retry."
+    else
+      echo "Can't find the necessary components for any viable vagrant providers (e.g., virtualbox), please fix and retry."
+    fi
+
+    exit 1
+  fi
+
   # Set VAGRANT_CWD to KUBE_ROOT so that we find the right Vagrantfile no
   # matter what directory the tools are called from.
   export VAGRANT_CWD="${KUBE_ROOT}"
@@ -89,6 +138,7 @@ function create-provision-scripts {
     echo "DNS_REPLICAS='${DNS_REPLICAS:-}'"
     echo "RUNTIME_CONFIG='${RUNTIME_CONFIG:-}'"
     echo "ADMISSION_CONTROL='${ADMISSION_CONTROL:-}'"
+    echo "VAGRANT_DEFAULT_PROVIDER='${VAGRANT_DEFAULT_PROVIDER:-}'"
     grep -v "^#" "${KUBE_ROOT}/cluster/vagrant/provision-master.sh"
     grep -v "^#" "${KUBE_ROOT}/cluster/vagrant/provision-network.sh"
   ) > "${KUBE_TEMP}/master-start.sh"
@@ -109,6 +159,7 @@ function create-provision-scripts {
       echo "MINION_CONTAINER_SUBNETS=(${MINION_CONTAINER_SUBNETS[@]})"
       echo "CONTAINER_SUBNET='${CONTAINER_SUBNET}'"
       echo "DOCKER_OPTS='${EXTRA_DOCKER_OPTS-}'"
+      echo "VAGRANT_DEFAULT_PROVIDER='${VAGRANT_DEFAULT_PROVIDER:-}'"
       grep -v "^#" "${KUBE_ROOT}/cluster/vagrant/provision-minion.sh"
       grep -v "^#" "${KUBE_ROOT}/cluster/vagrant/provision-network.sh"
     ) > "${KUBE_TEMP}/minion-start-${i}.sh"
@@ -116,6 +167,9 @@ function create-provision-scripts {
 }
 
 function verify-cluster {
+  # TODO: How does the user know the difference between "tak[ing] some
+  # time" and "loop[ing] forever"? Can we give more specific feedback on
+  # whether "an error" has occurred?
   echo "Each machine instance has been created/updated."
   echo "  Now waiting for the Salt provisioning process to complete on each machine."
   echo "  This can take some time based on your network, disk, and cpu speed."