VMware vSphere Integrated Containers provider (#206)

* Add Virtual Kubelet provider for VIC

Initial virtual kubelet provider for VMware VIC.  This provider currently
handles creating and starting of a pod VM via the VIC portlayer and persona
server.  Image store handling via the VIC persona server.  This provider
currently requires the feature/wolfpack branch of VIC.

* Added pod stop and delete.  Also added node capacity.

Added the ability to stop and delete pod VMs via VIC.  Also retrieve
node capacity information from the VCH.

* Cleanup and readme file

Some file clean up and added a Readme.md markdown file for the VIC
provider.

* Cleaned up errors, added function comments, moved operation code

1. Cleaned up error handling.  Set standard for creating errors.
2. Added method prototype comments for all interface functions.
3. Moved PodCreator, PodStarter, PodStopper, and PodDeleter to a new folder.

* Add mocking code and unit tests for podcache, podcreator, and podstarter

Used the unit test framework used in VIC to handle assertions in the provider's
unit test.  Mocking code generated using OSS project mockery, which is compatible
with the testify assertion framework.

* Vendored packages for the VIC provider

Requires feature/wolfpack branch of VIC and a few specific commit sha of
projects used within VIC.

* Implementation of POD Stopper and Deleter unit tests (#4)

* Updated files for initial PR

vendor/github.com/vmware/govmomi/property/collector.go

@@ -0,0 +1,205 @@
+/*
+Copyright (c) 2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package property
+
+import (
+	"context"
+	"errors"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// Collector models the PropertyCollector managed object.
+//
+// For more information, see:
+// http://pubs.vmware.com/vsphere-60/index.jsp?topic=%2Fcom.vmware.wssdk.apiref.doc%2Fvmodl.query.PropertyCollector.html
+//
+type Collector struct {
+	roundTripper soap.RoundTripper
+	reference    types.ManagedObjectReference
+}
+
+// DefaultCollector returns the session's default property collector.
+func DefaultCollector(c *vim25.Client) *Collector {
+	p := Collector{
+		roundTripper: c,
+		reference:    c.ServiceContent.PropertyCollector,
+	}
+
+	return &p
+}
+
+func (p Collector) Reference() types.ManagedObjectReference {
+	return p.reference
+}
+
+// Create creates a new session-specific Collector that can be used to
+// retrieve property updates independent of any other Collector.
+func (p *Collector) Create(ctx context.Context) (*Collector, error) {
+	req := types.CreatePropertyCollector{
+		This: p.Reference(),
+	}
+
+	res, err := methods.CreatePropertyCollector(ctx, p.roundTripper, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	newp := Collector{
+		roundTripper: p.roundTripper,
+		reference:    res.Returnval,
+	}
+
+	return &newp, nil
+}
+
+// Destroy destroys this Collector.
+func (p *Collector) Destroy(ctx context.Context) error {
+	req := types.DestroyPropertyCollector{
+		This: p.Reference(),
+	}
+
+	_, err := methods.DestroyPropertyCollector(ctx, p.roundTripper, &req)
+	if err != nil {
+		return err
+	}
+
+	p.reference = types.ManagedObjectReference{}
+	return nil
+}
+
+func (p *Collector) CreateFilter(ctx context.Context, req types.CreateFilter) error {
+	req.This = p.Reference()
+
+	_, err := methods.CreateFilter(ctx, p.roundTripper, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (p *Collector) WaitForUpdates(ctx context.Context, v string) (*types.UpdateSet, error) {
+	req := types.WaitForUpdatesEx{
+		This:    p.Reference(),
+		Version: v,
+	}
+
+	res, err := methods.WaitForUpdatesEx(ctx, p.roundTripper, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}
+
+func (p *Collector) RetrieveProperties(ctx context.Context, req types.RetrieveProperties) (*types.RetrievePropertiesResponse, error) {
+	req.This = p.Reference()
+	return methods.RetrieveProperties(ctx, p.roundTripper, &req)
+}
+
+// Retrieve loads properties for a slice of managed objects. The dst argument
+// must be a pointer to a []interface{}, which is populated with the instances
+// of the specified managed objects, with the relevant properties filled in. If
+// the properties slice is nil, all properties are loaded.
+func (p *Collector) Retrieve(ctx context.Context, objs []types.ManagedObjectReference, ps []string, dst interface{}) error {
+	if len(objs) == 0 {
+		return errors.New("object references is empty")
+	}
+
+	var propSpec *types.PropertySpec
+	var objectSet []types.ObjectSpec
+
+	for _, obj := range objs {
+		// Ensure that all object reference types are the same
+		if propSpec == nil {
+			propSpec = &types.PropertySpec{
+				Type: obj.Type,
+			}
+
+			if ps == nil {
+				propSpec.All = types.NewBool(true)
+			} else {
+				propSpec.PathSet = ps
+			}
+		} else {
+			if obj.Type != propSpec.Type {
+				return errors.New("object references must have the same type")
+			}
+		}
+
+		objectSpec := types.ObjectSpec{
+			Obj:  obj,
+			Skip: types.NewBool(false),
+		}
+
+		objectSet = append(objectSet, objectSpec)
+	}
+
+	req := types.RetrieveProperties{
+		SpecSet: []types.PropertyFilterSpec{
+			{
+				ObjectSet: objectSet,
+				PropSet:   []types.PropertySpec{*propSpec},
+			},
+		},
+	}
+
+	res, err := p.RetrieveProperties(ctx, req)
+	if err != nil {
+		return err
+	}
+
+	if d, ok := dst.(*[]types.ObjectContent); ok {
+		*d = res.Returnval
+		return nil
+	}
+
+	return mo.LoadRetrievePropertiesResponse(res, dst)
+}
+
+// RetrieveWithFilter populates dst as Retrieve does, but only for entities matching the given filter.
+func (p *Collector) RetrieveWithFilter(ctx context.Context, objs []types.ManagedObjectReference, ps []string, dst interface{}, filter Filter) error {
+	if len(filter) == 0 {
+		return p.Retrieve(ctx, objs, ps, dst)
+	}
+
+	var content []types.ObjectContent
+
+	err := p.Retrieve(ctx, objs, filter.Keys(), &content)
+	if err != nil {
+		return err
+	}
+
+	objs = filter.MatchObjectContent(content)
+
+	if len(objs) == 0 {
+		return nil
+	}
+
+	return p.Retrieve(ctx, objs, ps, dst)
+}
+
+// RetrieveOne calls Retrieve with a single managed object reference.
+func (p *Collector) RetrieveOne(ctx context.Context, obj types.ManagedObjectReference, ps []string, dst interface{}) error {
+	var objs = []types.ManagedObjectReference{obj}
+	return p.Retrieve(ctx, objs, ps, dst)
+}

vendor/github.com/vmware/govmomi/property/filter.go

@@ -0,0 +1,139 @@
+/*
+Copyright (c) 2017 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package property
+
+import (
+	"fmt"
+	"path"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// Filter provides methods for matching against types.DynamicProperty
+type Filter map[string]types.AnyType
+
+// Keys returns the Filter map keys as a []string
+func (f Filter) Keys() []string {
+	keys := make([]string, 0, len(f))
+
+	for key := range f {
+		keys = append(keys, key)
+	}
+
+	return keys
+}
+
+// MatchProperty returns true if a Filter entry matches the given prop.
+func (f Filter) MatchProperty(prop types.DynamicProperty) bool {
+	match, ok := f[prop.Name]
+	if !ok {
+		return false
+	}
+
+	if match == prop.Val {
+		return true
+	}
+
+	ptype := reflect.TypeOf(prop.Val)
+
+	if strings.HasPrefix(ptype.Name(), "ArrayOf") {
+		pval := reflect.ValueOf(prop.Val).Field(0)
+
+		for i := 0; i < pval.Len(); i++ {
+			prop.Val = pval.Index(i).Interface()
+
+			if f.MatchProperty(prop) {
+				return true
+			}
+		}
+
+		return false
+	}
+
+	if reflect.TypeOf(match) != ptype {
+		s, ok := match.(string)
+		if !ok {
+			return false
+		}
+
+		// convert if we can
+		switch prop.Val.(type) {
+		case bool:
+			match, _ = strconv.ParseBool(s)
+		case int16:
+			x, _ := strconv.ParseInt(s, 10, 16)
+			match = int16(x)
+		case int32:
+			x, _ := strconv.ParseInt(s, 10, 32)
+			match = int32(x)
+		case int64:
+			match, _ = strconv.ParseInt(s, 10, 64)
+		case float32:
+			x, _ := strconv.ParseFloat(s, 32)
+			match = float32(x)
+		case float64:
+			match, _ = strconv.ParseFloat(s, 64)
+		case fmt.Stringer:
+			prop.Val = prop.Val.(fmt.Stringer).String()
+		default:
+			if ptype.Kind() != reflect.String {
+				return false
+			}
+			// An enum type we can convert to a string type
+			prop.Val = reflect.ValueOf(prop.Val).String()
+		}
+	}
+
+	switch pval := prop.Val.(type) {
+	case string:
+		s := match.(string)
+		if s == "*" {
+			return true // TODO: path.Match fails if s contains a '/'
+		}
+		m, _ := path.Match(s, pval)
+		return m
+	default:
+		return reflect.DeepEqual(match, pval)
+	}
+}
+
+// MatchPropertyList returns true if all given props match the Filter.
+func (f Filter) MatchPropertyList(props []types.DynamicProperty) bool {
+	for _, p := range props {
+		if !f.MatchProperty(p) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// MatchObjectContent returns a list of ObjectContent.Obj where the ObjectContent.PropSet matches the Filter.
+func (f Filter) MatchObjectContent(objects []types.ObjectContent) []types.ManagedObjectReference {
+	var refs []types.ManagedObjectReference
+
+	for _, o := range objects {
+		if f.MatchPropertyList(o.PropSet) {
+			refs = append(refs, o.Obj)
+		}
+	}
+
+	return refs
+}

vendor/github.com/vmware/govmomi/property/filter_test.go

@@ -0,0 +1,60 @@
+/*
+Copyright (c) 2017 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package property
+
+import (
+	"testing"
+
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+func TestMatchProperty(t *testing.T) {
+	tests := []struct {
+		key  string
+		val  types.AnyType
+		pass types.AnyType
+		fail types.AnyType
+	}{
+		{"string", "bar", "bar", "foo"},
+		{"match", "foo.bar", "foo.*", "foobarbaz"},
+		{"moref", types.ManagedObjectReference{Type: "HostSystem", Value: "foo"}, "HostSystem:foo", "bar"}, // implements fmt.Stringer
+		{"morefm", types.ManagedObjectReference{Type: "HostSystem", Value: "foo"}, "*foo", "bar"},
+		{"morefs", types.ArrayOfManagedObjectReference{ManagedObjectReference: []types.ManagedObjectReference{{Type: "HostSystem", Value: "foo"}}}, "*foo", "bar"},
+		{"enum", types.VirtualMachinePowerStatePoweredOn, "poweredOn", "poweredOff"},
+		{"int16", int32(16), int32(16), int32(42)},
+		{"int32", int32(32), int32(32), int32(42)},
+		{"int32s", int32(32), "32", "42"},
+		{"int64", int64(64), int64(64), int64(42)},
+		{"int64s", int64(64), "64", "42"},
+		{"float32", float32(32.32), float32(32.32), float32(42.0)},
+		{"float32s", float32(32.32), "32.32", "42.0"},
+		{"float64", float64(64.64), float64(64.64), float64(42.0)},
+		{"float64s", float64(64.64), "64.64", "42.0"},
+	}
+
+	for _, test := range tests {
+		p := types.DynamicProperty{Name: test.key, Val: test.val}
+
+		for match, value := range map[bool]types.AnyType{true: test.pass, false: test.fail} {
+			result := Filter{test.key: value}.MatchProperty(p)
+
+			if result != match {
+				t.Errorf("%s: %t", test.key, result)
+			}
+		}
+	}
+}

vendor/github.com/vmware/govmomi/property/wait.go

@@ -0,0 +1,115 @@
+/*
+Copyright (c) 2015-2017 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package property
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// WaitFilter provides helpers to construct a types.CreateFilter for use with property.Wait
+type WaitFilter struct {
+	types.CreateFilter
+}
+
+// Add a new ObjectSpec and PropertySpec to the WaitFilter
+func (f *WaitFilter) Add(obj types.ManagedObjectReference, kind string, ps []string, set ...types.BaseSelectionSpec) *WaitFilter {
+	spec := types.ObjectSpec{
+		Obj:       obj,
+		SelectSet: set,
+	}
+
+	pset := types.PropertySpec{
+		Type:    kind,
+		PathSet: ps,
+	}
+
+	if len(ps) == 0 {
+		pset.All = types.NewBool(true)
+	}
+
+	f.Spec.ObjectSet = append(f.Spec.ObjectSet, spec)
+
+	f.Spec.PropSet = append(f.Spec.PropSet, pset)
+
+	return f
+}
+
+// Wait creates a new WaitFilter and calls the specified function for each ObjectUpdate via WaitForUpdates
+func Wait(ctx context.Context, c *Collector, obj types.ManagedObjectReference, ps []string, f func([]types.PropertyChange) bool) error {
+	filter := new(WaitFilter).Add(obj, obj.Type, ps)
+
+	return WaitForUpdates(ctx, c, filter, func(updates []types.ObjectUpdate) bool {
+		for _, update := range updates {
+			if f(update.ChangeSet) {
+				return true
+			}
+		}
+
+		return false
+	})
+}
+
+// WaitForUpdates waits for any of the specified properties of the specified managed
+// object to change. It calls the specified function for every update it
+// receives. If this function returns false, it continues waiting for
+// subsequent updates. If this function returns true, it stops waiting and
+// returns.
+//
+// To only receive updates for the specified managed object, the function
+// creates a new property collector and calls CreateFilter. A new property
+// collector is required because filters can only be added, not removed.
+//
+// The newly created collector is destroyed before this function returns (both
+// in case of success or error).
+//
+func WaitForUpdates(ctx context.Context, c *Collector, filter *WaitFilter, f func([]types.ObjectUpdate) bool) error {
+	p, err := c.Create(ctx)
+	if err != nil {
+		return err
+	}
+
+	// Attempt to destroy the collector using the background context, as the
+	// specified context may have timed out or have been cancelled.
+	defer p.Destroy(context.Background())
+
+	err = p.CreateFilter(ctx, filter.CreateFilter)
+	if err != nil {
+		return err
+	}
+
+	for version := ""; ; {
+		res, err := p.WaitForUpdates(ctx, version)
+		if err != nil {
+			return err
+		}
+
+		// Retry if the result came back empty
+		if res == nil {
+			continue
+		}
+
+		version = res.Version
+
+		for _, fs := range res.FilterSet {
+			if f(fs.ObjectSet) {
+				return nil
+			}
+		}
+	}
+}