vagrant-skytap 0.1.11 → 0.2.0

data/_patches-20160118a/vm-vanished

@@ -0,0 +1,42 @@
+# HG changeset patch
+# Parent 1b8860f8b5129c2ab846c4464378c7a582ac0a90
+raise error on vm reload if it's gone?
+
+diff -r 1b8860f8b512 lib/vagrant-skytap/api/vm.rb
+--- a/lib/vagrant-skytap/api/vm.rb	Mon Nov 09 20:51:32 2015 -0800
++++ b/lib/vagrant-skytap/api/vm.rb	Mon Nov 09 20:52:02 2015 -0800
+@@ -35,6 +35,7 @@
+         end
+ 
+         def refresh_from_environment
++          raise VmVanished, name: machine.name unless vm = environment.get_vm_by_id(id)
+           refresh(vm.attrs)
+         end
+ 
+diff -r 1b8860f8b512 lib/vagrant-skytap/errors.rb
+--- a/lib/vagrant-skytap/errors.rb	Mon Nov 09 20:51:32 2015 -0800
++++ b/lib/vagrant-skytap/errors.rb	Mon Nov 09 20:52:02 2015 -0800
+@@ -27,6 +27,10 @@
+         error_key(:does_not_exist)
+       end
+ 
++      class VmVanished < VagrantSkytapError
++        error_key(:vm_vanished)
++      end
++
+       class BadVmUrl < VagrantSkytapError
+         error_key(:bad_vm_url)
+       end
+diff -r 1b8860f8b512 locales/en.yml
+--- a/locales/en.yml	Mon Nov 09 20:51:32 2015 -0800
++++ b/locales/en.yml	Mon Nov 09 20:52:02 2015 -0800
+@@ -76,6 +76,9 @@
+       does_not_exist: |-
+         %{object_name} was not found.
+ 
++      vm_vanished: |-
++        The VM '%{name}' no longer exists on Skytap.
++
+       operation_failed: |-
+         The operation failed: %{err}
+ 

data/lib/vagrant-skytap/action/clear_forwarded_ports.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module Skytap
+    module Action
+      # This is based on code from the VirtualBox provider.
+      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(:clear_forwarded_ports, env[:machine])
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/action/forward_ports.rb

@@ -0,0 +1,42 @@
+require 'vagrant-skytap/util/compile_forwarded_ports'
+
+module VagrantPlugins
+  module Skytap
+    module Action
+      # This is based on code from the VirtualBox provider.
+      class ForwardPorts
+        include Util::CompileForwardedPorts
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+          env[:forwarded_ports] ||= compile_forwarded_ports(env[:machine].config)
+
+          if env[:forwarded_ports].any?(&:privileged_host_port?)
+            env[:ui].warn I18n.t("vagrant.actions.vm.forward_ports.privileged_ports")
+          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.internal_ssh_port?
+              @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[:machine])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/action/prepare_forwarded_port_collision_params.rb

@@ -0,0 +1,37 @@
+module VagrantPlugins
+  module Skytap
+    module Action
+      # This is based on code from the VirtualBox provider.
+      class PrepareForwardedPortCollisionParams
+        def initialize(app, env)
+          @app = app
+        end
+
+        # This logic is based on the VirtualBox provider
+        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[:machine])
+
+          # Build the remap for any existing collision detections
+          remap = {}
+          env[:port_collision_remap] = remap
+          env[:host].capability(:read_forwarded_ports, env[:machine]).each do |fp|
+            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] == fp.id
+                remap[options[:host]] = fp.host_port
+                break
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/action.rb

@@ -15,6 +15,7 @@ module VagrantPlugins
             when :missing_environment, :missing_vm, :no_vms
               b1.use MessageNotCreated
             else
+              b1.use ClearForwardedPorts
               b1.use StopVm
             end
           end
@@ -30,6 +31,7 @@ module VagrantPlugins
             when :missing_environment, :missing_vm, :no_vms
               b1.use MessageNotCreated
             else
+              b1.use ClearForwardedPorts
               b1.use SuspendVm
             end
           end
@@ -65,6 +67,7 @@ module VagrantPlugins
               end
             end
           end
+          b.use ClearForwardedPorts
           b.use PrepareNFSValidIds
           b.use SyncedFolderCleanup
         end
