vagrant-xapi 0.0.1 → 1.0.0

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
+require_relative "base"
+require_relative "../services/diff_disks"
+require_relative "../services/power"
+require_relative "../services/networks"
+require_relative "../services/ip_detector"
+
+module VagrantPlugins
+  module Xapi
+    module Action
+      # Starts a halted VM. VMs on an internal network all run on the host of
+      # the first VM that used it (internal networks exist per host).
+      class StartVm < Base
+        def call(env)
+          wrap { Action.placed(env, ctx(env), vm(env)) { |power, ref, host| power.start(ref, host: host) } }
+          @app.call(env)
+        end
+      end
+
+      # Yields Power, the VM and the host it must run on: on an internal
+      # network the host of a running peer, under the project's placement
+      # lock; otherwise nil (XAPI chooses).
+      def self.placed(env, ctx, ref)
+        networks = Services::Networks.new(ctx, project: Glue.project_path(env[:machine]))
+        internal = networks.internal_networks_of(ref)
+        power = Services::Power.new(ctx)
+        return yield(power, ref, nil) if internal.empty?
+
+        networks.placement_lock { yield(power, ref, networks.running_peer_host(internal, except: ref)) }
+      end
+
+      # Vagrant's SSH communicator lists Errno::EPIPE among the errors to
+      # retry, but wait_for_ready connects with a single try and does not
+      # rescue it, so `vagrant up` died with a stack trace. net-ssh raises it
+      # when sshd closes a connection right after accepting it. OpenSSH 9.8
+      # and newer do that for a while after failed logins from the same
+      # address (PerSourcePenalties), e.g. while cloud-init is still creating
+      # the vagrant user. Here it counts as "not ready yet", within the same
+      # timeout.
+      module BrokenPipeRetry
+        RETRY_DELAY = 5
+        # Repeated, so a wait that never ends does not look stuck.
+        WARN_EVERY = 60
+
+        def wait_for_ready(timeout)
+          deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+          warned_at = nil
+          begin
+            super([deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC), 1].max)
+          rescue Errno::EPIPE
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            return false if now + RETRY_DELAY >= deadline
+
+            if warned_at.nil? || now - warned_at >= WARN_EVERY
+              instance_variable_get(:@machine)&.ui&.detail(I18n.t("vagrant_xapi.messages.ssh_broken_pipe"))
+              warned_at = now
+            end
+            sleep RETRY_DELAY
+            retry
+          end
+        end
+      end
+
+      # Vagrant's WaitForCommunicator with BrokenPipeRetry on the machine's
+      # communicator.
+      class WaitForCommunicator < Vagrant::Action::Builtin::WaitForCommunicator
+        def call(env)
+          communicator = env[:machine].communicate
+          unless communicator.singleton_class.include?(BrokenPipeRetry)
+            communicator.singleton_class.prepend(BrokenPipeRetry)
+          end
+          super
+        end
+      end
+
+      # Removes snapshot disks an interrupted `vagrant xapi diff` left attached,
+      # before the guest boots: they carry the same file system UUIDs as the
+      # VM's own disks, so the guest could mount (or boot from) the copy. One
+      # that cannot be removed stops the boot with an error.
+      class RemoveDiffDisks < Base
+        def call(env)
+          wrap do
+            disks = Services::DiffDisks.new(ctx(env))
+            # Under the diff lock of the VM: a diff still running on it (the
+            # VM was halted under it) keeps its disks until it is done.
+            disks.synchronize(vm(env), wait: Services::DiffDisks::LEFTOVER_LOCK_WAIT) do
+              disks.cleanup_leftovers(vm(env), unattached: false, required: true)
+            end
+          end
+          @app.call(env)
+        end
+      end
+
+      # Waits until the guest reports an IP (config.vm.boot_timeout).
+      class WaitForIp < Base
+        def call(env)
+          machine = env[:machine]
+          wrap do
+            c = ctx(env)
+            env[:ui].info(I18n.t("vagrant_xapi.messages.waiting_for_ip"))
+            ip, source = Glue.ip_detector(machine, c).wait(vm(env), timeout: machine.config.vm.boot_timeout)
+            env[:ui].detail(I18n.t("vagrant_xapi.messages.ip_found", ip: ip, source: source))
+            env[:xapi_ip] = ip
+          end
+          @app.call(env)
+        end
+      end
+
+      # clean_shutdown, then hard_shutdown after shutdown_timeout; with
+      # --force (env[:force_halt]) straight to hard_shutdown.
+      class HaltVm < Base
+        def call(env)
+          wrap do
+            ref = vm(env)
+            Services::Power.new(ctx(env)).shutdown(ref, timeout: config(env).shutdown_timeout,
+                                                        force: env[:force_halt] ? true : false)
+          end
+          @app.call(env)
+        end
+      end
+
+      class SuspendVm < Base
+        def call(env)
+          wrap { Services::Power.new(ctx(env)).suspend(vm(env)) }
+          @app.call(env)
+        end
+      end
+
+      # Resumes a suspended VM, on an internal network on the host of its
+      # peers, like StartVm.
+      class ResumeVm < Base
+        def call(env)
+          wrap { Action.placed(env, ctx(env), vm(env)) { |power, ref, host| power.resume(ref, host: host) } }
+          @app.call(env)
+        end
+      end
+
+      class UnpauseVm < Base
+        def call(env)
+          wrap { Services::Power.new(ctx(env)).unpause(vm(env)) }
+          @app.call(env)
+        end
+      end
+
+      # Static addresses on VIFs other than device 0 are set in the guest
+      # through the guest capability configure_networks, like VirtualBox.
+      class ConfigureGuestNetworks < Base
+        def call(env)
+          machine = env[:machine]
+          networks = Glue.vif_plan(machine).select do |spec|
+            spec.device.positive? && spec.kind != :himn && spec.static_ip? && spec.auto_config
+          end
+          if !networks.empty? && machine.guest.capability?(:configure_networks)
+            env[:ui].info(I18n.t("vagrant.actions.vm.network.configuring"))
+            machine.guest.capability(:configure_networks, networks.map { |spec| guest_network(spec) })
+          end
+          @app.call(env)
+        end
+
+        private
+
+        # Vagrant's guest capabilities take :static with a dotted netmask, and
+        # :static6 with a prefix length.
+        def guest_network(spec)
+          prefix = spec.prefix_length
+          if spec.ipv6?
+            return { type: :static6, ip: spec.ip.to_s, netmask: prefix, interface: spec.device,
+                     gateway: spec.gateway }.compact
+          end
+
+          {
+            type: :static,
+            ip: spec.ip.to_s,
+            netmask: IPAddr.new("255.255.255.255").mask(prefix).to_s,
+            interface: spec.device,
+            gateway: spec.gateway
+          }.compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../services/snapshots"
+
+module VagrantPlugins
+  module Xapi
+    module Action
+      class SnapshotSave < Base
+        def call(env)
+          name = env[:snapshot_name]
+          env[:ui].info(I18n.t("vagrant.actions.vm.snapshot.saving", name: name))
+          wrap do
+            Services::Snapshots.new(ctx(env)).save(vm(env), name, memory: config(env).snapshot_memory)
+          end
+          env[:ui].success(I18n.t("vagrant.actions.vm.snapshot.saved", name: name))
+          @app.call(env)
+        end
+      end
+
+      # Like VirtualBox: halt (forced) first, then revert. A checkpoint comes
+      # back as suspended; action_start then resumes it.
+      class SnapshotRestore < Base
+        def call(env)
+          name = env[:snapshot_name]
+          env[:ui].info(I18n.t("vagrant.actions.vm.snapshot.restoring", name: name))
+          wrap { Services::Snapshots.new(ctx(env)).restore(vm(env), name) }
+          @app.call(env)
+        end
+      end
+
+      class SnapshotDelete < Base
+        def call(env)
+          name = env[:snapshot_name]
+          env[:ui].info(I18n.t("vagrant.actions.vm.snapshot.deleting", name: name))
+          wrap { Services::Snapshots.new(ctx(env)).delete(vm(env), name) }
+          env[:ui].success(I18n.t("vagrant.actions.vm.snapshot.deleted", name: name))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xapi/action.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module Xapi
+    # Action stacks. Each one starts with TranslateErrors, ConfigValidate and
+    # ConnectXapi. The order of steps follows the VirtualBox provider.
+    module Action
+      action_root = File.expand_path("action", __dir__)
+
+      autoload :TranslateErrors, "#{action_root}/base"
+      autoload :ConnectXapi, "#{action_root}/base"
+      autoload :IsCreated, "#{action_root}/base"
+      autoload :CheckRunning, "#{action_root}/base"
+      autoload :Message, "#{action_root}/base"
+      autoload :ImportTemplate, "#{action_root}/create"
+      autoload :CreateVm, "#{action_root}/create"
+      autoload :ConfigureVm, "#{action_root}/create"
+      autoload :StartVm, "#{action_root}/power"
+      autoload :RemoveDiffDisks, "#{action_root}/power"
+      autoload :WaitForIp, "#{action_root}/power"
+      autoload :WaitForCommunicator, "#{action_root}/power"
+      autoload :HaltVm, "#{action_root}/power"
+      autoload :SuspendVm, "#{action_root}/power"
+      autoload :ResumeVm, "#{action_root}/power"
+      autoload :UnpauseVm, "#{action_root}/power"
+      autoload :ConfigureGuestNetworks, "#{action_root}/power"
+      autoload :StartTunnels, "#{action_root}/network"
+      autoload :StopTunnels, "#{action_root}/network"
+      autoload :EnsureTunnels, "#{action_root}/network"
+      autoload :PrepareForwardedPortCollisionParams, "#{action_root}/network"
+      autoload :PrepareNFSValidIds, "#{action_root}/network"
+      autoload :PrepareNFSSettings, "#{action_root}/network"
+      autoload :DestroyVm, "#{action_root}/destroy"
+      autoload :CheckOwner, "#{action_root}/destroy"
+      autoload :SnapshotSave, "#{action_root}/snapshots"
+      autoload :SnapshotRestore, "#{action_root}/snapshots"
+      autoload :SnapshotDelete, "#{action_root}/snapshots"
+      autoload :PackageSetupFolders, "#{action_root}/package"
+      autoload :PackageSetupFiles, "#{action_root}/package"
+      autoload :Package, "#{action_root}/package"
+      autoload :PackageExport, "#{action_root}/package"
+      autoload :PackageVagrantfile, "#{action_root}/package"
+      autoload :CloudInitSetup, "#{action_root}/cloud_init"
+
+      include Vagrant::Action::Builtin
+
+      # Common head of every stack.
+      def self.base(validate: true)
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use TranslateErrors
+          b.use ConfigValidate if validate
+          b.use ConnectXapi
+        end
+      end
+
+      # A stack for an existing VM: the steps from the block run connected,
+      # after validation. A machine without an id is not created without
+      # asking the pool, so for a machine that was never created or is
+      # destroyed these stacks say so and never connect; its Vagrantfile may
+      # not reach the pool (`vagrant destroy` under the user's default
+      # provider, a host that is gone).
+      def self.created(validate: true, not_created: :message, &steps)
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use TranslateErrors
+          b.use Call, IsCreated do |env, b2|
+            unless env[:result]
+              raise Vagrant::Errors::VMNotCreatedError if not_created == :raise
+
+              b2.use Message, :not_created
+              next
+            end
+
+            b2.use ConfigValidate if validate
+            b2.use ConnectXapi
+            steps.call(b2)
+          end
+        end
+      end
+
+      # up: import the box as template if needed, create the VM, then start.
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use TranslateErrors
+          # The box Vagrantfile may carry provider defaults, so handle the
+          # box before validating, like VirtualBox does.
+          b.use Call, IsCreated do |env, b2|
+            b2.use HandleBox unless env[:result]
+          end
+          b.use ConfigValidate
+          b.use ConnectXapi
+          b.use Call, IsCreated do |env, b2|
+            unless env[:result]
+              b2.use ImportTemplate
+              b2.use CreateVm
+            end
+          end
+          b.use action_start
+        end
+      end
+
+      # halted: boot; suspended: resume; paused: unpause; running: message.
+      def self.action_start
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use BoxCheckOutdated
+          b.use Call, IsState, :running do |env, b2|
+            if env[:result]
+              b2.use Message, :already_running
+              b2.use Provision
+              b2.use EnsureTunnels
+              next
+            end
+
+            b2.use Call, IsState, :suspended do |env2, b3|
+              if env2[:result]
+                b3.use action_resume
+                next
+              end
+
+              b3.use Call, IsState, :paused do |env3, b4|
+                if env3[:result]
+                  b4.use UnpauseVm
+                  b4.use EnsureTunnels
+                  next
+                end
+
+                b4.use action_boot
+              end
+            end
+          end
+        end
+      end
+
+      # The start steps for a halted VM.
+      def self.action_boot
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Provision
+          b.use EnvSet, port_collision_repair: true
+          # Tunnels left over when the VM was stopped outside Vagrant.
+          b.use StopTunnels
+          b.use PrepareForwardedPortCollisionParams
+          b.use HandleForwardedPortCollisions
+          b.use PrepareNFSValidIds
+          b.use SyncedFolderCleanup
+          b.use SyncedFolders
+          b.use PrepareNFSSettings
+          b.use SetHostname
+          b.use CloudInitSetup
+          # Before the disk steps, so they never see (or number around) a
+          # leftover diff disk.
+          b.use RemoveDiffDisks
+          b.use CleanupDisks
+          b.use Disk
+          b.use StartVm
+          b.use WaitForIp
+          b.use WaitForCommunicator, [:running]
+          b.use ConfigureGuestNetworks
+          b.use CloudInitWait
+          b.use StartTunnels
+        end
+      end
+
+      def self.action_halt
+        created do |b|
+          b.use StopTunnels
+          b.use Call, GracefulHalt, :halted, :running do |env, b2|
+            b2.use HaltVm unless env[:result]
+          end
+        end
+      end
+
+      def self.action_reload
+        created do |b|
+          b.use action_halt
+          b.use ConfigureVm
+          b.use action_start
+        end
+      end
+
+      def self.action_destroy
+        created(validate: false) do |b|
+          b.use Call, DestroyConfirm do |env, b2|
+            unless env[:result]
+              b2.use Message, :will_not_destroy
+              next
+            end
+
+            b2.use ConfigValidate
+            b2.use CheckOwner
+            b2.use ProvisionerCleanup, :before
+            b2.use EnvSet, force_halt: true
+            b2.use StopTunnels
+            b2.use HaltVm
+            b2.use DestroyVm
+            b2.use PrepareNFSValidIds
+            b2.use SyncedFolderCleanup
+          end
+        end
+      end
+
+      def self.action_suspend
+        created do |b|
+          b.use Call, IsState, :running do |env, b2|
+            unless env[:result]
+              b2.use Message, :not_running
+              next
+            end
+
+            b2.use StopTunnels
+            b2.use SuspendVm
+          end
+        end
+      end
+
+      def self.action_resume
+        created(validate: false) do |b|
+          b.use Call, IsState, :suspended do |env, b2|
+            unless env[:result]
+              b2.use Message, :not_suspended
+              next
+            end
+
+            # Tunnels are set up anew on resume, so a taken port can still be
+            # repaired (VirtualBox cannot, its forwards live in the VM).
+            b2.use EnvSet, port_collision_repair: true
+            b2.use StopTunnels
+            b2.use PrepareForwardedPortCollisionParams
+            b2.use HandleForwardedPortCollisions
+            b2.use Provision
+            b2.use ResumeVm
+            b2.use WaitForIp
+            b2.use WaitForCommunicator, [:running]
+            b2.use StartTunnels
+          end
+        end
+      end
+
+      def self.action_provision
+        created do |b|
+          b.use Call, IsState, :running do |env, b2|
+            unless env[:result]
+              b2.use Message, :not_running
+              next
+            end
+
+            b2.use Provision
+          end
+        end
+      end
+
+      def self.action_ssh
+        base(validate: false).tap do |b|
+          b.use CheckRunning
+          b.use SSHExec
+        end
+      end
+
+      def self.action_ssh_run
+        base(validate: false).tap do |b|
+          b.use CheckRunning
+          b.use SSHRun
+        end
+      end
+
+      def self.action_package
+        created do |b|
+          b.use PackageSetupFolders
+          b.use PackageSetupFiles
+          b.use action_halt
+          b.use StopTunnels
+          b.use PrepareNFSValidIds
+          b.use SyncedFolderCleanup
+          b.use Package
+          b.use PackageExport
+          b.use PackageVagrantfile
+        end
+      end
+
+      def self.action_snapshot_save
+        created do |b|
+          b.use SnapshotSave
+        end
+      end
+
+      def self.action_snapshot_restore
+        created(not_created: :raise) do |b|
+          b.use EnvSet, force_halt: true
+          b.use action_halt
+          b.use SnapshotRestore
+
+          b.use Call, IsEnvSet, :snapshot_delete do |env, b2|
+            b2.use action_snapshot_delete if env[:result]
+          end
+
+          b.use Call, IsEnvSet, :snapshot_start do |env, b2|
+            b2.use action_start if env[:result]
+          end
+        end
+      end
+
+      def self.action_snapshot_delete
+        created do |b|
+          b.use SnapshotDelete
+        end
+      end
+
+      def self.action_sync_folders
+        base(validate: false).tap do |b|
+          b.use PrepareNFSValidIds
+          b.use SyncedFolders
+          b.use PrepareNFSSettings
+        end
+      end
+    end
+  end
+end