vagrant-xapi 0.0.1 → 1.0.0

data/lib/vagrant-xapi/services/networks.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "digest"
+require "ipaddr"
+
+require_relative "base"
+require_relative "lock"
+require_relative "lookup"
+
+module VagrantPlugins
+  module Xapi
+    module Services
+      # One VIF to create.
+      #   kind: :public, :private (existing network), :internal (no PIF),
+      #         :default (default_network), :himn
+      VifSpec = Struct.new(
+        :device, :kind, :network, :bridge, :internal_name, :mac, :mtu, :ip, :netmask,
+        :gateway, :locking_mode, :auto_config, keyword_init: true
+      ) do
+        def static_ip?
+          !ip.to_s.empty?
+        end
+
+        def ipv6?
+          ip.to_s.include?(":")
+        end
+
+        # netmask may be a prefix length ("24", 64) or a dotted mask.
+        def prefix_length
+          return(ipv6? ? 64 : 24) if netmask.to_s.empty?
+          return netmask.to_i if netmask.to_s =~ /\A\d+\z/
+
+          IPAddr.new(netmask.to_s).to_i.to_s(2).count("1")
+        end
+      end
+
+      # Turns Vagrant network definitions into VIFs and manages internal
+      # networks. XAPI has no NAT and no DHCP: every VIF hangs on a real
+      # network of the pool.
+      class Networks
+        include Helpers
+
+        def initialize(ctx, project:)
+          @ctx = ctx
+          @client = ctx.client
+          @lookup = Lookup.new(ctx)
+          @project = project.to_s
+        end
+
+        def self.default_internal_name(project)
+          "vagrant-xapi-#{Digest::SHA256.hexdigest(project.to_s)[0, 10]}"
+        end
+
+        # Pure planning: the order of VIFs.
+        #
+        # @param networks [Array<[Symbol, Hash]>] config.vm.networks with
+        #   provider-scoped options already applied
+        # @param default_network [String, nil]
+        # @param himn [Boolean] add a VIF on the host internal management network
+        # @return [Array<VifSpec>]
+        def self.plan(networks, default_network:, himn: false, project: "")
+          list = networks.reject { |type, _| type == :forwarded_port }
+          public_idx = list.index { |type, _| type == :public_network }
+          ordered = []
+          if public_idx
+            ordered << list[public_idx]
+            list = list.each_with_index.reject { |_, i| i == public_idx }.map(&:first)
+          else
+            ordered << [:default, { network: default_network }]
+          end
+          ordered.concat(list)
+
+          specs = ordered.each_with_index.map do |(type, opts), device|
+            opts ||= {}
+            kind = case type
+                   when :default then :default
+                   when :public_network then :public
+                   when :private_network
+                     opts[:network] || opts[:bridge] ? :private : :internal
+                   else
+                     next nil
+                   end
+            VifSpec.new(
+              device: device,
+              kind: kind,
+              network: opts[:network],
+              bridge: opts[:bridge],
+              internal_name: kind == :internal ? (opts[:name] || default_internal_name(project)).to_s : nil,
+              mac: normalize_mac(opts[:mac]),
+              mtu: opts[:mtu],
+              ip: opts[:ip],
+              netmask: opts[:netmask],
+              gateway: opts[:gateway],
+              locking_mode: opts[:locking_mode],
+              # auto_config: false = the user configures the guest network.
+              auto_config: opts[:auto_config] != false
+            )
+          end.compact
+          specs.each_with_index { |s, i| s.device = i }
+          specs << VifSpec.new(device: specs.size, kind: :himn) if himn
+          specs
+        end
+
+        def self.normalize_mac(mac)
+          return nil if mac.nil? || mac.to_s.empty?
+
+          hex = mac.to_s.delete(":-").downcase
+          return mac.to_s unless hex =~ /\A[0-9a-f]{12}\z/
+
+          hex.scan(/../).join(":")
+        end
+
+        # Recreates all VIFs of a halted VM. Keeps the MAC address per device
+        # unless one is configured, so cloud-init network-config stays valid.
+        # Every network is resolved before a VIF is removed: a name that no
+        # longer resolves must not leave the VM without VIFs and lose their
+        # MACs.
+        # @return [Hash{Integer => String}] device => MAC
+        def apply(vm, specs)
+          resolved = specs.map do |spec|
+            network = resolve(spec)
+            [spec, network, spec.mtu ? spec.mtu.to_i : @client.call("network.get_MTU", network).to_i]
+          end
+          existing = @client.call("VM.get_VIFs", vm).map { |v| [v, @client.call("VIF.get_record", v)] }
+          old_macs = existing.to_h { |_ref, rec| [rec["device"].to_i, rec["MAC"]] }
+          existing.each { |ref, _| @client.call("VIF.destroy", ref) }
+
+          resolved.each_with_object({}) do |(spec, network, mtu), macs|
+            record = {
+              "device" => spec.device.to_s,
+              "network" => network,
+              "VM" => vm,
+              "MAC" => spec.mac || (spec.kind == :himn ? "" : old_macs[spec.device].to_s),
+              "MTU" => mtu,
+              "other_config" => {},
+              "qos_algorithm_type" => "",
+              "qos_algorithm_params" => {}
+            }
+            record["locking_mode"] = spec.locking_mode.to_s if spec.locking_mode
+            vif = @client.call("VIF.create", record)
+            macs[spec.device] = @client.call("VIF.get_MAC", vif)
+          end
+        end
+
+        # @return [String] network ref
+        def resolve(spec)
+          case spec.kind
+          when :default
+            spec.network ? @lookup.network(spec.network) : @lookup.management_network
+          when :public, :private
+            if spec.network
+              @lookup.network(spec.network)
+            elsif spec.bridge
+              @lookup.network_by_bridge(spec.bridge)
+            else
+              @lookup.management_network
+            end
+          when :internal
+            ensure_internal(spec.internal_name)
+          when :himn
+            @lookup.himn_network
+          end
+        end
+
+        # Internal network without PIF, created when missing and marked with
+        # the project.
+        def ensure_internal(name)
+          found = find_internal(name)
+          return found if found
+
+          Lock.new(@ctx, "network.#{name}", ttl: 300, wait: 300).synchronize do
+            find_internal(name) || begin
+              @ctx.ui&.info(:creating_network, name: name)
+              @client.call("network.create", {
+                "name_label" => name,
+                "name_description" => "Internal network created by vagrant-xapi for #{@project}",
+                "MTU" => 1500,
+                "other_config" => { Marking::PROJECT => @project, Marking::NETWORK => name },
+                "tags" => []
+              })
+            end
+          end
+        end
+
+        # Only a network marked for this project is used. A network with the
+        # same name that belongs to another project (or to nobody) is never
+        # joined: that would connect two projects on one L2 segment.
+        def find_internal(name)
+          refs = @client.call("network.get_by_name_label", name)
+          return nil if refs.empty?
+
+          ours = refs.find { |r| Marking.ours?(@client.call("network.get_other_config", r), Marking::PROJECT, @project) }
+          raise Error.new(:internal_network_taken, name: name) unless ours
+
+          ours
+        end
+
+        # Internal networks (with our marking) the VM is attached to.
+        def internal_networks_of(vm)
+          @client.call("VM.get_VIFs", vm).filter_map do |vif|
+            net = @client.call("VIF.get_network", vif)
+            oc = @client.call("network.get_other_config", net)
+            net if oc.key?(Marking::NETWORK) && @client.call("network.get_PIFs", net).empty?
+          end.uniq
+        end
+
+        # Internal networks only exist per host, so all VMs on one must run on
+        # the same host: the host of a VM that already runs on one of them.
+        # @return [String, nil] host ref, nil when no other VM runs there
+        def running_peer_host(networks, except:)
+          networks.each do |net|
+            @client.call("network.get_VIFs", net).each do |vif|
+              peer = ignore_missing { @client.call("VIF.get_VM", vif) }
+              next if peer.nil? || peer == except
+
+              rec = ignore_missing { @client.call("VM.get_record", peer) }
+              next unless rec && rec["power_state"] == "Running" && !null_ref?(rec["resident_on"])
+
+              return rec["resident_on"]
+            end
+          end
+          nil
+        end
+
+        # Serializes VM starts of this project, so two machines on the same
+        # internal network cannot both start before either one runs.
+        def placement_lock(&block)
+          Lock.new(@ctx, "placement.#{Digest::SHA256.hexdigest(@project)[0, 16]}", ttl: 600, wait: 1800)
+              .synchronize(&block)
+        end
+
+        # Removes internal networks of this project that no VIF uses anymore.
+        def cleanup_unused(candidates)
+          candidates.each do |net|
+            ignore_missing do
+              oc = @client.call("network.get_other_config", net)
+              next unless Marking.ours?(oc, Marking::PROJECT, @project) && oc.key?(Marking::NETWORK)
+              next unless @client.call("network.get_VIFs", net).empty?
+
+              @ctx.ui&.detail(:removing_network, name: @client.call("network.get_name_label", net))
+              @client.call("network.destroy", net)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/services/power.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module VagrantPlugins
+  module Xapi
+    module Services
+      # Power operations, always through Async.* tasks.
+      class Power
+        include Helpers
+
+        STATES = {
+          "Halted" => :halted,
+          "Running" => :running,
+          "Suspended" => :suspended,
+          "Paused" => :paused
+        }.freeze
+
+        def initialize(ctx)
+          @ctx = ctx
+          @client = ctx.client
+        end
+
+        # @return [Hash] :state (Symbol), :operations (Array<String>)
+        def state(vm)
+          rec = @client.call("VM.get_record", vm)
+          {
+            state: STATES.fetch(rec["power_state"], :unknown),
+            operations: (rec["current_operations"] || {}).values.map(&:to_s)
+          }
+        end
+
+        def power_state(vm)
+          STATES.fetch(@client.call("VM.get_power_state", vm), :unknown)
+        end
+
+        # @param host [String, nil] host ref to start on (internal networks)
+        def start(vm, host: nil)
+          @ctx.ui&.info(:starting_vm)
+          if host && !null_ref?(host)
+            @ctx.run_task("VM.start_on", vm, host, false, false, label: "start")
+          else
+            @ctx.run_task("VM.start", vm, false, false, label: "start")
+          end
+        end
+
+        # clean_shutdown, then hard_shutdown after `timeout` seconds.
+        def shutdown(vm, timeout:, force: false)
+          state = power_state(vm)
+          return if state == :halted
+
+          if force || state != :running
+            hard_shutdown(vm)
+            return
+          end
+
+          @ctx.ui&.info(:clean_shutdown)
+          begin
+            @ctx.client.run_task("VM.clean_shutdown", vm, label: "clean_shutdown",
+                                                          timeout: timeout, cancel: @ctx.cancel)
+          rescue Api::TaskTimeout, Api::XapiError => e
+            @ctx.logger&.info("clean shutdown failed (#{e.message}); forcing")
+          end
+          hard_shutdown(vm) unless power_state(vm) == :halted
+        end
+
+        def hard_shutdown(vm)
+          return if power_state(vm) == :halted
+
+          @ctx.ui&.info(:hard_shutdown)
+          @ctx.run_task("VM.hard_shutdown", vm, label: "hard_shutdown")
+        end
+
+        def suspend(vm)
+          @ctx.ui&.info(:suspending)
+          @ctx.run_task("VM.suspend", vm, label: "suspend", progress_key: :suspending_progress)
+        rescue Api::XapiError => e
+          case e.code
+          when "VM_MISSING_PV_DRIVERS", "VM_LACKS_FEATURE_SUSPEND", "VM_LACKS_FEATURE"
+            raise Error.new(:suspend_no_drivers)
+          when "VM_NO_SUSPEND_SR", "SR_NOT_FOUND"
+            raise Error.new(:suspend_no_sr)
+          else
+            raise
+          end
+        end
+
+        # @param host [String, nil] host ref to resume on (internal networks)
+        def resume(vm, host: nil)
+          @ctx.ui&.info(:resuming)
+          if host && !null_ref?(host)
+            @ctx.run_task("VM.resume_on", vm, host, false, false, label: "resume", progress_key: :resuming_progress)
+          else
+            @ctx.run_task("VM.resume", vm, false, false, label: "resume", progress_key: :resuming_progress)
+          end
+        end
+
+        def unpause(vm)
+          @ctx.run_task("VM.unpause", vm, label: "unpause")
+        end
+
+        def resident_host(vm)
+          @client.call("VM.get_resident_on", vm)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/services/rfb.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "securerandom"
+
+module VagrantPlugins
+  module Xapi
+    module Services
+      # The RFB (VNC) handshake of the console proxy. Towards the local
+      # viewer it asks for a one-time VNC password, so no other local user
+      # can watch the console through the port, and macOS Screen Sharing,
+      # which always wants a password, connects without asking (the password
+      # goes into the vnc:// URL). Towards XAPI, which controls access with
+      # the session and offers no authentication, it chooses "None". After
+      # both handshakes the bytes pass through unchanged.
+      module Rfb
+        NONE = 1
+        VNC_AUTH = 2
+        TIMEOUT = 30
+        VERSION_RE = /\ARFB (\d{3})\.(\d{3})\n\z/.freeze
+
+        class Error < StandardError; end
+
+        module_function
+
+        # VNC uses at most 8 characters.
+        def password
+          SecureRandom.alphanumeric(8)
+        end
+
+        # The answer to a VNC challenge: DES-ECB with the password as key,
+        # the bits of every key byte reversed (as VNC does). OpenSSL 3 keeps
+        # single DES in its legacy provider; 3DES with the key three times is
+        # the same cipher and is in the default provider.
+        def vnc_response(password, challenge)
+          key = password.to_s.b[0, 8].ljust(8, "\0").bytes.map { |b| reverse_bits(b) }.pack("C*")
+          cipher = OpenSSL::Cipher.new("des-ede3")
+          cipher.encrypt
+          cipher.key = key * 3
+          cipher.padding = 0
+          cipher.update(challenge.b) + cipher.final
+        end
+
+        # Whether this Ruby/OpenSSL can do it (3DES may be missing, e.g. in a
+        # FIPS-only build).
+        def available?
+          vnc_response("x", "\0" * 16).bytesize == 16
+        rescue OpenSSL::Cipher::CipherError, RuntimeError
+          false
+        end
+
+        # Towards the viewer: offers only VNC authentication.
+        # @return [Boolean] whether the viewer knew the password
+        def serve_viewer(io, password)
+          io.write("RFB 003.008\n")
+          minor = minor_version(read(io, 12))
+          if minor < 7
+            io.write([VNC_AUTH].pack("N"))
+          else
+            io.write([1, VNC_AUTH].pack("CC"))
+            chosen = read(io, 1).unpack1("C")
+            raise Error, "the viewer chose security type #{chosen}" unless chosen == VNC_AUTH
+          end
+          challenge = SecureRandom.random_bytes(16)
+          io.write(challenge)
+          ok = OpenSSL.fixed_length_secure_compare(read(io, 16), vnc_response(password, challenge))
+          io.write([ok ? 0 : 1].pack("N"))
+          io.write([14].pack("N") + "Wrong password") if !ok && minor >= 8
+          ok
+        end
+
+        # Towards XAPI: takes "None".
+        def join_server(io)
+          minor = minor_version(read(io, 12))
+          io.write(format("RFB 003.%03d\n", minor))
+          if minor < 7
+            type = read(io, 4).unpack1("N")
+            raise Error, reason(io) if type.zero?
+            raise Error, "the console asks for security type #{type}" unless type == NONE
+          else
+            count = read(io, 1).unpack1("C")
+            raise Error, reason(io) if count.zero?
+            raise Error, "the console offers no access without authentication" unless read(io, count).bytes.include?(NONE)
+
+            io.write([NONE].pack("C"))
+            # Only 3.8 sends a result for "None".
+            raise Error, reason(io) if minor >= 8 && !read(io, 4).unpack1("N").zero?
+          end
+        end
+
+        # 3, 7 or 8: the protocol versions with different handshakes. Apple's
+        # 3.889 behaves as 3.8 here.
+        def minor_version(line)
+          m = VERSION_RE.match(line)
+          raise Error, "not an RFB greeting: #{line.inspect}" unless m && m[1] == "003"
+
+          minor = m[2].to_i
+          if minor >= 8 then 8
+          elsif minor == 7 then 7
+          else 3
+          end
+        end
+
+        def reason(io)
+          read(io, [read(io, 4).unpack1("N"), 1024].min)
+        rescue Error
+          "refused"
+        end
+
+        def read(io, count)
+          data = +"".b
+          while data.bytesize < count
+            pending = io.respond_to?(:pending) && io.pending.positive?
+            raise Error, "timed out" unless pending || IO.select([io], nil, nil, TIMEOUT)
+
+            data << io.readpartial(count - data.bytesize)
+          end
+          data
+        rescue EOFError, IOError, SystemCallError
+          raise Error, "the connection closed during the handshake"
+        end
+
+        def reverse_bits(byte)
+          format("%08b", byte).reverse.to_i(2)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/services/snapshots.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module VagrantPlugins
+  module Xapi
+    module Services
+      # vagrant snapshot save/restore/delete/list (and therefore push/pop).
+      class Snapshots
+        include Helpers
+
+        def initialize(ctx)
+          @ctx = ctx
+          @client = ctx.client
+        end
+
+        # Names, oldest first (push/pop depend on this order).
+        def list(vm)
+          records(vm).map { |_ref, rec| rec["name_label"] }
+        end
+
+        # [[ref, record], ...] sorted by snapshot_time
+        def records(vm)
+          @client.call("VM.get_snapshots", vm)
+                 .map { |ref| [ref, @client.call("VM.get_record", ref)] }
+                 .sort_by { |_ref, rec| rec["snapshot_time"].to_s }
+        end
+
+        def find(vm, name)
+          hits = records(vm).select { |_ref, rec| rec["name_label"] == name.to_s }
+          raise Error.new(:snapshot_not_found, name: name.to_s) if hits.empty?
+
+          hits.last.first
+        end
+
+        # @param memory [Boolean] checkpoint (with RAM) when running
+        def save(vm, name, memory: false)
+          raise Error.new(:snapshot_exists, name: name.to_s) if list(vm).include?(name.to_s)
+
+          vm_uuid = @client.call("VM.get_uuid", vm)
+          running = @client.call("VM.get_power_state", vm) == "Running"
+          method = memory && running ? "VM.checkpoint" : "VM.snapshot"
+          snap = @ctx.run_task(method, vm, name.to_s, label: "snapshot #{name}").ref
+          raise Error.new(:snapshot_failed, name: name.to_s) unless snap
+
+          set_oc("VM", snap, Marking::SNAPSHOT_OF, vm_uuid)
+          # Mark the snapshot's disks so destroy can find them.
+          disk_vdis(snap).each { |vdi| set_oc("VDI", vdi, Marking::OWNER_VM, vm_uuid) }
+          snap
+        end
+
+        # @return [Symbol] power state after revert (:suspended for checkpoints)
+        def restore(vm, name)
+          snap = find(vm, name)
+          @ctx.run_task("VM.revert", snap, label: "revert #{name}")
+          Power::STATES.fetch(@client.call("VM.get_power_state", vm), :unknown)
+        end
+
+        def delete(vm, name)
+          destroy_snapshot(find(vm, name))
+        end
+
+        def delete_all(vm)
+          records(vm).each { |ref, _| destroy_snapshot(ref) }
+        end
+
+        # VDIs first, then the snapshot object; the SM layer coalesces the
+        # VHD chain in the background.
+        def destroy_snapshot(snap)
+          vdis = vbds_of(snap).filter_map do |_vbd, rec|
+            rec["VDI"] if rec["type"] == "Disk" && !null_ref?(rec["VDI"])
+          end
+          suspend_vdi = ignore_missing { @client.call("VM.get_suspend_VDI", snap) }
+          vdis << suspend_vdi unless null_ref?(suspend_vdi)
+          vdis.uniq.each { |vdi| ignore_missing { @client.call("VDI.destroy", vdi) } }
+          ignore_missing { @client.call("VM.destroy", snap) }
+        end
+      end
+    end
+  end
+end