vagrant-skytap 0.2.10 → 0.3.0

data/lib/vagrant-skytap/connection/tunnel_choice.rb

@@ -0,0 +1,118 @@
+# Copyright (c) 2014-2016 Skytap, Inc.
+#
+# The MIT License (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require 'vagrant-skytap/connection'
+
+# An ICNR tunnel connects networks in two different Skytap environments.
+# In the case where the host is a Skytap VM, a tunnel is the most convenient
+# way of establishing communication with the guest VM.
+
+module VagrantPlugins
+  module Skytap
+    module Connection
+      class TunnelChoice < Choice
+        attr_reader :host_network, :guest_network
+
+        def initialize(env, host_network, iface)
+          @env = env
+          @iface = iface
+          @host_network = host_network
+          @guest_network = iface.network
+          @execution = TunnelExecution.make(env, iface, host_network)
+        end
+
+        def choose
+          execution.execute
+          @iface = iface.vm.reload.get_interface_by_id(iface.id)
+          @host_network = host_network.environment.reload.networks.find{|n| n.id == host_network.id}
+          nat_address = iface.nat_address_for_network(host_network)
+          [nat_address, DEFAULT_PORT]
+        end
+
+        def valid?
+          @validation_error_message = nil
+
+          unless host_network.tunnelable?
+            @validation_error_message = I18n.t("vagrant_skytap.connections.tunnel.errors.host_network_not_tunnelable")
+            return false
+          end
+
+          unless host_network.nat_enabled?
+            @validation_error_message = I18n.t("vagrant_skytap.connections.tunnel.errors.host_network_nat_disabled")
+            return false
+          end
+
+          unless guest_network.nat_enabled?
+            if guest_network.subnet.overlaps?(host_network.subnet)
+              @validation_error_message = I18n.t("vagrant_skytap.connections.tunnel.errors.guest_network_overlaps")
+              return false
+            end
+          end
+
+          true
+        end
+
+        class TunnelExecution < Execution
+          attr_reader :host_network, :guest_network
+
+          def self.make(env, iface, host_network)
+            if host_network.try(:connected_to_network?, iface.network)
+              UseExecution.new(env, iface, host_network)
+            else
+              CreateAndUseExecution.new(env, iface, host_network)
+            end
+          end
+
+          def initialize(env, iface, host_network)
+            super
+            @host_network = host_network
+            @guest_network = iface.network
+          end
+
+          def message
+            "#{verb}: #{host_network.name}"
+          end
+        end
+
+        class UseExecution < TunnelExecution
+          def verb
+            I18n.t("vagrant_skytap.connections.tunnel.verb_use")
+          end
+
+          def execute
+            # No-op
+          end
+        end
+
+        class CreateAndUseExecution < TunnelExecution
+          def verb
+            I18n.t("vagrant_skytap.connections.tunnel.verb_create_and_use")
+          end
+
+          def execute
+            guest_network.connect_to_network(host_network)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/connection/vpn_choice.rb

