vagrant-skytap 0.1.11 → 0.2.0

data/lib/vagrant-skytap/util/compile_forwarded_ports.rb

@@ -0,0 +1,35 @@
+require "vagrant/util/scoped_hash_override"
+require 'vagrant-skytap/model/forwarded_port'
+module VagrantPlugins
+  module Skytap
+    module Util
+      # This is based on code from the VirtualBox provider.
+      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/lib/vagrant-skytap/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Skytap
-    VERSION = "0.1.11"
+    VERSION = "0.2.0"
   end
 end

data/locales/en.yml

@@ -109,6 +109,9 @@ en:
       region_mismatch: |-
         A VM from the '%{vm_region}' region cannot be added to an environment in the '%{environment_region}' region.
 
+      feature_not_supported_for_host_os: |-
+        The %{feature_name} feature is currently not supported for your host operating system.
+
     states:
       short_not_created: |-
         not created

data/spec/unit/environment_spec.rb

@@ -81,9 +81,21 @@ describe VagrantPlugins::Skytap::API::Environment do
       expect {described_class.check_vm_before_adding(env, subject)}.to_not raise_error
     end
 
-    it "raises NotTemplateVm if the vm is not a template vm" do
+    it "raises nothing if the vm is part of an environment" do
       vm = VagrantPlugins::Skytap::API::Vm.new(config_vm_attrs, nil, env)
-      expect {described_class.check_vm_before_adding(env, vm)}.to raise_error(Errors::NotTemplateVm)
+      expect {described_class.check_vm_before_adding(env, vm)}.to_not raise_error
+    end
+
+    it "raises SourceVmNotStopped if the environment vm is running" do
+      vm = VagrantPlugins::Skytap::API::Vm.new(config_vm_attrs, nil, env)
+      allow(vm).to receive(:runstate).and_return('running')
+      expect {described_class.check_vm_before_adding(env, vm)}.to raise_error(Errors::SourceVmNotStopped)
+    end
+
+    it "raises SourceVmNotStopped if the environment vm is suspended" do
+      vm = VagrantPlugins::Skytap::API::Vm.new(config_vm_attrs, nil, env)
+      allow(vm).to receive(:runstate).and_return('suspended')
+      expect {described_class.check_vm_before_adding(env, vm)}.to raise_error(Errors::SourceVmNotStopped)
     end
   end
 

data/spec/unit/forwarded_port_spec.rb

@@ -0,0 +1,45 @@
+require_relative 'base'
+require "vagrant-skytap/model/forwarded_port"
+
+describe VagrantPlugins::Skytap::Model::ForwardedPort do
+  include_context "unit"
+
+  let(:fp1) { VagrantPlugins::Skytap::Model::ForwardedPort.new("tcp9000", 9000, 80, protocol: 'tcp') }
+  let(:fp2) { VagrantPlugins::Skytap::Model::ForwardedPort.new("tcp80", 80, 80, protocol: 'tcp') }
+  let(:fp3) { VagrantPlugins::Skytap::Model::ForwardedPort.new("tcp2222", 2222, 22, protocol: 'tcp') }
+  let(:fp4) { VagrantPlugins::Skytap::Model::ForwardedPort.new("ssh", 2201, 22, protocol: 'tcp') }
+  let(:fp5) { VagrantPlugins::Skytap::Model::ForwardedPort.new("tcp1024", 1024, 80, protocol: 'tcp') }
+  let(:fp6) { VagrantPlugins::Skytap::Model::ForwardedPort.new("tcp9000", 80, 1025, protocol: 'tcp') }
+
+  describe "privileged_host_port?" do
+    it "returns false for host port above 1024" do
+      expect(fp1.privileged_host_port?).to be false
+    end
+
+    it "returns true for host port below 1024" do
+      expect(fp2.privileged_host_port?).to be true
+    end
+
+    it "returns true for host port 1024" do
+      expect(fp5.privileged_host_port?).to be true
+    end
+
+    it "returns true for host port 80 if guest port is over 1024" do
+      expect(fp6.privileged_host_port?).to be true
+    end
+  end
+
+  describe "internal_ssh_port?" do
+    it "returns false for typical host port" do
+      expect(fp1.internal_ssh_port?).to be false
+    end
+
+    it "returns true when guest port is 22 and host port is 2222" do
+      expect(fp3.internal_ssh_port?).to be true
+    end
+
+    it "returns true when id has special value 'ssh'" do
+      expect(fp4.internal_ssh_port?).to be true
+    end
+  end
+end

