You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
870 lines
28 KiB
Go
870 lines
28 KiB
Go
//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)
|