vagrant-skytap 0.1.11 → 0.2.0

data/_patches-20160113/eng-10166-halt-spec

@@ -0,0 +1,40 @@
+# HG changeset patch
+# Parent 55c178c0f5096eedd87b19b31f647a9f3b37bec9
+diff -r 55c178c0f509 -r 1d887cdba67b spec/acceptance/provider/halt_spec.rb
+--- a/spec/acceptance/provider/halt_spec.rb	Mon Oct 12 11:22:04 2015 -0700
++++ b/spec/acceptance/provider/halt_spec.rb	Mon Oct 12 11:22:13 2015 -0700
+@@ -1,3 +1,34 @@
++# This tests that an instance can be halted correctly
+ shared_examples 'provider/halt' do |provider, options|
++  if !options[:box]
++    raise ArgumentError,
++          "box option must be specified for provider: #{provider}"
++  end
+ 
++  include_context 'acceptance'
++
++  before do
++    environment.skeleton('generic')
++    assert_execute('vagrant', 'box', 'add', 'basic', options[:box])
++    assert_execute('vagrant', 'up', "--provider=#{provider}")
++  end
++
++  after do
++    assert_execute('vagrant', 'destroy', '--force')
++  end
++
++  it 'should halt the machine and bring it back up' do
++    status("Test: machine can be halted")
++    halt_result = execute("vagrant", "halt")
++    expect(halt_result).to exit_with(0)
++
++    status("Test: machine can be brought up after halt")
++    up_result = execute("vagrant", "up")
++    expect(up_result).to exit_with(0)
++
++    status("Test: machine is running after up")
++    echo_result = execute("vagrant", "ssh", "-c", "echo foo")
++    expect(echo_result).to exit_with(0)
++    expect(echo_result.stdout).to match(/foo\n$/)
++  end
+ end

data/_patches-20160113/eng-10256

