vagrant-skytap 0.1.11 → 0.2.0

data/_patches-20160112a/then-copy-the-newer-files

@@ -0,0 +1,632 @@
+# HG changeset patch
+# Parent 444a060a037d79990b65d796632a91bbed6f6918
+# Parent  444a060a037d79990b65d796632a91bbed6f6918
+ENG-10256 port forwarding
+
+diff -r 444a060a037d lib/vagrant-skytap/action.rb
+--- a/lib/vagrant-skytap/action.rb	Tue Jan 12 22:30:01 2016 -0800
++++ b/lib/vagrant-skytap/action.rb	Tue Jan 12 22:44:41 2016 -0800
+@@ -290,9 +290,9 @@
+           b.use ClearForwardedPorts
+           b.use ReadSSHInfo
+           b.use Message, "forwarding ports"
+-          #b.use EnvSet, port_collision_repair: true # does it just work?
+-          #b.use PrepareForwardedPortCollisionParams
+-          #b.use HandleForwardedPortCollisions
++          b.use EnvSet, port_collision_repair: true # does it just work?
++          b.use PrepareForwardedPortCollisionParams
++          b.use HandleForwardedPortCollisions
+           b.use ForwardPorts
+         end
+       end
+diff -r 444a060a037d lib/vagrant-skytap/action/clear_forwarded_ports.rb
+--- a/lib/vagrant-skytap/action/clear_forwarded_ports.rb	Tue Jan 12 22:30:01 2016 -0800
++++ b/lib/vagrant-skytap/action/clear_forwarded_ports.rb	Tue Jan 12 22:44:41 2016 -0800
+@@ -12,27 +12,11 @@
+         end
+ 
+         def call(env)
+-          if pidfiles = read_pidfiles.presence
+-            env[:ui].info I18n.t("vagrant.actions.vm.clear_forward_ports.deleting")
+-            kill_tunnels(pidfiles)
+-          end
++          env[:ui].info I18n.t("vagrant.actions.vm.clear_forward_ports.deleting")
++          pidfiles = @env[:host].capability(:kill_forwarded_ports, @env)
+ 
+           @app.call(env)
+         end
+-
+-        def read_pidfiles
+-          pidfiles = []
+-          Vagrant::Util::SafeChdir.safe_chdir(@env[:machine].data_dir) do
+-            pidfiles = Dir.glob("*.pid")
+-          end
+-          pidfiles
+-        end
+-
+-        def kill_tunnels(pidfiles)
+-          pidfiles.each do |pidfile|
+-            @env[:host].capability(:kill_ssh_tunnel, pidfile, @env)
+-          end
+-        end
+       end
+     end
+   end
+diff -r 444a060a037d lib/vagrant-skytap/action/prepare_forwarded_port_collision_params.rb
+--- a/lib/vagrant-skytap/action/prepare_forwarded_port_collision_params.rb	Tue Jan 12 22:30:01 2016 -0800
++++ b/lib/vagrant-skytap/action/prepare_forwarded_port_collision_params.rb	Tue Jan 12 22:44:41 2016 -0800
+@@ -9,12 +9,12 @@
+         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] = read_used_ports
++          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
+-          read_forwarded_ports.each do |_nic, name, hostport, _guestport|
++          env[:host].capability(:read_forwarded_ports, env).each do |_nic, name, hostport, _guestport|
+             env[:machine].config.vm.networks.each do |type, options|
+               next if type != :forwarded_port
+ 
+@@ -29,16 +29,6 @@
+ 
+           @app.call(env)
+         end
+-
+-        def read_used_ports
+-          #env[:machine].provider.driver.read_used_ports
+-          []
+-        end
+-
+-        def read_forwarded_ports
+-          #env[:machine].provider.driver.read_forwarded_ports
+-          []
+-        end
+       end
+     end
+   end
+diff -r 444a060a037d lib/vagrant-skytap/hosts/bsd/cap/ssh_tunnel.rb
+--- a/lib/vagrant-skytap/hosts/bsd/cap/ssh_tunnel.rb	Tue Jan 12 22:30:01 2016 -0800
++++ b/lib/vagrant-skytap/hosts/bsd/cap/ssh_tunnel.rb	Tue Jan 12 22:44:41 2016 -0800
+@@ -1,109 +1,12 @@
+-require "pathname"
+-require "tmpdir"
+-require 'childprocess'
+-require "vagrant/util/subprocess"
+-#require 'byebug'
+-#require 'ap'
+-require 'log4r'
+-require "vagrant/util/safe_chdir"
++require "vagrant-skytap/hosts/common/cap/ssh_tunnel"
+ 
+ module VagrantPlugins
+   module Skytap
+     module HostBSD
+       module Cap
+-        class SSHTunnel
+-          def self.start_ssh_tunnel(env, fp, env_hash)
+-            logger = Log4r::Logger.new("vagrant::hosts::bsd")
+-            port = {
+-              adapter:   fp.adapter,
+-              guestip:   fp.guest_ip,
+-              guestport: fp.guest_port,
+-              hostip:    fp.host_ip,
+-              hostport:  fp.host_port,
+-              name:      fp.id,
+-              protocol:  fp.protocol
+-            }
+-
+-            pidfile = pidfile_name(port, env_hash)
+-            pid = read_pid(pidfile)
+-            if pid && autossh_pid?(pid)
+-              logger.info("An autossh process already exists with pid #{pid}.")
+-            else
+-              args = autossh_args(port, pidfile, env_hash)
+-              Vagrant::Util::Subprocess.execute("autossh", *args)
+-            end
+-          end
+-
+-          def self.kill_ssh_tunnel(env, pidfile, env_hash)
+-            logger = Log4r::Logger.new("vagrant::hosts::bsd")
+-            pidfile = File.join(env_hash[:machine].data_dir, pidfile)
+-            pid = read_pid(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
+-
+-          private
+-
+-          def self.pidfile_name(port, env_hash)
+-            tunnel_name = [port[:hostip], port[:name]].compact.join('_')
+-            File.join(env_hash[:machine].data_dir, "#{tunnel_name}.pid")
+-          end
+-
+-          def self.read_pid(pidfile)
+-            File.read(pidfile).presence.try(:to_i) if File.exist?(pidfile)
+-          end
+-
+-          # Checks that the pid is actually an autossh process (and not
+-          # something else using a recycled pid).
+-          def self.autossh_pid?(pid)
+-            # get_comm_for_pid(pid) == 'autossh'
+-            true
+-          end
+-
+-          # Get the command, minus any arguments, for the given
+-          # pid. I don't expect this to be compatible cross-platform yet...
+-          # This could be complicated cross-platform, and Sys::ProcTable
+-          # could likewise be complicated cross-platform ...
+-          def self.get_comm_for_pid(pid)
+-            result = Vagrant::Util::Subprocess.execute("ps", "-p", pid.to_s, "-o", "comm")
+-            result.stdout.split("\n").last
+-          end
+-
+-          def self.autossh_args(port, pidfile, env_hash)
+-            ssh_info = env_hash[:machine_ssh_info]
+-            ssh_options = {
+-              "ServerAliveInterval" => 10,
+-              "ServerAliveCountMax" => 3,
+-              "StrictHostKeyChecking" => "no",
+-            }
+-            environment_variables = {
+-              env: {
+-                "AUTOSSH_PIDFILE" => pidfile,
+-                "AUTOSSH_PORT" => 0, # turns off monitoring
+-                "AUTOSSH_LOGFILE" => "/tmp/autossh.log",
+-              }
+-            }
+-            forward_string = [
+-              port[:hostport],
+-              "localhost",
+-              port[:guestport]
+-            ].join(':')
+-
+-            autossh_args = []
+-            autossh_args << "-q"
+-            autossh_args << "-N"
+-            autossh_args << "-f"
+-            autossh_args << "-i" << env_hash[:machine].data_dir.join("private_key").to_s
+-            autossh_args << "-L" << forward_string
+-            ssh_options.each do |k, v|
+-              autossh_args << "-o" << "#{k}=#{v}"
+-            end
+-            autossh_args << "#{ssh_info[:username]}@#{ssh_info[:host]}"
+-            autossh_args << environment_variables
++        class SSHTunnel < VagrantPlugins::Skytap::HostCommon::Cap::SSHTunnel
++          def self.create_logger
++            Log4r::Logger.new("vagrant::hosts::bsd")
+           end
+         end
+       end
+diff -r 444a060a037d 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	Tue Jan 12 22:44:41 2016 -0800
+@@ -0,0 +1,119 @@
++require "pathname"
++require "tmpdir"
++require 'childprocess'
++require "vagrant/util/subprocess"
++require 'byebug'
++require 'awesome_print'
++require 'log4r'
++require "vagrant/util/safe_chdir"
++
++module VagrantPlugins
++  module Skytap
++    module HostCommon
++      module Cap
++        class SSHTunnel
++          def self.create_logger
++            Log4r::Logger.new("vagrant::hosts::common")
++          end
++
++          # called per port by ForwardPorts
++          def self.start_ssh_tunnel(env, fp, env_hash)
++            logger = create_logger
++            machine = env_hash[:machine]
++            pid = read_pid(File.join(machine.data_dir, pidfile_name(fp)))
++            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 self.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 self.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 self.pidfile_name(fp)
++            "#{fp[:host_ip]}.pid"
++          end
++
++          def self.read_pid(pidfile_path)
++            File.read(pidfile_path).presence.try(:to_i) if File.exist?(pidfile_path)
++          end
++
++          def self.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 self.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 self.get_comm_for_pid(pid)
++            result = Vagrant::Util::Subprocess.execute("ps", "-p", pid.to_s, "-o", "comm")
++            result.stdout.split("\n").last
++          end
++
++          ####################################
++
++          def self.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" => pidfile,
++                "AUTOSSH_PORT" => 0, # turn off monitoring
++              }
++            }
++
++            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
++        end
++      end
++    end
++  end
++end
+diff -r 444a060a037d lib/vagrant-skytap/hosts/linux/cap/ssh_tunnel.rb
+--- a/lib/vagrant-skytap/hosts/linux/cap/ssh_tunnel.rb	Tue Jan 12 22:30:01 2016 -0800
++++ b/lib/vagrant-skytap/hosts/linux/cap/ssh_tunnel.rb	Tue Jan 12 22:44:41 2016 -0800
+@@ -1,109 +1,12 @@
+-require "pathname"
+-require "tmpdir"
+-require 'childprocess'
+-require "vagrant/util/subprocess"
+-#require 'byebug'
+-#require 'ap'
+-require 'log4r'
+-require "vagrant/util/safe_chdir"
++require "vagrant-skytap/hosts/common/cap/ssh_tunnel"
+ 
+ module VagrantPlugins
+   module Skytap
+     module HostLinux
+       module Cap
+-        class SSHTunnel
+-          def self.start_ssh_tunnel(env, fp, env_hash)
+-            logger = Log4r::Logger.new("vagrant::hosts::bsd")
+-            port = {
+-              adapter:   fp.adapter,
+-              guestip:   fp.guest_ip,
+-              guestport: fp.guest_port,
+-              hostip:    fp.host_ip,
+-              hostport:  fp.host_port,
+-              name:      fp.id,
+-              protocol:  fp.protocol
+-            }
+-
+-            pidfile = pidfile_name(port, env_hash)
+-            pid = read_pid(pidfile)
+-            if pid && autossh_pid?(pid)
+-              logger.info("An autossh process already exists with pid #{pid}.")
+-            else
+-              args = autossh_args(port, pidfile, env_hash)
+-              Vagrant::Util::Subprocess.execute("autossh", *args)
+-            end
+-          end
+-
+-          def self.kill_ssh_tunnel(env, pidfile, env_hash)
+-            logger = Log4r::Logger.new("vagrant::hosts::bsd")
+-            pidfile = File.join(env_hash[:machine].data_dir, pidfile)
+-            pid = read_pid(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
+-
+-          private
+-
+-          def self.pidfile_name(port, env_hash)
+-            tunnel_name = [port[:hostip], port[:name]].compact.join('_')
+-            File.join(env_hash[:machine].data_dir, "#{tunnel_name}.pid")
+-          end
+-
+-          def self.read_pid(pidfile)
+-            File.read(pidfile).presence.try(:to_i) if File.exist?(pidfile)
+-          end
+-
+-          # Checks that the pid is actually an autossh process (and not
+-          # something else using a recycled pid).
+-          def self.autossh_pid?(pid)
+-            # get_comm_for_pid(pid) == 'autossh'
+-            true
+-          end
+-
+-          # Get the command, minus any arguments, for the given
+-          # pid. I don't expect this to be compatible cross-platform yet...
+-          # This could be complicated cross-platform, and Sys::ProcTable
+-          # could likewise be complicated cross-platform ...
+-          def self.get_comm_for_pid(pid)
+-            result = Vagrant::Util::Subprocess.execute("ps", "-p", pid.to_s, "-o", "comm")
+-            result.stdout.split("\n").last
+-          end
+-
+-          def self.autossh_args(port, pidfile, env_hash)
+-            ssh_info = env_hash[:machine_ssh_info]
+-            ssh_options = {
+-              "ServerAliveInterval" => 10,
+-              "ServerAliveCountMax" => 3,
+-              "StrictHostKeyChecking" => "no",
+-            }
+-            environment_variables = {
+-              env: {
+-                "AUTOSSH_PIDFILE" => pidfile,
+-                "AUTOSSH_PORT" => 0, # turns off monitoring
+-                #"AUTOSSH_LOGFILE" => "./autossh.log",
+-              }
+-            }
+-            forward_string = [
+-              port[:hostport],
+-              "localhost",
+-              port[:guestport]
+-            ].join(':')
+-
+-            autossh_args = []
+-            autossh_args << "-q"
+-            autossh_args << "-N"
+-            autossh_args << "-f"
+-            autossh_args << "-i" << env_hash[:machine].data_dir.join("private_key").to_s
+-            autossh_args << "-L" << forward_string
+-            ssh_options.each do |k, v|
+-              autossh_args << "-o" << "#{k}=#{v}"
+-            end
+-            autossh_args << "#{ssh_info[:username]}@#{ssh_info[:host]}"
+-            autossh_args << environment_variables
++        class SSHTunnel < VagrantPlugins::Skytap::HostCommon::Cap::SSHTunnel
++          def self.create_logger
++            Log4r::Logger.new("vagrant::hosts::linux")
+           end
+         end
+       end
+diff -r 444a060a037d 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	Tue Jan 12 22:44:41 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 444a060a037d lib/vagrant-skytap/plugin.rb
+--- a/lib/vagrant-skytap/plugin.rb	Tue Jan 12 22:30:01 2016 -0800
++++ b/lib/vagrant-skytap/plugin.rb	Tue Jan 12 22:44:41 2016 -0800
+@@ -59,6 +59,21 @@
+         HostBSD::Cap::SSHTunnel
+       end
+ 
++      host_capability("bsd", "kill_forwarded_ports") do
++        require_relative "hosts/bsd/cap/ssh_tunnel"
++        HostBSD::Cap::SSHTunnel
++      end
++
++      host_capability("bsd", "read_used_ports") do
++        require_relative "hosts/bsd/cap/ssh_tunnel"
++        HostBSD::Cap::SSHTunnel
++      end
++
++      host_capability("bsd", "read_forwarded_ports") do
++        require_relative "hosts/bsd/cap/ssh_tunnel"
++        HostBSD::Cap::SSHTunnel
++      end
++
+       host_capability("linux", "start_ssh_tunnel") do
+         require_relative "hosts/linux/cap/ssh_tunnel"
+         HostLinux::Cap::SSHTunnel
+@@ -69,6 +84,121 @@
+         HostLinux::Cap::SSHTunnel
+       end
+ 
++      host_capability("linux", "kill_forwarded_ports") do
++        require_relative "hosts/windows/cap/ssh_tunnel"
++        HostWindows::Cap::SSHTunnel
++      end
++
++      host_capability("linux", "read_used_ports") do
++        require_relative "hosts/linux/cap/ssh_tunnel"
++        HostLinux::Cap::SSHTunnel
++      end
++
++      host_capability("linux", "read_forwarded_ports") do
++        require_relative "hosts/linux/cap/ssh_tunnel"
++        HostLinux::Cap::SSHTunnel
++      end
++
++      host_capability("windows", "start_ssh_tunnel") do
++        require_relative "hosts/windows/cap/ssh_tunnel"
++        HostWindows::Cap::SSHTunnel
++      end
++
++      host_capability("windows", "kill_ssh_tunnel") do
++        require_relative "hosts/windows/cap/ssh_tunnel"
++        HostWindows::Cap::SSHTunnel
++      end
++
++      host_capability("windows", "kill_forwarded_ports") do
++        require_relative "hosts/windows/cap/ssh_tunnel"
++        HostWindows::Cap::SSHTunnel
++      end
++
++#      host_capability("windows", "read_used_ports") do
++#        require_relative "hosts/windows/cap/ssh_tunnel"
++#        HostWindows::Cap::SSHTunnel
++#      end
++#
++#      host_capability("windows", "read_forwarded_ports") do
++#        require_relative "hosts/windows/cap/ssh_tunnel"
++#        HostWindows::Cap::SSHTunnel
++#      end
++
++      host_capability("bsd", "start_ssh_tunnel") do
++        require_relative "hosts/bsd/cap/ssh_tunnel"
++        HostBSD::Cap::SSHTunnel
++      end
++
++      host_capability("bsd", "kill_ssh_tunnel") do
++        require_relative "hosts/bsd/cap/ssh_tunnel"
++        HostBSD::Cap::SSHTunnel
++      end
++
++      host_capability("bsd", "kill_forwarded_ports") do
++        require_relative "hosts/bsd/cap/ssh_tunnel"
++        HostBSD::Cap::SSHTunnel
++      end
++
++#      host_capability("bsd", "read_used_ports") do
++#        require_relative "hosts/bsd/cap/ssh_tunnel"
++#        HostBSD::Cap::SSHTunnel
++#      end
++#
++#      host_capability("bsd", "read_forwarded_ports") do
++#        require_relative "hosts/bsd/cap/ssh_tunnel"
++#        HostBSD::Cap::SSHTunnel
++#      end
++
++      host_capability("linux", "start_ssh_tunnel") do
++        require_relative "hosts/linux/cap/ssh_tunnel"
++        HostLinux::Cap::SSHTunnel
++      end
++
++      host_capability("linux", "kill_ssh_tunnel") do
++        require_relative "hosts/linux/cap/ssh_tunnel"
++        HostLinux::Cap::SSHTunnel
++      end
++
++      host_capability("linux", "kill_forwarded_ports") do
++        require_relative "hosts/windows/cap/ssh_tunnel"
++        HostWindows::Cap::SSHTunnel
++      end
++
++#      host_capability("linux", "read_used_ports") do
++#        require_relative "hosts/linux/cap/ssh_tunnel"
++#        HostLinux::Cap::SSHTunnel
++#      end
++#
++#      host_capability("linux", "read_forwarded_ports") do
++#        require_relative "hosts/linux/cap/ssh_tunnel"
++#        HostLinux::Cap::SSHTunnel
++#      end
++
++      host_capability("windows", "start_ssh_tunnel") do
++        require_relative "hosts/windows/cap/ssh_tunnel"
++        HostWindows::Cap::SSHTunnel
++      end
++
++      host_capability("windows", "kill_ssh_tunnel") do
++        require_relative "hosts/windows/cap/ssh_tunnel"
++        HostWindows::Cap::SSHTunnel
++      end
++
++      host_capability("windows", "kill_forwarded_ports") do
++        require_relative "hosts/windows/cap/ssh_tunnel"
++        HostWindows::Cap::SSHTunnel
++      end
++
++      host_capability("windows", "read_used_ports") do
++        require_relative "hosts/windows/cap/ssh_tunnel"
++        HostWindows::Cap::SSHTunnel
++      end
++
++      host_capability("windows", "read_forwarded_ports") do
++        require_relative "hosts/windows/cap/ssh_tunnel"
++        HostWindows::Cap::SSHTunnel
++      end
++
+       # This initializes the internationalization strings.
+       def self.setup_i18n
+         I18n.load_path << File.expand_path("locales/en.yml", Skytap.source_root)
+diff -r 444a060a037d lib/vagrant-skytap/util/compile_forwarded_ports.rb
+--- a/lib/vagrant-skytap/util/compile_forwarded_ports.rb	Tue Jan 12 22:30:01 2016 -0800
++++ b/lib/vagrant-skytap/util/compile_forwarded_ports.rb	Tue Jan 12 22:44:41 2016 -0800
+@@ -12,8 +12,6 @@
+           mappings = {}
+ 
+           config.vm.networks.each do |type, options|
+-#            puts type, options
+-#            debugger
+             if type == :forwarded_port
+               guest_port = options[:guest]
+               host_port  = options[:host]