// @generated #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct WorkflowExecutionEvent { /// Workflow execution id #[prost(message, optional, tag="1")] pub execution_id: ::core::option::Option, /// the id of the originator (Propeller) of the event #[prost(string, tag="2")] pub producer_id: ::prost::alloc::string::String, #[prost(enumeration="super::core::workflow_execution::Phase", tag="3")] pub phase: i32, /// This timestamp represents when the original event occurred, it is generated /// by the executor of the workflow. #[prost(message, optional, tag="4")] pub occurred_at: ::core::option::Option<::prost_types::Timestamp>, #[prost(oneof="workflow_execution_event::OutputResult", tags="5, 6, 7")] pub output_result: ::core::option::Option, } /// Nested message and enum types in `WorkflowExecutionEvent`. pub mod workflow_execution_event { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum OutputResult { /// URL to the output of the execution, it encodes all the information /// including Cloud source provider. ie., s3://... #[prost(string, tag="5")] OutputUri(::prost::alloc::string::String), /// Error information for the execution #[prost(message, tag="6")] Error(super::super::core::ExecutionError), /// Raw output data produced by this workflow execution. #[prost(message, tag="7")] OutputData(super::super::core::LiteralMap), } } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct NodeExecutionEvent { /// Unique identifier for this node execution #[prost(message, optional, tag="1")] pub id: ::core::option::Option, /// the id of the originator (Propeller) of the event #[prost(string, tag="2")] pub producer_id: ::prost::alloc::string::String, #[prost(enumeration="super::core::node_execution::Phase", tag="3")] pub phase: i32, /// This timestamp represents when the original event occurred, it is generated /// by the executor of the node. #[prost(message, optional, tag="4")] pub occurred_at: ::core::option::Option<::prost_types::Timestamp>, /// \[To be deprecated\] Specifies which task (if any) launched this node. #[prost(message, optional, tag="9")] pub parent_task_metadata: ::core::option::Option, /// Specifies the parent node of the current node execution. Node executions at level zero will not have a parent node. #[prost(message, optional, tag="10")] pub parent_node_metadata: ::core::option::Option, /// Retry group to indicate grouping of nodes by retries #[prost(string, tag="11")] pub retry_group: ::prost::alloc::string::String, /// Identifier of the node in the original workflow/graph /// This maps to value of WorkflowTemplate.nodes\[X\].id #[prost(string, tag="12")] pub spec_node_id: ::prost::alloc::string::String, /// Friendly readable name for the node #[prost(string, tag="13")] pub node_name: ::prost::alloc::string::String, #[prost(int32, tag="16")] pub event_version: i32, /// Whether this node launched a subworkflow. #[prost(bool, tag="17")] pub is_parent: bool, /// Whether this node yielded a dynamic workflow. #[prost(bool, tag="18")] pub is_dynamic: bool, /// 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) #[prost(string, tag="19")] pub deck_uri: ::prost::alloc::string::String, /// 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. #[prost(message, optional, tag="21")] pub reported_at: ::core::option::Option<::prost_types::Timestamp>, /// Indicates if this node is an ArrayNode. #[prost(bool, tag="22")] pub is_array: bool, #[prost(oneof="node_execution_event::InputValue", tags="5, 20")] pub input_value: ::core::option::Option, #[prost(oneof="node_execution_event::OutputResult", tags="6, 7, 15")] pub output_result: ::core::option::Option, /// Additional metadata to do with this event's node target based /// on the node type #[prost(oneof="node_execution_event::TargetMetadata", tags="8, 14")] pub target_metadata: ::core::option::Option, } /// Nested message and enum types in `NodeExecutionEvent`. pub mod node_execution_event { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum InputValue { #[prost(string, tag="5")] InputUri(::prost::alloc::string::String), /// Raw input data consumed by this node execution. #[prost(message, tag="20")] InputData(super::super::core::LiteralMap), } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum OutputResult { /// URL to the output of the execution, it encodes all the information /// including Cloud source provider. ie., s3://... #[prost(string, tag="6")] OutputUri(::prost::alloc::string::String), /// Error information for the execution #[prost(message, tag="7")] Error(super::super::core::ExecutionError), /// Raw output data produced by this node execution. #[prost(message, tag="15")] OutputData(super::super::core::LiteralMap), } /// Additional metadata to do with this event's node target based /// on the node type #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum TargetMetadata { #[prost(message, tag="8")] WorkflowNodeMetadata(super::WorkflowNodeMetadata), #[prost(message, tag="14")] TaskNodeMetadata(super::TaskNodeMetadata), } } /// For Workflow Nodes we need to send information about the workflow that's launched #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct WorkflowNodeMetadata { #[prost(message, optional, tag="1")] pub execution_id: ::core::option::Option, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct TaskNodeMetadata { /// Captures the status of caching for this execution. #[prost(enumeration="super::core::CatalogCacheStatus", tag="1")] pub cache_status: i32, /// This structure carries the catalog artifact information #[prost(message, optional, tag="2")] pub catalog_key: ::core::option::Option, /// Captures the status of cache reservations for this execution. #[prost(enumeration="super::core::catalog_reservation::Status", tag="3")] pub reservation_status: i32, /// The latest checkpoint location #[prost(string, tag="4")] pub checkpoint_uri: ::prost::alloc::string::String, /// In the case this task launched a dynamic workflow we capture its structure here. #[prost(message, optional, tag="16")] pub dynamic_workflow: ::core::option::Option, } /// For dynamic workflow nodes we send information about the dynamic workflow definition that gets generated. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct DynamicWorkflowNodeMetadata { /// id represents the unique identifier of the workflow. #[prost(message, optional, tag="1")] pub id: ::core::option::Option, /// Represents the compiled representation of the embedded dynamic workflow. #[prost(message, optional, tag="2")] pub compiled_workflow: ::core::option::Option, /// 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. #[prost(string, tag="3")] pub dynamic_job_spec_uri: ::prost::alloc::string::String, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ParentTaskExecutionMetadata { #[prost(message, optional, tag="1")] pub id: ::core::option::Option, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ParentNodeExecutionMetadata { /// Unique identifier of the parent node id within the execution /// This is value of core.NodeExecutionIdentifier.node_id of the parent node #[prost(string, tag="1")] pub node_id: ::prost::alloc::string::String, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct EventReason { /// An explanation for this event #[prost(string, tag="1")] pub reason: ::prost::alloc::string::String, /// The time this reason occurred #[prost(message, optional, tag="2")] pub occurred_at: ::core::option::Option<::prost_types::Timestamp>, } /// Plugin specific execution event information. For tasks like Python, Hive, Spark, DynamicJob. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct TaskExecutionEvent { /// ID of the task. In combination with the retryAttempt this will indicate /// the task execution uniquely for a given parent node execution. #[prost(message, optional, tag="1")] pub task_id: ::core::option::Option, /// 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 #[prost(message, optional, tag="2")] pub parent_node_execution_id: ::core::option::Option, /// retry attempt number for this task, ie., 2 for the second attempt #[prost(uint32, tag="3")] pub retry_attempt: u32, /// Phase associated with the event #[prost(enumeration="super::core::task_execution::Phase", tag="4")] pub phase: i32, /// id of the process that sent this event, mainly for trace debugging #[prost(string, tag="5")] pub producer_id: ::prost::alloc::string::String, /// log information for the task execution #[prost(message, repeated, tag="6")] pub logs: ::prost::alloc::vec::Vec, /// This timestamp represents when the original event occurred, it is generated /// by the executor of the task. #[prost(message, optional, tag="7")] pub occurred_at: ::core::option::Option<::prost_types::Timestamp>, /// Custom data that the task plugin sends back. This is extensible to allow various plugins in the system. #[prost(message, optional, tag="11")] pub custom_info: ::core::option::Option<::prost_types::Struct>, /// 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. #[prost(uint32, tag="12")] pub phase_version: u32, /// An optional explanation for the phase transition. /// Deprecated: Use reasons instead. #[deprecated] #[prost(string, tag="13")] pub reason: ::prost::alloc::string::String, /// An optional list of explanations for the phase transition. #[prost(message, repeated, tag="21")] pub reasons: ::prost::alloc::vec::Vec, /// 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. #[prost(string, tag="14")] pub task_type: ::prost::alloc::string::String, /// Metadata around how a task was executed. #[prost(message, optional, tag="16")] pub metadata: ::core::option::Option, /// 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. #[prost(int32, tag="18")] pub event_version: i32, /// 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. #[prost(message, optional, tag="20")] pub reported_at: ::core::option::Option<::prost_types::Timestamp>, #[prost(oneof="task_execution_event::InputValue", tags="8, 19")] pub input_value: ::core::option::Option, #[prost(oneof="task_execution_event::OutputResult", tags="9, 10, 17")] pub output_result: ::core::option::Option, } /// Nested message and enum types in `TaskExecutionEvent`. pub mod task_execution_event { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum InputValue { /// URI of the input file, it encodes all the information /// including Cloud source provider. ie., s3://... #[prost(string, tag="8")] InputUri(::prost::alloc::string::String), /// Raw input data consumed by this task execution. #[prost(message, tag="19")] InputData(super::super::core::LiteralMap), } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum OutputResult { /// URI to the output of the execution, it will be in a format that encodes all the information /// including Cloud source provider. ie., s3://... #[prost(string, tag="9")] OutputUri(::prost::alloc::string::String), /// Error information for the execution #[prost(message, tag="10")] Error(super::super::core::ExecutionError), /// Raw output data produced by this task execution. #[prost(message, tag="17")] OutputData(super::super::core::LiteralMap), } } /// This message contains metadata about external resources produced or used by a specific task execution. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ExternalResourceInfo { /// Identifier for an external resource created by this task execution, for example Qubole query ID or presto query ids. #[prost(string, tag="1")] pub external_id: ::prost::alloc::string::String, /// 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. #[prost(uint32, tag="2")] pub index: u32, /// Retry attempt number for this external resource, ie., 2 for the second attempt #[prost(uint32, tag="3")] pub retry_attempt: u32, /// Phase associated with the external resource #[prost(enumeration="super::core::task_execution::Phase", tag="4")] pub phase: i32, /// Captures the status of caching for this external resource execution. #[prost(enumeration="super::core::CatalogCacheStatus", tag="5")] pub cache_status: i32, /// log information for the external resource execution #[prost(message, repeated, tag="6")] pub logs: ::prost::alloc::vec::Vec, } /// This message holds task execution metadata specific to resource allocation used to manage concurrent /// executions for a project namespace. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ResourcePoolInfo { /// Unique resource ID used to identify this execution when allocating a token. #[prost(string, tag="1")] pub allocation_token: ::prost::alloc::string::String, /// Namespace under which this task execution requested an allocation token. #[prost(string, tag="2")] pub namespace: ::prost::alloc::string::String, } /// 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. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct TaskExecutionMetadata { /// Unique, generated name for this task execution used by the backend. #[prost(string, tag="1")] pub generated_name: ::prost::alloc::string::String, /// Additional data on external resources on other back-ends or platforms (e.g. Hive, Qubole, etc) launched by this task execution. #[prost(message, repeated, tag="2")] pub external_resources: ::prost::alloc::vec::Vec, /// 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. #[prost(message, repeated, tag="3")] pub resource_pool_info: ::prost::alloc::vec::Vec, /// The identifier of the plugin used to execute this task. #[prost(string, tag="4")] pub plugin_identifier: ::prost::alloc::string::String, #[prost(enumeration="task_execution_metadata::InstanceClass", tag="16")] pub instance_class: i32, } /// Nested message and enum types in `TaskExecutionMetadata`. pub mod task_execution_metadata { /// Includes the broad category of machine used for this specific task execution. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum InstanceClass { /// The default instance class configured for the flyte application platform. Default = 0, /// The instance class configured for interruptible tasks. Interruptible = 1, } impl InstanceClass { /// String value of the enum field names used in the ProtoBuf definition. /// /// The values are not transformed in any way and thus are considered stable /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { InstanceClass::Default => "DEFAULT", InstanceClass::Interruptible => "INTERRUPTIBLE", } } /// Creates an enum from field names used in the ProtoBuf definition. pub fn from_str_name(value: &str) -> ::core::option::Option { match value { "DEFAULT" => Some(Self::Default), "INTERRUPTIBLE" => Some(Self::Interruptible), _ => None, } } } } /// This is the cloud event parallel to the raw WorkflowExecutionEvent message. It's filled in with additional /// information that downstream consumers may find useful. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CloudEventWorkflowExecution { #[prost(message, optional, tag="1")] pub raw_event: ::core::option::Option, #[prost(message, optional, tag="2")] pub output_interface: ::core::option::Option, /// The following are ExecutionMetadata fields /// We can't have the ExecutionMetadata object directly because of import cycle #[prost(message, repeated, tag="3")] pub artifact_ids: ::prost::alloc::vec::Vec, #[prost(message, optional, tag="4")] pub reference_execution: ::core::option::Option, #[prost(string, tag="5")] pub principal: ::prost::alloc::string::String, /// The ID of the LP that generated the execution that generated the Artifact. /// Here for provenance information. /// Launch plan IDs are easier to get than workflow IDs so we'll use these for now. #[prost(message, optional, tag="6")] pub launch_plan_id: ::core::option::Option, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CloudEventNodeExecution { #[prost(message, optional, tag="1")] pub raw_event: ::core::option::Option, /// The relevant task execution if applicable #[prost(message, optional, tag="2")] pub task_exec_id: ::core::option::Option, /// The typed interface for the task that produced the event. #[prost(message, optional, tag="3")] pub output_interface: ::core::option::Option, /// The following are ExecutionMetadata fields /// We can't have the ExecutionMetadata object directly because of import cycle #[prost(message, repeated, tag="4")] pub artifact_ids: ::prost::alloc::vec::Vec, #[prost(string, tag="5")] pub principal: ::prost::alloc::string::String, /// The ID of the LP that generated the execution that generated the Artifact. /// Here for provenance information. /// Launch plan IDs are easier to get than workflow IDs so we'll use these for now. #[prost(message, optional, tag="6")] pub launch_plan_id: ::core::option::Option, } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CloudEventTaskExecution { #[prost(message, optional, tag="1")] pub raw_event: ::core::option::Option, } /// This event is to be sent by Admin after it creates an execution. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CloudEventExecutionStart { /// The execution created. #[prost(message, optional, tag="1")] pub execution_id: ::core::option::Option, /// The launch plan used. #[prost(message, optional, tag="2")] pub launch_plan_id: ::core::option::Option, #[prost(message, optional, tag="3")] pub workflow_id: ::core::option::Option, /// Artifact inputs to the workflow execution for which we have the full Artifact ID. These are likely the result of artifact queries that are run. #[prost(message, repeated, tag="4")] pub artifact_ids: ::prost::alloc::vec::Vec, /// Artifact inputs to the workflow execution for which we only have the tracking bit that's installed into the Literal's metadata by the Artifact service. #[prost(string, repeated, tag="5")] pub artifact_trackers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, #[prost(string, tag="6")] pub principal: ::prost::alloc::string::String, } // @@protoc_insertion_point(module)