data/spec/unit/hosts/common/cap/ssh_tunnel_spec.rb

@@ -0,0 +1,180 @@
+require File.expand_path("../../../../base", __FILE__)
+require "vagrant-skytap/model/forwarded_port"
+
+describe "VagrantPlugins::Skytap::HostCommon::Cap::SSHTunnel" do
+  let(:described_class) do
+    VagrantPlugins::Skytap::Plugin.components.host_capabilities[:bsd].get(:start_ssh_tunnel)
+  end
+
+  let(:machine)         { double("machine") }
+  let(:forwarded_port1) { VagrantPlugins::Skytap::Model::ForwardedPort.new('tcp9000', 9000, 80, protocol: "tcp") }
+  let(:forwarded_port2) { VagrantPlugins::Skytap::Model::ForwardedPort.new('tcp9001', 9001, 81, protocol: "tcp") }
+  let(:pidfile1)        { "tcp9000_tcp_9000_80.pid" }
+  let(:ssh_info)        { {username: 'user', host: '10.0.0.1'} }
+  let(:env_path)        { Pathname.new(File.expand_path("../../../../support/forwarded_ports", __FILE__)) }
+  let(:env)             { double("env") }
+
+  let(:subprocess)      { double("Vagrant::Util::Subprocess") }
+  let(:result)          { Vagrant::Util::Subprocess::Result.new(0, "", "") }
+
+  before do
+    allow(env).to receive(:local_data_path).and_return(env_path)
+    allow(machine).to receive(:data_dir).and_return(env.local_data_path.join("machines/vm1/skytap"))
+    allow(machine).to receive(:ssh_info).and_return(ssh_info)
+    allow(machine).to receive(:name).and_return('vm1')
+
+    result
+    stub_const("Vagrant::Util::Subprocess", subprocess)
+    allow(subprocess).to receive(:execute).and_return(result)
+  end
+
+  describe "start_ssh_tunnel" do
+    it "kills an existing tunnel" do
+      expect(described_class).to receive(:kill_ssh_tunnel)
+      #expect(subprocess).to receive(:execute).with('kill', '99999')
+      #expect(subprocess).to receive(:execute).with('autossh', "-f", anything)
+      described_class.start_ssh_tunnel(env, forwarded_port1, machine)
+    end
+  end
+
+  describe "kill_ssh_tunnel" do
+    it "kills the right process" do
+      expect(subprocess).to receive(:execute).once.with('kill', '99999')
+      described_class.kill_ssh_tunnel(env, forwarded_port1, machine)
+    end
+  end
+
+  describe "clear_forwarded_ports" do
+    it "kills two processes" do
+      expect(subprocess).to receive(:execute).with('kill', '99999')
+      expect(subprocess).to receive(:execute).with('kill', '90210')
+      described_class.clear_forwarded_ports(env, machine)
+    end
+  end
+
+  describe "read_forwarded_ports" do
+    it "returns two ForwardedPort objects for vm1 only" do
+      fps = described_class.read_forwarded_ports(env, machine)
+      expect(fps.count).to eq(2)
+      fp1, fp2 = fps.sort_by(&:id)
+
+      expect(fp1.id).to eq("tcp9000")
+      expect(fp1.host_port).to eq(9000)
+      expect(fp1.guest_port).to eq(80)
+      expect(fp1.protocol).to eq("tcp")
+
+      expect(fp2.id).to eq("tcp9001")
+      expect(fp2.host_port).to eq(9001)
+      expect(fp2.guest_port).to eq(81)
+      expect(fp2.protocol).to eq("tcp")
+    end
+  end
+
+  describe "read_used_ports" do
+    it "returns one ForwardedPort object for all skytap machines except vm1" do
+      fps = described_class.read_used_ports(env, machine)
+      expect(fps.count).to eq(2)
+      fp1, fp2 = fps.sort_by(&:id)
+
+      expect(fp1.id).to eq("tcp8080")
+      expect(fp1.host_port).to eq(8080)
+      expect(fp1.guest_port).to eq(80)
+      expect(fp1.protocol).to eq("tcp")
+
+      expect(fp2.id).to eq("tcp8888")
+      expect(fp2.host_port).to eq(8888)
+      expect(fp2.guest_port).to eq(80)
+      expect(fp2.protocol).to eq("tcp")
+    end
+  end
+
+  describe "read_pid" do
+    it "reads the pid" do
+      pid = described_class.read_pid(machine.data_dir.join(pidfile1))
+      expect(pid).to eq(99999)
+    end
+
+    it "returns nil if pidfile missing" do
+      pid = described_class.read_pid(machine.data_dir.join("tcp12345.pid"))
+      expect(pid).to be(nil)
+    end
+  end
+
+  describe "get_fp_from_directory" do
+    it "gets the ForwardedPorts for the directory" do
+      fps = described_class.get_fp_from_directory(machine.data_dir)
+      expect(fps.count).to eq(2)
+      fp1, fp2 = fps.sort_by(&:id)
+
+      expect(fp1.id).to eq("tcp9000")
+      expect(fp1.host_port).to eq(9000)
+      expect(fp1.guest_port).to eq(80)
+      expect(fp1.protocol).to eq("tcp")
+
+      expect(fp2.id).to eq("tcp9001")
+      expect(fp2.host_port).to eq(9001)
+      expect(fp2.guest_port).to eq(81)
+      expect(fp2.protocol).to eq("tcp")
+    end
+  end
+
+  describe "machine_data_dirs" do
+    it "gets only skytap machine dirs" do
+      map = described_class.machine_data_dirs(env)
+      expect(map).to eq({
+        'vm1' => env_path.join("machines/vm1/skytap"),
+        'vm2' => env_path.join("machines/vm2/skytap"),
+        'vm4' => env_path.join("machines/vm4/skytap"),
+      })
+      expect(map.values.first).to be_a(Pathname)
+    end
+  end
+
+  describe "pidfile_to_fp" do
+    it "parses the pidfile name" do
+      fp = described_class.pidfile_to_fp(pidfile1)
+      expect(fp.id).to eq("tcp9000")
+      expect(fp.host_port).to eq(9000)
+      expect(fp.guest_port).to eq(80)
+      expect(fp.protocol).to eq("tcp")
+    end
+  end
+
+  describe "fp_to_pidfile" do
+    it "creates the pidfile name" do
+      pidfile = described_class.fp_to_pidfile(forwarded_port1)
+      expect(pidfile).to eq(pidfile1)
+    end
+  end
+
+  describe "pidfile_path" do
+    it "gets the pidfile path" do
+      path = described_class.pidfile_path(forwarded_port1, machine)
+      expect(path).to eq(machine.data_dir.join(pidfile1).to_s)
+    end
+  end
+
+  describe "ssh_args" do
+    it "returns expected args" do
+      args = described_class.ssh_args(forwarded_port1, machine)
+      expect(args).to eq(["-q", "-N",
+        "-i", machine.data_dir.join("private_key").to_s,
+        "-L", "9000:localhost:80",
+        "-o", "ServerAliveInterval=10",
+        "-o", "ServerAliveCountMax=3",
+        "-o", "StrictHostKeyChecking=no",
+        "user@10.0.0.1"
+      ])
+    end
+  end
+
+  describe "autossh_environment_variables" do
+    it "defaults monitoring port to 0" do
+      vars = described_class.autossh_environment_variables(forwarded_port1, machine)
+      expect(vars).to eq({
+        "AUTOSSH_PIDFILE" => machine.data_dir.join(pidfile1).to_s,
+        "AUTOSSH_PORT"    => 0,
+      })
+    end
+  end
+end

