event.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: flyteidl/event/event.proto

package event

import (
	fmt "fmt"
	core "github.com/flyteorg/flyteidl/gen/pb-go/flyteidl/core"
	proto "github.com/golang/protobuf/proto"
	_struct "github.com/golang/protobuf/ptypes/struct"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

// Includes the broad category of machine used for this specific task execution.
type TaskExecutionMetadata_InstanceClass int32

const (
	// The default instance class configured for the flyte application platform.
	TaskExecutionMetadata_DEFAULT TaskExecutionMetadata_InstanceClass = 0
	// The instance class configured for interruptible tasks.
	TaskExecutionMetadata_INTERRUPTIBLE TaskExecutionMetadata_InstanceClass = 1
)

var TaskExecutionMetadata_InstanceClass_name = map[int32]string{
	0: "DEFAULT",
	1: "INTERRUPTIBLE",
}

var TaskExecutionMetadata_InstanceClass_value = map[string]int32{
	"DEFAULT":       0,
	"INTERRUPTIBLE": 1,
}

func (x TaskExecutionMetadata_InstanceClass) String() string {
	return proto.EnumName(TaskExecutionMetadata_InstanceClass_name, int32(x))
}

func (TaskExecutionMetadata_InstanceClass) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_4b035d24120b1b12, []int{10, 0}
}