@@ -0,0 +1,543 @@
+# HG changeset patch
+# Parent c16d73c17f55bd5e4df485673953831cf65101cd
+# Parent  c16d73c17f55bd5e4df485673953831cf65101cd
+ENG-10256 port forwarding
+
+diff -r c16d73c17f55 Vagrantfile
+--- a/Vagrantfile	Wed Jan 13 12:22:11 2016 -0800
++++ b/Vagrantfile	Wed Jan 13 12:24:25 2016 -0800
+@@ -125,7 +125,7 @@
+     box.vm.provision "shell", path: "provisioning/apache.sh"
+     box.vm.provision "shell", path: "provisioning/vagrant.sh"
+ 
+-    #box.vm.network :forwarded_port, guest: 80, host: 9000
++    box.vm.network :forwarded_port, guest: 80, host: 9000
+     #box.vm.network :forwarded_port, guest: 21, host: 9001
+   end
+ 
+diff -r c16d73c17f55 lib/vagrant-skytap/action.rb
+--- a/lib/vagrant-skytap/action.rb	Wed Jan 13 12:22:11 2016 -0800
++++ b/lib/vagrant-skytap/action.rb	Wed Jan 13 12:24:25 2016 -0800
+@@ -15,6 +15,7 @@
+             when :missing_environment, :missing_vm, :no_vms
+               b1.use MessageNotCreated
+             else
++              b1.use ClearForwardedPorts
+               b1.use StopVm
+             end
+           end
+@@ -30,6 +31,7 @@
+             when :missing_environment, :missing_vm, :no_vms
+               b1.use MessageNotCreated
+             else
++              b1.use ClearForwardedPorts
+               b1.use SuspendVm
+             end
+           end
+@@ -65,6 +67,7 @@
+               end
+             end
+           end
++          b.use ClearForwardedPorts
+           b.use PrepareNFSValidIds
+           b.use SyncedFolderCleanup
+         end
+@@ -251,6 +254,7 @@
+             end
+           end
+           b.use WaitForCommunicator
++          b.use action_forward_ports
+         end
+       end
+ 
+@@ -281,15 +285,28 @@
+         end
+       end
+ 
++      def self.action_forward_ports
++        Vagrant::Action::Builder.new.tap do |b|
++          b.use ClearForwardedPorts
++          b.use ReadSSHInfo
++          b.use EnvSet, port_collision_repair: true
++          b.use PrepareForwardedPortCollisionParams
++          b.use HandleForwardedPortCollisions
++          b.use ForwardPorts
++        end
++      end
++
+       # The autoload farm
+       action_root = Pathname.new(File.expand_path("../action", __FILE__))
+       autoload :StoreExtraData, action_root.join("store_extra_data")
+       autoload :AddVmToEnvironment, action_root.join("add_vm_to_environment")
++      autoload :ClearForwardedPorts, action_root.join("clear_forwarded_ports")
+       autoload :CreateEnvironment, action_root.join("create_environment")
+       autoload :DeleteEnvironment, action_root.join("delete_environment")
+       autoload :DeleteVm, action_root.join("delete_vm")
+       autoload :ExistenceCheck, action_root.join("existence_check")
+       autoload :FetchEnvironment, action_root.join("fetch_environment")
++      autoload :ForwardPorts, action_root.join("forward_ports")
+       autoload :InitializeAPIClient, action_root.join("initialize_api_client")
+       autoload :InitialState, action_root.join("initial_state")
+       autoload :IsParallelized, action_root.join("is_parallelized")
+@@ -302,6 +319,7 @@
+       autoload :MessageEnvironmentUrl, action_root.join("message_environment_url")
+       autoload :MessageResuming, action_root.join("message_resuming")
+       autoload :MessageWillNotDestroy, action_root.join("message_will_not_destroy")
++      autoload :PrepareForwardedPortCollisionParams, action_root.join("prepare_forwarded_port_collision_params")
+       autoload :PrepareNFSSettings, action_root.join("prepare_nfs_settings")
+       autoload :PrepareNFSValidIds, action_root.join("prepare_nfs_valid_ids")
+       autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+diff -r c16d73c17f55 lib/vagrant-skytap/action/clear_forwarded_ports.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/action/clear_forwarded_ports.rb	Wed Jan 13 12:24:25 2016 -0800
+@@ -0,0 +1,18 @@
++module VagrantPlugins
++  module Skytap
++    module Action
++      class ClearForwardedPorts
++        def initialize(app, env)
++          @app = app
++        end
++
++        def call(env)
++          env[:ui].info I18n.t("vagrant.actions.vm.clear_forward_ports.deleting")
++          env[:host].capability(:kill_forwarded_ports, env)
++
++          @app.call(env)
++        end
++      end
++    end
++  end
++end
+diff -r c16d73c17f55 lib/vagrant-skytap/action/forward_ports.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/action/forward_ports.rb	Wed Jan 13 12:24:25 2016 -0800
+@@ -0,0 +1,50 @@
++require 'vagrant-skytap/util/compile_forwarded_ports'
++
++module VagrantPlugins
++  module Skytap
++    module Action
++      class ForwardPorts
++        include Util::CompileForwardedPorts
++
++        def initialize(app, env)
++          @app = app
++        end
++
++        #--------------------------------------------------------------
++        # Execution
++        #--------------------------------------------------------------
++        def call(env)
++          @env = env
++
++          # Get the ports we're forwarding
++          env[:forwarded_ports] ||= compile_forwarded_ports(env[:machine].config)
++
++          # Warn if we're port forwarding to any privileged ports...
++          env[:forwarded_ports].each do |fp|
++            if fp.host_port <= 1024
++              env[:ui].warn I18n.t("vagrant.actions.vm.forward_ports.privileged_ports")
++              break
++            end
++          end
++
++          env[:ui].output(I18n.t("vagrant.actions.vm.forward_ports.forwarding"))
++          forward_ports
++
++          @app.call(env)
++        end
++
++        def forward_ports
++          @env[:forwarded_ports].each do |fp|
++            unless fp.guest_port == 22 && fp.host_port == 2222
++              @env[:ui].detail(I18n.t("vagrant.actions.vm.forward_ports.forwarding_entry",
++                                        adapter: fp.adapter,
++                                        guest_port: fp.guest_port,
++                                        host_port: fp.host_port))
++              @env[:host].capability(:start_ssh_tunnel, fp, @env)
++            end
++          end
++        end
++      end
++    end
++  end
++end
+diff -r c16d73c17f55 lib/vagrant-skytap/action/prepare_forwarded_port_collision_params.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/action/prepare_forwarded_port_collision_params.rb	Wed Jan 13 12:24:25 2016 -0800
+@@ -0,0 +1,35 @@
++module VagrantPlugins
++  module Skytap
++    module Action
++      class PrepareForwardedPortCollisionParams
++        def initialize(app, env)
++          @app = app
++        end
++
++        def call(env)
++          # Get the forwarded ports used by other virtual machines and
++          # consider those in use as well.
++          env[:port_collision_extra_in_use] = env[:host].capability(:read_used_ports, env)
++
++          # Build the remap for any existing collision detections
++          remap = {}
++          env[:port_collision_remap] = remap
++          env[:host].capability(:read_forwarded_ports, env).each do |name, hostport|
++            env[:machine].config.vm.networks.each do |type, options|
++              next if type != :forwarded_port
++
++              # If the ID matches the name of the forwarded port, then
++              # remap.
++              if options[:id] == name
++                remap[options[:host]] = hostport
++                break
++              end
++            end
++          end
++
++          @app.call(env)
++        end
++      end
++    end
++  end
++end
+diff -r c16d73c17f55 lib/vagrant-skytap/hosts/bsd/cap/ssh_tunnel.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/hosts/bsd/cap/ssh_tunnel.rb	Wed Jan 13 12:24:25 2016 -0800
+@@ -0,0 +1,15 @@
++require "vagrant-skytap/hosts/common/cap/ssh_tunnel"
++
++module VagrantPlugins
++  module Skytap
++    module HostBSD
++      module Cap
++        class SSHTunnel < VagrantPlugins::Skytap::HostCommon::Cap::SSHTunnel
++          def self.create_logger
++            Log4r::Logger.new("vagrant::hosts::bsd")
++          end
++        end
++      end
++    end
++  end
++end
+diff -r c16d73c17f55 lib/vagrant-skytap/hosts/common/cap/ssh_tunnel.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/hosts/common/cap/ssh_tunnel.rb	Wed Jan 13 12:24:25 2016 -0800
+@@ -0,0 +1,133 @@
++require "pathname"
++require "tmpdir"
++require 'childprocess'
++require "vagrant/util/subprocess"
++require 'log4r'
++require "vagrant/util/safe_chdir"
++
++module VagrantPlugins
++  module Skytap
++    module HostCommon
++      module Cap
++        class SSHTunnel
++          class << self
++            def create_logger
++              Log4r::Logger.new("vagrant::hosts::common")
++            end
++
++            # called per port by ForwardPorts
++            def start_ssh_tunnel(env, fp, env_hash)
++              logger = create_logger
++              machine = env_hash[:machine]
++              pidfile = pidfile_name(fp)
++              pid = read_pid(File.join(machine.data_dir, pidfile))
++              if pid && autossh_pid?(pid)
++                logger.info("An autossh process already exists with pid #{pid}.")
++              else
++                args = autossh_args(fp, pidfile, env_hash)
++                Vagrant::Util::Subprocess.execute("autossh", *args)
++              end
++            end
++
++            # called for machine by ClearForwardedPorts
++            def kill_forwarded_ports(env, env_hash)
++              get_pidfiles_for_machine(env_hash[:machine]).each do |pidfile|
++                kill_ssh_tunnel(env, pidfile, env_hash)
++              end
++            end
++
++            # exposed but not called currently from any action
++            def kill_ssh_tunnel(env, pidfile, env_hash)
++              logger = create_logger
++              machine = env_hash[:machine]
++              pid = read_pid(File.join(machine.data_dir, pidfile))
++              if pid && autossh_pid?(pid)
++                Vagrant::Util::Subprocess.execute("kill", pid.to_s)
++              else
++                logger.info("Cleaning up stale autossh pidfile #{pidfile}.")
++                Vagrant::Util::Subprocess.execute("rm", pidfile)
++              end
++            end
++
++            ####################################
++
++            def pidfile_name(fp)
++              "#{fp.protocol}#{fp.host_port}.pid"
++            end
++
++            def read_pid(pidfile_path)
++              File.read(pidfile_path).presence.try(:to_i) if File.exist?(pidfile_path)
++            end
++
++            def get_pidfiles_for_machine(machine)
++              pidfiles = []
++              Vagrant::Util::SafeChdir.safe_chdir(machine.data_dir) do
++                pidfiles = Dir.glob("*.pid")
++              end
++              pidfiles
++            end
++
++            ####################################
++
++            # Checks that the pid is actually an autossh process (and not
++            # something else using a recycled pid).
++            def autossh_pid?(pid)
++              # get_comm_for_pid(pid) == 'autossh'
++              true
++            end
++
++            # Get the command, minus any arguments, for the given
++            # pid. This probably needs to be overridden per host cap
++            def get_comm_for_pid(pid)
++              result = Vagrant::Util::Subprocess.execute("ps", "-p", pid.to_s, "-o", "comm")
++              result.stdout.split("\n").last
++            end
++
++            ####################################
++
++            def autossh_args(fp, pidfile, env_hash)
++              machine = env_hash[:machine]
++              ssh_info = env_hash[:machine_ssh_info]
++              ssh_options = {
++                "ServerAliveInterval" => 10,
++                "ServerAliveCountMax" => 3,
++                "StrictHostKeyChecking" => "no",
++              }
++              environment_variables = {
++                env: {
++                  "AUTOSSH_PIDFILE" => File.join(machine.data_dir, pidfile),
++                  "AUTOSSH_PORT" => 0, # turn off monitoring
++                  "AUTOSSH_LOGFILE" => "/tmp/autossh.log",
++                }
++              }
++
++              autossh_args = []
++              autossh_args << "-q"
++              autossh_args << "-N"
++              autossh_args << "-f"
++              autossh_args << "-i" << machine.data_dir.join("private_key").to_s
++              autossh_args << "-L" << "#{fp.host_port}:localhost:#{fp.guest_port}"
++              ssh_options.each do |k, v|
++                autossh_args << "-o" << "#{k}=#{v}"
++              end
++              autossh_args << "#{ssh_info[:username]}@#{ssh_info[:host]}"
++              autossh_args << environment_variables
++            end
++
++            def read_used_ports(*args)
++              []
++            end
++
++            def read_forwarded_ports(env, env_hash, machine = nil)
++              logger = create_logger
++              machine ||= env_hash[:machine]
++              get_pidfiles_for_machine(machine).collect do |pidfile|
++                read_pid(File.join(machine.data_dir, pidfile))
++              end
++            end
++          end
++        end
++      end
++    end
++  end
++end
+diff -r c16d73c17f55 lib/vagrant-skytap/hosts/linux/cap/ssh_tunnel.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/hosts/linux/cap/ssh_tunnel.rb	Wed Jan 13 12:24:25 2016 -0800
+@@ -0,0 +1,15 @@
++require "vagrant-skytap/hosts/common/cap/ssh_tunnel"
++
++module VagrantPlugins
++  module Skytap
++    module HostLinux
++      module Cap
++        class SSHTunnel < VagrantPlugins::Skytap::HostCommon::Cap::SSHTunnel
++          def self.create_logger
++            Log4r::Logger.new("vagrant::hosts::linux")
++          end
++        end
++      end
++    end
++  end
++end
+diff -r c16d73c17f55 lib/vagrant-skytap/hosts/windows/cap/ssh_tunnel.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/hosts/windows/cap/ssh_tunnel.rb	Wed Jan 13 12:24:25 2016 -0800
+@@ -0,0 +1,23 @@
++require "vagrant-skytap/hosts/common/cap/ssh_tunnel"
++
++module VagrantPlugins
++  module Skytap
++    module HostWindows
++      module Cap
++        class SSHTunnel < VagrantPlugins::Skytap::HostCommon::Cap::SSHTunnel
++          def self.create_logger
++            Log4r::Logger.new("vagrant::hosts::windows")
++          end
++
++          def self.start_ssh_tunnel(env, fp, env_hash)
++            env[:ui].info I18n.t("Port forwarding is currently not supported on Windows. Skipping...")
++          end
++
++          def self.kill_ssh_tunnel(env, pidfile, env_hash)
++            env[:ui].info I18n.t("Port forwarding is currently not supported on Windows. Skipping...")
++          end
++        end
++      end
++    end
++  end
++end
+diff -r c16d73c17f55 lib/vagrant-skytap/model/forwarded_port.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/model/forwarded_port.rb	Wed Jan 13 12:24:25 2016 -0800
+@@ -0,0 +1,70 @@
++module VagrantPlugins
++  module Skytap
++    module Model
++      # Represents a single forwarded port for VirtualBox. This has various
++      # helpers and defaults for a forwarded port.
++      class ForwardedPort
++        # The NAT adapter on which to attach the forwarded port.
++        #
++        # @return [Integer]
++        attr_reader :adapter
++
++        # If true, this port should be auto-corrected.
++        #
++        # @return [Boolean]
++        attr_reader :auto_correct
++
++        # The unique ID for the forwarded port.
++        #
++        # @return [String]
++        attr_reader :id
++
++        # The protocol to forward.
++        #
++        # @return [String]
++        attr_reader :protocol
++
++        # The IP that the forwarded port will connect to on the guest machine.
++        #
++        # @return [String]
++        attr_reader :guest_ip
++
++        # The port on the guest to be exposed on the host.
++        #
++        # @return [Integer]
++        attr_reader :guest_port
++
++        # The IP that the forwarded port will bind to on the host machine.
++        #
++        # @return [String]
++        attr_reader :host_ip
++
++        # The port on the host used to access the port on the guest.
++        #
++        # @return [Integer]
++        attr_reader :host_port
++
++        def initialize(id, host_port, guest_port, options)
++          @id         = id
++          @guest_port = guest_port
++          @host_port  = host_port
++
++          options ||= {}
++          @auto_correct = false
++          @auto_correct = options[:auto_correct] if options.key?(:auto_correct)
++          @adapter  = (options[:adapter] || 1).to_i
++          @guest_ip = options[:guest_ip] || nil
++          @host_ip = options[:host_ip] || nil
++          @protocol = options[:protocol] || "tcp"
++        end
++
++        # This corrects the host port and changes it to the given new port.
++        #
++        # @param [Integer] new_port The new port
++        def correct_host_port(new_port)
++          @host_port = new_port
++        end
++      end
++    end
++  end
++end
+diff -r c16d73c17f55 lib/vagrant-skytap/plugin.rb
+--- a/lib/vagrant-skytap/plugin.rb	Wed Jan 13 12:22:11 2016 -0800
++++ b/lib/vagrant-skytap/plugin.rb	Wed Jan 13 12:24:25 2016 -0800
+@@ -49,6 +49,21 @@
+         Cap::PublicAddress
+       end
+ 
++      %w[start_ssh_tunnel kill_ssh_tunnel kill_forwarded_ports read_used_ports read_forwarded_ports].each do |cap|
++        host_capability("bsd", cap) do
++          require_relative "hosts/bsd/cap/ssh_tunnel"
++          HostBSD::Cap::SSHTunnel
++        end
++        host_capability("linux", cap) do
++          require_relative "hosts/linux/cap/ssh_tunnel"
++          HostLinux::Cap::SSHTunnel
++        end
++        host_capability("windows", cap) do
++          require_relative "hosts/windows/cap/ssh_tunnel"
++          HostWindows::Cap::SSHTunnel
++        end
++      end
++
+       # This initializes the internationalization strings.
+       def self.setup_i18n
+         I18n.load_path << File.expand_path("locales/en.yml", Skytap.source_root)
+diff -r c16d73c17f55 lib/vagrant-skytap/util/compile_forwarded_ports.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/util/compile_forwarded_ports.rb	Wed Jan 13 12:24:25 2016 -0800
+@@ -0,0 +1,34 @@
++require "vagrant/util/scoped_hash_override"
++require 'vagrant-skytap/model/forwarded_port'
++module VagrantPlugins
++  module Skytap
++    module Util
++      module CompileForwardedPorts
++        include Vagrant::Util::ScopedHashOverride
++
++        # This method compiles the forwarded ports into {ForwardedPort}
++        # models.
++        def compile_forwarded_ports(config)
++          mappings = {}
++
++          config.vm.networks.each do |type, options|
++            if type == :forwarded_port
++              guest_port = options[:guest]
++              host_port  = options[:host]
++              protocol   = options[:protocol] || "tcp"
++              options    = scoped_hash_override(options, :skytap)
++              id         = options[:id]
++
++              # If the forwarded port was marked as disabled, ignore.
++              next if options[:disabled]
++              mappings[host_port.to_s + protocol.to_s] =
++                Model::ForwardedPort.new(id, host_port, guest_port, options)
++            end
++          end
++
++          mappings.values
++        end
++      end
++    end
++  end
++end

