github.com/cloud-foundations/dominator@v0.0.0-20221004181915-6e4fee580046/hypervisor/manager/api.go (about)

     1  package manager
     2  
     3  import (
     4  	"io"
     5  	"net"
     6  	"path/filepath"
     7  	"sync"
     8  	"time"
     9  
    10  	"github.com/Cloud-Foundations/Dominator/lib/filesystem"
    11  	"github.com/Cloud-Foundations/Dominator/lib/filter"
    12  	"github.com/Cloud-Foundations/Dominator/lib/log"
    13  	"github.com/Cloud-Foundations/Dominator/lib/objectserver/cachingreader"
    14  	"github.com/Cloud-Foundations/Dominator/lib/srpc"
    15  	"github.com/Cloud-Foundations/Dominator/lib/tags"
    16  	proto "github.com/Cloud-Foundations/Dominator/proto/hypervisor"
    17  )
    18  
    19  type addressPoolType struct {
    20  	Free       []proto.Address
    21  	Registered []proto.Address
    22  }
    23  
    24  type DhcpServer interface {
    25  	AddLease(address proto.Address, hostname string) error
    26  	AddSubnet(subnet proto.Subnet)
    27  	MakeAcknowledgmentChannel(ipAddr net.IP) <-chan struct{}
    28  	MakeRequestChannel(macAddr string) <-chan net.IP
    29  	RemoveLease(ipAddr net.IP)
    30  	RemoveSubnet(subnetId string)
    31  }
    32  
    33  type Manager struct {
    34  	StartOptions
    35  	rootCookie        []byte
    36  	memTotalInMiB     uint64
    37  	numCPU            int
    38  	serialNumber      string
    39  	volumeDirectories []string
    40  	volumeInfos       map[string]volumeInfo // Key: volumeDirectory.
    41  	mutex             sync.RWMutex          // Lock everything below (those can change).
    42  	addressPool       addressPoolType
    43  	healthStatus      string
    44  	notifiers         map[<-chan proto.Update]chan<- proto.Update
    45  	objectCache       *cachingreader.ObjectServer
    46  	ownerGroups       map[string]struct{}
    47  	ownerUsers        map[string]struct{}
    48  	subnets           map[string]proto.Subnet // Key: Subnet ID.
    49  	subnetChannels    []chan<- proto.Subnet
    50  	vms               map[string]*vmInfoType // Key: IP address.
    51  }
    52  
    53  type StartOptions struct {
    54  	BridgeMap          map[string]net.Interface // Key: interface name.
    55  	DhcpServer         DhcpServer
    56  	ImageServerAddress string
    57  	Logger             log.DebugLogger
    58  	ObjectCacheBytes   uint64
    59  	ShowVgaConsole     bool
    60  	StateDir           string
    61  	Username           string
    62  	VlanIdToBridge     map[uint]string // Key: VLAN ID, value: bridge interface.
    63  	VolumeDirectories  []string
    64  }
    65  
    66  type vmInfoType struct {
    67  	mutex                      sync.RWMutex
    68  	accessToken                []byte
    69  	accessTokenCleanupNotifier chan<- struct{}
    70  	commandChannel             chan<- string
    71  	destroyTimer               *time.Timer
    72  	dirname                    string
    73  	doNotWriteOrSend           bool
    74  	hasHealthAgent             bool
    75  	ipAddress                  string
    76  	logger                     log.DebugLogger
    77  	manager                    *Manager
    78  	metadataChannels           map[chan<- string]struct{}
    79  	monitorSockname            string
    80  	ownerUsers                 map[string]struct{}
    81  	serialInput                io.Writer
    82  	serialOutput               chan<- byte
    83  	stoppedNotifier            chan<- struct{}
    84  	updating                   bool
    85  	proto.LocalVmInfo
    86  }
    87  
    88  type volumeInfo struct {
    89  	canTrim bool
    90  }
    91  
    92  func New(startOptions StartOptions) (*Manager, error) {
    93  	return newManager(startOptions)
    94  }
    95  
    96  func (m *Manager) AcknowledgeVm(ipAddr net.IP,
    97  	authInfo *srpc.AuthInformation) error {
    98  	return m.acknowledgeVm(ipAddr, authInfo)
    99  }
   100  
   101  func (m *Manager) AddAddressesToPool(addresses []proto.Address) error {
   102  	return m.addAddressesToPool(addresses)
   103  }
   104  
   105  func (m *Manager) AddVmVolumes(ipAddr net.IP,
   106  	authInfo *srpc.AuthInformation, volumeSizes []uint64) error {
   107  	return m.addVmVolumes(ipAddr, authInfo, volumeSizes)
   108  }
   109  
   110  func (m *Manager) BecomePrimaryVmOwner(ipAddr net.IP,
   111  	authInfo *srpc.AuthInformation) error {
   112  	return m.becomePrimaryVmOwner(ipAddr, authInfo)
   113  }
   114  
   115  func (m *Manager) ChangeOwners(ownerGroups, ownerUsers []string) error {
   116  	return m.changeOwners(ownerGroups, ownerUsers)
   117  }
   118  
   119  func (m *Manager) ChangeVmConsoleType(ipAddr net.IP,
   120  	authInfo *srpc.AuthInformation, consoleType proto.ConsoleType) error {
   121  	return m.changeVmConsoleType(ipAddr, authInfo, consoleType)
   122  }
   123  
   124  func (m *Manager) ChangeVmDestroyProtection(ipAddr net.IP,
   125  	authInfo *srpc.AuthInformation, destroyProtection bool) error {
   126  	return m.changeVmDestroyProtection(ipAddr, authInfo, destroyProtection)
   127  }
   128  
   129  func (m *Manager) ChangeVmOwnerUsers(ipAddr net.IP,
   130  	authInfo *srpc.AuthInformation, extraUsers []string) error {
   131  	return m.changeVmOwnerUsers(ipAddr, authInfo, extraUsers)
   132  }
   133  
   134  func (m *Manager) ChangeVmSize(ipAddr net.IP, authInfo *srpc.AuthInformation,
   135  	memoryInMiB uint64, milliCPUs uint) error {
   136  	return m.changeVmSize(ipAddr, authInfo, memoryInMiB, milliCPUs)
   137  }
   138  
   139  func (m *Manager) ChangeVmTags(ipAddr net.IP, authInfo *srpc.AuthInformation,
   140  	tgs tags.Tags) error {
   141  	return m.changeVmTags(ipAddr, authInfo, tgs)
   142  }
   143  
   144  func (m *Manager) CheckOwnership(authInfo *srpc.AuthInformation) bool {
   145  	return m.checkOwnership(authInfo)
   146  }
   147  
   148  func (m *Manager) CheckVmHasHealthAgent(ipAddr net.IP) (bool, error) {
   149  	return m.checkVmHasHealthAgent(ipAddr)
   150  }
   151  
   152  func (m *Manager) CloseUpdateChannel(channel <-chan proto.Update) {
   153  	m.closeUpdateChannel(channel)
   154  }
   155  
   156  func (m *Manager) CommitImportedVm(ipAddr net.IP,
   157  	authInfo *srpc.AuthInformation) error {
   158  	return m.commitImportedVm(ipAddr, authInfo)
   159  }
   160  
   161  func (m *Manager) ConnectToVmConsole(ipAddr net.IP,
   162  	authInfo *srpc.AuthInformation) (net.Conn, error) {
   163  	return m.connectToVmConsole(ipAddr, authInfo)
   164  }
   165  
   166  func (m *Manager) ConnectToVmSerialPort(ipAddr net.IP,
   167  	authInfo *srpc.AuthInformation,
   168  	portNumber uint) (chan<- byte, <-chan byte, error) {
   169  	return m.connectToVmSerialPort(ipAddr, authInfo, portNumber)
   170  }
   171  
   172  func (m *Manager) CopyVm(conn *srpc.Conn, request proto.CopyVmRequest) error {
   173  	return m.copyVm(conn, request)
   174  }
   175  
   176  func (m *Manager) CreateVm(conn *srpc.Conn) error {
   177  	return m.createVm(conn)
   178  }
   179  
   180  func (m *Manager) DeleteVmVolume(ipAddr net.IP, authInfo *srpc.AuthInformation,
   181  	accessToken []byte, volumeIndex uint) error {
   182  	return m.deleteVmVolume(ipAddr, authInfo, accessToken, volumeIndex)
   183  }
   184  
   185  func (m *Manager) DestroyVm(ipAddr net.IP,
   186  	authInfo *srpc.AuthInformation, accessToken []byte) error {
   187  	return m.destroyVm(ipAddr, authInfo, accessToken)
   188  }
   189  
   190  func (m *Manager) DiscardVmAccessToken(ipAddr net.IP,
   191  	authInfo *srpc.AuthInformation, accessToken []byte) error {
   192  	return m.discardVmAccessToken(ipAddr, authInfo, accessToken)
   193  }
   194  
   195  func (m *Manager) DiscardVmOldImage(ipAddr net.IP,
   196  	authInfo *srpc.AuthInformation) error {
   197  	return m.discardVmOldImage(ipAddr, authInfo)
   198  }
   199  
   200  func (m *Manager) DiscardVmOldUserData(ipAddr net.IP,
   201  	authInfo *srpc.AuthInformation) error {
   202  	return m.discardVmOldUserData(ipAddr, authInfo)
   203  }
   204  
   205  func (m *Manager) DiscardVmSnapshot(ipAddr net.IP,
   206  	authInfo *srpc.AuthInformation) error {
   207  	return m.discardVmSnapshot(ipAddr, authInfo)
   208  }
   209  
   210  func (m *Manager) ExportLocalVm(authInfo *srpc.AuthInformation,
   211  	request proto.ExportLocalVmRequest) (*proto.ExportLocalVmInfo, error) {
   212  	return m.exportLocalVm(authInfo, request)
   213  }
   214  
   215  func (m *Manager) GetHealthStatus() string {
   216  	return m.getHealthStatus()
   217  }
   218  
   219  func (m *Manager) GetImageServerAddress() string {
   220  	return m.ImageServerAddress
   221  }
   222  
   223  func (m *Manager) GetNumVMs() (uint, uint) {
   224  	return m.getNumVMs()
   225  }
   226  
   227  func (m *Manager) GetRootCookiePath() string {
   228  	return filepath.Join(m.StartOptions.StateDir, "root-cookie")
   229  }
   230  
   231  func (m *Manager) GetVmBootLog(ipAddr net.IP) (io.ReadCloser, error) {
   232  	return m.getVmBootLog(ipAddr)
   233  }
   234  
   235  func (m *Manager) GetVmAccessToken(ipAddr net.IP,
   236  	authInfo *srpc.AuthInformation, lifetime time.Duration) ([]byte, error) {
   237  	return m.getVmAccessToken(ipAddr, authInfo, lifetime)
   238  }
   239  
   240  func (m *Manager) GetVmInfo(ipAddr net.IP) (proto.VmInfo, error) {
   241  	return m.getVmInfo(ipAddr)
   242  }
   243  
   244  func (m *Manager) GetVmUserData(ipAddr net.IP) (io.ReadCloser, error) {
   245  	rc, _, err := m.getVmUserData(ipAddr,
   246  		&srpc.AuthInformation{HaveMethodAccess: true},
   247  		nil)
   248  	return rc, err
   249  }
   250  
   251  func (m *Manager) GetVmUserDataRPC(ipAddr net.IP,
   252  	authInfo *srpc.AuthInformation, accessToken []byte) (
   253  	io.ReadCloser, uint64, error) {
   254  	return m.getVmUserData(ipAddr, authInfo, accessToken)
   255  }
   256  
   257  func (m *Manager) GetVmVolume(conn *srpc.Conn) error {
   258  	return m.getVmVolume(conn)
   259  }
   260  
   261  func (m *Manager) ImportLocalVm(authInfo *srpc.AuthInformation,
   262  	request proto.ImportLocalVmRequest) error {
   263  	return m.importLocalVm(authInfo, request)
   264  }
   265  
   266  func (m *Manager) ListAvailableAddresses() []proto.Address {
   267  	return m.listAvailableAddresses()
   268  }
   269  
   270  func (m *Manager) ListRegisteredAddresses() []proto.Address {
   271  	return m.listRegisteredAddresses()
   272  }
   273  
   274  func (m *Manager) ListSubnets(doSort bool) []proto.Subnet {
   275  	return m.listSubnets(doSort)
   276  }
   277  
   278  func (m *Manager) ListVMs(request proto.ListVMsRequest) []string {
   279  	return m.listVMs(request)
   280  }
   281  
   282  func (m *Manager) ListVolumeDirectories() []string {
   283  	return m.volumeDirectories
   284  }
   285  
   286  func (m *Manager) MakeSubnetChannel() <-chan proto.Subnet {
   287  	return m.makeSubnetChannel()
   288  }
   289  
   290  func (m *Manager) MakeUpdateChannel() <-chan proto.Update {
   291  	return m.makeUpdateChannel()
   292  }
   293  
   294  func (m *Manager) MigrateVm(conn *srpc.Conn) error {
   295  	return m.migrateVm(conn)
   296  }
   297  
   298  func (m *Manager) NotifyVmMetadataRequest(ipAddr net.IP, path string) {
   299  	m.notifyVmMetadataRequest(ipAddr, path)
   300  }
   301  
   302  func (m *Manager) PatchVmImage(conn *srpc.Conn,
   303  	request proto.PatchVmImageRequest) error {
   304  	return m.patchVmImage(conn, request)
   305  }
   306  
   307  func (m *Manager) PowerOff(stopVMs bool) error {
   308  	return m.powerOff(stopVMs)
   309  }
   310  
   311  func (m *Manager) PrepareVmForMigration(ipAddr net.IP,
   312  	authInfo *srpc.AuthInformation, accessToken []byte, enable bool) error {
   313  	return m.prepareVmForMigration(ipAddr, authInfo, accessToken, enable)
   314  }
   315  
   316  func (m *Manager) RemoveAddressesFromPool(addresses []proto.Address) error {
   317  	return m.removeAddressesFromPool(addresses)
   318  }
   319  
   320  func (m *Manager) RemoveExcessAddressesFromPool(maxFree map[string]uint) error {
   321  	return m.removeExcessAddressesFromPool(maxFree)
   322  }
   323  
   324  func (m *Manager) RegisterVmMetadataNotifier(ipAddr net.IP,
   325  	authInfo *srpc.AuthInformation, pathChannel chan<- string) error {
   326  	return m.registerVmMetadataNotifier(ipAddr, authInfo, pathChannel)
   327  }
   328  
   329  func (m *Manager) ReplaceVmImage(conn *srpc.Conn,
   330  	authInfo *srpc.AuthInformation) error {
   331  	return m.replaceVmImage(conn, authInfo)
   332  }
   333  
   334  func (m *Manager) ReplaceVmUserData(ipAddr net.IP, reader io.Reader,
   335  	size uint64, authInfo *srpc.AuthInformation) error {
   336  	return m.replaceVmUserData(ipAddr, reader, size, authInfo)
   337  }
   338  
   339  func (m *Manager) RestoreVmFromSnapshot(ipAddr net.IP,
   340  	authInfo *srpc.AuthInformation, forceIfNotStopped bool) error {
   341  	return m.restoreVmFromSnapshot(ipAddr, authInfo, forceIfNotStopped)
   342  }
   343  
   344  func (m *Manager) RestoreVmImage(ipAddr net.IP,
   345  	authInfo *srpc.AuthInformation) error {
   346  	return m.restoreVmImage(ipAddr, authInfo)
   347  }
   348  
   349  func (m *Manager) RestoreVmUserData(ipAddr net.IP,
   350  	authInfo *srpc.AuthInformation) error {
   351  	return m.restoreVmUserData(ipAddr, authInfo)
   352  }
   353  
   354  func (m *Manager) ScanVmRoot(ipAddr net.IP, authInfo *srpc.AuthInformation,
   355  	scanFilter *filter.Filter) (*filesystem.FileSystem, error) {
   356  	return m.scanVmRoot(ipAddr, authInfo, scanFilter)
   357  }
   358  
   359  func (m *Manager) ShutdownVMsAndExit() {
   360  	m.shutdownVMsAndExit()
   361  }
   362  
   363  func (m *Manager) SnapshotVm(ipAddr net.IP, authInfo *srpc.AuthInformation,
   364  	forceIfNotStopped, snapshotRootOnly bool) error {
   365  	return m.snapshotVm(ipAddr, authInfo, forceIfNotStopped, snapshotRootOnly)
   366  }
   367  
   368  func (m *Manager) StartVm(ipAddr net.IP, authInfo *srpc.AuthInformation,
   369  	accessToken []byte, dhcpTimeout time.Duration) (
   370  	bool, error) {
   371  	return m.startVm(ipAddr, authInfo, accessToken, dhcpTimeout)
   372  }
   373  
   374  func (m *Manager) StopVm(ipAddr net.IP, authInfo *srpc.AuthInformation,
   375  	accessToken []byte) error {
   376  	return m.stopVm(ipAddr, authInfo, accessToken)
   377  }
   378  
   379  func (m *Manager) UpdateSubnets(request proto.UpdateSubnetsRequest) error {
   380  	return m.updateSubnets(request)
   381  }
   382  
   383  func (m *Manager) UnregisterVmMetadataNotifier(ipAddr net.IP,
   384  	pathChannel chan<- string) error {
   385  	return m.unregisterVmMetadataNotifier(ipAddr, pathChannel)
   386  }
   387  
   388  func (m *Manager) WriteHtml(writer io.Writer) {
   389  	m.writeHtml(writer)
   390  }