@@ -0,0 +1,132 @@
+# Copyright (c) 2014-2016 Skytap, Inc.
+#
+# The MIT License (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require 'vagrant-skytap/connection'
+require 'vagrant-skytap/api/vpn_attachment'
+
+module VagrantPlugins
+  module Skytap
+    module Connection
+      class VpnChoice < Choice
+        attr_reader :vm, :vpn, :attachment
+
+        def initialize(env, vpn, vm)
+          @env = env
+          @vpn = vpn
+          @vm = vm
+          @iface = select_interface(vm, vpn)
+          @execution = VPNAttachmentExecution.make(env, iface, vpn)
+        end
+
+        # Finds an interface on the guest VM which is connected to a network
+        # which lies inside the VPN's subnet. If the VPN is NAT enabled, this
+        # method simply returns the first interface.
+        #
+        # @param [API::Vm] vm The guest VM
+        # @param [API::Vpn] vpn The VPN this VpnChoice will connect to
+        # @return [API::Interface] An interface connected to a suitable network
+        def select_interface(vm, vpn)
+          vm.interfaces.select(&:network).tap do |ifaces|
+            unless vpn.nat_enabled?
+              ifaces.select! {|i| vpn.subsumes?(i.network) }
+            end
+          end.first
+        end
+
+        def choose
+          execution.execute
+          @iface = vm.reload.get_interface_by_id(iface.id)
+          host = iface.address_for(vpn)
+          [host, DEFAULT_PORT]
+        end
+
+        # To communicate with the guest VM over a VPN, the guest's network
+        # must be both attached and connected to the VPN. The various
+        # subclasses perform different REST calls depending on which of these
+        # conditions are already met.
+        class VPNAttachmentExecution < Execution
+          attr_reader :vpn, :attachment
+
+          def self.make(env, iface, vpn)
+            attachment = iface.attachment_for(vpn)
+
+            if attachment.try(:connected?)
+              UseExecution.new(env, iface, vpn, attachment)
+            elsif attachment
+              ConnectAndUseExecution.new(env, iface, vpn, attachment)
+            else
+              AttachConnectAndUseExecution.new(env, iface, vpn)
+            end
+          end
+
+          def initialize(env, iface, vpn, attachment=nil)
+            super
+            @vpn = vpn
+            @attachment = attachment
+          end
+
+          def message
+            "#{verb}: #{vpn.name}".tap do |ret|
+              if vpn.nat_enabled?
+                ret << " " << I18n.t("vagrant_skytap.connections.vpn_attachment.nat_enabled")
+              else
+                ret << " " << I18n.t("vagrant_skytap.connections.vpn_attachment.local_subnet",
+                  local_subnet: vpn.local_subnet)
+              end
+            end
+          end
+        end
+
+        class UseExecution < VPNAttachmentExecution
+          def verb
+            I18n.t("vagrant_skytap.connections.vpn_attachment.verb_use")
+          end
+
+          def execute
+            # No-op
+          end
+        end
+
+        class ConnectAndUseExecution < VPNAttachmentExecution
+          def verb
+            I18n.t("vagrant_skytap.connections.vpn_attachment.verb_connect")
+          end
+
+          def execute
+            attachment.connect!
+          end
+        end
+
+        class AttachConnectAndUseExecution < VPNAttachmentExecution
+          def verb
+            I18n.t("vagrant_skytap.connections.vpn_attachment.verb_attach")
+          end
+
+          def execute
+            @attachment = API::VpnAttachment.create(iface.network, vpn, env)
+            @attachment.connect!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/connection.rb

@@ -0,0 +1,123 @@
+# Copyright (c) 2014-2016 Skytap, Inc.
+#
+# The MIT License (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require 'net/ssh/transport/session'
+
+# Encapsulates a chooseable option for establishing communication with the
+# guest VM over SSH/WinRM. All valid options (e.g. using specific VPNs,
+# creating a published service, etc.) are collected as Choices and
+# presented to the user.
+
+module VagrantPlugins
+  module Skytap
+    module Connection
+      DEFAULT_PORT = Net::SSH::Transport::Session::DEFAULT_PORT
+
+      # A Choice represents the potential for establishing a connection to the
+      # guest VM via a specific resource.
+      class Choice
+        attr_reader :env, :iface, :execution, :validation_error_message
+
+        # Thia method should be overridden to call #make on the
+        # [Connection::Execution] subclass for this particular resource type.
+        # The execution holds all the information needed to establish the
+        # connection.
+        def initialize(*args)
+          @env = args.first
+        end
+
+        # Invokes the execution, and determines the IP address and port for
+        # communicating with the guest VM.
+        #
+        # @return [Array] Tuple of [String], [Integer] The IP address and port
+        #   for communicating with the guest VM.
+        def choose
+          raise NotImplementedError.new('Must override')
+        end
+
+        # Override this method to add any validation logic needed by a specific
+        # resource type. For example, [Connection::TunnelChoice] must check for
+        # subnet overlaps. If this method returns false, this particular choice
+        # should not be offered to the user. For some resource types, it may
+        # be useful to set @validation_error_message on this choice when
+        # returning false.
+        #
+        # @return [Boolean]
+        def valid?
+          true
+        end
+
+        def to_s
+          execution.message
+        end
+      end
+
+      # An Execution implements a strategy for establishing a connection
+      # to the guest VM using a given resource. A resource may have more
+      # than one strategy, depending on the initial state of the connection.
+      # (When the guest VM is first created, no connection will exist.)
+      class Execution
+        attr_reader :env, :iface
+
+        def initialize(*args)
+          @env, @iface, _ = args
+        end
+
+        # Creates an execution object which will perform the correct actions
+        # to establish a connection via a specific connectable resource. This
+        # method should be overridden to return an object of the correct
+        # execution subclass given the resource's initial state. For example,
+        # if the guest's network is already attached to this VPN, but
+        # disconnected, this method would return a ConnectAndUseExecution.
+        #
+        # @return [Connection::Execution]
+        def make(*args)
+          raise NotImplementedError.new('Must override')
+        end
+
+        # Performs the API calls which establish the connection for
+        # communicating with the guest VM. If the connection is already
+        # established, as in the case of a guest VM which already exists,
+        # this may be a no-op.
+        def execute
+          raise NotImplementedError.new('Must override')
+        end
+
+        # The name of the action(s) performed by this execution subclass,
+        # e.g. "Connect and use".
+        #
+        # @return [String]
+        def verb
+          raise NotImplementedError.new('Must override')
+        end
+
+        # The description of the actions to be taken when this choice is
+        # executed, e.g. "Connect to and use VPN 1".
+        #
+        # @return [String]
+        def message
+          verb
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/errors.rb