data/_patches-20160113/eng-10256-ubuntu-testing

@@ -0,0 +1,88 @@
+# HG changeset patch
+# Parent 9b3dc8dd5d19d0effc35672a8e3bbeb50ef381a8
+DO NOT COMMIT. Vagrantfile for testing on Ubuntu VM.
+
+diff -r 9b3dc8dd5d19 eng-10256/Vagrantfile
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/eng-10256/Vagrantfile	Wed Jan 06 15:54:52 2016 -0800
+@@ -0,0 +1,44 @@
++# Vagrantfile for creating an Ubuntu "master" VM with Vagrant installed
++
++SKYTAP_PROVIDER_GEM_PATH = "../vagrant-skytap-0.1.13.pre1.gem"
++
++$script_install_packages = <<SCRIPT
++  sudo apt-get update
++  sudo apt-get install -y autossh lynx-cur
++SCRIPT
++
++$script_vagrant = <<SCRIPT
++  which vagrant
++  if [ $? -ne 0 ]; then
++    wget https://releases.hashicorp.com/vagrant/1.8.0/vagrant_1.8.0_x86_64.deb -q0
++    dpkg -i vagrant_1.8.0_x86_64.deb
++  fi
++SCRIPT
++
++Vagrant.configure(2) do |config|
++  config.vm.box = "skytap/empty"
++  config.vm.synced_folder ".", "/vagrant", disabled: true
++
++  config.vm.provider :skytap do |skytap, override|
++    skytap.username  = "username"
++    skytap.api_token = "00BADBEE"
++    skytap.vpn_url   = "/vpns/vpn-711360"
++  end
++
++  config.vm.define "vm1" do |box|
++    box.vm.provider :skytap do |box|
++      box.vm_url = "/vms/6869434"
++    end
++
++    box.ssh.username = "skytap"
++    box.ssh.password = "ChangeMe!"
++
++    box.vm.provision "shell", inline: "touch this_is_master"
++    box.vm.provision "shell", inline: $script_install_packages
++    box.vm.provision "shell", inline: $script_vagrant
++    box.vm.provision "file",  source: "vagrantfile_master", destination: "project/Vagrantfile"
++
++    box.vm.provision "file",  source: SKYTAP_PROVIDER_GEM_PATH, destination: "vagrant-skytap.gem"
++    box.vm.provision "shell", inline: "vagrant plugin install vagrant-skytap.gem", privileged: false
++  end
++end
+diff -r 9b3dc8dd5d19 eng-10256/vagrantfile_master
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/eng-10256/vagrantfile_master	Wed Jan 06 15:54:52 2016 -0800
+@@ -0,0 +1,32 @@
++# Vagrantfile for creating Ubuntu "slave" VM
++# This should be run on the "master" VM
++
++$script_install_packages = <<SCRIPT
++  sudo apt-get update
++  sudo apt-get install -y apache2 lynx-cur
++SCRIPT
++
++Vagrant.configure(2) do |config|
++  config.vm.box = "skytap/empty"
++  config.vm.synced_folder ".", "/vagrant", disabled: true
++
++  config.vm.provider :skytap do |skytap, override|
++    skytap.username  = "username"
++    skytap.api_token = "00BADBEE"
++    skytap.vpn_url   = "/vpns/vpn-711360"
++  end
++
++  config.vm.define "vm1" do |box|
++    box.vm.provider :skytap do |box|
++      box.vm_url = "/vms/6869434"
++    end
++    box.ssh.username    = "skytap"
++    box.ssh.password    = "ChangeMe!"
++
++    box.vm.provision "shell", inline: "touch this_is_slave"
++    box.vm.provision "shell", inline: $script_install_packages
++
++    box.vm.network :forwarded_port, guest: 80, host: 8080
++  end
++end
++