type WorkflowExecutionEvent struct {
	// Workflow execution id
	ExecutionId *core.WorkflowExecutionIdentifier `protobuf:"bytes,1,opt,name=execution_id,json=executionId,proto3" json:"execution_id,omitempty"`
	// the id of the originator (Propeller) of the event
	ProducerId string                       `protobuf:"bytes,2,opt,name=producer_id,json=producerId,proto3" json:"producer_id,omitempty"`
	Phase      core.WorkflowExecution_Phase `protobuf:"varint,3,opt,name=phase,proto3,enum=flyteidl.core.WorkflowExecution_Phase" json:"phase,omitempty"`
	// This timestamp represents when the original event occurred, it is generated
	// by the executor of the workflow.
	OccurredAt *timestamp.Timestamp `protobuf:"bytes,4,opt,name=occurred_at,json=occurredAt,proto3" json:"occurred_at,omitempty"`
	// Types that are valid to be assigned to OutputResult:
	//	*WorkflowExecutionEvent_OutputUri
	//	*WorkflowExecutionEvent_Error
	//	*WorkflowExecutionEvent_OutputData
	OutputResult         isWorkflowExecutionEvent_OutputResult `protobuf_oneof:"output_result"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

func (m *WorkflowExecutionEvent) Reset()         { *m = WorkflowExecutionEvent{} }
func (m *WorkflowExecutionEvent) String() string { return proto.CompactTextString(m) }
func (*WorkflowExecutionEvent) ProtoMessage()    {}
func (*WorkflowExecutionEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b035d24120b1b12, []int{0}
}

func (m *WorkflowExecutionEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_WorkflowExecutionEvent.Unmarshal(m, b)
}
func (m *WorkflowExecutionEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_WorkflowExecutionEvent.Marshal(b, m, deterministic)
}
func (m *WorkflowExecutionEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WorkflowExecutionEvent.Merge(m, src)
}
func (m *WorkflowExecutionEvent) XXX_Size() int {
	return xxx_messageInfo_WorkflowExecutionEvent.Size(m)
}
func (m *WorkflowExecutionEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_WorkflowExecutionEvent.DiscardUnknown(m)
}

var xxx_messageInfo_WorkflowExecutionEvent proto.InternalMessageInfo

func (m *WorkflowExecutionEvent) GetExecutionId() *core.WorkflowExecutionIdentifier {
	if m != nil {
		return m.ExecutionId
	}
	return nil
}

func (m *WorkflowExecutionEvent) GetProducerId() string {
	if m != nil {
		return m.ProducerId
	}
	return ""
}

func (m *WorkflowExecutionEvent) GetPhase() core.WorkflowExecution_Phase {
	if m != nil {
		return m.Phase
	}
	return core.WorkflowExecution_UNDEFINED
}

func (m *WorkflowExecutionEvent) GetOccurredAt() *timestamp.Timestamp {
	if m != nil {
		return m.OccurredAt
	}
	return nil
}

type isWorkflowExecutionEvent_OutputResult interface {
	isWorkflowExecutionEvent_OutputResult()
}

type WorkflowExecutionEvent_OutputUri struct {
	OutputUri string `protobuf:"bytes,5,opt,name=output_uri,json=outputUri,proto3,oneof"`
}

type WorkflowExecutionEvent_Error struct {
	Error *core.ExecutionError `protobuf:"bytes,6,opt,name=error,proto3,oneof"`
}

type WorkflowExecutionEvent_OutputData struct {
	OutputData *core.LiteralMap `protobuf:"bytes,7,opt,name=output_data,json=outputData,proto3,oneof"`
}

func (*WorkflowExecutionEvent_OutputUri) isWorkflowExecutionEvent_OutputResult() {}

func (*WorkflowExecutionEvent_Error) isWorkflowExecutionEvent_OutputResult() {}

func (*WorkflowExecutionEvent_OutputData) isWorkflowExecutionEvent_OutputResult() {}

func (m *WorkflowExecutionEvent) GetOutputResult() isWorkflowExecutionEvent_OutputResult {
	if m != nil {
		return m.OutputResult
	}
	return nil
}

func (m *WorkflowExecutionEvent) GetOutputUri() string {
	if x, ok := m.GetOutputResult().(*WorkflowExecutionEvent_OutputUri); ok {
		return x.OutputUri
	}
	return ""
}

func (m *WorkflowExecutionEvent) GetError() *core.ExecutionError {
	if x, ok := m.GetOutputResult().(*WorkflowExecutionEvent_Error); ok {
		return x.Error
	}
	return nil
}

func (m *WorkflowExecutionEvent) GetOutputData() *core.LiteralMap {
	if x, ok := m.GetOutputResult().(*WorkflowExecutionEvent_OutputData); ok {
		return x.OutputData
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*WorkflowExecutionEvent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*WorkflowExecutionEvent_OutputUri)(nil),
		(*WorkflowExecutionEvent_Error)(nil),
		(*WorkflowExecutionEvent_OutputData)(nil),
	}
}

type NodeExecutionEvent struct {
	// Unique identifier for this node execution
	Id *core.NodeExecutionIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// the id of the originator (Propeller) of the event
	ProducerId string                   `protobuf:"bytes,2,opt,name=producer_id,json=producerId,proto3" json:"producer_id,omitempty"`
	Phase      core.NodeExecution_Phase `protobuf:"varint,3,opt,name=phase,proto3,enum=flyteidl.core.NodeExecution_Phase" json:"phase,omitempty"`
	// This timestamp represents when the original event occurred, it is generated
	// by the executor of the node.
	OccurredAt *timestamp.Timestamp `protobuf:"bytes,4,opt,name=occurred_at,json=occurredAt,proto3" json:"occurred_at,omitempty"`
	// Types that are valid to be assigned to InputValue:
	//	*NodeExecutionEvent_InputUri
	//	*NodeExecutionEvent_InputData
	InputValue isNodeExecutionEvent_InputValue `protobuf_oneof:"input_value"`
	// Types that are valid to be assigned to OutputResult:
	//	*NodeExecutionEvent_OutputUri
	//	*NodeExecutionEvent_Error
	//	*NodeExecutionEvent_OutputData
	OutputResult isNodeExecutionEvent_OutputResult `protobuf_oneof:"output_result"`
	// Additional metadata to do with this event's node target based
	// on the node type
	//
	// Types that are valid to be assigned to TargetMetadata:
	//	*NodeExecutionEvent_WorkflowNodeMetadata
	//	*NodeExecutionEvent_TaskNodeMetadata
	TargetMetadata isNodeExecutionEvent_TargetMetadata `protobuf_oneof:"target_metadata"`
	// [To be deprecated] Specifies which task (if any) launched this node.
	ParentTaskMetadata *ParentTaskExecutionMetadata `protobuf:"bytes,9,opt,name=parent_task_metadata,json=parentTaskMetadata,proto3" json:"parent_task_metadata,omitempty"`
	// Specifies the parent node of the current node execution. Node executions at level zero will not have a parent node.
	ParentNodeMetadata *ParentNodeExecutionMetadata `protobuf:"bytes,10,opt,name=parent_node_metadata,json=parentNodeMetadata,proto3" json:"parent_node_metadata,omitempty"`
	// Retry group to indicate grouping of nodes by retries
	RetryGroup string `protobuf:"bytes,11,opt,name=retry_group,json=retryGroup,proto3" json:"retry_group,omitempty"`
	// Identifier of the node in the original workflow/graph
	// This maps to value of WorkflowTemplate.nodes[X].id
	SpecNodeId string `protobuf:"bytes,12,opt,name=spec_node_id,json=specNodeId,proto3" json:"spec_node_id,omitempty"`
	// Friendly readable name for the node
	NodeName     string `protobuf:"bytes,13,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
	EventVersion int32  `protobuf:"varint,16,opt,name=event_version,json=eventVersion,proto3" json:"event_version,omitempty"`
	// Whether this node launched a subworkflow.
	IsParent bool `protobuf:"varint,17,opt,name=is_parent,json=isParent,proto3" json:"is_parent,omitempty"`
	// Whether this node yielded a dynamic workflow.
	IsDynamic bool `protobuf:"varint,18,opt,name=is_dynamic,json=isDynamic,proto3" json:"is_dynamic,omitempty"`
	// String location uniquely identifying where the deck HTML file is
	// NativeUrl specifies the url in the format of the configured storage provider (e.g. s3://my-bucket/randomstring/suffix.tar)
	DeckUri              string   `protobuf:"bytes,19,opt,name=deck_uri,json=deckUri,proto3" json:"deck_uri,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NodeExecutionEvent) Reset()         { *m = NodeExecutionEvent{} }
func (m *NodeExecutionEvent) String() string { return proto.CompactTextString(m) }
func (*NodeExecutionEvent) ProtoMessage()    {}
func (*NodeExecutionEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b035d24120b1b12, []int{1}
}

func (m *NodeExecutionEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NodeExecutionEvent.Unmarshal(m, b)
}
func (m *NodeExecutionEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NodeExecutionEvent.Marshal(b, m, deterministic)
}
func (m *NodeExecutionEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeExecutionEvent.Merge(m, src)
}
func (m *NodeExecutionEvent) XXX_Size() int {
	return xxx_messageInfo_NodeExecutionEvent.Size(m)
}
func (m *NodeExecutionEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeExecutionEvent.DiscardUnknown(m)
}

var xxx_messageInfo_NodeExecutionEvent proto.InternalMessageInfo

func (m *NodeExecutionEvent) GetId() *core.NodeExecutionIdentifier {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *NodeExecutionEvent) GetProducerId() string {
	if m != nil {
		return m.ProducerId
	}
	return ""
}

func (m *NodeExecutionEvent) GetPhase() core.NodeExecution_Phase {
	if m != nil {
		return m.Phase
	}
	return core.NodeExecution_UNDEFINED
}

func (m *NodeExecutionEvent) GetOccurredAt() *timestamp.Timestamp {
	if m != nil {
		return m.OccurredAt
	}
	return nil
}

type isNodeExecutionEvent_InputValue interface {
	isNodeExecutionEvent_InputValue()
}

type NodeExecutionEvent_InputUri struct {
	InputUri string `protobuf:"bytes,5,opt,name=input_uri,json=inputUri,proto3,oneof"`
}

type NodeExecutionEvent_InputData struct {
	InputData *core.LiteralMap `protobuf:"bytes,20,opt,name=input_data,json=inputData,proto3,oneof"`
}

func (*NodeExecutionEvent_InputUri) isNodeExecutionEvent_InputValue() {}

func (*NodeExecutionEvent_InputData) isNodeExecutionEvent_InputValue() {}

func (m *NodeExecutionEvent) GetInputValue() isNodeExecutionEvent_InputValue {
	if m != nil {
		return m.InputValue
	}
	return nil
}

func (m *NodeExecutionEvent) GetInputUri() string {
	if x, ok := m.GetInputValue().(*NodeExecutionEvent_InputUri); ok {
		return x.InputUri
	}
	return ""
}

func (m *NodeExecutionEvent) GetInputData() *core.LiteralMap {
	if x, ok := m.GetInputValue().(*NodeExecutionEvent_InputData); ok {
		return x.InputData
	}
	return nil
}

type isNodeExecutionEvent_OutputResult interface {
	isNodeExecutionEvent_OutputResult()
}

type NodeExecutionEvent_OutputUri struct {
	OutputUri string `protobuf:"bytes,6,opt,name=output_uri,json=outputUri,proto3,oneof"`
}

type NodeExecutionEvent_Error struct {
	Error *core.ExecutionError `protobuf:"bytes,7,opt,name=error,proto3,oneof"`
}

type NodeExecutionEvent_OutputData struct {
	OutputData *core.LiteralMap `protobuf:"bytes,15,opt,name=output_data,json=outputData,proto3,oneof"`
}

func (*NodeExecutionEvent_OutputUri) isNodeExecutionEvent_OutputResult() {}

func (*NodeExecutionEvent_Error) isNodeExecutionEvent_OutputResult() {}

func (*NodeExecutionEvent_OutputData) isNodeExecutionEvent_OutputResult() {}

func (m *NodeExecutionEvent) GetOutputResult() isNodeExecutionEvent_OutputResult {
	if m != nil {
		return m.OutputResult
	}
	return nil
}

func (m *NodeExecutionEvent) GetOutputUri() string {
	if x, ok := m.GetOutputResult().(*NodeExecutionEvent_OutputUri); ok {
		return x.OutputUri
	}
	return ""
}

func (m *NodeExecutionEvent) GetError() *core.ExecutionError {
	if x, ok := m.GetOutputResult().(*NodeExecutionEvent_Error); ok {
		return x.Error
	}
	return nil
}

func (m *NodeExecutionEvent) GetOutputData() *core.LiteralMap {
	if x, ok := m.GetOutputResult().(*NodeExecutionEvent_OutputData); ok {
		return x.OutputData
	}
	return nil
}

type isNodeExecutionEvent_TargetMetadata interface {
	isNodeExecutionEvent_TargetMetadata()
}

type NodeExecutionEvent_WorkflowNodeMetadata struct {
	WorkflowNodeMetadata *WorkflowNodeMetadata `protobuf:"bytes,8,opt,name=workflow_node_metadata,json=workflowNodeMetadata,proto3,oneof"`
}

type NodeExecutionEvent_TaskNodeMetadata struct {
	TaskNodeMetadata *TaskNodeMetadata `protobuf:"bytes,14,opt,name=task_node_metadata,json=taskNodeMetadata,proto3,oneof"`
}

func (*NodeExecutionEvent_WorkflowNodeMetadata) isNodeExecutionEvent_TargetMetadata() {}

func (*NodeExecutionEvent_TaskNodeMetadata) isNodeExecutionEvent_TargetMetadata() {}

func (m *NodeExecutionEvent) GetTargetMetadata() isNodeExecutionEvent_TargetMetadata {
	if m != nil {
		return m.TargetMetadata
	}
	return nil
}

func (m *NodeExecutionEvent) GetWorkflowNodeMetadata() *WorkflowNodeMetadata {
	if x, ok := m.GetTargetMetadata().(*NodeExecutionEvent_WorkflowNodeMetadata); ok {
		return x.WorkflowNodeMetadata
	}
	return nil
}

func (m *NodeExecutionEvent) GetTaskNodeMetadata() *TaskNodeMetadata {
	if x, ok := m.GetTargetMetadata().(*NodeExecutionEvent_TaskNodeMetadata); ok {
		return x.TaskNodeMetadata
	}
	return nil
}

func (m *NodeExecutionEvent) GetParentTaskMetadata() *ParentTaskExecutionMetadata {
	if m != nil {
		return m.ParentTaskMetadata
	}
	return nil
}

func (m *NodeExecutionEvent) GetParentNodeMetadata() *ParentNodeExecutionMetadata {
	if m != nil {
		return m.ParentNodeMetadata
	}
	return nil
}

func (m *NodeExecutionEvent) GetRetryGroup() string {
	if m != nil {
		return m.RetryGroup
	}
	return ""
}

func (m *NodeExecutionEvent) GetSpecNodeId() string {
	if m != nil {
		return m.SpecNodeId
	}
	return ""
}

func (m *NodeExecutionEvent) GetNodeName() string {
	if m != nil {
		return m.NodeName
	}
	return ""
}

func (m *NodeExecutionEvent) GetEventVersion() int32 {
	if m != nil {
		return m.EventVersion
	}
	return 0
}

func (m *NodeExecutionEvent) GetIsParent() bool {
	if m != nil {
		return m.IsParent
	}
	return false
}

func (m *NodeExecutionEvent) GetIsDynamic() bool {
	if m != nil {
		return m.IsDynamic
	}
	return false
}

func (m *NodeExecutionEvent) GetDeckUri() string {
	if m != nil {
		return m.DeckUri
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*NodeExecutionEvent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*NodeExecutionEvent_InputUri)(nil),
		(*NodeExecutionEvent_InputData)(nil),
		(*NodeExecutionEvent_OutputUri)(nil),
		(*NodeExecutionEvent_Error)(nil),
		(*NodeExecutionEvent_OutputData)(nil),
		(*NodeExecutionEvent_WorkflowNodeMetadata)(nil),
		(*NodeExecutionEvent_TaskNodeMetadata)(nil),
	}
}

// For Workflow Nodes we need to send information about the workflow that's launched
type WorkflowNodeMetadata struct {
	ExecutionId          *core.WorkflowExecutionIdentifier `protobuf:"bytes,1,opt,name=execution_id,json=executionId,proto3" json:"execution_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

func (m *WorkflowNodeMetadata) Reset()         { *m = WorkflowNodeMetadata{} }
func (m *WorkflowNodeMetadata) String() string { return proto.CompactTextString(m) }
func (*WorkflowNodeMetadata) ProtoMessage()    {}
func (*WorkflowNodeMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b035d24120b1b12, []int{2}
}

func (m *WorkflowNodeMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_WorkflowNodeMetadata.Unmarshal(m, b)
}
func (m *WorkflowNodeMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_WorkflowNodeMetadata.Marshal(b, m, deterministic)
}
func (m *WorkflowNodeMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WorkflowNodeMetadata.Merge(m, src)
}
func (m *WorkflowNodeMetadata) XXX_Size() int {
	return xxx_messageInfo_WorkflowNodeMetadata.Size(m)
}
func (m *WorkflowNodeMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_WorkflowNodeMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_WorkflowNodeMetadata proto.InternalMessageInfo

func (m *WorkflowNodeMetadata) GetExecutionId() *core.WorkflowExecutionIdentifier {
	if m != nil {
		return m.ExecutionId
	}
	return nil
}

type TaskNodeMetadata struct {
	// Captures the status of caching for this execution.
	CacheStatus core.CatalogCacheStatus `protobuf:"varint,1,opt,name=cache_status,json=cacheStatus,proto3,enum=flyteidl.core.CatalogCacheStatus" json:"cache_status,omitempty"`
	// This structure carries the catalog artifact information
	CatalogKey *core.CatalogMetadata `protobuf:"bytes,2,opt,name=catalog_key,json=catalogKey,proto3" json:"catalog_key,omitempty"`
	// Captures the status of cache reservations for this execution.
	ReservationStatus core.CatalogReservation_Status `protobuf:"varint,3,opt,name=reservation_status,json=reservationStatus,proto3,enum=flyteidl.core.CatalogReservation_Status" json:"reservation_status,omitempty"`
	// The latest checkpoint location
	CheckpointUri string `protobuf:"bytes,4,opt,name=checkpoint_uri,json=checkpointUri,proto3" json:"checkpoint_uri,omitempty"`
	// In the case this task launched a dynamic workflow we capture its structure here.
	DynamicWorkflow      *DynamicWorkflowNodeMetadata `protobuf:"bytes,16,opt,name=dynamic_workflow,json=dynamicWorkflow,proto3" json:"dynamic_workflow,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

func (m *TaskNodeMetadata) Reset()         { *m = TaskNodeMetadata{} }
func (m *TaskNodeMetadata) String() string { return proto.CompactTextString(m) }
func (*TaskNodeMetadata) ProtoMessage()    {}
func (*TaskNodeMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b035d24120b1b12, []int{3}
}

func (m *TaskNodeMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskNodeMetadata.Unmarshal(m, b)
}
func (m *TaskNodeMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskNodeMetadata.Marshal(b, m, deterministic)
}
func (m *TaskNodeMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskNodeMetadata.Merge(m, src)
}
func (m *TaskNodeMetadata) XXX_Size() int {
	return xxx_messageInfo_TaskNodeMetadata.Size(m)
}
func (m *TaskNodeMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskNodeMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_TaskNodeMetadata proto.InternalMessageInfo

func (m *TaskNodeMetadata) GetCacheStatus() core.CatalogCacheStatus {
	if m != nil {
		return m.CacheStatus
	}
	return core.CatalogCacheStatus_CACHE_DISABLED
}

func (m *TaskNodeMetadata) GetCatalogKey() *core.CatalogMetadata {
	if m != nil {
		return m.CatalogKey
	}
	return nil
}

func (m *TaskNodeMetadata) GetReservationStatus() core.CatalogReservation_Status {
	if m != nil {
		return m.ReservationStatus
	}
	return core.CatalogReservation_RESERVATION_DISABLED
}

func (m *TaskNodeMetadata) GetCheckpointUri() string {
	if m != nil {
		return m.CheckpointUri
	}
	return ""
}

func (m *TaskNodeMetadata) GetDynamicWorkflow() *DynamicWorkflowNodeMetadata {
	if m != nil {
		return m.DynamicWorkflow
	}
	return nil
}

// For dynamic workflow nodes we send information about the dynamic workflow definition that gets generated.
type DynamicWorkflowNodeMetadata struct {
	// id represents the unique identifier of the workflow.
	Id *core.Identifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Represents the compiled representation of the embedded dynamic workflow.
	CompiledWorkflow     *core.CompiledWorkflowClosure `protobuf:"bytes,2,opt,name=compiled_workflow,json=compiledWorkflow,proto3" json:"compiled_workflow,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *DynamicWorkflowNodeMetadata) Reset()         { *m = DynamicWorkflowNodeMetadata{} }
func (m *DynamicWorkflowNodeMetadata) String() string { return proto.CompactTextString(m) }
func (*DynamicWorkflowNodeMetadata) ProtoMessage()    {}
func (*DynamicWorkflowNodeMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b035d24120b1b12, []int{4}
}

func (m *DynamicWorkflowNodeMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DynamicWorkflowNodeMetadata.Unmarshal(m, b)
}
func (m *DynamicWorkflowNodeMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DynamicWorkflowNodeMetadata.Marshal(b, m, deterministic)
}
func (m *DynamicWorkflowNodeMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DynamicWorkflowNodeMetadata.Merge(m, src)
}
func (m *DynamicWorkflowNodeMetadata) XXX_Size() int {
	return xxx_messageInfo_DynamicWorkflowNodeMetadata.Size(m)
}
func (m *DynamicWorkflowNodeMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_DynamicWorkflowNodeMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_DynamicWorkflowNodeMetadata proto.InternalMessageInfo

func (m *DynamicWorkflowNodeMetadata) GetId() *core.Identifier {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *DynamicWorkflowNodeMetadata) GetCompiledWorkflow() *core.CompiledWorkflowClosure {
	if m != nil {
		return m.CompiledWorkflow
	}
	return nil
}

type ParentTaskExecutionMetadata struct {
	Id                   *core.TaskExecutionIdentifier `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *ParentTaskExecutionMetadata) Reset()         { *m = ParentTaskExecutionMetadata{} }
func (m *ParentTaskExecutionMetadata) String() string { return proto.CompactTextString(m) }
func (*ParentTaskExecutionMetadata) ProtoMessage()    {}
func (*ParentTaskExecutionMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b035d24120b1b12, []int{5}
}

func (m *ParentTaskExecutionMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParentTaskExecutionMetadata.Unmarshal(m, b)
}
func (m *ParentTaskExecutionMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParentTaskExecutionMetadata.Marshal(b, m, deterministic)
}
func (m *ParentTaskExecutionMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParentTaskExecutionMetadata.Merge(m, src)
}
func (m *ParentTaskExecutionMetadata) XXX_Size() int {
	return xxx_messageInfo_ParentTaskExecutionMetadata.Size(m)
}
func (m *ParentTaskExecutionMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_ParentTaskExecutionMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_ParentTaskExecutionMetadata proto.InternalMessageInfo

func (m *ParentTaskExecutionMetadata) GetId() *core.TaskExecutionIdentifier {
	if m != nil {
		return m.Id
	}
	return nil
}

type ParentNodeExecutionMetadata struct {
	// Unique identifier of the parent node id within the execution
	// This is value of core.NodeExecutionIdentifier.node_id of the parent node
	NodeId               string   `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParentNodeExecutionMetadata) Reset()         { *m = ParentNodeExecutionMetadata{} }
func (m *ParentNodeExecutionMetadata) String() string { return proto.CompactTextString(m) }
func (*ParentNodeExecutionMetadata) ProtoMessage()    {}
func (*ParentNodeExecutionMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b035d24120b1b12, []int{6}
}

func (m *ParentNodeExecutionMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParentNodeExecutionMetadata.Unmarshal(m, b)
}
func (m *ParentNodeExecutionMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParentNodeExecutionMetadata.Marshal(b, m, deterministic)
}
func (m *ParentNodeExecutionMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParentNodeExecutionMetadata.Merge(m, src)
}
func (m *ParentNodeExecutionMetadata) XXX_Size() int {
	return xxx_messageInfo_ParentNodeExecutionMetadata.Size(m)
}
func (m *ParentNodeExecutionMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_ParentNodeExecutionMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_ParentNodeExecutionMetadata proto.InternalMessageInfo

func (m *ParentNodeExecutionMetadata) GetNodeId() string {
	if m != nil {
		return m.NodeId
	}
	return ""
}

// Plugin specific execution event information. For tasks like Python, Hive, Spark, DynamicJob.
type TaskExecutionEvent struct {
	// ID of the task. In combination with the retryAttempt this will indicate
	// the task execution uniquely for a given parent node execution.
	TaskId *core.Identifier `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
	// A task execution is always kicked off by a node execution, the event consumer
	// will use the parent_id to relate the task to it's parent node execution
	ParentNodeExecutionId *core.NodeExecutionIdentifier `protobuf:"bytes,2,opt,name=parent_node_execution_id,json=parentNodeExecutionId,proto3" json:"parent_node_execution_id,omitempty"`
	// retry attempt number for this task, ie., 2 for the second attempt
	RetryAttempt uint32 `protobuf:"varint,3,opt,name=retry_attempt,json=retryAttempt,proto3" json:"retry_attempt,omitempty"`
	// Phase associated with the event
	Phase core.TaskExecution_Phase `protobuf:"varint,4,opt,name=phase,proto3,enum=flyteidl.core.TaskExecution_Phase" json:"phase,omitempty"`
	// id of the process that sent this event, mainly for trace debugging
	ProducerId string `protobuf:"bytes,5,opt,name=producer_id,json=producerId,proto3" json:"producer_id,omitempty"`
	// log information for the task execution
	Logs []*core.TaskLog `protobuf:"bytes,6,rep,name=logs,proto3" json:"logs,omitempty"`
	// This timestamp represents when the original event occurred, it is generated
	// by the executor of the task.
	OccurredAt *timestamp.Timestamp `protobuf:"bytes,7,opt,name=occurred_at,json=occurredAt,proto3" json:"occurred_at,omitempty"`
	// Types that are valid to be assigned to InputValue:
	//	*TaskExecutionEvent_InputUri
	//	*TaskExecutionEvent_InputData
	InputValue isTaskExecutionEvent_InputValue `protobuf_oneof:"input_value"`
	// Types that are valid to be assigned to OutputResult:
	//	*TaskExecutionEvent_OutputUri
	//	*TaskExecutionEvent_Error
	//	*TaskExecutionEvent_OutputData
	OutputResult isTaskExecutionEvent_OutputResult `protobuf_oneof:"output_result"`
	// Custom data that the task plugin sends back. This is extensible to allow various plugins in the system.
	CustomInfo *_struct.Struct `protobuf:"bytes,11,opt,name=custom_info,json=customInfo,proto3" json:"custom_info,omitempty"`
	// Some phases, like RUNNING, can send multiple events with changed metadata (new logs, additional custom_info, etc)
	// that should be recorded regardless of the lack of phase change.
	// The version field should be incremented when metadata changes across the duration of an individual phase.
	PhaseVersion uint32 `protobuf:"varint,12,opt,name=phase_version,json=phaseVersion,proto3" json:"phase_version,omitempty"`
	// An optional explanation for the phase transition.
	Reason string `protobuf:"bytes,13,opt,name=reason,proto3" json:"reason,omitempty"`
	// A predefined yet extensible Task type identifier. If the task definition is already registered in flyte admin
	// this type will be identical, but not all task executions necessarily use pre-registered definitions and this
	// type is useful to render the task in the UI, filter task executions, etc.
	TaskType string `protobuf:"bytes,14,opt,name=task_type,json=taskType,proto3" json:"task_type,omitempty"`
	// Metadata around how a task was executed.
	Metadata *TaskExecutionMetadata `protobuf:"bytes,16,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// The event version is used to indicate versioned changes in how data is reported using this
	// proto message. For example, event_verison > 0 means that maps tasks report logs using the
	// TaskExecutionMetadata ExternalResourceInfo fields for each subtask rather than the TaskLog
	// in this message.
	EventVersion         int32    `protobuf:"varint,18,opt,name=event_version,json=eventVersion,proto3" json:"event_version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskExecutionEvent) Reset()         { *m = TaskExecutionEvent{} }
func (m *TaskExecutionEvent) String() string { return proto.CompactTextString(m) }
func (*TaskExecutionEvent) ProtoMessage()    {}
func (*TaskExecutionEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b035d24120b1b12, []int{7}
}

func (m *TaskExecutionEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskExecutionEvent.Unmarshal(m, b)
}
func (m *TaskExecutionEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskExecutionEvent.Marshal(b, m, deterministic)
}
func (m *TaskExecutionEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskExecutionEvent.Merge(m, src)
}
func (m *TaskExecutionEvent) XXX_Size() int {
	return xxx_messageInfo_TaskExecutionEvent.Size(m)
}
func (m *TaskExecutionEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskExecutionEvent.DiscardUnknown(m)
}

var xxx_messageInfo_TaskExecutionEvent proto.InternalMessageInfo

func (m *TaskExecutionEvent) GetTaskId() *core.Identifier {
	if m != nil {
		return m.TaskId
	}
	return nil
}

func (m *TaskExecutionEvent) GetParentNodeExecutionId() *core.NodeExecutionIdentifier {
	if m != nil {
		return m.ParentNodeExecutionId
	}
	return nil
}

func (m *TaskExecutionEvent) GetRetryAttempt() uint32 {
	if m != nil {
		return m.RetryAttempt
	}
	return 0
}

func (m *TaskExecutionEvent) GetPhase() core.TaskExecution_Phase {
	if m != nil {
		return m.Phase
	}
	return core.TaskExecution_UNDEFINED
}

func (m *TaskExecutionEvent) GetProducerId() string {
	if m != nil {
		return m.ProducerId
	}
	return ""
}

func (m *TaskExecutionEvent) GetLogs() []*core.TaskLog {
	if m != nil {
		return m.Logs
	}
	return nil
}

func (m *TaskExecutionEvent) GetOccurredAt() *timestamp.Timestamp {
	if m != nil {
		return m.OccurredAt
	}
	return nil
}

type isTaskExecutionEvent_InputValue interface {
	isTaskExecutionEvent_InputValue()
}

type TaskExecutionEvent_InputUri struct {
	InputUri string `protobuf:"bytes,8,opt,name=input_uri,json=inputUri,proto3,oneof"`
}

type TaskExecutionEvent_InputData struct {
	InputData *core.LiteralMap `protobuf:"bytes,19,opt,name=input_data,json=inputData,proto3,oneof"`
}

func (*TaskExecutionEvent_InputUri) isTaskExecutionEvent_InputValue() {}

func (*TaskExecutionEvent_InputData) isTaskExecutionEvent_InputValue() {}

func (m *TaskExecutionEvent) GetInputValue() isTaskExecutionEvent_InputValue {
	if m != nil {
		return m.InputValue
	}
	return nil
}

func (m *TaskExecutionEvent) GetInputUri() string {
	if x, ok := m.GetInputValue().(*TaskExecutionEvent_InputUri); ok {
		return x.InputUri
	}
	return ""
}

func (m *TaskExecutionEvent) GetInputData() *core.LiteralMap {
	if x, ok := m.GetInputValue().(*TaskExecutionEvent_InputData); ok {
		return x.InputData
	}
	return nil
}

type isTaskExecutionEvent_OutputResult interface {
	isTaskExecutionEvent_OutputResult()
}

type TaskExecutionEvent_OutputUri struct {
	OutputUri string `protobuf:"bytes,9,opt,name=output_uri,json=outputUri,proto3,oneof"`
}

type TaskExecutionEvent_Error struct {
	Error *core.ExecutionError `protobuf:"bytes,10,opt,name=error,proto3,oneof"`
}

type TaskExecutionEvent_OutputData struct {
	OutputData *core.LiteralMap `protobuf:"bytes,17,opt,name=output_data,json=outputData,proto3,oneof"`
}

func (*TaskExecutionEvent_OutputUri) isTaskExecutionEvent_OutputResult() {}

func (*TaskExecutionEvent_Error) isTaskExecutionEvent_OutputResult() {}

func (*TaskExecutionEvent_OutputData) isTaskExecutionEvent_OutputResult() {}

func (m *TaskExecutionEvent) GetOutputResult() isTaskExecutionEvent_OutputResult {
	if m != nil {
		return m.OutputResult
	}
	return nil
}

func (m *TaskExecutionEvent) GetOutputUri() string {
	if x, ok := m.GetOutputResult().(*TaskExecutionEvent_OutputUri); ok {
		return x.OutputUri
	}
	return ""
}

func (m *TaskExecutionEvent) GetError() *core.ExecutionError {
	if x, ok := m.GetOutputResult().(*TaskExecutionEvent_Error); ok {
		return x.Error
	}
	return nil
}

func (m *TaskExecutionEvent) GetOutputData() *core.LiteralMap {
	if x, ok := m.GetOutputResult().(*TaskExecutionEvent_OutputData); ok {
		return x.OutputData
	}
	return nil
}

func (m *TaskExecutionEvent) GetCustomInfo() *_struct.Struct {
	if m != nil {
		return m.CustomInfo
	}
	return nil
}

func (m *TaskExecutionEvent) GetPhaseVersion() uint32 {
	if m != nil {
		return m.PhaseVersion
	}
	return 0
}

func (m *TaskExecutionEvent) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

func (m *TaskExecutionEvent) GetTaskType() string {
	if m != nil {
		return m.TaskType
	}
	return ""
}

func (m *TaskExecutionEvent) GetMetadata() *TaskExecutionMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *TaskExecutionEvent) GetEventVersion() int32 {
	if m != nil {
		return m.EventVersion
	}
	return 0
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*TaskExecutionEvent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*TaskExecutionEvent_InputUri)(nil),
		(*TaskExecutionEvent_InputData)(nil),
		(*TaskExecutionEvent_OutputUri)(nil),
		(*TaskExecutionEvent_Error)(nil),
		(*TaskExecutionEvent_OutputData)(nil),
	}
}

// This message contains metadata about external resources produced or used by a specific task execution.
type ExternalResourceInfo struct {
	// Identifier for an external resource created by this task execution, for example Qubole query ID or presto query ids.
	ExternalId string `protobuf:"bytes,1,opt,name=external_id,json=externalId,proto3" json:"external_id,omitempty"`
	// A unique index for the external resource with respect to all external resources for this task. Although the
	// identifier may change between task reporting events or retries, this will remain the same to enable aggregating
	// information from multiple reports.
	Index uint32 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	// Retry attempt number for this external resource, ie., 2 for the second attempt
	RetryAttempt uint32 `protobuf:"varint,3,opt,name=retry_attempt,json=retryAttempt,proto3" json:"retry_attempt,omitempty"`
	// Phase associated with the external resource
	Phase core.TaskExecution_Phase `protobuf:"varint,4,opt,name=phase,proto3,enum=flyteidl.core.TaskExecution_Phase" json:"phase,omitempty"`
	// Captures the status of caching for this external resource execution.
	CacheStatus core.CatalogCacheStatus `protobuf:"varint,5,opt,name=cache_status,json=cacheStatus,proto3,enum=flyteidl.core.CatalogCacheStatus" json:"cache_status,omitempty"`
	// log information for the external resource execution
	Logs                 []*core.TaskLog `protobuf:"bytes,6,rep,name=logs,proto3" json:"logs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *ExternalResourceInfo) Reset()         { *m = ExternalResourceInfo{} }
func (m *ExternalResourceInfo) String() string { return proto.CompactTextString(m) }
func (*ExternalResourceInfo) ProtoMessage()    {}
func (*ExternalResourceInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b035d24120b1b12, []int{8}
}

func (m *ExternalResourceInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExternalResourceInfo.Unmarshal(m, b)
}
func (m *ExternalResourceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExternalResourceInfo.Marshal(b, m, deterministic)
}
func (m *ExternalResourceInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExternalResourceInfo.Merge(m, src)
}
func (m *ExternalResourceInfo) XXX_Size() int {
	return xxx_messageInfo_ExternalResourceInfo.Size(m)
}
func (m *ExternalResourceInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ExternalResourceInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ExternalResourceInfo proto.InternalMessageInfo

func (m *ExternalResourceInfo) GetExternalId() string {
	if m != nil {
		return m.ExternalId
	}
	return ""
}

func (m *ExternalResourceInfo) GetIndex() uint32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *ExternalResourceInfo) GetRetryAttempt() uint32 {
	if m != nil {
		return m.RetryAttempt
	}
	return 0
}

func (m *ExternalResourceInfo) GetPhase() core.TaskExecution_Phase {
	if m != nil {
		return m.Phase
	}
	return core.TaskExecution_UNDEFINED
}

func (m *ExternalResourceInfo) GetCacheStatus() core.CatalogCacheStatus {
	if m != nil {
		return m.CacheStatus
	}
	return core.CatalogCacheStatus_CACHE_DISABLED
}

func (m *ExternalResourceInfo) GetLogs() []*core.TaskLog {
	if m != nil {
		return m.Logs
	}
	return nil
}

// This message holds task execution metadata specific to resource allocation used to manage concurrent
// executions for a project namespace.
type ResourcePoolInfo struct {
	// Unique resource ID used to identify this execution when allocating a token.
	AllocationToken string `protobuf:"bytes,1,opt,name=allocation_token,json=allocationToken,proto3" json:"allocation_token,omitempty"`
	// Namespace under which this task execution requested an allocation token.
	Namespace            string   `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ResourcePoolInfo) Reset()         { *m = ResourcePoolInfo{} }
func (m *ResourcePoolInfo) String() string { return proto.CompactTextString(m) }
func (*ResourcePoolInfo) ProtoMessage()    {}
func (*ResourcePoolInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b035d24120b1b12, []int{9}
}

func (m *ResourcePoolInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ResourcePoolInfo.Unmarshal(m, b)
}
func (m *ResourcePoolInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ResourcePoolInfo.Marshal(b, m, deterministic)
}
func (m *ResourcePoolInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResourcePoolInfo.Merge(m, src)
}
func (m *ResourcePoolInfo) XXX_Size() int {
	return xxx_messageInfo_ResourcePoolInfo.Size(m)
}
func (m *ResourcePoolInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ResourcePoolInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ResourcePoolInfo proto.InternalMessageInfo

func (m *ResourcePoolInfo) GetAllocationToken() string {
	if m != nil {
		return m.AllocationToken
	}
	return ""
}

func (m *ResourcePoolInfo) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

// Holds metadata around how a task was executed.
// As a task transitions across event phases during execution some attributes, such its generated name, generated external resources,
// and more may grow in size but not change necessarily based on the phase transition that sparked the event update.
// Metadata is a container for these attributes across the task execution lifecycle.
type TaskExecutionMetadata struct {
	// Unique, generated name for this task execution used by the backend.
	GeneratedName string `protobuf:"bytes,1,opt,name=generated_name,json=generatedName,proto3" json:"generated_name,omitempty"`
	// Additional data on external resources on other back-ends or platforms (e.g. Hive, Qubole, etc) launched by this task execution.
	ExternalResources []*ExternalResourceInfo `protobuf:"bytes,2,rep,name=external_resources,json=externalResources,proto3" json:"external_resources,omitempty"`
	// Includes additional data on concurrent resource management used during execution..
	// This is a repeated field because a plugin can request multiple resource allocations during execution.
	ResourcePoolInfo []*ResourcePoolInfo `protobuf:"bytes,3,rep,name=resource_pool_info,json=resourcePoolInfo,proto3" json:"resource_pool_info,omitempty"`
	// The identifier of the plugin used to execute this task.
	PluginIdentifier     string                              `protobuf:"bytes,4,opt,name=plugin_identifier,json=pluginIdentifier,proto3" json:"plugin_identifier,omitempty"`
	InstanceClass        TaskExecutionMetadata_InstanceClass `protobuf:"varint,16,opt,name=instance_class,json=instanceClass,proto3,enum=flyteidl.event.TaskExecutionMetadata_InstanceClass" json:"instance_class,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
	XXX_unrecognized     []byte                              `json:"-"`
	XXX_sizecache        int32                               `json:"-"`
}

func (m *TaskExecutionMetadata) Reset()         { *m = TaskExecutionMetadata{} }
func (m *TaskExecutionMetadata) String() string { return proto.CompactTextString(m) }
func (*TaskExecutionMetadata) ProtoMessage()    {}
func (*TaskExecutionMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b035d24120b1b12, []int{10}
}

func (m *TaskExecutionMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskExecutionMetadata.Unmarshal(m, b)
}
func (m *TaskExecutionMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskExecutionMetadata.Marshal(b, m, deterministic)
}
func (m *TaskExecutionMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskExecutionMetadata.Merge(m, src)
}
func (m *TaskExecutionMetadata) XXX_Size() int {
	return xxx_messageInfo_TaskExecutionMetadata.Size(m)
}
func (m *TaskExecutionMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskExecutionMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_TaskExecutionMetadata proto.InternalMessageInfo

func (m *TaskExecutionMetadata) GetGeneratedName() string {
	if m != nil {
		return m.GeneratedName
	}
	return ""
}

func (m *TaskExecutionMetadata) GetExternalResources() []*ExternalResourceInfo {
	if m != nil {
		return m.ExternalResources
	}
	return nil
}

func (m *TaskExecutionMetadata) GetResourcePoolInfo() []*ResourcePoolInfo {
	if m != nil {
		return m.ResourcePoolInfo
	}
	return nil
}

func (m *TaskExecutionMetadata) GetPluginIdentifier() string {
	if m != nil {
		return m.PluginIdentifier
	}
	return ""
}

func (m *TaskExecutionMetadata) GetInstanceClass() TaskExecutionMetadata_InstanceClass {
	if m != nil {
		return m.InstanceClass
	}
	return TaskExecutionMetadata_DEFAULT
}

func init() {
	proto.RegisterEnum("flyteidl.event.TaskExecutionMetadata_InstanceClass", TaskExecutionMetadata_InstanceClass_name, TaskExecutionMetadata_InstanceClass_value)
	proto.RegisterType((*WorkflowExecutionEvent)(nil), "flyteidl.event.WorkflowExecutionEvent")
	proto.RegisterType((*NodeExecutionEvent)(nil), "flyteidl.event.NodeExecutionEvent")
	proto.RegisterType((*WorkflowNodeMetadata)(nil), "flyteidl.event.WorkflowNodeMetadata")
	proto.RegisterType((*TaskNodeMetadata)(nil), "flyteidl.event.TaskNodeMetadata")
	proto.RegisterType((*DynamicWorkflowNodeMetadata)(nil), "flyteidl.event.DynamicWorkflowNodeMetadata")
	proto.RegisterType((*ParentTaskExecutionMetadata)(nil), "flyteidl.event.ParentTaskExecutionMetadata")
	proto.RegisterType((*ParentNodeExecutionMetadata)(nil), "flyteidl.event.ParentNodeExecutionMetadata")
	proto.RegisterType((*TaskExecutionEvent)(nil), "flyteidl.event.TaskExecutionEvent")
	proto.RegisterType((*ExternalResourceInfo)(nil), "flyteidl.event.ExternalResourceInfo")
	proto.RegisterType((*ResourcePoolInfo)(nil), "flyteidl.event.ResourcePoolInfo")
	proto.RegisterType((*TaskExecutionMetadata)(nil), "flyteidl.event.TaskExecutionMetadata")
}

func init() { proto.RegisterFile("flyteidl/event/event.proto", fileDescriptor_4b035d24120b1b12) }

var fileDescriptor_4b035d24120b1b12 = []byte{
	// 1441 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xdb, 0x6e, 0xdb, 0x46,
	0x13, 0xb6, 0xe4, 0x83, 0xa4, 0xa1, 0x25, 0x4b, 0x1b, 0xc7, 0x61, 0xe2, 0x38, 0xd6, 0xaf, 0xbf,
	0x29, 0x94, 0x04, 0x95, 0x00, 0x05, 0x49, 0x83, 0x36, 0x40, 0xe1, 0x53, 0x6b, 0xa1, 0x8e, 0x61,
	0xd0, 0x72, 0x02, 0xa4, 0x2d, 0x88, 0x35, 0xb9, 0x96, 0x17, 0xa2, 0xb8, 0xc4, 0x72, 0xe9, 0x44,
	0x0f, 0x93, 0xf6, 0xbe, 0x8f, 0xd3, 0x37, 0xe9, 0x1b, 0x14, 0xdc, 0x25, 0x29, 0x93, 0x62, 0x6d,
	0xe7, 0xd0, 0x1b, 0x03, 0x9c, 0x99, 0xfd, 0x76, 0x76, 0x4e, 0xdf, 0x58, 0x70, 0xef, 0xcc, 0x99,
	0x08, 0x42, 0x6d, 0xa7, 0x4b, 0x2e, 0x88, 0x2b, 0xd4, 0xdf, 0x8e, 0xc7, 0x99, 0x60, 0xa8, 0x16,
	0xeb, 0x3a, 0x52, 0x7a, 0xef, 0x7e, 0x62, 0x6b, 0x31, 0x4e, 0xba, 0x0e, 0x15, 0x84, 0x63, 0xc7,
	0x57, 0xd6, 0x59, 0xad, 0xc5, 0xc6, 0x1e, 0x75, 0x08, 0x8f, 0xb4, 0x1b, 0x69, 0x2d, 0x79, 0x4f,
	0xac, 0x40, 0x50, 0xe6, 0x46, 0xea, 0x07, 0x69, 0x35, 0xb5, 0x89, 0x2b, 0xe8, 0x19, 0x4d, 0x8e,
	0xaf, 0x67, 0xc0, 0xb1, 0xc0, 0x0e, 0x1b, 0x46, 0xca, 0xcd, 0x21, 0x63, 0x43, 0x87, 0x74, 0xe5,
	0xd7, 0x69, 0x70, 0xd6, 0x15, 0x74, 0x4c, 0x7c, 0x81, 0xc7, 0x5e, 0xec, 0x5a, 0xd6, 0xc0, 0x17,
	0x3c, 0xb0, 0xa2, 0x67, 0xb6, 0xfe, 0x9c, 0x87, 0xb5, 0x37, 0x8c, 0x8f, 0xce, 0x1c, 0xf6, 0x6e,
	0x2f, 0xf6, 0x6b, 0x2f, 0x7c, 0x31, 0x7a, 0x05, 0xcb, 0x89, 0xa7, 0x26, 0xb5, 0xf5, 0x42, 0xb3,
	0xd0, 0xd6, 0x7a, 0x8f, 0x3b, 0x49, 0x60, 0x42, 0x6f, 0x3a, 0x33, 0x87, 0xfb, 0x89, 0xfb, 0x86,
	0x46, 0xa6, 0x42, 0xb4, 0x09, 0x9a, 0xc7, 0x99, 0x1d, 0x58, 0x84, 0x87, 0x68, 0xc5, 0x66, 0xa1,
	0x5d, 0x31, 0x20, 0x16, 0xf5, 0x6d, 0xf4, 0x12, 0x16, 0xbd, 0x73, 0xec, 0x13, 0x7d, 0xbe, 0x59,
	0x68, 0xd7, 0x7a, 0x5f, 0x5f, 0x77, 0x51, 0xe7, 0x28, 0xb4, 0x36, 0xd4, 0x21, 0xf4, 0x3d, 0x68,
	0xcc, 0xb2, 0x02, 0xce, 0x89, 0x6d, 0x62, 0xa1, 0x2f, 0x48, 0x67, 0xef, 0x75, 0xd4, 0xe3, 0x3b,
	0xf1, 0xe3, 0x3b, 0x83, 0x38, 0x3a, 0x06, 0xc4, 0xe6, 0x5b, 0x02, 0x6d, 0x02, 0xb0, 0x40, 0x78,
	0x81, 0x30, 0x03, 0x4e, 0xf5, 0xc5, 0xd0, 0xb5, 0xfd, 0x39, 0xa3, 0xa2, 0x64, 0x27, 0x9c, 0xa2,
	0x67, 0xb0, 0x48, 0x38, 0x67, 0x5c, 0x5f, 0x92, 0xb8, 0x1b, 0x19, 0xdf, 0xa6, 0x91, 0x0b, 0x8d,
	0xf6, 0xe7, 0x0c, 0x65, 0x8d, 0x5e, 0x82, 0x16, 0xe1, 0xda, 0x58, 0x60, 0xbd, 0x24, 0x0f, 0xdf,
	0xcd, 0x1c, 0x3e, 0x50, 0xa5, 0xf4, 0x0a, 0x7b, 0xfb, 0x73, 0x46, 0xe4, 0xc7, 0x2e, 0x16, 0x78,
	0x7b, 0x05, 0xaa, 0xd1, 0x69, 0x4e, 0xfc, 0xc0, 0x11, 0xad, 0xbf, 0xca, 0x80, 0x0e, 0x99, 0x4d,
	0x32, 0x89, 0x7a, 0x0e, 0xc5, 0x24, 0x3d, 0xd9, 0xa8, 0xa5, 0xcc, 0x2f, 0xa5, 0xa6, 0x48, 0x6f,
	0x90, 0x91, 0x17, 0xe9, 0x8c, 0xb4, 0xae, 0xc2, 0xfe, 0x82, 0xd9, 0xd8, 0x80, 0x0a, 0x75, 0xb3,
	0xc9, 0x28, 0x4b, 0x51, 0x98, 0x8b, 0xef, 0x00, 0x94, 0x5a, 0xc6, 0x74, 0xf5, 0xfa, 0x98, 0x2a,
	0xb4, 0x30, 0xa4, 0x99, 0x44, 0x2f, 0x49, 0xec, 0x42, 0x6e, 0xa2, 0x4b, 0x37, 0x49, 0x74, 0xe1,
	0x5f, 0x12, 0xbd, 0x72, 0x9d, 0x53, 0x85, 0xcb, 0x89, 0x46, 0xbf, 0xc2, 0xda, 0xbb, 0xa8, 0xba,
	0x4d, 0x97, 0xd9, 0xc4, 0x1c, 0x13, 0x81, 0x25, 0x50, 0x59, 0x02, 0x7d, 0xd5, 0x49, 0x0f, 0xa3,
	0xa4, 0x17, 0xc2, 0x0c, 0xbc, 0x8a, 0x6c, 0xf7, 0x8b, 0xc6, 0xea, 0xbb, 0x1c, 0x39, 0x3a, 0x02,
	0x24, 0xb0, 0x3f, 0xca, 0x20, 0xd7, 0x24, 0x72, 0x33, 0x8b, 0x3c, 0xc0, 0xfe, 0x28, 0x83, 0x5a,
	0x17, 0x19, 0x19, 0xfa, 0x0d, 0x56, 0x3d, 0xcc, 0x89, 0x2b, 0x4c, 0x09, 0x9c, 0x60, 0x56, 0x24,
	0xe6, 0x93, 0x2c, 0xe6, 0x91, 0xb4, 0x0d, 0x91, 0x93, 0xf0, 0xc5, 0x50, 0x06, 0xf2, 0x12, 0x65,
	0x0e, 0x7c, 0xda, 0x65, 0xb8, 0x0a, 0x3e, 0x55, 0x8c, 0x59, 0xf8, 0x94, 0xf7, 0x9b, 0xa0, 0x71,
	0x22, 0xf8, 0xc4, 0x1c, 0x72, 0x16, 0x78, 0xba, 0xa6, 0xca, 0x5e, 0x8a, 0x7e, 0x0a, 0x25, 0xa8,
	0x09, 0xcb, 0xbe, 0x47, 0x2c, 0x75, 0x3b, 0xb5, 0xf5, 0x65, 0x65, 0x11, 0xca, 0x42, 0xa0, 0xbe,
	0x8d, 0xd6, 0xa1, 0x22, 0x95, 0x2e, 0x1e, 0x13, 0xbd, 0x2a, 0xd5, 0xe5, 0x50, 0x70, 0x88, 0xc7,
	0x04, 0xfd, 0x1f, 0xaa, 0xd2, 0x31, 0xf3, 0x82, 0x70, 0x9f, 0x32, 0x57, 0xaf, 0x37, 0x0b, 0xed,
	0x45, 0x63, 0x59, 0x0a, 0x5f, 0x2b, 0x59, 0x88, 0x40, 0x7d, 0x53, 0x79, 0xa7, 0x37, 0x9a, 0x85,
	0x76, 0xd9, 0x28, 0x53, 0x5f, 0x3d, 0x05, 0x6d, 0x00, 0x50, 0xdf, 0xb4, 0x27, 0x2e, 0x1e, 0x53,
	0x4b, 0x47, 0x52, 0x5b, 0xa1, 0xfe, 0xae, 0x12, 0xa0, 0xbb, 0x50, 0xb6, 0x89, 0x35, 0x92, 0x25,
	0x7c, 0x4b, 0x5e, 0x5e, 0x0a, 0xbf, 0x4f, 0x38, 0xdd, 0xae, 0x82, 0xa6, 0x7a, 0xe3, 0x02, 0x3b,
	0x01, 0x99, 0x99, 0x20, 0xdb, 0x0d, 0x58, 0x11, 0x98, 0x0f, 0x89, 0x48, 0xa2, 0xda, 0x22, 0xb0,
	0x9a, 0x57, 0x4e, 0x5f, 0x78, 0xfc, 0xb7, 0xfe, 0x2e, 0x42, 0x3d, 0x5b, 0x5c, 0x68, 0x17, 0x96,
	0x2d, 0x6c, 0x9d, 0x13, 0xd3, 0x17, 0x58, 0x04, 0xbe, 0xbc, 0xa3, 0xd6, 0xfb, 0x5f, 0xe6, 0x8e,
	0x1d, 0x45, 0x78, 0x3b, 0xa1, 0xe5, 0xb1, 0x34, 0x34, 0x34, 0x6b, 0xfa, 0x81, 0x7e, 0x00, 0x2d,
	0xe2, 0x44, 0x73, 0x44, 0x26, 0x72, 0x8e, 0x69, 0xbd, 0x07, 0xf9, 0x20, 0x49, 0x65, 0x40, 0x74,
	0xe4, 0x67, 0x32, 0x41, 0x6f, 0x00, 0x71, 0xe2, 0x13, 0x7e, 0x81, 0xe5, 0x63, 0x23, 0x67, 0xd4,
	0xd0, 0x6b, 0xe7, 0xe3, 0x18, 0x53, 0xfb, 0x4e, 0xe4, 0x53, 0xe3, 0x12, 0x46, 0xe4, 0xd9, 0x43,
	0xa8, 0x59, 0xe7, 0xc4, 0x1a, 0x79, 0x8c, 0xba, 0x6a, 0xe4, 0x2c, 0xc8, 0x7c, 0x55, 0xa7, 0xd2,
	0x70, 0xe8, 0xbc, 0x86, 0x7a, 0x94, 0x6c, 0x33, 0xee, 0x60, 0x59, 0x34, 0x39, 0xc5, 0x1e, 0xd5,
	0x40, 0x5e, 0xc6, 0x8c, 0x15, 0x3b, 0xad, 0x6c, 0x7d, 0x28, 0xc0, 0xfa, 0x15, 0x07, 0xd0, 0xa3,
	0x4b, 0xc4, 0x91, 0x1d, 0x56, 0x19, 0xae, 0x38, 0x86, 0x46, 0xb4, 0xd4, 0xd8, 0x53, 0x1f, 0x8b,
	0xb9, 0x94, 0xb3, 0x13, 0xd9, 0xc5, 0x57, 0xee, 0x38, 0xcc, 0x0f, 0x38, 0x31, 0xea, 0x56, 0x46,
	0xd1, 0x3a, 0x81, 0xf5, 0x2b, 0x66, 0xc3, 0x95, 0xbc, 0x96, 0x3a, 0x91, 0xf6, 0xb5, 0xf5, 0x3c,
	0x86, 0xcd, 0x9d, 0x09, 0xe8, 0x0e, 0x94, 0xe2, 0xce, 0x2e, 0xc8, 0x6c, 0x2c, 0xb9, 0xb2, 0xab,
	0x5b, 0x7f, 0x94, 0x00, 0xa5, 0x70, 0x15, 0xbd, 0xf6, 0xa0, 0x24, 0xc7, 0xdc, 0x4d, 0x42, 0xb5,
	0x14, 0x5a, 0xf6, 0x6d, 0x64, 0x82, 0x7e, 0x79, 0x84, 0xa5, 0x1a, 0xa9, 0xf8, 0x51, 0x44, 0x7d,
	0xdb, 0x9b, 0x7d, 0x4a, 0xdf, 0x0e, 0x87, 0x8c, 0x1a, 0x62, 0x58, 0x08, 0x32, 0xf6, 0x84, 0xac,
	0xd6, 0xaa, 0xb1, 0x2c, 0x85, 0x5b, 0x4a, 0x36, 0xe5, 0xef, 0x85, 0x5c, 0xfe, 0x4e, 0xbd, 0x35,
	0xcd, 0xdf, 0x99, 0xd5, 0x60, 0x71, 0x66, 0x35, 0x78, 0x0c, 0x0b, 0x0e, 0x1b, 0xfa, 0xfa, 0x52,
	0x73, 0xbe, 0xad, 0xf5, 0xd6, 0x72, 0x90, 0x0f, 0xd8, 0xd0, 0x90, 0x36, 0xd9, 0x65, 0xa0, 0xf4,
	0xe9, 0xcb, 0x40, 0xf9, 0x9a, 0x65, 0xe0, 0xd6, 0x67, 0x2c, 0x03, 0x95, 0x2b, 0x96, 0x01, 0xf8,
	0x9c, 0x65, 0xa0, 0xf1, 0x71, 0xcb, 0xc0, 0x0b, 0xd0, 0xac, 0xc0, 0x17, 0x6c, 0x6c, 0x52, 0xf7,
	0x8c, 0x49, 0x7a, 0xd2, 0x7a, 0x77, 0x66, 0xa2, 0x75, 0x2c, 0xb7, 0x78, 0x03, 0x94, 0x6d, 0xdf,
	0x3d, 0x63, 0x61, 0x4d, 0xc8, 0xec, 0x25, 0xc4, 0xb3, 0xac, 0x6a, 0x42, 0x0a, 0x63, 0xe2, 0x59,
	0x83, 0x25, 0x4e, 0xb0, 0xcf, 0xdc, 0x88, 0xb7, 0xa2, 0xaf, 0x90, 0x90, 0x64, 0x95, 0x8b, 0x89,
	0x47, 0xe4, 0x72, 0x50, 0x31, 0xca, 0xa1, 0x60, 0x30, 0xf1, 0x08, 0xda, 0x82, 0x72, 0xc2, 0xc2,
	0x6a, 0x30, 0x3d, 0xcc, 0x5b, 0x1c, 0x66, 0xf9, 0x37, 0x39, 0x36, 0xcb, 0x8a, 0x68, 0x96, 0x15,
	0xaf, 0xa3, 0xaf, 0xd6, 0xef, 0x45, 0x58, 0xdd, 0x7b, 0x2f, 0x08, 0x77, 0xb1, 0x63, 0x10, 0x9f,
	0x05, 0xdc, 0x22, 0xf2, 0xe9, 0x9b, 0xa0, 0x91, 0x48, 0x3e, 0xed, 0x6b, 0x88, 0x45, 0x7d, 0x1b,
	0xad, 0xc2, 0x22, 0x75, 0x6d, 0xf2, 0x5e, 0x76, 0x5f, 0xd5, 0x50, 0x1f, 0xff, 0x75, 0x17, 0x65,
	0xe9, 0x6d, 0xf1, 0x93, 0xe8, 0xed, 0x23, 0x5a, 0xad, 0xf5, 0x0b, 0xd4, 0xe3, 0xb8, 0x1c, 0x31,
	0xe6, 0xc8, 0xd8, 0x3c, 0x82, 0x3a, 0x76, 0x1c, 0x66, 0x29, 0x72, 0x13, 0x6c, 0x44, 0xdc, 0x28,
	0x40, 0x2b, 0x53, 0xf9, 0x20, 0x14, 0xa3, 0xfb, 0x50, 0x09, 0x57, 0x1a, 0xdf, 0xc3, 0x16, 0x89,
	0xfe, 0x1f, 0x98, 0x0a, 0x5a, 0x1f, 0xe6, 0xe1, 0x76, 0xfe, 0xa4, 0x7e, 0x08, 0xb5, 0x21, 0x71,
	0x09, 0xc7, 0x82, 0xd8, 0x6a, 0x29, 0x52, 0x17, 0x54, 0x13, 0xa9, 0xdc, 0x8c, 0x8e, 0x01, 0x25,
	0x59, 0xe2, 0x91, 0x9b, 0xbe, 0x5e, 0x94, 0xef, 0x9a, 0xd9, 0x71, 0xf3, 0xf2, 0x6c, 0x34, 0x48,
	0x46, 0xea, 0xa3, 0x43, 0x49, 0xde, 0xf2, 0xc3, 0xf4, 0x18, 0x73, 0x54, 0xdb, 0xcc, 0x4b, 0xd0,
	0x99, 0xf5, 0x36, 0x1b, 0x1c, 0xa3, 0xce, 0xb3, 0xe1, 0x7a, 0x02, 0x0d, 0xcf, 0x09, 0x86, 0x34,
	0x9c, 0xd5, 0xf1, 0x14, 0x8e, 0x68, 0xbb, 0xae, 0x14, 0xd3, 0xe9, 0x8c, 0xde, 0x42, 0x8d, 0xba,
	0xbe, 0xc0, 0xae, 0x45, 0x4c, 0xcb, 0xc1, 0xbe, 0x2f, 0xdb, 0xa3, 0xd6, 0x7b, 0x7a, 0xa3, 0xf6,
	0xe8, 0xf4, 0xa3, 0xb3, 0x3b, 0xe1, 0x51, 0xa3, 0x4a, 0x2f, 0x7f, 0xb6, 0xba, 0x50, 0x4d, 0xe9,
	0x91, 0x06, 0xa5, 0xdd, 0xbd, 0x1f, 0xb7, 0x4e, 0x0e, 0x06, 0xf5, 0x39, 0xd4, 0x80, 0x6a, 0xff,
	0x70, 0xb0, 0x67, 0x18, 0x27, 0x47, 0x83, 0xfe, 0xf6, 0xc1, 0x5e, 0xbd, 0xb0, 0xfd, 0xed, 0xdb,
	0x67, 0x43, 0x2a, 0xce, 0x83, 0xd3, 0x8e, 0xc5, 0xc6, 0x5d, 0xe9, 0x00, 0xe3, 0xc3, 0x6e, 0xf2,
	0xeb, 0xc1, 0x90, 0xb8, 0x5d, 0xef, 0xf4, 0x9b, 0x21, 0xeb, 0xa6, 0x7f, 0xf7, 0x38, 0x5d, 0x92,
	0x53, 0xe5, 0xe9, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x79, 0x24, 0x7b, 0x45, 0x10, 0x11, 0x00,
	0x00,
}