//go:build libvirt package hypervisor import ( "context" "errors" "fmt" "sync" "sync/atomic" "time" "git.luoli.live/root/virt/agent/operation" "git.luoli.live/root/virt/agent/publicguard" "git.luoli.live/root/virt/agent/vpcrouting" "libvirt.org/go/libvirt" ) const ( libvirtReconnectInitialDelay = time.Second libvirtReconnectMaximumDelay = 30 * time.Second libvirtCleanupErrorLimit = 16 publicGuardWatchInterval = 5 * time.Second ) // libvirtJobEvents wakes backup waiters when JOB_COMPLETED arrives. It is a // hint, not a result: callers must still use GetJobStats to establish the // terminal state. Closing a connection also advances the generation so a // waiter can promptly observe the lost session. var libvirtJobEvents = newLibvirtEventBroadcaster() type managedLibvirtSession struct { generation uint64 backend Hypervisor closeFn func() error dead atomic.Bool // refs and retired are protected by managedLibvirt.mu. drained is closed // exactly once after retirement when the last public call releases its // immutable session reference. refs int retired bool drained chan struct{} } type libvirtConnectionCleanup struct { closeRegistered bool jobID int deregister func(int) error unregisterClose func() error closeConnection func() error } func (cleanup *libvirtConnectionCleanup) run() error { var cleanupErrors []error // Registrations are unwound in strict reverse order: JOB_COMPLETED, close // callback, then the connection reference itself. if cleanup.jobID >= 0 { if err := cleanup.deregister(cleanup.jobID); err != nil { cleanupErrors = append(cleanupErrors, fmt.Errorf("deregister completed job events: %w", err)) } } if cleanup.closeRegistered { if err := cleanup.unregisterClose(); err != nil { cleanupErrors = append(cleanupErrors, fmt.Errorf("unregister connection close callback: %w", err)) } } if err := cleanup.closeConnection(); err != nil { cleanupErrors = append(cleanupErrors, fmt.Errorf("close libvirt connection: %w", err)) } return errors.Join(cleanupErrors...) } type managedLibvirtSessionFactory func(uint64) (*managedLibvirtSession, error) type managedLibvirt struct { ctx context.Context cancel context.CancelFunc mu sync.Mutex current *managedLibvirtSession nextGeneration uint64 closing bool lastConnectErr error currentGeneration atomic.Uint64 reconnect chan struct{} factory managedLibvirtSessionFactory retryDelay func(int) time.Duration workerWG sync.WaitGroup retiredWG sync.WaitGroup cleanupMu sync.Mutex cleanupErrs []error startOnce sync.Once closeOnce sync.Once closeErr error } func openManagedLibvirt(uri string, local LocalConfig, clientVersion uint32, traffic *trafficStore) *managedLibvirt { var manager *managedLibvirt manager = newManagedLibvirt(func(generation uint64) (*managedLibvirtSession, error) { return manager.openSession(uri, local, clientVersion, traffic, generation) }, defaultLibvirtReconnectDelay) manager.start() return manager } func (m *managedLibvirt) start() { // Preserve the useful startup behavior of attempting the local socket once, // while allowing the Agent to start and report unavailable if the daemon is // temporarily down. This reconnect loop restores transport liveness only; // it never replays or reconciles an operation. m.startOnce.Do(func() { // Register the whole startup/reconnect lifecycle before the first // potentially blocking connection attempt. Close uses the same mutex // before Wait, which prevents an Add-after-Wait race. m.mu.Lock() if m.closing { m.mu.Unlock() return } m.workerWG.Add(1) m.mu.Unlock() _ = m.connectAndPublish() go m.reconnectLoop() if !m.hasUsableSession() { m.signalReconnect() } }) } func newManagedLibvirt(factory managedLibvirtSessionFactory, retryDelay func(int) time.Duration) *managedLibvirt { ctx, cancel := context.WithCancel(context.Background()) if retryDelay == nil { retryDelay = defaultLibvirtReconnectDelay } return &managedLibvirt{ ctx: ctx, cancel: cancel, reconnect: make(chan struct{}, 1), factory: factory, retryDelay: retryDelay, } } func defaultLibvirtReconnectDelay(failures int) time.Duration { if failures <= 1 { return libvirtReconnectInitialDelay } delay := libvirtReconnectInitialDelay for attempt := 1; attempt < failures && delay < libvirtReconnectMaximumDelay; attempt++ { delay *= 2 if delay > libvirtReconnectMaximumDelay { return libvirtReconnectMaximumDelay } } return delay } func (m *managedLibvirt) openSession(uri string, local LocalConfig, clientVersion uint32, traffic *trafficStore, generation uint64) (*managedLibvirtSession, error) { conn, err := libvirt.NewConnect(uri) if err != nil { return nil, translateLibvirtError("connect", err) } session := &managedLibvirtSession{ generation: generation, drained: make(chan struct{}), } cleanup := &libvirtConnectionCleanup{ jobID: -1, deregister: conn.DomainEventDeregister, unregisterClose: func() error { return conn.UnregisterCloseCallback() }, closeConnection: func() error { _, err := conn.Close() return err }, } session.closeFn = cleanup.run failSetup := func(action string, cause error) (*managedLibvirtSession, error) { return nil, errors.Join(translateLibvirtError(action, cause), session.closeFn()) } if err := conn.RegisterCloseCallback(func(_ *libvirt.Connect, _ libvirt.ConnectCloseReason) { // The callback can run on libvirt's event thread. It only marks this // immutable generation dead and performs non-blocking wakeups; reconnect, // callback deregistration, and Close all happen on manager workers. session.dead.Store(true) if !m.isCurrentGeneration(session) { return } libvirtJobEvents.notify() storageStreamEvents.notify() m.signalReconnect() }); err != nil { return failSetup("register connection close callback", err) } cleanup.closeRegistered = true cleanup.jobID, err = conn.DomainEventJobCompletedRegister(nil, func(_ *libvirt.Connect, _ *libvirt.Domain, _ *libvirt.DomainEventJobCompleted) { if !m.isCurrentGeneration(session) { return } libvirtJobEvents.notify() }) if err != nil { return failSetup("register completed job events", err) } daemonVersion, err := conn.GetLibVersion() if err != nil { return failSetup("get daemon libvirt version", err) } vpcRouter, err := vpcrouting.Open(local.VPCStatePath) if err != nil { return failSetup("initialize VPC host router", err) } if local.RestoreVPCState { restoreContext, cancelRestore := context.WithTimeout(m.ctx, 60*time.Second) restoreErr := vpcRouter.Restore(restoreContext) cancelRestore() if restoreErr != nil { return failSetup("restore VPC host routing", restoreErr) } } publicGuard, err := publicguard.Open(local.PublicGuardLockPath, local.PublicGuardStatePath) if err != nil { return failSetup("initialize public network guard", err) } backend := &Libvirt{ conn: conn, local: local, traffic: traffic, vpcRouter: vpcRouter, publicGuard: publicGuard, guestAgentResponseTimeoutSupported: supportsGuestAgentResponseTimeout(clientVersion, daemonVersion), } if err := backend.ensureManagedVPCAntiSpoofFilter(); err != nil { return failSetup("initialize project-owned VPC anti-spoof filter", err) } restoreContext, cancelRestore := context.WithTimeout(m.ctx, 60*time.Second) restoreErr := backend.reconcilePublicGuard(restoreContext, nil) cancelRestore() if restoreErr != nil { return failSetup("restore public network guard", restoreErr) } guardContext, cancelGuard := context.WithCancel(m.ctx) guardDone := make(chan struct{}) go func() { defer close(guardDone) publicGuard.Watch(guardContext, publicGuardWatchInterval, func(projectionCtx context.Context) ([]publicguard.Binding, error) { return backend.publicGuardProjection(projectionCtx, nil) }) }() closeConnection := session.closeFn session.closeFn = func() error { cancelGuard() <-guardDone return closeConnection() } session.backend = backend alive, err := conn.IsAlive() if err != nil || !alive || session.dead.Load() { if err != nil { return failSetup("verify libvirt connection", err) } return nil, errors.Join(NewError(ErrUnavailable, "libvirt_unavailable", "libvirt is unavailable", nil), session.closeFn()) } return session, nil } func (m *managedLibvirt) reconnectLoop() { defer m.workerWG.Done() failures := 0 for { select { case <-m.ctx.Done(): return case <-m.reconnect: } for { if m.ctx.Err() != nil { return } m.detachDeadSession() if m.hasUsableSession() { failures = 0 break } if err := m.connectAndPublish(); err == nil { failures = 0 break } failures++ timer := time.NewTimer(m.retryDelay(failures)) select { case <-m.ctx.Done(): if !timer.Stop() { <-timer.C } return case <-m.reconnect: if !timer.Stop() { <-timer.C } case <-timer.C: } } } } func (m *managedLibvirt) connectAndPublish() error { m.mu.Lock() if m.closing { m.mu.Unlock() return context.Canceled } m.nextGeneration++ generation := m.nextGeneration m.mu.Unlock() session, err := m.factory(generation) if err != nil { m.mu.Lock() m.lastConnectErr = err m.mu.Unlock() return err } if session == nil || session.backend == nil || session.closeFn == nil { err = errors.New("libvirt session factory returned an incomplete session") if session != nil && session.closeFn != nil { m.cleanupSession(session) } m.mu.Lock() m.lastConnectErr = err m.mu.Unlock() return err } if session.drained == nil { session.drained = make(chan struct{}) } session.generation = generation m.mu.Lock() if m.closing || m.current != nil || session.dead.Load() { m.mu.Unlock() m.cleanupSession(session) if session.dead.Load() { return NewError(ErrUnavailable, "libvirt_unavailable", "libvirt is unavailable", nil) } return context.Canceled } m.current = session m.currentGeneration.Store(session.generation) if session.dead.Load() { m.current = nil m.currentGeneration.Store(0) m.retireSessionLocked(session) m.mu.Unlock() return NewError(ErrUnavailable, "libvirt_unavailable", "libvirt is unavailable", nil) } m.lastConnectErr = nil m.mu.Unlock() return nil } func (m *managedLibvirt) hasUsableSession() bool { m.mu.Lock() defer m.mu.Unlock() return !m.closing && m.current != nil && !m.current.dead.Load() } // detachDeadSession runs only outside libvirt callbacks. It atomically stops // new acquisitions, then retires the old generation after existing calls have // released their references. func (m *managedLibvirt) detachDeadSession() bool { m.mu.Lock() defer m.mu.Unlock() if m.current == nil || !m.current.dead.Load() { return false } session := m.current m.current = nil m.currentGeneration.Store(0) m.retireSessionLocked(session) return true } func (m *managedLibvirt) retireSessionLocked(session *managedLibvirtSession) { if session == nil || session.retired { return } session.retired = true if session.refs == 0 { close(session.drained) } m.retiredWG.Add(1) go func() { defer m.retiredWG.Done() <-session.drained m.cleanupSession(session) }() } func (m *managedLibvirt) cleanupSession(session *managedLibvirtSession) { if session == nil || session.closeFn == nil { return } if err := session.closeFn(); err != nil { // Once libvirt has told us this generation is dead, INVALID_CONN, // NO_CONNECT, and RPC errors are expected while unregistering callbacks // and releasing the stale handle. They must not poison a later clean // shutdown after the manager has successfully reconnected. if session.dead.Load() && onlyLibvirtConnectionFailures(err) { return } m.cleanupMu.Lock() if len(m.cleanupErrs) < libvirtCleanupErrorLimit { m.cleanupErrs = append(m.cleanupErrs, err) } else { m.cleanupErrs[libvirtCleanupErrorLimit-1] = err } m.cleanupMu.Unlock() } } func (m *managedLibvirt) acquire(ctx context.Context) (*managedLibvirtSession, func(), error) { if err := ctx.Err(); err != nil { return nil, nil, err } m.mu.Lock() if m.closing || m.current == nil || m.current.dead.Load() { cause := m.lastConnectErr m.mu.Unlock() return nil, nil, NewError(ErrUnavailable, "libvirt_unavailable", "libvirt is unavailable", cause) } session := m.current session.refs++ m.mu.Unlock() var once sync.Once release := func() { once.Do(func() { m.mu.Lock() session.refs-- if session.retired && session.refs == 0 { close(session.drained) } m.mu.Unlock() }) } return session, release, nil } func (m *managedLibvirt) isCurrentGeneration(session *managedLibvirtSession) bool { return session != nil && m.currentGeneration.Load() == session.generation } func (m *managedLibvirt) signalReconnect() { select { case m.reconnect <- struct{}{}: default: } } func (m *managedLibvirt) markConnectionLost(session *managedLibvirtSession) { if session == nil { return } session.dead.Store(true) if !m.isCurrentGeneration(session) { return } libvirtJobEvents.notify() storageStreamEvents.notify() m.signalReconnect() } func (m *managedLibvirt) Close() error { m.closeOnce.Do(func() { m.mu.Lock() m.closing = true m.currentGeneration.Store(0) if m.current != nil { session := m.current m.current = nil m.retireSessionLocked(session) } m.cancel() m.mu.Unlock() m.workerWG.Wait() m.retiredWG.Wait() m.cleanupMu.Lock() m.closeErr = errors.Join(m.cleanupErrs...) m.cleanupMu.Unlock() }) return m.closeErr } func isLibvirtConnectionFailure(err error) bool { var libvirtErr libvirt.Error if errors.As(err, &libvirtErr) { switch libvirtErr.Code { case libvirt.ERR_INVALID_CONN, libvirt.ERR_NO_CONNECT, libvirt.ERR_RPC: return true } } var publicError *Error return errors.As(err, &publicError) && publicError.Code == "libvirt_unavailable" } func onlyLibvirtConnectionFailures(err error) bool { if err == nil { return true } if joined, ok := err.(interface{ Unwrap() []error }); ok { causes := joined.Unwrap() if len(causes) == 0 { return false } for _, cause := range causes { if !onlyLibvirtConnectionFailures(cause) { return false } } return true } if wrapped, ok := err.(interface{ Unwrap() error }); ok { if cause := wrapped.Unwrap(); cause != nil { return onlyLibvirtConnectionFailures(cause) } } return isLibvirtConnectionFailure(err) } func managedCall[T any](m *managedLibvirt, ctx context.Context, mutation bool, call func(Hypervisor) (T, error)) (T, error) { var zero T session, release, err := m.acquire(ctx) if err != nil { if mutation { // No backend method was invoked, including when admission ended on // a canceled or expired context while waiting for a usable session. err = operation.MarkNotApplied(err) } return zero, err } defer release() value, err := call(session.backend) if err == nil { return value, nil } if isLibvirtConnectionFailure(err) { m.markConnectionLost(session) if mutation && !operation.IsUncertain(err) && !operation.IsNotApplied(err) { err = operation.MarkUncertain(err) } } return value, err } func managedCallError(m *managedLibvirt, ctx context.Context, mutation bool, call func(Hypervisor) error) error { _, err := managedCall(m, ctx, mutation, func(backend Hypervisor) (struct{}, error) { return struct{}{}, call(backend) }) return err } func (m *managedLibvirt) Ping(ctx context.Context) error { return managedCallError(m, ctx, false, func(h Hypervisor) error { return h.Ping(ctx) }) } func (m *managedLibvirt) Capabilities(ctx context.Context) (Capabilities, error) { return managedCall(m, ctx, false, func(h Hypervisor) (Capabilities, error) { return h.Capabilities(ctx) }) } func (m *managedLibvirt) ConfigureStorage(ctx context.Context, request StorageConfigurationRequest) (StorageConfigurationResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (StorageConfigurationResult, error) { return h.ConfigureStorage(ctx, request) }) } func (m *managedLibvirt) ApplyVPCNetwork(ctx context.Context, request vpcrouting.ApplyRequest) (vpcrouting.Result, error) { return managedCall(m, ctx, true, func(h Hypervisor) (vpcrouting.Result, error) { return h.ApplyVPCNetwork(ctx, request) }) } func (m *managedLibvirt) RemoveVPCNetwork(ctx context.Context, request vpcrouting.RemoveRequest) (vpcrouting.Result, error) { return managedCall(m, ctx, true, func(h Hypervisor) (vpcrouting.Result, error) { return h.RemoveVPCNetwork(ctx, request) }) } func (m *managedLibvirt) ApplyVPCPort(ctx context.Context, uuid string, request VPCPortRequest) (VPCPortResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (VPCPortResult, error) { return h.ApplyVPCPort(ctx, uuid, request) }) } func (m *managedLibvirt) RemoveVPCPort(ctx context.Context, uuid string, request VPCPortRequest) (VPCPortResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (VPCPortResult, error) { return h.RemoveVPCPort(ctx, uuid, request) }) } func (m *managedLibvirt) ListVMs(ctx context.Context) ([]VMMetadata, error) { return managedCall(m, ctx, false, func(h Hypervisor) ([]VMMetadata, error) { return h.ListVMs(ctx) }) } func (m *managedLibvirt) GetVMState(ctx context.Context, uuid string) (VMState, error) { return managedCall(m, ctx, false, func(h Hypervisor) (VMState, error) { return h.GetVMState(ctx, uuid) }) } func (m *managedLibvirt) GetVMMetadata(ctx context.Context, uuid string) (VMMetadata, error) { return managedCall(m, ctx, false, func(h Hypervisor) (VMMetadata, error) { return h.GetVMMetadata(ctx, uuid) }) } func (m *managedLibvirt) GetBackupReadiness(ctx context.Context, uuid string) (BackupReadiness, error) { return managedCall(m, ctx, false, func(h Hypervisor) (BackupReadiness, error) { return h.GetBackupReadiness(ctx, uuid) }) } func (m *managedLibvirt) CreateVM(ctx context.Context, request CreateVMRequest) (VMMetadata, error) { return managedCall(m, ctx, true, func(h Hypervisor) (VMMetadata, error) { return h.CreateVM(ctx, request) }) } func (m *managedLibvirt) CreateBackup(ctx context.Context, uuid string, request BackupRequest) (BackupResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (BackupResult, error) { return h.CreateBackup(ctx, uuid, request) }) } func (m *managedLibvirt) CleanupBackupWorkspace(ctx context.Context, uuid string, request CleanupBackupWorkspaceRequest) (CleanupBackupWorkspaceResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (CleanupBackupWorkspaceResult, error) { return h.CleanupBackupWorkspace(ctx, uuid, request) }) } func (m *managedLibvirt) RestoreBackup(ctx context.Context, request RestoreBackupRequest) (RestoreBackupResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (RestoreBackupResult, error) { return h.RestoreBackup(ctx, request) }) } func (m *managedLibvirt) RecoverBackup(ctx context.Context, uuid string, request RecoverBackupRequest) (RecoverBackupResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (RecoverBackupResult, error) { return h.RecoverBackup(ctx, uuid, request) }) } func (m *managedLibvirt) PreparePeerMigration(ctx context.Context, uuid string, request PreparePeerMigrationRequest) (PreparePeerMigrationResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (PreparePeerMigrationResult, error) { return h.PreparePeerMigration(ctx, uuid, request) }) } func (m *managedLibvirt) ReceivePeerMigration(ctx context.Context, request ReceivePeerMigrationRequest) (ReceivePeerMigrationResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (ReceivePeerMigrationResult, error) { return h.ReceivePeerMigration(ctx, request) }) } func (m *managedLibvirt) ActivatePeerMigration(ctx context.Context, uuid string, request ActivatePeerMigrationRequest) (PeerMigrationStateResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (PeerMigrationStateResult, error) { return h.ActivatePeerMigration(ctx, uuid, request) }) } func (m *managedLibvirt) RollbackPeerMigration(ctx context.Context, uuid string, request RollbackPeerMigrationRequest) (PeerMigrationStateResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (PeerMigrationStateResult, error) { return h.RollbackPeerMigration(ctx, uuid, request) }) } func (m *managedLibvirt) CleanupPeerMigration(ctx context.Context, uuid string, request CleanupPeerMigrationRequest) (DeleteVMResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (DeleteVMResult, error) { return h.CleanupPeerMigration(ctx, uuid, request) }) } func (m *managedLibvirt) CleanupPeerMigrationTarget(ctx context.Context, uuid string, request CleanupPeerMigrationTargetRequest) (DeleteVMResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (DeleteVMResult, error) { return h.CleanupPeerMigrationTarget(ctx, uuid, request) }) } func (m *managedLibvirt) DeleteVM(ctx context.Context, uuid string, request DeleteVMRequest) (DeleteVMResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (DeleteVMResult, error) { return h.DeleteVM(ctx, uuid, request) }) } func (m *managedLibvirt) ForceDeleteVM(ctx context.Context, uuid string, request ForceDeleteVMRequest) (DeleteVMResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (DeleteVMResult, error) { return h.ForceDeleteVM(ctx, uuid, request) }) } func (m *managedLibvirt) Power(ctx context.Context, uuid string, request PowerRequest) (VMState, error) { return managedCall(m, ctx, true, func(h Hypervisor) (VMState, error) { return h.Power(ctx, uuid, request) }) } func (m *managedLibvirt) ResizeResources(ctx context.Context, uuid string, request ResizeResourcesRequest) (ResizeResourcesResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (ResizeResourcesResult, error) { return h.ResizeResources(ctx, uuid, request) }) } func (m *managedLibvirt) UpdateSettings(ctx context.Context, uuid string, request SettingsRequest) (VMMetadata, error) { return managedCall(m, ctx, true, func(h Hypervisor) (VMMetadata, error) { return h.UpdateSettings(ctx, uuid, request) }) } func (m *managedLibvirt) ResolveNetworkSelector(ctx context.Context, selector string) (LocalNetworkSource, error) { return managedCall(m, ctx, false, func(h Hypervisor) (LocalNetworkSource, error) { return h.ResolveNetworkSelector(ctx, selector) }) } func (m *managedLibvirt) ChangeNetwork(ctx context.Context, uuid string, request ChangeNetworkRequest) (VMMetadata, error) { return managedCall(m, ctx, true, func(h Hypervisor) (VMMetadata, error) { return h.ChangeNetwork(ctx, uuid, request) }) } func (m *managedLibvirt) SetNetworkState(ctx context.Context, uuid string, enabled bool, request NetworkStateRequest) error { return managedCallError(m, ctx, true, func(h Hypervisor) error { return h.SetNetworkState(ctx, uuid, enabled, request) }) } func (m *managedLibvirt) SetServiceState(ctx context.Context, uuid string, enabled bool, request ServiceStateRequest) (VMState, error) { return managedCall(m, ctx, true, func(h Hypervisor) (VMState, error) { return h.SetServiceState(ctx, uuid, enabled, request) }) } func (m *managedLibvirt) Reinstall(ctx context.Context, uuid string, request ReinstallRequest) (VMMetadata, error) { return managedCall(m, ctx, true, func(h Hypervisor) (VMMetadata, error) { return h.Reinstall(ctx, uuid, request) }) } func (m *managedLibvirt) GetMetrics(ctx context.Context, uuid string) (Metrics, error) { return managedCall(m, ctx, false, func(h Hypervisor) (Metrics, error) { return h.GetMetrics(ctx, uuid) }) } func (m *managedLibvirt) GetConsole(ctx context.Context, uuid string) (ConsoleSession, error) { return managedCall(m, ctx, false, func(h Hypervisor) (ConsoleSession, error) { return h.GetConsole(ctx, uuid) }) } func (m *managedLibvirt) ListSnapshots(ctx context.Context, uuid string) ([]Snapshot, error) { return managedCall(m, ctx, false, func(h Hypervisor) ([]Snapshot, error) { return h.ListSnapshots(ctx, uuid) }) } func (m *managedLibvirt) CreateSnapshot(ctx context.Context, uuid string, request SnapshotRequest) (Snapshot, error) { return managedCall(m, ctx, true, func(h Hypervisor) (Snapshot, error) { return h.CreateSnapshot(ctx, uuid, request) }) } func (m *managedLibvirt) DeleteSnapshot(ctx context.Context, uuid, key string, request SnapshotMutationRequest) (SnapshotMutationResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (SnapshotMutationResult, error) { return h.DeleteSnapshot(ctx, uuid, key, request) }) } func (m *managedLibvirt) RestoreSnapshot(ctx context.Context, uuid, key string, request SnapshotMutationRequest) (SnapshotMutationResult, error) { return managedCall(m, ctx, true, func(h Hypervisor) (SnapshotMutationResult, error) { return h.RestoreSnapshot(ctx, uuid, key, request) }) } func (m *managedLibvirt) GetFirewall(ctx context.Context, uuid string) (FirewallPolicy, error) { return managedCall(m, ctx, false, func(h Hypervisor) (FirewallPolicy, error) { return h.GetFirewall(ctx, uuid) }) } func (m *managedLibvirt) ApplyFirewall(ctx context.Context, uuid string, policy FirewallPolicy) (FirewallPolicy, error) { return managedCall(m, ctx, true, func(h Hypervisor) (FirewallPolicy, error) { return h.ApplyFirewall(ctx, uuid, policy) }) } func (m *managedLibvirt) GetRescue(ctx context.Context, uuid string) (RescueState, error) { return managedCall(m, ctx, false, func(h Hypervisor) (RescueState, error) { return h.GetRescue(ctx, uuid) }) } func (m *managedLibvirt) EnterRescue(ctx context.Context, uuid string, request RescueRequest) (RescueState, error) { return managedCall(m, ctx, true, func(h Hypervisor) (RescueState, error) { return h.EnterRescue(ctx, uuid, request) }) } func (m *managedLibvirt) ForceStartRescue(ctx context.Context, uuid string, request ForceRescueStartRequest) (RescueState, error) { return managedCall(m, ctx, true, func(h Hypervisor) (RescueState, error) { return h.ForceStartRescue(ctx, uuid, request) }) } func (m *managedLibvirt) ExitRescue(ctx context.Context, uuid string, request ExitRescueRequest) (RescueState, error) { return managedCall(m, ctx, true, func(h Hypervisor) (RescueState, error) { return h.ExitRescue(ctx, uuid, request) }) } func (m *managedLibvirt) ListTemplates(ctx context.Context) ([]ImageTemplate, error) { return managedCall(m, ctx, false, func(h Hypervisor) ([]ImageTemplate, error) { return h.ListTemplates(ctx) }) } func (m *managedLibvirt) ImportTemplate(ctx context.Context, request ImportTemplateRequest) (ImageTemplate, error) { return managedCall(m, ctx, true, func(h Hypervisor) (ImageTemplate, error) { return h.ImportTemplate(ctx, request) }) } func (m *managedLibvirt) UpdateTemplate(ctx context.Context, id string, request UpdateTemplateRequest) (ImageTemplate, error) { return managedCall(m, ctx, true, func(h Hypervisor) (ImageTemplate, error) { return h.UpdateTemplate(ctx, id, request) }) } func (m *managedLibvirt) DeleteTemplate(ctx context.Context, id string) error { return managedCallError(m, ctx, true, func(h Hypervisor) error { return h.DeleteTemplate(ctx, id) }) } func (m *managedLibvirt) ListRescueTemplates(ctx context.Context) ([]RescueTemplate, error) { return managedCall(m, ctx, false, func(h Hypervisor) ([]RescueTemplate, error) { return h.ListRescueTemplates(ctx) }) } func (m *managedLibvirt) ImportRescueTemplate(ctx context.Context, request ImportRescueTemplateRequest) (RescueTemplate, error) { return managedCall(m, ctx, true, func(h Hypervisor) (RescueTemplate, error) { return h.ImportRescueTemplate(ctx, request) }) } func (m *managedLibvirt) DeleteRescueTemplate(ctx context.Context, id string) error { return managedCallError(m, ctx, true, func(h Hypervisor) error { return h.DeleteRescueTemplate(ctx, id) }) } func (m *managedLibvirt) ListUserISOs(ctx context.Context, ownerID int64) ([]UserISO, error) { return managedCall(m, ctx, false, func(h Hypervisor) ([]UserISO, error) { return h.ListUserISOs(ctx, ownerID) }) } func (m *managedLibvirt) ImportUserISO(ctx context.Context, request ImportUserISORequest) (UserISO, error) { return managedCall(m, ctx, true, func(h Hypervisor) (UserISO, error) { return h.ImportUserISO(ctx, request) }) } func (m *managedLibvirt) DeleteUserISO(ctx context.Context, id string, ownerID int64) error { return managedCallError(m, ctx, true, func(h Hypervisor) error { return h.DeleteUserISO(ctx, id, ownerID) }) } func (m *managedLibvirt) InspectOperation(ctx context.Context, record operation.Record) (OperationInspection, error) { return managedCall(m, ctx, false, func(h Hypervisor) (OperationInspection, error) { return h.InspectOperation(ctx, record) }) } var _ Hypervisor = (*managedLibvirt)(nil)