@@ -89,6 +89,10 @@ module VagrantPlugins
         error_key(:no_connection_options)
       end
 
+      class NoSkytapConnectionOptions < VagrantSkytapError
+        error_key(:no_skytap_connection_options)
+      end
+
       class FeatureNotSupportedForHostOs < VagrantSkytapError
         error_key(:feature_not_supported_for_host_os)
       end

data/lib/vagrant-skytap/plugin.rb

@@ -71,6 +71,11 @@ module VagrantPlugins
         Cap::PublicAddress
       end
 
+      provider_capability(:skytap, :host_metadata) do
+        require_relative "cap/host_metadata"
+        Cap::HostMetadata
+      end
+
       %w[start_ssh_tunnel kill_ssh_tunnel clear_forwarded_ports read_forwarded_ports read_used_ports].each do |cap|
         host_capability("bsd", cap) do
           require_relative "hosts/bsd/cap/ssh_tunnel"

data/lib/vagrant-skytap/setup_helper.rb

@@ -29,7 +29,7 @@ require 'net/ssh/transport/session'
 module VagrantPlugins
   module Skytap
     class SetupHelper
-      attr_reader :env, :environment, :machine, :provider_config
+      attr_reader :env, :environment, :host_vm, :machine, :provider_config
       attr_reader :username, :password, :host, :port
 
       def self.run!(env, environment)
@@ -40,6 +40,7 @@ module VagrantPlugins
         @env = env
         @logger = Log4r::Logger.new("vagrant_skytap::setup_helper")
         @environment = environment
+        @host_vm = env[:vagrant_host_vm]
         @machine = env[:machine]
         @provider_config = env[:machine].provider_config
         @username = @machine.config.ssh.username
@@ -54,6 +55,10 @@ module VagrantPlugins
         end
       end
 
+      def running_in_skytap_vm?
+        !!host_vm
+      end
+
       def run!
         ask_routing
         ask_credentials
@@ -94,30 +99,46 @@ module VagrantPlugins
       end
 
       def ask_routing
-        @logger.debug("ask_routing")
         unless host && port
           iface = current_vm.interfaces.first
-          choices = connection_choices(iface).select(&:valid?)
+          choices = connection_choices(iface)
+
+          if running_in_skytap_vm?
+            unless choices.any?(&:valid?)
+              raise Errors::NoSkytapConnectionOptions, message: choices.collect(&:validation_error_message).first
+            end
+          end
+
+          choices.select!(&:valid?)
           raise Errors::NoConnectionOptions unless choices.present?
 
-          if vpn_url = @provider_config.vpn_url
+          choice = nil
+          if !running_in_skytap_vm? && vpn_url = @provider_config.vpn_url
             choice = choices.detect do |choice|
               choice.vpn && vpn_url.include?(choice.vpn.id)
             end
             raise Errors::DoesNotExist, object_name: vpn_url unless choice