data/spec/unit/prepare_collision_params_spec.rb

@@ -0,0 +1,57 @@
+require_relative 'base'
+require "vagrant-skytap/model/forwarded_port"
+
+describe VagrantPlugins::Skytap::Model::ForwardedPort do
+  include_context "unit"
+
+  let(:fp1) { VagrantPlugins::Skytap::Model::ForwardedPort.new("tcp9000", 9000, 80, protocol: 'tcp') }
+  let(:fp2) { VagrantPlugins::Skytap::Model::ForwardedPort.new("tcp80", 80, 80, protocol: 'tcp') }
+  let(:fp3) { VagrantPlugins::Skytap::Model::ForwardedPort.new("tcp2222", 2222, 22, protocol: 'tcp') }
+  let(:fp4) { VagrantPlugins::Skytap::Model::ForwardedPort.new("ssh", 2201, 22, protocol: 'tcp') }
+  let(:fp5) { VagrantPlugins::Skytap::Model::ForwardedPort.new("tcp1024", 1024, 80, protocol: 'tcp') }
+  let(:fp6) { VagrantPlugins::Skytap::Model::ForwardedPort.new("tcp9000", 80, 1025, protocol: 'tcp') }
+
+  describe "privileged_host_port?" do
+    it "returns false for host port above 1024" do
+      expect(fp1.privileged_host_port?).to be false
+    end
+
+    it "returns true for host port below 1024" do
+      expect(fp2.privileged_host_port?).to be true
+    end
+
+    it "returns true for host port 1024" do
+      expect(fp5.privileged_host_port?).to be true
+    end
+
+    it "returns true for host port 80 if guest port is over 1024" do
+      expect(fp6.privileged_host_port?).to be true
+    end
+  end
+
+  describe "internal_ssh_port?" do
+    it "returns false for typical host port" do
+      expect(fp1.internal_ssh_port?).to be false
+    end
+
+    it "returns true when guest port is 22 and host port is 2222" do
+      expect(fp3.internal_ssh_port?).to be true
+    end
+
+    it "returns true when id has special value 'ssh'" do
+      expect(fp4.internal_ssh_port?).to be true
+    end
+  end
+end
+
+
+#- [ ] Set up a “real" environment & machine
+#- [ ] Give it a Vagrantfile with a collision
+#- [ ] Provide matching machine folders.
+#- [ ] read_used_ports and read_forwarded_ports will have natural return values.
+#- [ ] Check that :port_collision_extra_in_use and :port_collision_remap are correct.
+#- [ ] Case where read_forwarded_ports returns []. :port_collision_remap should be {}.
+#- [ ] Case where read_forwarded_ports returns an object with the same id as something
+#      in env[:machine].config.vm.networks: :port_collision_remap should be
+#      {<config hostport> => FP hostport}
+#    - [ ] observe what virtualbox does