@@ -175,6 +178,7 @@ module VagrantPlugins
               b1.use MessageResuming
               b1.use RunVm
               b1.use WaitForCommunicator
+              b1.use action_forward_ports
             end
           end
         end
@@ -251,6 +255,7 @@ module VagrantPlugins
             end
           end
           b.use WaitForCommunicator
+          b.use action_forward_ports
         end
       end
 
@@ -281,15 +286,27 @@ module VagrantPlugins
         end
       end
 
+      def self.action_forward_ports
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ClearForwardedPorts
+          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 @@ module VagrantPlugins
       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")

data/lib/vagrant-skytap/api/environment.rb

@@ -20,8 +20,16 @@ module VagrantPlugins
             vm = Vm.fetch(env, vm_url)
             check_vm_before_adding(env, vm)
 
-            resp = env[:api_client].post(RESOURCE_ROOT, JSON.dump(template_id: vm.template_id, vm_ids: [vm.id]))
-            fetch(env, resp['Location'])
+            args = {vm_ids: [vm.id]}.tap do |ret|
+              if vm.from_template?
+                ret[:template_id] = vm.template_id
+              else
+                ret[:configuration_id] = vm.configuration_id
+              end
+            end
+
+            resp = env[:api_client].post(RESOURCE_ROOT, JSON.dump(args))
+            new(JSON.load(resp.body), env)
           end
 
           def fetch(env, url)
@@ -34,7 +42,6 @@ module VagrantPlugins
           end
 
           def check_vm_before_adding(env, vm)
-            raise Errors::NotTemplateVm, url: vm.url unless vm.from_template?
             raise Errors::SourceVmNotStopped, name: env[:machine].name, url: vm.url unless vm.stopped?
           end
         end
@@ -107,7 +114,15 @@ module VagrantPlugins
           check_vm_before_adding(env, vm)
           vm_ids = vms.collect(&:id)
 
-          update_with_retry(template_id: vm.template_id, vm_ids: [vm.id])
+          args = {vm_ids: [vm.id]}.tap do |ret|
+            if vm.from_template?
+              ret[:template_id] = vm.template_id
+            else
+              ret[:merge_configuration] = vm.configuration_id
+            end
+          end
+
+          update_with_retry(args)
           new_vm_ids = vms.collect(&:id) - vm_ids
           get_vm_by_id(new_vm_ids.last)
         end

data/lib/vagrant-skytap/api/vm.rb

@@ -12,7 +12,7 @@ module VagrantPlugins
         attr_reader :provider_config
         attr_reader :environment
 
-        reads :id, :interfaces, :credentials, :name
+        reads :id, :interfaces, :credentials, :name, :configuration_url, :template_url
 
         class << self
           def fetch(env, url)
@@ -57,19 +57,23 @@ module VagrantPlugins
         end
 
         def from_template?
-          !!get_api_attribute('template_url')
+          !!template_url
         end
 
         def template_id
-          get_api_attribute('template_url') =~ /templates\/(\d+)/
+          template_url =~ /templates\/(\d+)/
+          $1
+        end
+
+        def configuration_id
+          configuration_url =~ /configurations\/(\d+)/
           $1
         end
 
         def region
           return @region if @region
-          resp = env[:api_client].get(get_api_attribute('template_url'))
-          template_attrs = JSON.load(resp.body)
-          @region = template_attrs['region']
+          resp = env[:api_client].get(template_url || configuration_url)
+          @region = JSON.load(resp.body)['region']
         end
 
         def delete

data/lib/vagrant-skytap/command/up.rb

@@ -54,7 +54,13 @@ module VagrantPlugins
           return if !argv
 
           # Validate the provisioners
-          validate_provisioner_flags!(options, argv)
+          if method(:validate_provisioner_flags!).arity == 1
+            validate_provisioner_flags!(options)
+          else
+            # Second argument was added in Vagrant 1.8.0
+            # https://github.com/mitchellh/vagrant/pull/5981
+            validate_provisioner_flags!(options, argv)
+          end
 
           # Go over each VM and bring it up
           @logger.debug("'Up' each target VM...")

data/lib/vagrant-skytap/errors.rb