-            @host, @port = choice.choose
+          elsif choices.count == 1
+            choice = choices.first
+            env[:ui].info("Using only available connection option: #{choice}")
           else
             question = "How do you want to connect to machine '#{@machine.name}'?"
-            ask_from_list(question, choices, 0) do |i, choice|
-              @host, @port = choice.choose
+            ask_from_list(question, choices, 0) do |i, _choice|
+              choice = _choice
             end
           end
+          @host, @port = choice.choose
         end
+        @logger.debug("ask_routing returning guest VM address and port: #{@host}:#{@port}")
         [@host, @port]
       end
 
       def connection_choices(iface)
-        vpn_choices(iface)
+        if running_in_skytap_vm?
+          tunnel_choices(iface)
+        else
+          vpn_choices(iface)
+        end
       end
 
       def vpn_choices(iface)
@@ -137,6 +158,11 @@ module VagrantPlugins
         iface.published_service_choices
       end
 
+      def tunnel_choices(guest_iface)
+        candidates = host_vm.interfaces.collect(&:network)
+        candidates.collect {|network| network.choice_for_setup(guest_iface) }
+      end
+
       def vpns
         VagrantPlugins::Skytap::API::Vpn.all(env, query: {region: environment.region})
       end

data/lib/vagrant-skytap/version.rb

@@ -22,6 +22,6 @@
 
 module VagrantPlugins
   module Skytap
-    VERSION = "0.2.10"
+    VERSION = "0.3.0"
   end
 end

data/locales/en.yml

@@ -100,6 +100,11 @@ en:
         There were no available options for connecting to the VM.
         Currently, the provider supports connections over VPN only.
 
+      no_skytap_connection_options: |-
+        Could not establish a connection between the host and guest VMs.
+        %{message}
+        Please correct the problem and try again.
+
       bad_vm_url: |-
         The specified vm_url was invalid: %{url}
 
@@ -143,6 +148,47 @@ en:
       long_busy: |-
         The Skytap instance is busy. Wait for the current operation to complete.
 
+    connections:
+      vpn_attachment:
+        verb_use: |-
+          Use VPN
+        verb_connect: |-
+          Connect to and use VPN
+        verb_attach: |-
+          Attach to and use VPN
+        nat_enabled: |-
+          (NAT-enabled)
+        local_subnet: |-
+          (local subnet: %{local_subnet})
+      published_service:
+        verb_use: |-
+          Use published service
+        verb_create_and_use: |-
+          Create and use published service
+      public_ip:
+        verb_use: |-
+          Use public IP
+        verb_attach: |-
+          Attach and use public IP
+        deployed: |-
+          (attached and deployed to another VM)
+        attached: |-
+          (attached to another VM)
+      tunnel:
+        verb_use: |-
+          Use existing tunnel to host network
+        verb_create_and_use: |-
+          Create and use tunnel to host network
+        errors:
+          host_network_not_tunnelable: |-
+            The host's network must be tunnelable.
+          host_network_nat_disabled: |-
+            The host's network must have NAT enabled.
+          guest_network_overlaps: |-
+            The guest's network subnet overlaps with the host's network.
+            (This can be resolved by changing network subnets, or by
+            enabling NAT on the guest network.)
+
     commands:
       publish_urls:
         list: |-

data/spec/unit/actions/prepare_nfs_settings_spec.rb

@@ -26,8 +26,12 @@ require "vagrant-skytap/action/prepare_nfs_settings"
 describe VagrantPlugins::Skytap::Action::PrepareNFSSettings do
   include_context "skytap"
 
-  let(:app) { lambda { |env| } }
-  let(:env) { { machine: machine} }
+  let(:json_path)       { File.join(File.expand_path('..', __FILE__), 'support', 'api_responses') }
+  let(:vm1_attrs)       { read_json(json_path, 'vm1.json') }
+
+  let(:app)             { lambda { |env| } }
+  let(:host_vm)         { nil }
+  let(:env)             { { machine: machine, ui: ui, host_vm: host_vm} }
 
   let(:machine)         { double(:machine, config: config, provider_config: provider_config, ssh_info: {host: guest_ip}) }
   let(:config)          { double(:config, vm: vm_config) }
