Update vmware/govmomi vendor: add vapi package

Zones implementation for vSphere cloud provider needs dependencies
which are not included in current vmware/govmomi vendor. So this
update added "vapi" package to support zones.

vendor/github.com/vmware/govmomi/simulator/registry.go

@@ -23,6 +23,7 @@ import (
 	"reflect"
 	"strings"
 	"sync"
+	"sync/atomic"
 
 	"github.com/vmware/govmomi/vim25"
 	"github.com/vmware/govmomi/vim25/mo"
@@ -46,10 +47,11 @@ var refValueMap = map[string]string{
 // Map is the default Registry instance.
 var Map = NewRegistry()
 
-// RegisterObject interface supports callbacks when objects are added and removed from the Registry
+// RegisterObject interface supports callbacks when objects are created, updated and deleted from the Registry
 type RegisterObject interface {
 	mo.Reference
 	PutObject(mo.Reference)
+	UpdateObject(mo.Reference, []types.PropertyChange)
 	RemoveObject(types.ManagedObjectReference)
 }
 
@@ -59,7 +61,7 @@ type Registry struct {
 	objects  map[types.ManagedObjectReference]mo.Reference
 	handlers map[types.ManagedObjectReference]RegisterObject
 	locks    map[types.ManagedObjectReference]sync.Locker
-	counter  int
+	counter  int64
 
 	Namespace string
 	Path      string
@@ -112,8 +114,8 @@ func (r *Registry) newReference(item mo.Reference) types.ManagedObjectReference
 	}
 
 	if ref.Value == "" {
-		r.counter++
-		ref.Value = fmt.Sprintf("%s-%d", valuePrefix(ref.Type), r.counter)
+		n := atomic.AddInt64(&r.counter, 1)
+		ref.Value = fmt.Sprintf("%s-%d", valuePrefix(ref.Type), n)
 	}
 
 	return ref
@@ -126,7 +128,9 @@ func (r *Registry) setReference(item mo.Reference, ref types.ManagedObjectRefere
 
 // AddHandler adds a RegisterObject handler to the Registry.
 func (r *Registry) AddHandler(h RegisterObject) {
+	r.m.Lock()
 	r.handlers[h.Reference()] = h
+	r.m.Unlock()
 }
 
 // NewEntity sets Entity().Self with a new, unique Value.
@@ -173,10 +177,23 @@ func (r *Registry) Any(kind string) mo.Entity {
 	return nil
 }
 
+// applyHandlers calls the given func for each r.handlers
+func (r *Registry) applyHandlers(f func(o RegisterObject)) {
+	r.m.Lock()
+	handlers := make([]RegisterObject, 0, len(r.handlers))
+	for _, handler := range r.handlers {
+		handlers = append(handlers, handler)
+	}
+	r.m.Unlock()
+
+	for i := range handlers {
+		f(handlers[i])
+	}
+}
+
 // Put adds a new object to Registry, generating a ManagedObjectReference if not already set.
 func (r *Registry) Put(item mo.Reference) mo.Reference {
 	r.m.Lock()
-	defer r.m.Unlock()
 
 	ref := item.Reference()
 	if ref.Type == "" || ref.Value == "" {
@@ -192,25 +209,50 @@ func (r *Registry) Put(item mo.Reference) mo.Reference {
 
 	r.objects[ref] = item
 
-	for _, h := range r.handlers {
-		h.PutObject(item)
-	}
+	r.m.Unlock()
+
+	r.applyHandlers(func(o RegisterObject) {
+		o.PutObject(item)
+	})
 
 	return item
 }
 
 // Remove removes an object from the Registry.
 func (r *Registry) Remove(item types.ManagedObjectReference) {
+	r.applyHandlers(func(o RegisterObject) {
+		o.RemoveObject(item)
+	})
+
 	r.m.Lock()
-	defer r.m.Unlock()
-
-	for _, h := range r.handlers {
-		h.RemoveObject(item)
-	}
-
 	delete(r.objects, item)
 	delete(r.handlers, item)
 	delete(r.locks, item)
+	r.m.Unlock()
+}
+
+// Update dispatches object property changes to RegisterObject handlers,
+// such as any PropertyCollector instances with in-progress WaitForUpdates calls.
+// The changes are also applied to the given object via mo.ApplyPropertyChange,
+// so there is no need to set object fields directly.
+func (r *Registry) Update(obj mo.Reference, changes []types.PropertyChange) {
+	for i := range changes {
+		if changes[i].Op == "" {
+			changes[i].Op = types.PropertyChangeOpAssign
+		}
+		if changes[i].Val != nil {
+			rval := reflect.ValueOf(changes[i].Val)
+			changes[i].Val = wrapValue(rval, rval.Type())
+		}
+	}
+
+	val := getManagedObject(obj).Addr().Interface().(mo.Reference)
+
+	mo.ApplyPropertyChange(val, changes)
+
+	r.applyHandlers(func(o RegisterObject) {
+		o.UpdateObject(val, changes)
+	})
 }
 
 // getEntityParent traverses up the inventory and returns the first object of type kind.
@@ -417,11 +459,23 @@ func (r *Registry) MarshalJSON() ([]byte, error) {
 }
 
 func (r *Registry) locker(obj mo.Reference) sync.Locker {
+	var ref types.ManagedObjectReference
+
+	switch x := obj.(type) {
+	case types.ManagedObjectReference:
+		ref = x
+		obj = r.Get(ref) // to check for sync.Locker
+	case *types.ManagedObjectReference:
+		ref = *x
+		obj = r.Get(ref) // to check for sync.Locker
+	default:
+		ref = obj.Reference()
+	}
+
 	if mu, ok := obj.(sync.Locker); ok {
 		return mu
 	}
 
-	ref := obj.Reference()
 	r.m.Lock()
 	mu, ok := r.locks[ref]
 	if !ok {
@@ -444,3 +498,9 @@ func (r *Registry) WithLock(obj mo.Reference, f func()) {
 	}
 	f()
 }
+
+// nopLocker can be embedded to opt-out of auto-locking (see Registry.WithLock)
+type nopLocker struct{}
+
+func (*nopLocker) Lock()   {}
+func (*nopLocker) Unlock() {}