data/spec/unit/support/forwarded_ports/machines/vm1/skytap/id

@@ -0,0 +1 @@
+1

data/spec/unit/support/forwarded_ports/machines/vm1/skytap/private_key

@@ -0,0 +1,4 @@
+-----BEGIN RSA PRIVATE KEY-----
+BOO!
+-----END RSA PRIVATE KEY-----
+

data/spec/unit/support/forwarded_ports/machines/vm1/skytap/tcp9000_tcp_9000_80.pid

@@ -0,0 +1 @@
+99999

data/spec/unit/support/forwarded_ports/machines/vm1/skytap/tcp9001_tcp_9001_81.pid

@@ -0,0 +1 @@
+90210

data/spec/unit/support/forwarded_ports/machines/vm1/virtualbox/id

@@ -0,0 +1 @@
+vb1

data/spec/unit/support/forwarded_ports/machines/vm2/skytap/id

@@ -0,0 +1 @@
+2

data/spec/unit/support/forwarded_ports/machines/vm2/skytap/tcp8080_tcp_8080_80.pid

@@ -0,0 +1 @@
+1111111111

data/spec/unit/support/forwarded_ports/machines/vm3/virtualbox/id

@@ -0,0 +1 @@
+vb3

data/spec/unit/support/forwarded_ports/machines/vm4/skytap/id

@@ -0,0 +1 @@
+4

data/spec/unit/support/forwarded_ports/machines/vm4/skytap/tcp8888_tcp_8888_80.pid

@@ -0,0 +1 @@
+22222222222