@@ -37,21 +41,42 @@ describe VagrantPlugins::Skytap::Action::PrepareNFSSettings do
   let(:guest_ip)        { '192.168.0.1' }
   let(:using_nfs)       { false }
 
+  let(:udpsocket)       { double("UDPSocket") }
+  let(:addresses)       { ["AF_INET", 99999, '127.0.0.1', host_ip] }
+  let(:socket)          { double(:socket, connect: nil, addr: addresses) }
+
+  let(:nat_host_ip)     { '10.0.4.1' }
+  let(:nat_guest_ip)    { '14.0.0.1' }
+  let(:guest_network)   { double(:guest_network, id: "2", attrs: {}, :nat_enabled? => false) }
+  let(:guest_iface)     { double(:guest_iface, network: guest_network) }
+  let(:guest_vm)        { double(:guest_vm, interfaces: [guest_iface]) }
+
+  let(:default_hostpath) {"."}
+  let(:default_disabled) { false }
+  let(:default_type)     { nil }
   let(:default_folder_props) do
-    {guestpath: "/vagrant", hostpath: ".", disabled: false}
+    {guestpath: "/vagrant", hostpath: default_hostpath, disabled: default_disabled, type: default_type}
   end
   let(:synced_folders)  { { "/vagrant" => default_folder_props } }
 
-  let(:instance)        { described_class.new(app, env) }
+  let(:instance) do
+    described_class.new(app, env).tap do |instance|
+      allow(instance).to receive(:machine).and_return(machine)
+      allow(instance).to receive(:host_vm).and_return(host_vm)
+      allow(instance).to receive(:current_vm).and_return(guest_vm)
+    end
+  end
 
   before do
-    allow(instance).to receive(:machine).and_return(machine)
-    allow(subject).to receive(:using_nfs?).and_return(using_nfs)
-    allow(subject).to receive(:read_host_ip).and_return(host_ip)
+    stub_const("UDPSocket", udpsocket)
+    allow(udpsocket).to receive(:open).and_yield(socket)
   end
 
   describe "#call" do
     subject {instance}
+    before do
+      allow(subject).to receive(:using_nfs?).and_return(using_nfs)
+    end
 
     context "when not using nfs" do
       it "does not set the host and guest ip addresses" do
@@ -82,25 +107,47 @@ describe VagrantPlugins::Skytap::Action::PrepareNFSSettings do
       end
 
       context "when its type is rsync" do
-        let(:default_folder_props) do
-          {guestpath: "/vagrant", hostpath: ".", disabled: false, type: :rsync}
-        end
+        let(:default_type) { :rsync }
         it {should be false }
       end
 
       context "when its type is nfs" do
-        let(:default_folder_props) do
-          {guestpath: "/vagrant", hostpath: ".", disabled: false, type: :nfs}
-        end
+        let(:default_type) { :nfs }
         it {should be true }
 
         context "when it is disabled" do
-          let(:default_folder_props) do
-            {guestpath: "/vagrant", hostpath: ".", disabled: true, type: :nfs}
-          end
+          let(:default_disabled) { true }
           it {should be false }
         end
       end
     end
   end
+
+  describe "read_host_ip" do
+    subject { instance.read_host_ip }
+
+    context "when not running in a VM" do
+      it { should eq host_ip }
+    end
+
+    context "when running in a VM" do
+      let(:host_iface) { double(:host_iface, nat_address_for_network: nat_host_ip) }
+      let(:host_vm)    { double(:host_vm, interfaces: [host_iface]) }
+
+      before do
+        allow(host_vm).to receive(:reload).and_return(host_vm)
+      end
+
+      context "when guest network is not NAT enabled" do
+        it { should eq host_ip }
+      end
+
+      context "when guest network is NAT enabled" do
+        before do
+          allow(guest_network).to receive(:nat_enabled?).and_return(true)
+        end
+        it { should eq nat_host_ip }
+      end
+    end
+  end
 end