513cebe7b7
* 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
125 lines
3.2 KiB
Plaintext
125 lines
3.2 KiB
Plaintext
/*
|
|
{4} ({1} and []{1})
|
|
*/
|
|
|
|
// {4} gets the value as a {1}, returns the optionalDefault
|
|
// value or a system default object if the value is the wrong type.
|
|
func (v *Value) {4}(optionalDefault ...{1}) {1} {
|
|
if s, ok := v.data.({1}); ok {
|
|
return s
|
|
}
|
|
if len(optionalDefault) == 1 {
|
|
return optionalDefault[0]
|
|
}
|
|
return {3}
|
|
}
|
|
|
|
// Must{4} gets the value as a {1}.
|
|
//
|
|
// Panics if the object is not a {1}.
|
|
func (v *Value) Must{4}() {1} {
|
|
return v.data.({1})
|
|
}
|
|
|
|
// {4}Slice gets the value as a []{1}, returns the optionalDefault
|
|
// value or nil if the value is not a []{1}.
|
|
func (v *Value) {4}Slice(optionalDefault ...[]{1}) []{1} {
|
|
if s, ok := v.data.([]{1}); ok {
|
|
return s
|
|
}
|
|
if len(optionalDefault) == 1 {
|
|
return optionalDefault[0]
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Must{4}Slice gets the value as a []{1}.
|
|
//
|
|
// Panics if the object is not a []{1}.
|
|
func (v *Value) Must{4}Slice() []{1} {
|
|
return v.data.([]{1})
|
|
}
|
|
|
|
// Is{4} gets whether the object contained is a {1} or not.
|
|
func (v *Value) Is{4}() bool {
|
|
_, ok := v.data.({1})
|
|
return ok
|
|
}
|
|
|
|
// Is{4}Slice gets whether the object contained is a []{1} or not.
|
|
func (v *Value) Is{4}Slice() bool {
|
|
_, ok := v.data.([]{1})
|
|
return ok
|
|
}
|
|
|
|
// Each{4} calls the specified callback for each object
|
|
// in the []{1}.
|
|
//
|
|
// Panics if the object is the wrong type.
|
|
func (v *Value) Each{4}(callback func(int, {1}) bool) *Value {
|
|
for index, val := range v.Must{4}Slice() {
|
|
carryon := callback(index, val)
|
|
if !carryon {
|
|
break
|
|
}
|
|
}
|
|
return v
|
|
}
|
|
|
|
// Where{4} uses the specified decider function to select items
|
|
// from the []{1}. The object contained in the result will contain
|
|
// only the selected items.
|
|
func (v *Value) Where{4}(decider func(int, {1}) bool) *Value {
|
|
var selected []{1}
|
|
v.Each{4}(func(index int, val {1}) bool {
|
|
shouldSelect := decider(index, val)
|
|
if !shouldSelect {
|
|
selected = append(selected, val)
|
|
}
|
|
return true
|
|
})
|
|
return &Value{data:selected}
|
|
}
|
|
|
|
// Group{4} uses the specified grouper function to group the items
|
|
// keyed by the return of the grouper. The object contained in the
|
|
// result will contain a map[string][]{1}.
|
|
func (v *Value) Group{4}(grouper func(int, {1}) string) *Value {
|
|
groups := make(map[string][]{1})
|
|
v.Each{4}(func(index int, val {1}) bool {
|
|
group := grouper(index, val)
|
|
if _, ok := groups[group]; !ok {
|
|
groups[group] = make([]{1}, 0)
|
|
}
|
|
groups[group] = append(groups[group], val)
|
|
return true
|
|
})
|
|
return &Value{data:groups}
|
|
}
|
|
|
|
// Replace{4} uses the specified function to replace each {1}s
|
|
// by iterating each item. The data in the returned result will be a
|
|
// []{1} containing the replaced items.
|
|
func (v *Value) Replace{4}(replacer func(int, {1}) {1}) *Value {
|
|
arr := v.Must{4}Slice()
|
|
replaced := make([]{1}, len(arr))
|
|
v.Each{4}(func(index int, val {1}) bool {
|
|
replaced[index] = replacer(index, val)
|
|
return true
|
|
})
|
|
return &Value{data:replaced}
|
|
}
|
|
|
|
// Collect{4} uses the specified collector function to collect a value
|
|
// for each of the {1}s in the slice. The data returned will be a
|
|
// []interface{}.
|
|
func (v *Value) Collect{4}(collector func(int, {1}) interface{}) *Value {
|
|
arr := v.Must{4}Slice()
|
|
collected := make([]interface{}, len(arr))
|
|
v.Each{4}(func(index int, val {1}) bool {
|
|
collected[index] = collector(index, val)
|
|
return true
|
|
})
|
|
return &Value{data:collected}
|
|
}
|