From e03b51a8dd783fb456a6ae6f9616b479de7dec4d Mon Sep 17 00:00:00 2001 From: erwinvaneyk Date: Tue, 15 May 2018 13:25:51 +0200 Subject: [PATCH] Added flow helper for internal://foreach --- pkg/fnenv/native/builtin/compose.go | 2 - pkg/fnenv/native/builtin/foreach.go | 115 +++++++++---- pkg/fnenv/native/builtin/foreach_test.go | 2 +- pkg/fnenv/native/builtin/noop.go | 2 +- pkg/fnenv/native/builtin/while.go | 44 +++-- pkg/types/aggregates/task.go | 9 +- pkg/types/helpers.go | 2 + pkg/types/typedvalues/controlflow.go | 116 +++++++++++++ pkg/types/typedvalues/util.go | 7 +- pkg/types/types.pb.go | 201 +++++++++++------------ pkg/types/types.proto | 2 +- 11 files changed, 333 insertions(+), 169 deletions(-) diff --git a/pkg/fnenv/native/builtin/compose.go b/pkg/fnenv/native/builtin/compose.go index 116c0f11..fe8fbd58 100644 --- a/pkg/fnenv/native/builtin/compose.go +++ b/pkg/fnenv/native/builtin/compose.go @@ -80,8 +80,6 @@ func (fn *FunctionCompose) Invoke(spec *types.TaskInvocationSpec) (*types.TypedV } output = p } - // Temporary: force the output of compose to be json (because it is by definition structured) - output.SetLabel("Content-Type", "application/json") logrus.Infof("[internal://%s] %v (Type: %s, Labels: %v)", Compose, typedvalues.MustFormat(output), output.GetType(), output.GetLabels()) return output, nil diff --git a/pkg/fnenv/native/builtin/foreach.go b/pkg/fnenv/native/builtin/foreach.go index 8b10ca87..481c2dba 100644 --- a/pkg/fnenv/native/builtin/foreach.go +++ b/pkg/fnenv/native/builtin/foreach.go @@ -1,6 +1,7 @@ package builtin import ( + "errors" "fmt" "github.com/fission/fission-workflows/pkg/types" @@ -8,25 +9,28 @@ import ( ) const ( - Foreach = "foreach" - ForeachInputHeader = "foreach" - ForeachInputDo = "do" + Foreach = "foreach" + ForeachInputForeach = "foreach" + ForeachInputDo = "do" + ForeachInputCollect = "collect" + ForeachInputSequential = "sequential" ) /* -FunctionForeach is a control flow construct to execute a certain task for each element in the provided input. +FunctionForeach is a control flow construct to execute a certain task for each item in the provided input. The tasks are executed in parallel. -Currently, foreach does not gather or store the outputs of the tasks in any way. +Note, currently the task in the 'do' does not have access to state in the current workflow. **Specification** -**input** | required | types | description -----------------|----------|---------------|-------------------------------------------------------- -foreach | yes | list | The list of elements that foreach should be looped over. -do | yes | task/workflow | The action to perform for every element. -sequential | no | bool | Whether to execute the tasks sequentially (default: false). +**input** | required | types | description +-------------------------|----------|---------------|-------------------------------------------------------- +foreach | yes | list | The list of elements that foreach should be looped over. +do | yes | task/workflow | The action to perform for every element. +sequential | no | bool | Whether to execute the tasks sequentially (default: false). +collect | no | bool | Collect the outputs of the tasks into an array (default: true). -The element is made available to the action using the field `element`. +The element is made available to the action using the field `_item`. **output** None @@ -42,7 +46,7 @@ foo: - c do: run: noop - inputs: "{ task().Inputs.element }" + inputs: "{ task().Inputs._item }" ``` A complete example of this function can be found in the [foreachwhale](../examples/whales/foreachwhale.wf.yaml) example. @@ -50,55 +54,94 @@ A complete example of this function can be found in the [foreachwhale](../exampl type FunctionForeach struct{} func (fn *FunctionForeach) Invoke(spec *types.TaskInvocationSpec) (*types.TypedValue, error) { - - // Verify and get loop header - headerTv, err := ensureInput(spec.GetInputs(), ForeachInputHeader) + // Verify and parse foreach + headerTv, err := ensureInput(spec.GetInputs(), ForeachInputForeach) if err != nil { return nil, err } - - // Parse header to an array i, err := typedvalues.Format(headerTv) if err != nil { return nil, err } - header, ok := i.([]interface{}) + foreach, ok := i.([]interface{}) if !ok { return nil, fmt.Errorf("condition '%v' needs to be a 'array', but was '%v'", i, headerTv.Type) } - // Task - // TODO also support workflows + // Parse task taskTv, err := ensureInput(spec.GetInputs(), ForeachInputDo, typedvalues.TypeTask) if err != nil { return nil, err } - task, err := typedvalues.FormatTask(taskTv) + flow, err := typedvalues.FormatControlFlow(taskTv) if err != nil { return nil, err } + if flow.Workflow() != nil { + return nil, errors.New("foreach does not support workflow inputs (yet)") + } - wf := &types.WorkflowSpec{ - OutputTask: "noopTask", - Tasks: map[string]*types.TaskSpec{ - "noopTask": { - FunctionRef: Noop, - }, - }, + // Parse collect + collect := true + collectTv, ok := spec.Inputs[ForeachInputCollect] + if ok { + b, err := typedvalues.FormatBool(collectTv) + if err != nil { + return nil, fmt.Errorf("collect could not be parsed into a boolean: %v", err) + } + collect = b } - for k, item := range header { - t := &types.TaskSpec{ - FunctionRef: task.FunctionRef, - Inputs: map[string]*types.TypedValue{}, + // Parse sequential + var seq bool + seqTv, ok := spec.Inputs[ForeachInputSequential] + if ok { + b, err := typedvalues.FormatBool(seqTv) + if err != nil { + return nil, fmt.Errorf("sequential could not be parsed into a boolean: %v", err) } - for inputKey, inputVal := range task.Inputs { - t.Input(inputKey, inputVal) + seq = b + } + + // Create the workflows + wf := &types.WorkflowSpec{ + OutputTask: "collector", + Tasks: types.Tasks{}, + } + + // Create the tasks for each element + var tasks []string // Needed to preserve order of the input array + for k, item := range foreach { + f := flow.Clone() + itemTv := typedvalues.MustParse(item) + itemTv.SetLabel("priority", "1000") // Ensure that item is resolved before other parameters + f.Input("_item", *itemTv) + + // TODO support workflows + t := f.Task() + name := fmt.Sprintf("do_%d", k) + wf.AddTask(name, t) + tasks = append(tasks, name) + + if seq && k != 0 { + t.Require(tasks[k-1]) } - t.Input("element", typedvalues.MustParse(item)) + } - wf.AddTask(fmt.Sprintf("do_%d", k), t) + // Add collector task + ct := &types.TaskSpec{ + FunctionRef: "compose", + Inputs: types.Inputs{}, + Requires: types.Require(tasks...), + } + var output []interface{} + for _, k := range tasks { + if collect { + output = append(output, fmt.Sprintf("{output('%s')}", k)) + } } + ct.Input(ComposeInput, typedvalues.MustParse(output)) + wf.AddTask("collector", ct) return typedvalues.Parse(wf) } diff --git a/pkg/fnenv/native/builtin/foreach_test.go b/pkg/fnenv/native/builtin/foreach_test.go index 08233d2d..a2161694 100644 --- a/pkg/fnenv/native/builtin/foreach_test.go +++ b/pkg/fnenv/native/builtin/foreach_test.go @@ -12,7 +12,7 @@ func TestFunctionForeach_Invoke(t *testing.T) { foreachElements := []interface{}{1, 2, 3, 4, "foo"} out, err := (&FunctionForeach{}).Invoke(&types.TaskInvocationSpec{ Inputs: map[string]*types.TypedValue{ - ForeachInputHeader: typedvalues.MustParse(foreachElements), + ForeachInputForeach: typedvalues.MustParse(foreachElements), ForeachInputDo: typedvalues.MustParse(&types.TaskSpec{ FunctionRef: Noop, }), diff --git a/pkg/fnenv/native/builtin/noop.go b/pkg/fnenv/native/builtin/noop.go index a15593ea..6d6955ba 100644 --- a/pkg/fnenv/native/builtin/noop.go +++ b/pkg/fnenv/native/builtin/noop.go @@ -50,6 +50,6 @@ func (fn *FunctionNoop) Invoke(spec *types.TaskInvocationSpec) (*types.TypedValu break } } - logrus.Info("[internal://%s] %v", Noop, typedvalues.MustFormat(output)) + logrus.Infof("[internal://%s] %v", Noop, typedvalues.MustFormat(output)) return output, nil } diff --git a/pkg/fnenv/native/builtin/while.go b/pkg/fnenv/native/builtin/while.go index ecd71fa6..460dfc03 100644 --- a/pkg/fnenv/native/builtin/while.go +++ b/pkg/fnenv/native/builtin/while.go @@ -15,7 +15,7 @@ const ( WhileInputDelay = "delay" WhileInputAction = "do" - WhileDefaultDelay = time.Duration(0) + WhileDefaultDelay = time.Duration(100) * time.Millisecond ) var ( @@ -33,7 +33,7 @@ The results of the executed action can be accessed using the task ID "action". ----------------|----------|-------------------|-------------------------------------------------------- expr | yes | bool | The condition which determines whether to continue or halt the loop. do | yes | task/workflow | The action to execute on each iteration. -limit | no | number | The max number of iterations of the loop. (default: unlimited) +limit | yes | number | The max number of iterations of the loop. Notes: - we currently cannot reevaluate the expr. @@ -73,7 +73,7 @@ func (fn *FunctionWhile) Invoke(spec *types.TaskInvocationSpec) (*types.TypedVal return nil, err } - // Limit TODO support setting of the limit + // Limit limitTv, err := ensureInput(spec.Inputs, WhileInputLimit) if err != nil { return nil, err @@ -110,13 +110,13 @@ func (fn *FunctionWhile) Invoke(spec *types.TaskInvocationSpec) (*types.TypedVal } // Action - action, err := ensureInput(spec.Inputs, WhileInputAction, typedvalues.TypeWorkflow, typedvalues.TypeTask) + action, err := ensureInput(spec.Inputs, WhileInputAction) if err != nil { return nil, err } - // Logic - if expr { + // Logic: escape while loop when expression is no longer true. + if !expr { // TODO support referencing of output in output value, to avoid needing to include 'prev' every time. if prev, ok := spec.Inputs["_prev"]; ok { return prev, nil @@ -128,29 +128,45 @@ func (fn *FunctionWhile) Invoke(spec *types.TaskInvocationSpec) (*types.TypedVal return nil, ErrLimitExceeded } + // Create the while-specific inputs + prevTv := typedvalues.MustParse("{output('action')}") + prevTv.SetLabel("priority", "1000") + countTv := typedvalues.MustParse(count + 1) + countTv.SetLabel("priority", "1000") + + // If the action is a control flow construct add the while-specific inputs + if typedvalues.IsControlFlow(action.Type) { + flow, _ := typedvalues.FormatControlFlow(action) + flow.Input("_prev", *prevTv) + flow.Input("_count", *countTv) + action, _ = typedvalues.ParseControlFlow(flow) + } + wf := &types.WorkflowSpec{ OutputTask: "condition", Tasks: map[string]*types.TaskSpec{ "wait": { FunctionRef: Sleep, - Inputs: map[string]*types.TypedValue{ + Inputs: types.Inputs{ SleepInput: typedvalues.MustParse(delay.String()), }, }, "action": { FunctionRef: Noop, - Inputs: typedvalues.Input(action), - Requires: types.Require("wait"), + Inputs: types.Inputs{ + NoopInput: action, + }, + Requires: types.Require("wait"), }, "condition": { FunctionRef: While, - Inputs: map[string]*types.TypedValue{ - WhileInputExpr: exprTv, - WhileInputDelay: delayTv, + Inputs: types.Inputs{ + WhileInputExpr: exprTv, + //WhileInputDelay: delayTv, // TODO fix; crashes when no delay is provided WhileInputLimit: limitTv, WhileInputAction: action, - "_count": typedvalues.MustParse(count + 1), - "_prev": typedvalues.MustParse("{output('action')}"), + "_count": countTv, + "_prev": prevTv, }, Requires: types.Require("action"), }, diff --git a/pkg/types/aggregates/task.go b/pkg/types/aggregates/task.go index 7a4bc53e..132e6286 100644 --- a/pkg/types/aggregates/task.go +++ b/pkg/types/aggregates/task.go @@ -73,16 +73,13 @@ func (ti *TaskInvocation) ApplyEvent(event *fes.Event) error { ti.Status.Status = types.TaskInvocationStatus_ABORTED ti.Status.UpdatedAt = event.Timestamp case events.Task_TASK_FAILED: - fnErr := &types.Error{} - err = proto.Unmarshal(event.Data, fnErr) + invoc := &types.TaskInvocation{} + err = proto.Unmarshal(event.Data, invoc) if err != nil { - fnErr.Code = "error" - fnErr.Message = err.Error() log.Errorf("failed to unmarshal event: '%v' (%v)", event, err) } - ti.Status.Status = types.TaskInvocationStatus_FAILED - ti.Status.Error = fnErr + ti.Status.Error = invoc.Status.Error ti.Status.UpdatedAt = event.Timestamp case events.Task_TASK_SKIPPED: ti.Status.Status = types.TaskInvocationStatus_SKIPPED diff --git a/pkg/types/helpers.go b/pkg/types/helpers.go index e96cbbaf..1c3b690d 100644 --- a/pkg/types/helpers.go +++ b/pkg/types/helpers.go @@ -217,3 +217,5 @@ type NamedTypedValue struct { TypedValue name string } + +type Inputs map[string]*TypedValue diff --git a/pkg/types/typedvalues/controlflow.go b/pkg/types/typedvalues/controlflow.go index e23ddb6e..6df9f714 100644 --- a/pkg/types/typedvalues/controlflow.go +++ b/pkg/types/typedvalues/controlflow.go @@ -97,3 +97,119 @@ func FormatWorkflow(v *types.TypedValue) (*types.WorkflowSpec, error) { func IsControlFlow(v ValueType) bool { return v == TypeTask || v == TypeWorkflow } + +func FormatControlFlow(v *types.TypedValue) (*Flow, error) { + switch ValueType(v.Type) { + case TypeTask: + t, err := FormatTask(v) + if err != nil { + return nil, err + } + return FlowTask(t), nil + case TypeWorkflow: + wf, err := FormatWorkflow(v) + if err != nil { + return nil, err + } + return FlowWorkflow(wf), nil + default: + return nil, ErrUnsupportedType + } +} + +func ParseControlFlow(i interface{}) (*types.TypedValue, error) { + switch t := i.(type) { + case *types.TaskSpec: + return ParseTask(t), nil + case *types.WorkflowSpec: + return ParseWorkflow(t), nil + default: + return nil, ErrUnsupportedType + } +} + +// Flow is a generic data type to provide a common API to working with dynamic tasks and workflows +type Flow struct { + task *types.TaskSpec + wf *types.WorkflowSpec +} + +func (f *Flow) Input(key string, i types.TypedValue) { + if f == nil { + return + } + if f.task != nil { + f.task.Input(key, &i) + } + if f.wf != nil { + // TODO support parameters in workflow spec + } +} + +func (f *Flow) Proto() proto.Message { + if f == nil { + return nil + } + if f.task != nil { + return f.task + } + return f.wf +} + +func (f *Flow) Clone() *Flow { + if f == nil { + return nil + } + if f.task != nil { + return FlowTask(proto.Clone(f.task).(*types.TaskSpec)) + } + if f.wf != nil { + return FlowWorkflow(proto.Clone(f.wf).(*types.WorkflowSpec)) + } + return nil +} + +func (f *Flow) Task() *types.TaskSpec { + if f == nil { + return nil + } + return f.task +} + +func (f *Flow) Workflow() *types.WorkflowSpec { + if f == nil { + return nil + } + return f.wf +} + +func (f *Flow) ApplyTask(fn func(t *types.TaskSpec)) { + if f != nil && f.task != nil { + fn(f.task) + } +} + +func (f *Flow) ApplyWorkflow(fn func(t *types.WorkflowSpec)) { + if f != nil && f.wf != nil { + fn(f.wf) + } +} + +func FlowTask(task *types.TaskSpec) *Flow { + return &Flow{task: task} +} + +func FlowWorkflow(wf *types.WorkflowSpec) *Flow { + return &Flow{wf: wf} +} + +func FlowInterface(i interface{}) (*Flow, error) { + switch t := i.(type) { + case *types.WorkflowSpec: + return FlowWorkflow(t), nil + case *types.TaskSpec: + return FlowTask(t), nil + default: + return nil, ErrUnsupportedType + } +} diff --git a/pkg/types/typedvalues/util.go b/pkg/types/typedvalues/util.go index 7451038f..8da1ce02 100644 --- a/pkg/types/typedvalues/util.go +++ b/pkg/types/typedvalues/util.go @@ -64,10 +64,8 @@ func FormatArray(t *types.TypedValue) ([]interface{}, error) { return v, nil } -type Inputs map[string]*types.TypedValue - -func Input(i interface{}) Inputs { - in := Inputs{} +func Input(i interface{}) types.Inputs { + in := types.Inputs{} in[types.INPUT_MAIN] = MustParse(i) return in } @@ -106,6 +104,7 @@ type namedInput struct { Val *types.TypedValue } +// PrioritizeInputs sorts the inputs based on the priority label (descending order) func PrioritizeInputs(inputs map[string]*types.TypedValue) []namedInput { var priorities []int priorityBuckets := map[int][]namedInput{} diff --git a/pkg/types/types.pb.go b/pkg/types/types.pb.go index 881f50ba..1cce5f83 100644 --- a/pkg/types/types.pb.go +++ b/pkg/types/types.pb.go @@ -247,7 +247,7 @@ type WorkflowSpec struct { // Tasks contains the specs of the tasks, with the key being the task id. // // Note: Dependency graph is build into the tasks. - Tasks map[string]*TaskSpec `protobuf:"bytes,2,rep,name=tasks" json:"tasks,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Tasks map[string]*TaskSpec `protobuf:"bytes,2,rep,name=tasks" json:"tasks,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=Value"` // From which task should the workflow return the output? Future: multiple? Implicit? OutputTask string `protobuf:"bytes,3,opt,name=outputTask" json:"outputTask,omitempty"` Description string `protobuf:"bytes,4,opt,name=description" json:"description,omitempty"` @@ -318,7 +318,7 @@ type WorkflowStatus struct { Status WorkflowStatus_Status `protobuf:"varint,1,opt,name=status,enum=WorkflowStatus_Status" json:"status,omitempty"` UpdatedAt *google_protobuf.Timestamp `protobuf:"bytes,2,opt,name=updatedAt" json:"updatedAt,omitempty"` // Tasks contains the status of the tasks, with the key being the task id. - Tasks map[string]*TaskStatus `protobuf:"bytes,3,rep,name=tasks" json:"tasks,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Tasks map[string]*TaskStatus `protobuf:"bytes,3,rep,name=tasks" json:"tasks,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=Value"` Error *Error `protobuf:"bytes,4,opt,name=error" json:"error,omitempty"` } @@ -393,7 +393,7 @@ func (m *WorkflowInvocation) GetStatus() *WorkflowInvocationStatus { // Workflow Invocation Model type WorkflowInvocationSpec struct { WorkflowId string `protobuf:"bytes,1,opt,name=workflowId" json:"workflowId,omitempty"` - Inputs map[string]*TypedValue `protobuf:"bytes,2,rep,name=inputs" json:"inputs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Inputs map[string]*TypedValue `protobuf:"bytes,2,rep,name=inputs" json:"inputs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=Value"` // ParentId contains the id of the encapsulating workflow invocation. // // This used within the workflow engine; for user-provided workflow invocations the parentId is ignored. @@ -429,11 +429,11 @@ func (m *WorkflowInvocationSpec) GetParentId() string { type WorkflowInvocationStatus struct { Status WorkflowInvocationStatus_Status `protobuf:"varint,1,opt,name=status,enum=WorkflowInvocationStatus_Status" json:"status,omitempty"` UpdatedAt *google_protobuf.Timestamp `protobuf:"bytes,2,opt,name=updatedAt" json:"updatedAt,omitempty"` - Tasks map[string]*TaskInvocation `protobuf:"bytes,3,rep,name=tasks" json:"tasks,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Tasks map[string]*TaskInvocation `protobuf:"bytes,3,rep,name=tasks" json:"tasks,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=Value"` Output *TypedValue `protobuf:"bytes,4,opt,name=output" json:"output,omitempty"` // In case the task ID also exists in the workflow spec, the dynamic task will be // used as an overlay over the static task. - DynamicTasks map[string]*Task `protobuf:"bytes,5,rep,name=dynamicTasks" json:"dynamicTasks,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + DynamicTasks map[string]*Task `protobuf:"bytes,5,rep,name=dynamicTasks" json:"dynamicTasks,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=Value"` Error *Error `protobuf:"bytes,6,opt,name=error" json:"error,omitempty"` } @@ -486,7 +486,7 @@ func (m *WorkflowInvocationStatus) GetError() *Error { type DependencyConfig struct { // Dependencies for this task to execute - Requires map[string]*TaskDependencyParameters `protobuf:"bytes,1,rep,name=requires" json:"requires,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Requires map[string]*TaskDependencyParameters `protobuf:"bytes,1,rep,name=requires" json:"requires,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=Value"` // Number of dependencies to wait for Await int32 `protobuf:"varint,2,opt,name=await" json:"await,omitempty"` } @@ -552,9 +552,9 @@ func (m *Task) GetStatus() *TaskStatus { type TaskSpec struct { // Name/identifier of the function FunctionRef string `protobuf:"bytes,1,opt,name=functionRef" json:"functionRef,omitempty"` - Inputs map[string]*TypedValue `protobuf:"bytes,2,rep,name=inputs" json:"inputs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Inputs map[string]*TypedValue `protobuf:"bytes,2,rep,name=inputs" json:"inputs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=Value"` // Dependencies for this task to execute - Requires map[string]*TaskDependencyParameters `protobuf:"bytes,3,rep,name=requires" json:"requires,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Requires map[string]*TaskDependencyParameters `protobuf:"bytes,3,rep,name=requires" json:"requires,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=Value"` // Number of dependencies to wait for Await int32 `protobuf:"varint,4,opt,name=await" json:"await,omitempty"` // Transform the output, or override the output with a literal @@ -706,7 +706,7 @@ type TaskInvocationSpec struct { // TaskId is the id of the task within the workflow TaskId string `protobuf:"bytes,2,opt,name=taskId" json:"taskId,omitempty"` // Inputs contain all inputs to the task invocation - Inputs map[string]*TypedValue `protobuf:"bytes,3,rep,name=inputs" json:"inputs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Inputs map[string]*TypedValue `protobuf:"bytes,3,rep,name=inputs" json:"inputs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=Value"` // InvocationId string `protobuf:"bytes,4,opt,name=invocationId" json:"invocationId,omitempty"` } @@ -814,8 +814,8 @@ func (m *ObjectMetadata) GetCreatedAt() *google_protobuf.Timestamp { // Copy of protobuf's Any, to avoid protobuf requirement of a protobuf-based type. type TypedValue struct { Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"` - Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` - Labels map[string]string `protobuf:"bytes,3,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Value []byte `protobuf:"bytes,2,opt,name=Value,proto3" json:"Value,omitempty"` + Labels map[string]string `protobuf:"bytes,3,rep,name=Labels" json:"Labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=Value"` } func (m *TypedValue) Reset() { *m = TypedValue{} } @@ -845,7 +845,7 @@ func (m *TypedValue) GetLabels() map[string]string { } type Error struct { - Code string `protobuf:"bytes,1,opt,name=code" json:"code,omitempty"` + // string code = 1; Message string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"` } @@ -854,13 +854,6 @@ func (m *Error) String() string { return proto.CompactTextString(m) } func (*Error) ProtoMessage() {} func (*Error) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } -func (m *Error) GetCode() string { - if m != nil { - return m.Code - } - return "" -} - func (m *Error) GetMessage() string { if m != nil { return m.Message @@ -899,7 +892,7 @@ func (m *FnRef) GetID() string { // Utility wrapper for a TypedValue map type TypedValueMap struct { - Value map[string]*TypedValue `protobuf:"bytes,1,rep,name=Value" json:"Value,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Value map[string]*TypedValue `protobuf:"bytes,1,rep,name=Value" json:"Value,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=Value"` } func (m *TypedValueMap) Reset() { *m = TypedValueMap{} } @@ -962,88 +955,88 @@ func init() { func init() { proto.RegisterFile("pkg/types/types.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ - // 1328 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcd, 0x6e, 0xdb, 0xc6, - 0x13, 0x0f, 0x29, 0x51, 0x96, 0x46, 0xb6, 0xa2, 0xff, 0xfe, 0xf3, 0xc1, 0xa8, 0x69, 0xe3, 0x30, - 0x2d, 0x62, 0x34, 0x0d, 0xdd, 0x38, 0x2d, 0x9a, 0x8f, 0x5e, 0x14, 0x91, 0x4e, 0x89, 0x38, 0x92, - 0x41, 0xcb, 0x09, 0x12, 0xa0, 0x08, 0x68, 0x71, 0x65, 0x30, 0x96, 0x48, 0x96, 0xa4, 0x62, 0xf8, - 0xdc, 0x43, 0x9f, 0xa0, 0x0f, 0xd0, 0x5e, 0x7b, 0xe8, 0xa9, 0xc7, 0xbe, 0x41, 0x0f, 0xbd, 0x16, - 0xe8, 0x1b, 0xf4, 0xd0, 0x57, 0x28, 0x76, 0xb9, 0x24, 0x77, 0x69, 0x29, 0xae, 0x0b, 0xe7, 0x62, - 0xef, 0xce, 0xce, 0xce, 0xec, 0xfc, 0x66, 0x7e, 0xb3, 0x4b, 0xc1, 0xc5, 0xf0, 0x60, 0x7f, 0x3d, - 0x39, 0x0a, 0x71, 0x9c, 0xfe, 0xd5, 0xc3, 0x28, 0x48, 0x82, 0xce, 0xb5, 0xfd, 0x20, 0xd8, 0x9f, - 0xe0, 0x75, 0x3a, 0xdb, 0x9b, 0x8d, 0xd7, 0x13, 0x6f, 0x8a, 0xe3, 0xc4, 0x99, 0x86, 0xa9, 0x82, - 0xf6, 0xad, 0x04, 0xf5, 0xe7, 0x41, 0x74, 0x30, 0x9e, 0x04, 0x87, 0xe8, 0x16, 0xd4, 0xa7, 0x38, - 0x71, 0x5c, 0x27, 0x71, 0x54, 0x69, 0x55, 0x5a, 0x6b, 0x6e, 0x9c, 0xd7, 0x07, 0x7b, 0xaf, 0xf1, - 0x28, 0x79, 0xca, 0xc4, 0x76, 0xae, 0x80, 0xae, 0x43, 0x35, 0x0e, 0xf1, 0x48, 0x95, 0xa9, 0xe2, - 0x8a, 0x9e, 0x59, 0xd9, 0x09, 0xf1, 0xc8, 0xa6, 0x4b, 0xe8, 0x26, 0xd4, 0xe2, 0xc4, 0x49, 0x66, - 0xb1, 0x5a, 0x61, 0xd6, 0x72, 0x25, 0x2a, 0xb6, 0xd9, 0xb2, 0xf6, 0xb3, 0x0c, 0xcb, 0xfc, 0x7e, - 0xf4, 0x01, 0x80, 0x13, 0x7a, 0xcf, 0x70, 0x14, 0x7b, 0x81, 0x4f, 0xcf, 0xd2, 0xb0, 0x39, 0x09, - 0xd2, 0x41, 0x49, 0x9c, 0xf8, 0x20, 0x56, 0xe5, 0xd5, 0xca, 0x5a, 0x73, 0x43, 0x15, 0xbc, 0xeb, - 0x43, 0xb2, 0x64, 0xfa, 0x49, 0x74, 0x64, 0xa7, 0x6a, 0xc4, 0x5e, 0x30, 0x4b, 0xc2, 0x59, 0x42, - 0x96, 0xe8, 0x69, 0x1a, 0x36, 0x27, 0x41, 0xab, 0xd0, 0x74, 0x71, 0x3c, 0x8a, 0xbc, 0x30, 0x21, - 0x0e, 0xab, 0x54, 0x81, 0x17, 0x21, 0x15, 0x96, 0xc6, 0x41, 0x34, 0xc2, 0x96, 0xab, 0x2a, 0x74, - 0x35, 0x9b, 0x22, 0x04, 0x55, 0xdf, 0x99, 0x62, 0xb5, 0x46, 0xc5, 0x74, 0x8c, 0x3a, 0x50, 0xf7, - 0xfc, 0x04, 0x47, 0xbe, 0x33, 0x51, 0x97, 0x56, 0xa5, 0xb5, 0xba, 0x9d, 0xcf, 0x3b, 0x3d, 0x80, - 0xe2, 0x80, 0xa8, 0x0d, 0x95, 0x03, 0x7c, 0xc4, 0x42, 0x24, 0x43, 0x74, 0x0d, 0x94, 0x37, 0xce, - 0x64, 0x86, 0x19, 0xb2, 0x0d, 0x1a, 0x0e, 0x45, 0x35, 0x95, 0x3f, 0x90, 0xef, 0x49, 0xda, 0x6f, - 0x32, 0xb4, 0x44, 0x30, 0x91, 0x9e, 0xa3, 0x4d, 0x8c, 0xb5, 0x36, 0x2e, 0x95, 0xd0, 0xd6, 0x45, - 0xd0, 0xd1, 0x3d, 0x68, 0xcc, 0x42, 0xd7, 0x49, 0xb0, 0xdb, 0x4d, 0x98, 0xaf, 0x8e, 0x9e, 0xd6, - 0x8b, 0x9e, 0xd5, 0x8b, 0x3e, 0xcc, 0xea, 0xc5, 0x2e, 0x94, 0xd1, 0xa7, 0x19, 0xfa, 0x15, 0x8a, - 0x7e, 0xa7, 0xec, 0xe8, 0x38, 0xfe, 0x57, 0x41, 0xc1, 0x51, 0x14, 0x44, 0x14, 0xd9, 0xe6, 0x46, - 0x4d, 0x37, 0xc9, 0xcc, 0x4e, 0x85, 0x1d, 0xf3, 0x04, 0x44, 0xae, 0x8b, 0x88, 0x34, 0x53, 0x44, - 0xd2, 0x68, 0x38, 0x4c, 0xee, 0x43, 0x8d, 0x41, 0xd1, 0x84, 0xa5, 0x6d, 0xb3, 0x6f, 0x58, 0xfd, - 0xc7, 0xed, 0x73, 0xa8, 0x01, 0x8a, 0x6d, 0x76, 0x8d, 0x17, 0x6d, 0x19, 0x01, 0xd4, 0x36, 0xbb, - 0xd6, 0x96, 0x69, 0xb4, 0x2b, 0x44, 0xc7, 0x30, 0xb7, 0xcc, 0xa1, 0x69, 0xb4, 0xab, 0xda, 0x0f, - 0x12, 0xa0, 0x2c, 0x08, 0xcb, 0x7f, 0x13, 0x8c, 0x1c, 0x9a, 0xf4, 0x53, 0x11, 0xe2, 0x96, 0x40, - 0x88, 0xcb, 0xfa, 0x71, 0x7b, 0x1c, 0x35, 0xee, 0x94, 0xa8, 0x71, 0x65, 0x9e, 0xba, 0x48, 0x92, - 0x3f, 0x24, 0xb8, 0x34, 0xdf, 0x26, 0x29, 0xef, 0xc3, 0x6c, 0xc5, 0xcd, 0xe8, 0x52, 0x48, 0xd0, - 0x43, 0xa8, 0x79, 0x7e, 0x38, 0x4b, 0x32, 0xbe, 0xdc, 0x58, 0x70, 0x38, 0xdd, 0xa2, 0x5a, 0x69, - 0xea, 0xd8, 0x16, 0x52, 0xcb, 0xa1, 0x13, 0x61, 0x3f, 0xb1, 0x5c, 0xc6, 0x9c, 0x7c, 0xde, 0xd9, - 0x84, 0x26, 0xb7, 0xe5, 0x5f, 0xa5, 0xee, 0x28, 0xc4, 0xee, 0x33, 0x22, 0xe2, 0x53, 0xf7, 0x7b, - 0x15, 0xd4, 0x45, 0x00, 0xa0, 0x7b, 0xa5, 0xc2, 0x5e, 0x5d, 0x88, 0xd5, 0xd9, 0x95, 0xf8, 0x03, - 0xb1, 0xc4, 0x3f, 0x5c, 0xec, 0xf2, 0x78, 0xb1, 0xdf, 0x80, 0x5a, 0xda, 0x5a, 0x58, 0xb5, 0x0b, - 0x41, 0xb3, 0x25, 0x34, 0x80, 0x65, 0xf7, 0xc8, 0x77, 0xa6, 0xde, 0x88, 0x1a, 0x50, 0x15, 0xea, - 0xe7, 0xd6, 0x62, 0x3f, 0x06, 0xa7, 0x9d, 0xba, 0x13, 0x0c, 0x14, 0x14, 0xab, 0xcd, 0xa3, 0x98, - 0x75, 0x02, 0xc5, 0x3e, 0x12, 0xf3, 0x74, 0x9e, 0x86, 0x55, 0x9c, 0x81, 0xcb, 0x55, 0x67, 0x13, - 0xfe, 0x77, 0xec, 0x2c, 0x73, 0x2c, 0xbe, 0x27, 0x5a, 0x54, 0xa8, 0x45, 0x3e, 0xe7, 0x5f, 0xf3, - 0x74, 0xdd, 0xed, 0x3f, 0xe9, 0x0f, 0x9e, 0xf7, 0xdb, 0xe7, 0xd0, 0x0a, 0x34, 0x76, 0x7a, 0x5f, - 0x99, 0xc6, 0x2e, 0xa1, 0xa9, 0x84, 0xce, 0x43, 0xd3, 0xea, 0xbf, 0xda, 0xb6, 0x07, 0x8f, 0x6d, - 0x73, 0x67, 0xa7, 0x2d, 0xd3, 0xf5, 0xdd, 0x5e, 0xcf, 0x34, 0x0d, 0x4a, 0xe3, 0x82, 0xd2, 0x55, - 0x62, 0xa7, 0xfb, 0x68, 0x60, 0x13, 0x4a, 0x2b, 0xda, 0xaf, 0x12, 0xb4, 0x0d, 0x1c, 0x62, 0xdf, - 0xc5, 0xfe, 0xe8, 0xa8, 0x17, 0xf8, 0x63, 0x6f, 0x1f, 0x3d, 0x84, 0x7a, 0x84, 0xbf, 0x99, 0x79, - 0x11, 0x26, 0xc5, 0x44, 0x10, 0xbf, 0xa6, 0x97, 0x95, 0x74, 0x9b, 0x69, 0xa4, 0x28, 0xe7, 0x1b, - 0xd0, 0x05, 0x50, 0x9c, 0x43, 0xc7, 0x4b, 0x2b, 0x49, 0xb1, 0xd3, 0x49, 0xe7, 0x19, 0xac, 0x08, - 0x1b, 0xe6, 0x40, 0xb1, 0x2e, 0x42, 0x71, 0x85, 0x42, 0x51, 0xb8, 0xdd, 0x76, 0x22, 0x67, 0x8a, - 0x13, 0x1c, 0x09, 0xdd, 0xec, 0x10, 0xaa, 0xf4, 0x6a, 0x3a, 0x55, 0x0f, 0x7a, 0x5f, 0xe8, 0x41, - 0xdc, 0xd5, 0x91, 0x76, 0x9d, 0x1b, 0xa5, 0xae, 0x23, 0x74, 0xd2, 0xac, 0xcf, 0xfc, 0x25, 0x43, - 0x3d, 0xdb, 0x47, 0x2e, 0xc6, 0xf1, 0xcc, 0x1f, 0xd1, 0x1a, 0xc0, 0x63, 0x16, 0x14, 0x2f, 0x42, - 0xb7, 0x4b, 0xbd, 0xe5, 0x62, 0xee, 0x74, 0x6e, 0x37, 0xb9, 0xcb, 0x65, 0x20, 0xe5, 0xd6, 0xe5, - 0x62, 0xc3, 0x89, 0xc8, 0x57, 0x39, 0xe4, 0x39, 0x9e, 0x29, 0x0b, 0x79, 0x76, 0x56, 0x1d, 0xea, - 0x9d, 0xa5, 0xf9, 0x4f, 0x29, 0x65, 0x26, 0xa3, 0xc2, 0xc7, 0xa5, 0x5e, 0x87, 0xb8, 0x0c, 0x9d, - 0x5d, 0x77, 0xbb, 0x0a, 0xca, 0x98, 0xe6, 0xb3, 0xc2, 0x7a, 0xc5, 0x26, 0x99, 0xd9, 0xa9, 0xf0, - 0xed, 0x97, 0xb5, 0xf6, 0x09, 0x4f, 0xdb, 0x9d, 0x61, 0x97, 0xd2, 0x8d, 0xbb, 0x65, 0x25, 0x8e, - 0x92, 0xb2, 0xf6, 0x93, 0x04, 0xea, 0x22, 0x18, 0xd0, 0x97, 0x50, 0x25, 0x8f, 0x55, 0x16, 0xea, - 0xda, 0x42, 0xbc, 0x38, 0x8a, 0x92, 0xe4, 0xd8, 0x74, 0x17, 0x2d, 0x8a, 0x89, 0xe7, 0xc4, 0x34, - 0xf4, 0x86, 0x9d, 0x4e, 0xb4, 0x87, 0xd0, 0x12, 0xb5, 0x51, 0x1d, 0xaa, 0x46, 0x77, 0xd8, 0x6d, - 0x9f, 0x23, 0x07, 0xee, 0x0d, 0xfa, 0x43, 0x7b, 0xb0, 0xd5, 0x96, 0x10, 0x82, 0x96, 0xf1, 0xa2, - 0xdf, 0x7d, 0x6a, 0xf5, 0x5e, 0x0d, 0x76, 0x87, 0xdb, 0xbb, 0xc3, 0xb6, 0xac, 0x7d, 0x2f, 0x41, - 0x4b, 0x6c, 0x7c, 0xa7, 0xa3, 0xdf, 0x4d, 0x81, 0x7e, 0xff, 0x2f, 0x35, 0x51, 0x8e, 0x88, 0xb7, - 0x4b, 0x44, 0xbc, 0x58, 0x56, 0x15, 0x29, 0xf9, 0xb7, 0x04, 0xe8, 0xb8, 0xad, 0x22, 0x8d, 0xd2, - 0xbc, 0x34, 0x5e, 0x82, 0x1a, 0xb9, 0x8f, 0x2c, 0x97, 0x01, 0xc4, 0x66, 0xe8, 0x8b, 0x9c, 0xb0, - 0x15, 0xd6, 0x01, 0x8f, 0x9b, 0x9e, 0x4b, 0x5d, 0x0d, 0x96, 0xbd, 0x5c, 0xcb, 0x72, 0xd9, 0x2b, - 0x59, 0x90, 0x9d, 0xd9, 0x83, 0xe0, 0x17, 0x19, 0x2e, 0xcc, 0x83, 0x04, 0x7d, 0x56, 0x22, 0xc8, - 0xd5, 0xb9, 0xc8, 0x9d, 0x1d, 0x55, 0x8a, 0x26, 0x53, 0x59, 0x7c, 0x99, 0xbf, 0x9d, 0x31, 0xaf, - 0xdf, 0xe9, 0x45, 0x47, 0x69, 0xf8, 0xc4, 0xda, 0xde, 0x36, 0x8d, 0x76, 0x4d, 0x7b, 0x09, 0x2d, - 0xb1, 0x3a, 0x51, 0x0b, 0x64, 0x2f, 0x7b, 0x13, 0xca, 0x9e, 0x4b, 0xa0, 0x18, 0x45, 0x98, 0x41, - 0x51, 0x39, 0x19, 0x8a, 0x5c, 0x59, 0xfb, 0x91, 0xb4, 0xaa, 0x3c, 0x78, 0xf2, 0xdd, 0x93, 0xb3, - 0xb7, 0x51, 0x70, 0xb2, 0xc8, 0xee, 0x32, 0x4b, 0x28, 0x5a, 0x87, 0xda, 0xc4, 0xd9, 0xc3, 0x13, - 0xae, 0xe3, 0xe7, 0x66, 0xf4, 0x2d, 0xba, 0xc2, 0x2a, 0x2d, 0x55, 0xeb, 0xdc, 0x87, 0x26, 0x27, - 0x9e, 0x53, 0x45, 0x82, 0x9f, 0x06, 0x5f, 0x38, 0x9f, 0x83, 0x42, 0xc1, 0x27, 0xc7, 0x1b, 0x05, - 0x6e, 0x7e, 0x3c, 0x32, 0x26, 0x1f, 0x71, 0x53, 0x1c, 0xc7, 0xce, 0x7e, 0xb6, 0x31, 0x9b, 0x6a, - 0x77, 0x40, 0xa1, 0xe4, 0x21, 0x2a, 0xd1, 0xcc, 0x27, 0x9f, 0xc9, 0x99, 0x0a, 0x9b, 0x12, 0x20, - 0x2d, 0x83, 0xbd, 0x80, 0x65, 0xcb, 0xd0, 0xbe, 0x93, 0x60, 0xa5, 0x88, 0xe3, 0xa9, 0x13, 0x92, - 0x0b, 0x80, 0x8e, 0xd9, 0xd3, 0xe2, 0x8a, 0x2e, 0x2c, 0xeb, 0x74, 0xc0, 0x5e, 0x8a, 0x74, 0x4c, - 0x3e, 0x7c, 0x0a, 0xe1, 0x7f, 0x27, 0xcb, 0x5d, 0x68, 0x15, 0x0b, 0x5b, 0x5e, 0x9c, 0x90, 0x8d, - 0xfc, 0x49, 0xc4, 0x8d, 0xf4, 0xdf, 0xa3, 0xa5, 0x97, 0x0a, 0xfd, 0xa5, 0x60, 0xaf, 0x46, 0xb3, - 0x7e, 0xf7, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x36, 0x7d, 0xf8, 0xf4, 0x43, 0x10, 0x00, 0x00, + // 1318 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcd, 0x6e, 0xdb, 0x46, + 0x10, 0x0e, 0x29, 0x51, 0x96, 0x46, 0xb6, 0xa2, 0x6e, 0xf3, 0xc3, 0xa8, 0x69, 0xe3, 0x30, 0x2d, + 0x62, 0x34, 0x0d, 0xdd, 0x38, 0x05, 0x9a, 0x9f, 0x5e, 0x14, 0x91, 0x4e, 0x89, 0x38, 0x92, 0x41, + 0xcb, 0x09, 0x12, 0xa0, 0x08, 0x68, 0x71, 0x65, 0x30, 0x96, 0x48, 0x96, 0xa4, 0x62, 0xf8, 0xdc, + 0x43, 0x9f, 0xa0, 0x0f, 0xd0, 0x5e, 0x7b, 0xe8, 0xa9, 0xc7, 0xbe, 0x41, 0x0f, 0xbd, 0x16, 0xe8, + 0x1b, 0xf4, 0xd0, 0x57, 0x28, 0x76, 0xb9, 0x24, 0x77, 0x69, 0x29, 0xae, 0x0b, 0xe7, 0x62, 0xef, + 0xce, 0xcc, 0xce, 0xec, 0x7e, 0x33, 0xdf, 0xec, 0x52, 0x70, 0x31, 0x3c, 0xd8, 0x5f, 0x4f, 0x8e, + 0x42, 0x1c, 0xa7, 0x7f, 0xf5, 0x30, 0x0a, 0x92, 0xa0, 0x73, 0x6d, 0x3f, 0x08, 0xf6, 0x27, 0x78, + 0x9d, 0xce, 0xf6, 0x66, 0xe3, 0xf5, 0xc4, 0x9b, 0xe2, 0x38, 0x71, 0xa6, 0x61, 0x6a, 0xa0, 0x7d, + 0x27, 0x41, 0xfd, 0x79, 0x10, 0x1d, 0x8c, 0x27, 0xc1, 0x21, 0xba, 0x05, 0xf5, 0x29, 0x4e, 0x1c, + 0xd7, 0x49, 0x1c, 0x55, 0x5a, 0x95, 0xd6, 0x9a, 0x1b, 0xe7, 0xf5, 0xc1, 0xde, 0x6b, 0x3c, 0x4a, + 0x9e, 0x32, 0xb1, 0x9d, 0x1b, 0xa0, 0xeb, 0x50, 0x8d, 0x43, 0x3c, 0x52, 0x65, 0x6a, 0xb8, 0xa2, + 0x67, 0x5e, 0x76, 0x42, 0x3c, 0xb2, 0xa9, 0x0a, 0xdd, 0x84, 0x5a, 0x9c, 0x38, 0xc9, 0x2c, 0x56, + 0x2b, 0xcc, 0x5b, 0x6e, 0x44, 0xc5, 0x36, 0x53, 0x6b, 0xbf, 0xc8, 0xb0, 0xcc, 0xaf, 0x47, 0x1f, + 0x01, 0x38, 0xa1, 0xf7, 0x0c, 0x47, 0xb1, 0x17, 0xf8, 0x74, 0x2f, 0x0d, 0x9b, 0x93, 0x20, 0x1d, + 0x94, 0xc4, 0x89, 0x0f, 0x62, 0x55, 0x5e, 0xad, 0xac, 0x35, 0x37, 0x54, 0x21, 0xba, 0x3e, 0x24, + 0x2a, 0xd3, 0x4f, 0xa2, 0x23, 0x3b, 0x35, 0x23, 0xfe, 0x82, 0x59, 0x12, 0xce, 0x12, 0xa2, 0xa2, + 0xbb, 0x69, 0xd8, 0x9c, 0x04, 0xad, 0x42, 0xd3, 0xc5, 0xf1, 0x28, 0xf2, 0xc2, 0x84, 0x04, 0xac, + 0x52, 0x03, 0x5e, 0x84, 0x54, 0x58, 0x1a, 0x07, 0xd1, 0x08, 0x5b, 0xae, 0xaa, 0x50, 0x6d, 0x36, + 0x45, 0x08, 0xaa, 0xbe, 0x33, 0xc5, 0x6a, 0x8d, 0x8a, 0xe9, 0x18, 0x75, 0xa0, 0xee, 0xf9, 0x09, + 0x8e, 0x7c, 0x67, 0xa2, 0x2e, 0xad, 0x4a, 0x6b, 0x75, 0x3b, 0x9f, 0x77, 0x7a, 0x00, 0xc5, 0x06, + 0x51, 0x1b, 0x2a, 0x07, 0xf8, 0x88, 0x1d, 0x91, 0x0c, 0xd1, 0x35, 0x50, 0xde, 0x38, 0x93, 0x19, + 0x66, 0xc8, 0x36, 0xe8, 0x71, 0x28, 0xaa, 0xa9, 0xfc, 0x81, 0x7c, 0x4f, 0xd2, 0x7e, 0x97, 0xa1, + 0x25, 0x82, 0x89, 0xf4, 0x1c, 0x6d, 0xe2, 0xac, 0xb5, 0x71, 0xa9, 0x84, 0xb6, 0x2e, 0x82, 0x8e, + 0xee, 0x41, 0x63, 0x16, 0xba, 0x4e, 0x82, 0xdd, 0x6e, 0xc2, 0x62, 0x75, 0xf4, 0xb4, 0x5e, 0xf4, + 0xac, 0x5e, 0xf4, 0x61, 0x56, 0x2f, 0x76, 0x61, 0x8c, 0x3e, 0xcf, 0xd0, 0xaf, 0x50, 0xf4, 0x3b, + 0xe5, 0x40, 0xc7, 0xf1, 0xbf, 0x0a, 0x0a, 0x8e, 0xa2, 0x20, 0xa2, 0xc8, 0x36, 0x37, 0x6a, 0xba, + 0x49, 0x66, 0x76, 0x2a, 0xec, 0x98, 0x27, 0x20, 0x72, 0x5d, 0x44, 0xa4, 0x99, 0x22, 0x92, 0x9e, + 0x86, 0xc3, 0xe4, 0x3e, 0xd4, 0x18, 0x14, 0x4d, 0x58, 0xda, 0x36, 0xfb, 0x86, 0xd5, 0x7f, 0xdc, + 0x3e, 0x87, 0x1a, 0xa0, 0xd8, 0x66, 0xd7, 0x78, 0xd1, 0x96, 0x11, 0x40, 0x6d, 0xb3, 0x6b, 0x6d, + 0x99, 0x46, 0xbb, 0x42, 0x6c, 0x0c, 0x73, 0xcb, 0x1c, 0x9a, 0x46, 0xbb, 0xaa, 0xfd, 0x28, 0x01, + 0xca, 0x0e, 0x61, 0xf9, 0x6f, 0x82, 0x91, 0x43, 0x93, 0x7e, 0x2a, 0x42, 0xdc, 0x12, 0x08, 0x71, + 0x59, 0x3f, 0xee, 0x8f, 0xa3, 0xc6, 0x9d, 0x12, 0x35, 0xae, 0xcc, 0x33, 0x17, 0x49, 0xf2, 0xa7, + 0x04, 0x97, 0xe6, 0xfb, 0x24, 0xe5, 0x7d, 0x98, 0x69, 0xdc, 0x8c, 0x2e, 0x85, 0x04, 0x3d, 0x84, + 0x9a, 0xe7, 0x87, 0xb3, 0x24, 0xe3, 0xcb, 0x8d, 0x05, 0x9b, 0xd3, 0x2d, 0x6a, 0x95, 0xa6, 0x8e, + 0x2d, 0x21, 0xb5, 0x1c, 0x3a, 0x11, 0xf6, 0x13, 0xcb, 0x65, 0xcc, 0xc9, 0xe7, 0x9d, 0x4d, 0x68, + 0x72, 0x4b, 0xfe, 0x53, 0xea, 0x8e, 0x42, 0xec, 0x3e, 0x23, 0x22, 0x3e, 0x75, 0x7f, 0x54, 0x41, + 0x5d, 0x04, 0x00, 0xba, 0x57, 0x2a, 0xec, 0xd5, 0x85, 0x58, 0x9d, 0x5d, 0x89, 0x3f, 0x10, 0x4b, + 0xfc, 0xe3, 0xc5, 0x21, 0x8f, 0x17, 0xfb, 0x0d, 0xa8, 0xa5, 0xad, 0x85, 0x55, 0xbb, 0x70, 0x68, + 0xa6, 0x42, 0x03, 0x58, 0x76, 0x8f, 0x7c, 0x67, 0xea, 0x8d, 0xa8, 0x03, 0x55, 0xa1, 0x71, 0x6e, + 0x2d, 0x8e, 0x63, 0x70, 0xd6, 0x69, 0x38, 0xc1, 0x41, 0x41, 0xb1, 0xda, 0x3c, 0x8a, 0x59, 0x27, + 0x50, 0xec, 0x13, 0x31, 0x4f, 0xe7, 0xe9, 0xb1, 0x8a, 0x3d, 0x70, 0xb9, 0xea, 0x6c, 0xc2, 0x7b, + 0xc7, 0xf6, 0x32, 0xc7, 0xe3, 0x07, 0xa2, 0x47, 0x85, 0x7a, 0xe4, 0x73, 0xfe, 0x0d, 0x4f, 0xd7, + 0xdd, 0xfe, 0x93, 0xfe, 0xe0, 0x79, 0xbf, 0x7d, 0x0e, 0xad, 0x40, 0x63, 0xa7, 0xf7, 0xb5, 0x69, + 0xec, 0x12, 0x9a, 0x4a, 0xe8, 0x3c, 0x34, 0xad, 0xfe, 0xab, 0x6d, 0x7b, 0xf0, 0xd8, 0x36, 0x77, + 0x76, 0xda, 0x32, 0xd5, 0xef, 0xf6, 0x7a, 0xa6, 0x69, 0x50, 0x1a, 0x17, 0x94, 0xae, 0x12, 0x3f, + 0xdd, 0x47, 0x03, 0x9b, 0x50, 0x5a, 0xd1, 0x7e, 0x93, 0xa0, 0x6d, 0xe0, 0x10, 0xfb, 0x2e, 0xf6, + 0x47, 0x47, 0xbd, 0xc0, 0x1f, 0x7b, 0xfb, 0xe8, 0x21, 0xd4, 0x23, 0xfc, 0xed, 0xcc, 0x8b, 0x30, + 0x29, 0x26, 0x82, 0xf8, 0x35, 0xbd, 0x6c, 0xa4, 0xdb, 0xcc, 0x22, 0x45, 0x39, 0x5f, 0x80, 0x2e, + 0x80, 0xe2, 0x1c, 0x3a, 0x5e, 0x5a, 0x49, 0x8a, 0x9d, 0x4e, 0x3a, 0xcf, 0x60, 0x45, 0x58, 0x30, + 0x07, 0x8a, 0x75, 0x11, 0x8a, 0x2b, 0x14, 0x8a, 0x22, 0xec, 0xb6, 0x13, 0x39, 0x53, 0x9c, 0xe0, + 0x48, 0xe8, 0x66, 0x87, 0x50, 0xa5, 0x57, 0xd3, 0xa9, 0x7a, 0xd0, 0x87, 0x42, 0x0f, 0xe2, 0xae, + 0x8e, 0xb4, 0xeb, 0xdc, 0x28, 0x75, 0x1d, 0xa1, 0x93, 0x66, 0x7d, 0xe6, 0x6f, 0x19, 0xea, 0xd9, + 0x3a, 0x72, 0x31, 0x8e, 0x67, 0xfe, 0x88, 0xd6, 0x00, 0x1e, 0xb3, 0x43, 0xf1, 0x22, 0x74, 0xbb, + 0xd4, 0x5b, 0x2e, 0xe6, 0x41, 0xe7, 0x76, 0x93, 0xbb, 0x5c, 0x06, 0x52, 0x6e, 0x5d, 0x2e, 0x16, + 0x9c, 0x88, 0x7c, 0x95, 0x43, 0x9e, 0xe3, 0x99, 0xb2, 0x90, 0x67, 0x67, 0xd5, 0xa1, 0xde, 0x59, + 0x9a, 0xff, 0x92, 0x52, 0x66, 0x32, 0x2a, 0x7c, 0x5a, 0xea, 0x75, 0x88, 0xcb, 0xd0, 0xd9, 0x75, + 0xb7, 0xab, 0xa0, 0x8c, 0x69, 0x3e, 0x2b, 0xac, 0x57, 0x6c, 0x92, 0x99, 0x9d, 0x0a, 0xdf, 0x7e, + 0x59, 0x6b, 0x9f, 0xf1, 0xb4, 0xdd, 0x19, 0x76, 0x29, 0xdd, 0xb8, 0x5b, 0x56, 0xe2, 0x28, 0x29, + 0x6b, 0x3f, 0x4b, 0xa0, 0x2e, 0x82, 0x01, 0x7d, 0x05, 0x55, 0xf2, 0x58, 0x65, 0x47, 0x5d, 0x5b, + 0x88, 0x17, 0x47, 0x51, 0x92, 0x1c, 0x9b, 0xae, 0xa2, 0x45, 0x31, 0xf1, 0x9c, 0x98, 0x1e, 0xbd, + 0x61, 0xa7, 0x13, 0xed, 0x21, 0xb4, 0x44, 0x6b, 0x54, 0x87, 0xaa, 0xd1, 0x1d, 0x76, 0xdb, 0xe7, + 0xc8, 0x86, 0x7b, 0x83, 0xfe, 0xd0, 0x1e, 0x6c, 0xb5, 0x25, 0x84, 0xa0, 0x65, 0xbc, 0xe8, 0x77, + 0x9f, 0x5a, 0xbd, 0x57, 0x83, 0xdd, 0xe1, 0xf6, 0xee, 0xb0, 0x2d, 0x6b, 0x3f, 0x48, 0xd0, 0x12, + 0x1b, 0xdf, 0xe9, 0xe8, 0x77, 0x53, 0xa0, 0xdf, 0xfb, 0xa5, 0x26, 0xca, 0x11, 0xf1, 0x76, 0x89, + 0x88, 0x17, 0xcb, 0xa6, 0x22, 0x25, 0xff, 0x91, 0x00, 0x1d, 0xf7, 0x55, 0xa4, 0x51, 0x9a, 0x97, + 0xc6, 0x4b, 0x50, 0x23, 0xf7, 0x91, 0xe5, 0x32, 0x80, 0xd8, 0x0c, 0x7d, 0x99, 0x13, 0xb6, 0xc2, + 0x3a, 0xe0, 0x71, 0xd7, 0x73, 0xa9, 0xab, 0xc1, 0xb2, 0x97, 0x5b, 0x59, 0x2e, 0x7b, 0x25, 0x0b, + 0xb2, 0x33, 0x7b, 0x10, 0xfc, 0x2a, 0xc3, 0x85, 0x79, 0x90, 0xa0, 0x2f, 0x4a, 0x04, 0xb9, 0x3a, + 0x17, 0xb9, 0xb3, 0xa3, 0x4a, 0xd1, 0x64, 0x2a, 0x8b, 0x2f, 0xf3, 0xb7, 0x33, 0xe6, 0xf5, 0x3b, + 0xbd, 0xe8, 0x28, 0x0d, 0x9f, 0x58, 0xdb, 0xdb, 0xa6, 0xd1, 0xae, 0x69, 0x2f, 0xa1, 0x25, 0x56, + 0x27, 0x6a, 0x81, 0xec, 0x65, 0x6f, 0x42, 0xd9, 0x73, 0x09, 0x14, 0xa3, 0x08, 0x33, 0x28, 0x2a, + 0x27, 0x43, 0x91, 0x1b, 0x6b, 0x3f, 0x91, 0x56, 0x95, 0x1f, 0x9e, 0x7c, 0xf7, 0xe4, 0xec, 0x6d, + 0x14, 0x9c, 0x2c, 0xb2, 0xbb, 0xcc, 0x12, 0x8a, 0xd6, 0xa1, 0x36, 0x71, 0xf6, 0xf0, 0x84, 0xeb, + 0xf8, 0xb9, 0x1b, 0x7d, 0x8b, 0x6a, 0x58, 0xa5, 0xa5, 0x66, 0x9d, 0xfb, 0xd0, 0xe4, 0xc4, 0x73, + 0xaa, 0x48, 0x88, 0xd3, 0xe0, 0x0b, 0xe7, 0x3a, 0x28, 0x14, 0x7c, 0xf2, 0xc1, 0x36, 0xc5, 0x71, + 0xec, 0xec, 0x67, 0x46, 0xd9, 0x54, 0xbb, 0x03, 0x0a, 0x25, 0x0a, 0x31, 0x89, 0x66, 0x3e, 0xf9, + 0x24, 0xce, 0x4c, 0xd8, 0x94, 0x80, 0x66, 0x19, 0xec, 0xb5, 0x2b, 0x5b, 0x86, 0xf6, 0xbd, 0x04, + 0x2b, 0xc5, 0x9e, 0x9f, 0x3a, 0x21, 0x69, 0xf6, 0x74, 0xcc, 0x9e, 0x11, 0x57, 0x74, 0x41, 0xad, + 0xd3, 0x01, 0x7b, 0x15, 0xd2, 0x31, 0xf9, 0xc8, 0x29, 0x84, 0xff, 0x9f, 0x18, 0x77, 0xa1, 0x55, + 0x28, 0xb6, 0xbc, 0x38, 0x21, 0x0b, 0xf9, 0x9d, 0x88, 0x0b, 0xe9, 0xbf, 0x47, 0x4b, 0x2f, 0x15, + 0xfa, 0xab, 0xc0, 0x5e, 0x8d, 0x66, 0xf8, 0xee, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x9b, 0x20, + 0x44, 0x06, 0x2f, 0x10, 0x00, 0x00, } diff --git a/pkg/types/types.proto b/pkg/types/types.proto index 4da60462..c017c4fb 100644 --- a/pkg/types/types.proto +++ b/pkg/types/types.proto @@ -220,7 +220,7 @@ message TypedValue { } message Error { - string code = 1; +// string code = 1; string message = 2; }