@@ -66,6 +66,10 @@ module VagrantPlugins
       class NoConnectionOptions < VagrantSkytapError
         error_key(:no_connection_options)
       end
+
+      class FeatureNotSupportedForHostOs < VagrantSkytapError
+        error_key(:feature_not_supported_for_host_os)
+      end
     end
   end
 end

data/lib/vagrant-skytap/hosts/bsd/cap/ssh_tunnel.rb

@@ -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

data/lib/vagrant-skytap/hosts/common/cap/ssh_tunnel.rb

@@ -0,0 +1,183 @@
+require "vagrant/util/subprocess"
+require "vagrant/util/safe_chdir"
+require "vagrant-skytap/model/forwarded_port"
+require 'log4r'
+
+# Port forwarding for the Skytap provider is implemented
+# using the autossh utility, which starts, monitors, and
+# restarts SSH tunnels, and optionally creates pidfiles.
+# We specify pidfile names which correspond to the
+# forwarded port fields.
+
+# Methods such as #ssh_args, which may need to return a
+# different value for a particular OS, can be overridden
+# by subclassing this capability file and registering
+# the new host capability in the provider plugin.
+
+module VagrantPlugins
+  module Skytap
+    module HostCommon
+      module Cap
+        class SSHTunnel
+          class << self
+            def create_logger
+              raise NotImplementedError
+            end
+
+            # Start an autossh process for the given [Model::ForwardedPort]
+            # on the given [Vagrant::Machine]. If autossh is not
+            # available on the host, an appropriate error message
+            # will be shown, asking the user to install it.
+            #
+            # @return [Vagrant::Util::Subprocess::Result]
+            def start_ssh_tunnel(env, fp, machine)
+              kill_ssh_tunnel(env, fp, machine)
+              args = ssh_args(fp, machine)
+              args << {env: autossh_environment_variables(fp, machine)}
+              Vagrant::Util::Subprocess.execute("autossh", "-f", *args)
+            end
+
+            # Kill the autossh process for the given [Model::ForwardedPort]
+            # on the given [Vagrant::Machine]. autossh will kill the ssh
+            # child process before terminating.
+            #
+            # @return [Vagrant::Util::Subprocess::Result]
+            def kill_ssh_tunnel(env, fp, machine)
+              if pid = read_pid(pidfile_path(fp, machine))
+                Vagrant::Util::Subprocess.execute("kill", pid.to_s)
+              end
+            end
+
+            # Convenience method which kills all autossh processes for
+            # the given [Vagrant::Machine].
+            #
+            # @return [Array] of [Model::ForwardedPort] objects
+            def clear_forwarded_ports(env, machine)
+              get_fp_from_directory(machine.data_dir).each do |fp|
+                kill_ssh_tunnel(env, fp, machine)
+              end
+            end
+
+            # The currently forwarded ports for this [Vagrant::Machine].
+            #
+            # @return [Array] of [Model::ForwardedPort] objects
+            def read_forwarded_ports(env, machine)
+              get_fp_from_directory(machine.data_dir)
+            end
+
+            # The currently forwarded ports for all *other*
+            # [Vagrant::Machine]s in this project.
+            #
+            # @return [Array] of [Model::ForwardedPort] objects
+            def read_used_ports(env, machine)
+              search_paths = machine_data_dirs(env).reject!{|k,v| k == machine.name.to_s}.values
+              search_paths.collect{|path| get_fp_from_directory(path)}.flatten
+            end
+
+
+
+            # Reads the process id (pid) from the given pidfile.
+            #
+            # @return [Integer], or nil if not found.
+            def read_pid(pidfile_path)
+              File.read(pidfile_path).presence.try(:to_i) if File.exist?(pidfile_path)
+            end
+
+            # Gets forwarded ports by reading pidfiles in the given
+            # directory.
+            #
+            # @return [Array] of [Model::ForwardedPort] objects
+            def get_fp_from_directory(dir)
+              pidfiles = []
+              Vagrant::Util::SafeChdir.safe_chdir(dir) do
+                pidfiles = Dir.glob("*.pid")
+              end
+              pidfiles.collect{|pidfile| pidfile_to_fp(pidfile)}
+            end
+
+            # Returns a mapping of machine names to their data_dirs
+            # (full paths).
+            #
+            # @return [Hash]
+            def machine_data_dirs(env)
+              h = {}
+              env_path = env.local_data_path
+              Vagrant::Util::SafeChdir.safe_chdir(env.local_data_path) do
+                Dir.foreach("machines") do |machine_name|
+                  data_dir = "machines/#{machine_name}/skytap"
+                  if Dir.exist?(data_dir)
+                    h[machine_name] = env_path.join(data_dir)
+                  end
+                end
+              end
+              h
+            end
+
+            # Gets the full path to the pidfile for the given
+            # [Model::ForwardedPort] and [Vagrant::Machine].
+            #
+            # @return [Model::ForwardedPort]
+            def pidfile_path(fp, machine)
+              machine.data_dir.join(fp_to_pidfile(fp)).to_s
+            end
+
+            # Generate a pidfile name which encodes enough information
+            # to reconstruct the given [Model::ForwardedPort].
+            #
+            # @return [String]
+            def fp_to_pidfile(fp)
+              "#{fp.id}_#{fp.protocol}_#{fp.host_port}_#{fp.guest_port}.pid"
+            end
+
+            # Create a [Model::ForwardedPort] from a parsed pidfile name.
+            #
+            # @return [Model::ForwardedPort]
+            def pidfile_to_fp(pidfile)
+              pidfile =~ /(\w*)_(\w*)_(\w*)_(\w*)\.pid/
+              id, protocol, host_port, guest_port = $1, $2, $3, $4
+              Model::ForwardedPort.new(id, host_port.to_i, guest_port.to_i, protocol: protocol)
+            end
+
+
+
+            # Gets the arguments to be passed to ssh for the given
+            # [Model::ForwardedPort] on the given [Vagrant::Machine].
+            #
+            # @return [Array] of [String]
+            def ssh_args(fp, machine)
+              ssh_info = machine.ssh_info
+              # TODO: tune these settings
+              ssh_options = {
+                "ServerAliveInterval" => 10,
+                "ServerAliveCountMax" => 3,
+                "StrictHostKeyChecking" => "no",
+              }
+
+              args = []
+              args << "-q" # quiet
+              args << "-N" # no remote command
+              args << "-i" << machine.data_dir.join("private_key").to_s
+              args << "-L" << "#{fp.host_port}:localhost:#{fp.guest_port}"
+              ssh_options.each do |k, v|
+                # options in ssh config file format
+                args << "-o" << "#{k}=#{v}"
+              end
+              args << "#{ssh_info[:username]}@#{ssh_info[:host]}"
+            end
+
+            # Gets the environment variables to be set when calling
+            # autossh.
+            #
+            # @return [Hash]
+            def autossh_environment_variables(fp, machine, monitoring_port = 0)
+              {
+                "AUTOSSH_PIDFILE" => pidfile_path(fp, machine),
+                "AUTOSSH_PORT" => monitoring_port,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/hosts/linux/cap/ssh_tunnel.rb

@@ -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

data/lib/vagrant-skytap/hosts/windows/cap/ssh_tunnel.rb

@@ -0,0 +1,27 @@
+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)
+            raise Errors::FeatureNotSupportedForHostOs, feature_name: "port forwarding"
+          end
+
+          def self.kill_ssh_tunnel(env, pidfile, env_hash)
+            raise Errors::FeatureNotSupportedForHostOs, feature_name: "port forwarding"
+          end
+
+          def self.kill_ssh_tunnel(env, machine)
+            raise Errors::FeatureNotSupportedForHostOs, feature_name: "port forwarding"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/model/forwarded_port.rb

@@ -0,0 +1,78 @@
+module VagrantPlugins
+  module Skytap
+    module Model
+      # This is based on code from the VirtualBox provider.
+      class ForwardedPort
+        # 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)
+          @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
+
+        # Returns true if the host port is privileged.
+        #
+        # @param [Boolean]
+        def privileged_host_port?
+          host_port <= 1024
+        end
+
+        # Returns true if this is the SSH port used internally
+        # by Vagrant.
+        #
+        # @param [Boolean]
+        def internal_ssh_port?
+          (guest_port == 22 && host_port == 2222) || id == "ssh"
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/plugin.rb

@@ -49,6 +49,21 @@ module VagrantPlugins
         Cap::PublicAddress
       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"
+          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)