kubernetes/vendor/github.com/vmware/govmomi/simulator/task.go
Madhav Jivrajani 8b064fa4be *: Bump version of vmware/govmomi
Bumping version to include changes that
better handle TLS errors. Bump nescessary
to prepare for when the version of Go is
bumped to 1.20

Signed-off-by: Madhav Jivrajani <madhav.jiv@gmail.com>
2023-01-12 15:08:45 +05:30

173 lines
4.4 KiB
Go

/*
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 simulator
import (
"fmt"
"reflect"
"strings"
"time"
"github.com/vmware/govmomi/vim25/mo"
"github.com/vmware/govmomi/vim25/types"
)
const vTaskSuffix = "_Task" // vmomi suffix
const sTaskSuffix = "Task" // simulator suffix (avoiding golint warning)
// TaskDelay applies to all tasks.
// Names for DelayConfig.MethodDelay will differ for task and api delays. API
// level names often look like PowerOff_Task, whereas the task name is simply
// PowerOff.
var TaskDelay = DelayConfig{}
type Task struct {
mo.Task
ctx *Context
Execute func(*Task) (types.AnyType, types.BaseMethodFault)
}
func NewTask(runner TaskRunner) *Task {
ref := runner.Reference()
name := reflect.TypeOf(runner).Elem().Name()
name = strings.Replace(name, "VM", "Vm", 1) // "VM" for the type to make go-lint happy, but "Vm" for the vmodl ID
return CreateTask(ref, name, runner.Run)
}
func CreateTask(e mo.Reference, name string, run func(*Task) (types.AnyType, types.BaseMethodFault)) *Task {
ref := e.Reference()
id := name
if strings.HasSuffix(id, sTaskSuffix) {
id = id[:len(id)-len(sTaskSuffix)]
name = id + vTaskSuffix
}
task := &Task{
Execute: run,
}
task.Self = Map.newReference(task)
task.Info.Key = task.Self.Value
task.Info.Task = task.Self
task.Info.Name = ucFirst(name)
task.Info.DescriptionId = fmt.Sprintf("%s.%s", ref.Type, id)
task.Info.Entity = &ref
task.Info.EntityName = ref.Value
task.Info.Reason = &types.TaskReasonUser{UserName: "vcsim"} // TODO: Context.Session.User
task.Info.QueueTime = time.Now()
task.Info.State = types.TaskInfoStateQueued
Map.Put(task)
return task
}
type TaskRunner interface {
mo.Reference
Run(*Task) (types.AnyType, types.BaseMethodFault)
}
// taskReference is a helper struct so we can call AcquireLock in Run()
type taskReference struct {
Self types.ManagedObjectReference
}
func (tr *taskReference) Reference() types.ManagedObjectReference {
return tr.Self
}
func (t *Task) Run(ctx *Context) types.ManagedObjectReference {
t.ctx = ctx
// alias the global Map to reduce data races in tests that reset the
// global Map variable.
vimMap := Map
vimMap.AtomicUpdate(t.ctx, t, []types.PropertyChange{
{Name: "info.startTime", Val: time.Now()},
{Name: "info.state", Val: types.TaskInfoStateRunning},
})
tr := &taskReference{
Self: *t.Info.Entity,
}
// in most cases, the caller already holds this lock, and we would like
// the lock to be held across the "hand off" to the async goroutine.
unlock := vimMap.AcquireLock(ctx, tr)
go func() {
TaskDelay.delay(t.Info.Name)
res, err := t.Execute(t)
unlock()
state := types.TaskInfoStateSuccess
var fault interface{}
if err != nil {
state = types.TaskInfoStateError
fault = types.LocalizedMethodFault{
Fault: err,
LocalizedMessage: fmt.Sprintf("%T", err),
}
}
vimMap.AtomicUpdate(t.ctx, t, []types.PropertyChange{
{Name: "info.completeTime", Val: time.Now()},
{Name: "info.state", Val: state},
{Name: "info.result", Val: res},
{Name: "info.error", Val: fault},
})
}()
return t.Self
}
// RunBlocking() should only be used when an async simulator task needs to wait
// on another async simulator task.
// It polls for task completion to avoid the need to set up a PropertyCollector.
func (t *Task) RunBlocking(ctx *Context) {
_ = t.Run(ctx)
t.Wait()
}
// Wait blocks until the task is complete.
func (t *Task) Wait() {
// we do NOT want to share our lock with the tasks's context, because
// the goroutine that executes the task will use ctx to update the
// state (among other things).
isolatedLockingContext := &Context{}
isRunning := func() bool {
var running bool
Map.WithLock(isolatedLockingContext, t, func() {
switch t.Info.State {
case types.TaskInfoStateSuccess, types.TaskInfoStateError:
running = false
default:
running = true
}
})
return running
}
for isRunning() {
time.Sleep(10 * time.Millisecond)
}
}