// NewDatastore returns a Datastore.
// ctx is a context,
// s is an authenticated session
// ds is the vsphere datastore
// rootdir is the top level directory to root all data. If root does not exist,
// it will be created. If it already exists, NOOP. This cannot be empty.
func NewDatastore(ctx context.Context, s *session.Session, ds *object.Datastore, rootdir string) (*Datastore, error) {
d := &Datastore{
ds: ds,
s: s,
fm: object.NewFileManager(s.Vim25()),
}
if strings.HasPrefix(rootdir, "/") {
rootdir = strings.TrimPrefix(rootdir, "/")
}
// Get the root directory element split from the rest of the path (if there is one)
root := strings.SplitN(rootdir, "/", 2)
// Create the first element. This handles vsan vmfs top level dirs.
if err := d.mkRootDir(ctx, root[0]); err != nil {
log.Infof("error creating root directory %s: %s", rootdir, err)
return nil, err
}
// Create the rest conventionally
if len(root) > 1 {
r, err := d.Mkdir(ctx, true, root[1])
if err != nil {
return nil, err
}
d.RootURL = r
}
log.Infof("Datastore path is %s", d.RootURL)
return d, nil
}
func Init(ctx context.Context, sess *session.Session, source extraconfig.DataSource, sink extraconfig.DataSink) error {
trace.End(trace.Begin(""))
initializer.once.Do(func() {
var err error
defer func() {
initializer.err = err
}()
f := find.NewFinder(sess.Vim25(), false)
var config Configuration
config.sink = sink
config.source = source
config.Decode()
config.PortGroups = make(map[string]object.NetworkReference)
log.Debugf("Decoded VCH config for network: %#v", config)
for nn, n := range config.ContainerNetworks {
pgref := new(types.ManagedObjectReference)
if !pgref.FromString(n.ID) {
log.Warnf("Could not reacquire object reference from id for network %s: %s", nn, n.ID)
}
var r object.Reference
if r, err = f.ObjectReference(ctx, *pgref); err != nil {
log.Warnf("could not get network reference for %s network: %s", nn, err)
err = nil
continue
}
config.PortGroups[nn] = r.(object.NetworkReference)
}
// make sure a NIC attached to the bridge network exists
config.BridgeLink, err = getBridgeLink(&config)
if err != nil {
return
}
var kv kvstore.KeyValueStore
kv, err = store.NewDatastoreKeyValue(ctx, sess, "network.contexts.default")
if err != nil {
return
}
var netctx *Context
if netctx, err = NewContext(&config, kv); err != nil {
return
}
if err = engageContext(ctx, netctx, exec.Config.EventManager); err == nil {
DefaultContext = netctx
log.Infof("Default network context allocated")
}
})
return initializer.err
}
func rm(t *testing.T, client *session.Session, name string) {
t.Logf("deleting %s", name)
fm := object.NewFileManager(client.Vim25())
task, err := fm.DeleteDatastoreFile(context.TODO(), name, client.Datacenter)
if !assert.NoError(t, err) {
return
}
_, _ = task.WaitForResult(context.TODO(), nil)
}
// NewDiagnosticManager returns a new DiagnosticManager object
func NewDiagnosticManager(session *session.Session) *Manager {
return &Manager{
DiagnosticManager: object.NewDiagnosticManager(
session.Vim25(),
),
Session: session,
}
}
// GetSelf gets VirtualMachine reference for the VM this process is running on
func GetSelf(ctx context.Context, s *session.Session) (*vm.VirtualMachine, error) {
u, err := UUID()
if err != nil {
return nil, err
}
search := object.NewSearchIndex(s.Vim25())
ref, err := search.FindByUuid(ctx, s.Datacenter, u, true, nil)
if err != nil {
return nil, err
}
if ref == nil {
return nil, fmt.Errorf("can't find the hosting vm")
}
return vm.NewVirtualMachine(ctx, s, ref.Reference()), nil
}
// NewResourcePool returns a New ResourcePool object
func NewVirtualApp(ctx context.Context, session *session.Session, moref types.ManagedObjectReference) *VirtualApp {
return &VirtualApp{
VirtualApp: object.NewVirtualApp(
session.Vim25(),
moref,
),
Session: session,
}
}
// NewResourcePool returns a New ResourcePool object
func NewResourcePool(ctx context.Context, session *session.Session, moref types.ManagedObjectReference) *ResourcePool {
return &ResourcePool{
ResourcePool: object.NewResourcePool(
session.Vim25(),
moref,
),
Session: session,
}
}
// GetDatastores returns a map of datastores given a map of names and urls
func GetDatastores(ctx context.Context, s *session.Session, dsURLs map[string]*url.URL) (map[string]*Helper, error) {
stores := make(map[string]*Helper)
fm := object.NewFileManager(s.Vim25())
for name, dsURL := range dsURLs {
vsDs, err := s.Finder.DatastoreOrDefault(ctx, s.DatastorePath)
if err != nil {
return nil, err
}
d := &Helper{
ds: vsDs,
s: s,
fm: fm,
RootURL: dsURL.Path,
}
stores[name] = d
}
return stores, nil
}
// NewDatastore returns a Datastore.
// ctx is a context,
// s is an authenticated session
// ds is the vsphere datastore
// rootdir is the top level directory to root all data. If root does not exist,
// it will be created. If it already exists, NOOP. This cannot be empty.
func NewHelper(ctx context.Context, s *session.Session, ds *object.Datastore, rootdir string) (*Helper, error) {
d := &Helper{
ds: ds,
s: s,
fm: object.NewFileManager(s.Vim25()),
}
if path.IsAbs(rootdir) {
rootdir = rootdir[1:]
}
if err := d.mkRootDir(ctx, rootdir); err != nil {
log.Infof("error creating root directory %s: %s", rootdir, err)
return nil, err
}
if d.RootURL == "" {
return nil, fmt.Errorf("failed to create root directory")
}
log.Infof("Datastore path is %s", d.RootURL)
return d, nil
}
func Init(ctx context.Context, sess *session.Session) error {
source, err := extraconfig.GuestInfoSource()
if err != nil {
return err
}
f := find.NewFinder(sess.Vim25(), false)
extraconfig.Decode(source, &exec.VCHConfig)
log.Debugf("Decoded VCH config for execution: %#v", exec.VCHConfig)
ccount := len(exec.VCHConfig.ComputeResources)
if ccount != 1 {
detail := fmt.Sprintf("expected singular compute resource element, found %d", ccount)
log.Errorf(detail)
return err
}
cr := exec.VCHConfig.ComputeResources[0]
r, err := f.ObjectReference(ctx, cr)
if err != nil {
detail := fmt.Sprintf("could not get resource pool or virtual app reference from %q: %s", cr.String(), err)
log.Errorf(detail)
return err
}
switch o := r.(type) {
case *object.VirtualApp:
exec.VCHConfig.VirtualApp = o
exec.VCHConfig.ResourcePool = o.ResourcePool
case *object.ResourcePool:
exec.VCHConfig.ResourcePool = o
default:
detail := fmt.Sprintf("could not get resource pool or virtual app from reference %q: object type is wrong", cr.String())
log.Errorf(detail)
return errors.New(detail)
}
// we have a resource pool, so lets create the event manager for monitoring
exec.VCHConfig.EventManager = vsphere.NewEventManager(sess)
// configure event manager to monitor the resource pool
exec.VCHConfig.EventManager.AddMonitoredObject(exec.VCHConfig.ResourcePool.Reference().String())
// instantiate the container cache now
exec.NewContainerCache()
// need to blacklist the VCH from eventlistening - too many reconfigures
vch, err := guest.GetSelf(ctx, sess)
if err != nil {
return fmt.Errorf("Unable to get a reference to the VCH: %s", err.Error())
}
exec.VCHConfig.EventManager.Blacklist(vch.Reference().String())
// other managed objects could be added for the event stream, but for now the resource pool will do
exec.VCHConfig.EventManager.Start()
//FIXME: temporary injection of debug network for debug nic
ne := exec.VCHConfig.Networks["client"]
if ne == nil {
detail := fmt.Sprintf("could not get client network reference for debug nic - this code can be removed once network mapping/dhcp client is present")
log.Errorf(detail)
return err
}
nr := new(types.ManagedObjectReference)
nr.FromString(ne.Network.ID)
r, err = f.ObjectReference(ctx, *nr)
if err != nil {
detail := fmt.Sprintf("could not get client network reference from %s: %s", nr.String(), err)
log.Errorf(detail)
return err
}
exec.VCHConfig.DebugNetwork = r.(object.NetworkReference)
extraconfig.Decode(source, &network.Config)
log.Debugf("Decoded VCH config for network: %#v", network.Config)
for nn, n := range network.Config.ContainerNetworks {
pgref := new(types.ManagedObjectReference)
if !pgref.FromString(n.ID) {
log.Errorf("Could not reacquire object reference from id for network %s: %s", nn, n.ID)
}
r, err = f.ObjectReference(ctx, *pgref)
if err != nil {
log.Warnf("could not get network reference for %s network", nn)
continue
}
n.PortGroup = r.(object.NetworkReference)
}
// Grab the storage layer config blobs from extra config
extraconfig.Decode(source, &storage.Config)
log.Debugf("Decoded VCH config for storage: %#v", storage.Config)
// Grab the AboutInfo about our host environment
about := sess.Vim25().ServiceContent.About
exec.VCHConfig.VCHMhz = exec.NCPU(ctx)
exec.VCHConfig.VCHMemoryLimit = exec.MemTotal(ctx)
exec.VCHConfig.HostOS = about.OsType
exec.VCHConfig.HostOSVersion = about.Version
exec.VCHConfig.HostProductName = about.Name
log.Debugf("Host - OS (%s), version (%s), name (%s)", about.OsType, about.Version, about.Name)
log.Debugf("VCH limits - %d Mhz, %d MB", exec.VCHConfig.VCHMhz, exec.VCHConfig.VCHMemoryLimit)
return nil
}
func Init(ctx context.Context, sess *session.Session, source extraconfig.DataSource, _ extraconfig.DataSink) error {
initializer.once.Do(func() {
var err error
defer func() {
if err != nil {
initializer.err = err
}
}()
f := find.NewFinder(sess.Vim25(), false)
extraconfig.Decode(source, &Config)
log.Debugf("Decoded VCH config for execution: %#v", Config)
ccount := len(Config.ComputeResources)
if ccount != 1 {
err = fmt.Errorf("expected singular compute resource element, found %d", ccount)
log.Error(err)
return
}
cr := Config.ComputeResources[0]
var r object.Reference
r, err = f.ObjectReference(ctx, cr)
if err != nil {
err = fmt.Errorf("could not get resource pool or virtual app reference from %q: %s", cr.String(), err)
log.Error(err)
return
}
switch o := r.(type) {
case *object.VirtualApp:
Config.VirtualApp = o
Config.ResourcePool = o.ResourcePool
case *object.ResourcePool:
Config.ResourcePool = o
default:
err = fmt.Errorf("could not get resource pool or virtual app from reference %q: object type is wrong", cr.String())
log.Error(err)
return
}
// we want to monitor the cluster, so create a vSphere Event Collector
// The cluster managed object will either be a proper vSphere Cluster or
// a specific host when standalone mode
ec := vsphere.NewCollector(sess.Vim25(), sess.Cluster.Reference().String())
// start the collection of vsphere events
err = ec.Start()
if err != nil {
err = fmt.Errorf("%s failed to start: %s", ec.Name(), err)
log.Error(err)
return
}
// create the event manager & register the existing collector
Config.EventManager = event.NewEventManager(ec)
// subscribe the exec layer to the event stream for Vm events
Config.EventManager.Subscribe(events.NewEventType(vsphere.VMEvent{}).Topic(), "exec", eventCallback)
// subscribe callback to handle vm registered event
Config.EventManager.Subscribe(events.NewEventType(vsphere.VMEvent{}).Topic(), "registeredVMEvent", func(ie events.Event) {
registeredVMCallback(sess, ie)
})
// instantiate the container cache now
NewContainerCache()
// Grab the AboutInfo about our host environment
about := sess.Vim25().ServiceContent.About
Config.VCHMhz = NCPU(ctx)
Config.VCHMemoryLimit = MemTotal(ctx)
Config.HostOS = about.OsType
Config.HostOSVersion = about.Version
Config.HostProductName = about.Name
log.Debugf("Host - OS (%s), version (%s), name (%s)", about.OsType, about.Version, about.Name)
log.Debugf("VCH limits - %d Mhz, %d MB", Config.VCHMhz, Config.VCHMemoryLimit)
// sync container cache
if err = Containers.sync(ctx, sess); err != nil {
return
}
})
return initializer.err
}
func Init(ctx context.Context, sess *session.Session) error {
source, err := extraconfig.GuestInfoSource()
if err != nil {
return err
}
f := find.NewFinder(sess.Vim25(), false)
extraconfig.Decode(source, &exec.Config)
log.Debugf("Decoded VCH config for execution: %#v", exec.Config)
ccount := len(exec.Config.ComputeResources)
if ccount != 1 {
detail := fmt.Sprintf("expected singular compute resource element, found %d", ccount)
log.Errorf(detail)
return err
}
cr := exec.Config.ComputeResources[0]
r, err := f.ObjectReference(ctx, cr)
if err != nil {
detail := fmt.Sprintf("could not get resource pool reference from %s: %s", cr.String(), err)
log.Errorf(detail)
return err
}
exec.Config.ResourcePool = r.(*object.ResourcePool)
//FIXME: temporary injection of debug network for debug nic
ne := exec.Config.Networks["client"]
if ne == nil {
detail := fmt.Sprintf("could not get client network reference for debug nic - this code can be removed once network mapping/dhcp client is present")
log.Errorf(detail)
return err
}
nr := new(types.ManagedObjectReference)
nr.FromString(ne.Network.ID)
r, err = f.ObjectReference(ctx, *nr)
if err != nil {
detail := fmt.Sprintf("could not get client network reference from %s: %s", nr.String(), err)
log.Errorf(detail)
return err
}
exec.Config.DebugNetwork = r.(object.NetworkReference)
extraconfig.Decode(source, &network.Config)
log.Debugf("Decoded VCH config for network: %#v", network.Config)
for nn, n := range network.Config.ContainerNetworks {
pgref := new(types.ManagedObjectReference)
if !pgref.FromString(n.ID) {
log.Errorf("Could not reacquire object reference from id for network %s: %s", nn, n.ID)
}
r, err = f.ObjectReference(ctx, *pgref)
if err != nil {
log.Warnf("could not get network reference for %s network", nn)
continue
}
n.PortGroup = r.(object.NetworkReference)
}
return nil
}
// NewVirtualMachine returns a NewVirtualMachine object
func NewVirtualMachine(ctx context.Context, session *session.Session, moref types.ManagedObjectReference) *VirtualMachine {
return NewVirtualMachineFromVM(ctx, session, object.NewVirtualMachine(session.Vim25(), moref))
}