event

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"`
	// dynamic_job_spec_uri is the location of the DynamicJobSpec proto message for this DynamicWorkflow. This is
	// required to correctly recover partially completed executions where the workflow has already been compiled.
	DynamicJobSpecUri    string   `protobuf:"bytes,3,opt,name=dynamic_job_spec_uri,json=dynamicJobSpecUri,proto3" json:"dynamic_job_spec_uri,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type DynamicWorkflowNodeMetadataValidationError struct {
	// contains filtered or unexported fields
}

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 `` /* 133-byte string literal not displayed */
	// 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:"-"`
}

type ExternalResourceInfoValidationError struct {
	// contains filtered or unexported fields
}

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"`
	// This timestamp represents the instant when the event was reported by the executing framework. For example,
	// when first processing a node the `occurred_at` timestamp should be the instant propeller makes progress, so when
	// literal inputs are initially copied. The event however will not be sent until after the copy completes.
	// Extracting both of these timestamps facilitates a more accurate portrayal of the evaluation time-series.
	ReportedAt           *timestamp.Timestamp `protobuf:"bytes,21,opt,name=reported_at,json=reportedAt,proto3" json:"reported_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

type NodeExecutionEventValidationError struct {
	// contains filtered or unexported fields
}

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

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

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

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

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

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

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

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:"-"`
}

type ParentNodeExecutionMetadataValidationError struct {
	// contains filtered or unexported fields
}

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:"-"`
}

type ParentTaskExecutionMetadataValidationError struct {
	// contains filtered or unexported fields
}

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:"-"`
}

type ResourcePoolInfoValidationError struct {
	// contains filtered or unexported fields
}

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 `` /* 128-byte string literal not displayed */
	// 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"`
	// This timestamp represents the instant when the event was reported by the executing framework. For example, a k8s
	// pod task may be marked completed at (ie. `occurred_at`) the instant the container running user code completes,
	// but this event will not be reported until the pod is marked as completed. Extracting both of these timestamps
	// facilitates a more accurate portrayal of the evaluation time-series.
	ReportedAt           *timestamp.Timestamp `protobuf:"bytes,20,opt,name=reported_at,json=reportedAt,proto3" json:"reported_at,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

type TaskExecutionEventValidationError struct {
	// contains filtered or unexported fields
}

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

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

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

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

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

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 `` /* 158-byte string literal not displayed */
	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
	XXX_unrecognized     []byte                              `json:"-"`
	XXX_sizecache        int32                               `json:"-"`
}

type TaskExecutionMetadataValidationError struct {
	// contains filtered or unexported fields
}

type TaskExecutionMetadata_InstanceClass int32

type TaskNodeMetadata struct {
	// Captures the status of caching for this execution.
	CacheStatus core.CatalogCacheStatus `` /* 133-byte string literal not displayed */
	// 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 `` /* 158-byte string literal not displayed */
	// 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:"-"`
}

type TaskNodeMetadataValidationError struct {
	// contains filtered or unexported fields
}

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:"-"`
}

type WorkflowExecutionEventValidationError struct {
	// contains filtered or unexported fields
}

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"`
}

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

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:"-"`
}

type WorkflowNodeMetadataValidationError struct {
	// contains filtered or unexported fields
}