/// The type of the parameter. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ValueType { #[prost(oneof = "value_type::Value", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9")] pub value: ::core::option::Option, } /// Nested message and enum types in `ValueType`. pub mod value_type { #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Value { /// String. #[prost(string, tag = "1")] StringValue(::prost::alloc::string::String), /// Integer. #[prost(int64, tag = "2")] IntValue(i64), /// Double Number. #[prost(double, tag = "3")] DoubleValue(f64), /// Boolean. #[prost(bool, tag = "4")] BooleanValue(bool), /// String Array. #[prost(message, tag = "5")] StringArray(super::StringParameterArray), /// Integer Array. #[prost(message, tag = "6")] IntArray(super::IntParameterArray), /// Double Number Array. #[prost(message, tag = "7")] DoubleArray(super::DoubleParameterArray), /// Boolean Array. #[prost(message, tag = "8")] BooleanArray(super::BooleanParameterArray), /// Json. #[prost(string, tag = "9")] JsonValue(::prost::alloc::string::String), } } /// This message only contains a field of string array. #[derive(Clone, PartialEq, ::prost::Message)] pub struct StringParameterArray { /// String array. #[prost(string, repeated, tag = "1")] pub string_values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// This message only contains a field of integer array. #[derive(Clone, PartialEq, ::prost::Message)] pub struct IntParameterArray { /// Integer array. #[prost(int64, repeated, tag = "1")] pub int_values: ::prost::alloc::vec::Vec, } /// This message only contains a field of double number array. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DoubleParameterArray { /// Double number array. #[prost(double, repeated, tag = "1")] pub double_values: ::prost::alloc::vec::Vec, } /// This message only contains a field of boolean array. #[derive(Clone, PartialEq, ::prost::Message)] pub struct BooleanParameterArray { /// Boolean array. #[prost(bool, repeated, tag = "1")] pub boolean_values: ::prost::alloc::vec::Vec, } /// This message is used for processing and persisting (when applicable) key /// value pair parameters for each event in the event bus. #[derive(Clone, PartialEq, ::prost::Message)] pub struct EventParameter { /// Key is used to retrieve the corresponding parameter value. This should be /// unique for a given fired event. These parameters must be predefined in the /// integration definition. #[prost(string, tag = "1")] pub key: ::prost::alloc::string::String, /// Values for the defined keys. Each value can either be string, int, double /// or any proto message. #[prost(message, optional, tag = "2")] pub value: ::core::option::Option, } /// Options for how to validate json schemas. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum JsonValidationOption { /// As per the default behavior, no validation will be run. Will not override /// any option set in a Task. Unspecified = 0, /// Do not run any validation against JSON schemas. Skip = 1, /// Validate all potential input JSON parameters against schemas specified in /// IntegrationParameter. PreExecution = 2, /// Validate all potential output JSON parameters against schemas specified in /// IntegrationParameter. PostExecution = 3, /// Perform both PRE_EXECUTION and POST_EXECUTION validations. PrePostExecution = 4, } /// Enum Product. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Product { /// Default value. Unspecified = 0, /// Integration Platform. Ip = 1, /// Apigee. Apigee = 2, /// Security Command Center. Security = 3, } /// The task configuration details. This is not the implementation of Task. /// There might be multiple TaskConfigs for the same Task. /// Next available id: 12 #[derive(Clone, PartialEq, ::prost::Message)] pub struct TaskConfig { /// Optional. The name for the task. #[prost(string, tag = "1")] pub task: ::prost::alloc::string::String, /// Required. The identifier of this task within its parent event config, /// specified by the client. This should be unique among all the tasks belong /// to the same event config. We use this field as the identifier to /// find next tasks (via field `next_tasks.task_id`). #[prost(string, tag = "2")] pub task_id: ::prost::alloc::string::String, /// Optional. The customized parameters the user can pass to this task. #[prost(map = "string, message", tag = "3")] pub parameters: ::std::collections::HashMap<::prost::alloc::string::String, EventParameter>, /// Optional. Determines the number of times the /// task will be retried on failure and with what retry strategy. /// This is applicable for asynchronous calls to Eventbus alone (Post To /// Queue, Schedule etc.). #[prost(message, optional, tag = "4")] pub failure_policy: ::core::option::Option, /// Optional. Determines the number of times the /// task will be retried on failure and with what retry strategy. /// This is applicable for synchronous calls to Eventbus alone (Post). #[prost(message, optional, tag = "5")] pub synchronous_call_failure_policy: ::core::option::Option, /// Optional. The set of tasks that are next in line to be executed as per the /// execution graph defined for the parent event, specified by /// `event_config_id`. Each of these next tasks are executed /// only if the condition associated with them evaluates to true. #[prost(message, repeated, tag = "6")] pub next_tasks: ::prost::alloc::vec::Vec, /// Optional. The policy dictating the execution of the next set of tasks for the current /// task. #[prost(enumeration = "task_config::NextTasksExecutionPolicy", tag = "7")] pub next_tasks_execution_policy: i32, /// Optional. The policy dictating the execution strategy of this task. #[prost(enumeration = "task_config::TaskExecutionStrategy", tag = "8")] pub task_execution_strategy: i32, /// Optional. User-provided label that is attached to this TaskConfig in the UI. #[prost(string, tag = "9")] pub display_name: ::prost::alloc::string::String, /// Optional. Determines what action to take upon successful task completion. #[prost(message, optional, tag = "10")] pub success_policy: ::core::option::Option, /// Optional. If set, overrides the option configured in the Task implementation class. #[prost(enumeration = "JsonValidationOption", tag = "11")] pub json_validation_option: i32, } /// Nested message and enum types in `TaskConfig`. pub mod task_config { /// Various policies for executing the next set of tasks. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum NextTasksExecutionPolicy { /// Default. Unspecified = 0, /// Execute all the tasks that satisfy their associated condition. RunAllMatch = 1, /// Execute the first task that satisfies the associated condition. RunFirstMatch = 2, } /// Various policies to trigger the execution of this task. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum TaskExecutionStrategy { /// Default. If the strategy is not set explicitly, it will default to /// `WHEN_ALL_SUCCEED`. Unspecified = 0, /// Wait until all of its previous tasks finished execution, then verify at /// least one of the edge conditions is met, and execute if possible. This /// should be considered as WHEN_ALL_TASKS_SUCCEED. WhenAllSucceed = 1, /// Start execution as long as any of its previous tasks finished execution /// and the corresponding edge condition is met (since we will execute if /// only that succeeding edge condition is met). WhenAnySucceed = 2, /// Wait until all of its previous tasks finished execution, then verify /// the all edge conditions are met and execute if possible. WhenAllTasksAndConditionsSucceed = 3, } } /// Policy that dictates the behavior for the task after it completes /// successfully. #[derive(Clone, PartialEq, ::prost::Message)] pub struct SuccessPolicy { /// State to which the execution snapshot status will be set if the task /// succeeds. #[prost(enumeration = "success_policy::FinalState", tag = "1")] pub final_state: i32, } /// Nested message and enum types in `SuccessPolicy`. pub mod success_policy { /// The state of execution. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum FinalState { /// UNSPECIFIED. Unspecified = 0, /// The default behavior, where successful tasks will be marked as SUCCEEDED. Succeeded = 1, /// Sets the state to SUSPENDED after executing. This is required for /// SuspensionTask; event execution will continue once the user calls /// ResolveSuspensions with the event_execution_info_id and the task number. Suspended = 2, } } /// Policy that defines the task retry logic and failure type. If no /// FailurePolicy is defined for a task, all its dependent tasks will not be /// executed (i.e, a `retry_strategy` of NONE will be applied). #[derive(Clone, PartialEq, ::prost::Message)] pub struct FailurePolicy { /// Defines what happens to the task upon failure. #[prost(enumeration = "failure_policy::RetryStrategy", tag = "1")] pub retry_strategy: i32, /// Required if retry_strategy is FIXED_INTERVAL or /// LINEAR/EXPONENTIAL_BACKOFF/RESTART_INTEGRATION_WITH_BACKOFF. Defines the /// number of times the task will be retried if failed. #[prost(int32, tag = "2")] pub max_retries: i32, /// Required if retry_strategy is FIXED_INTERVAL or /// LINEAR/EXPONENTIAL_BACKOFF/RESTART_INTEGRATION_WITH_BACKOFF. Defines the /// initial interval in seconds for backoff. #[prost(message, optional, tag = "3")] pub interval_time: ::core::option::Option<::prost_types::Timestamp>, } /// Nested message and enum types in `FailurePolicy`. pub mod failure_policy { /// The behavior when the taks failed. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum RetryStrategy { /// UNSPECIFIED. Unspecified = 0, /// Ignores the failure of this task. The rest of the integration will be /// executed Assuming this task succeeded. Ignore = 1, /// Causes a permanent failure of the task. However, if the last task(s) /// of event was successfully completed despite the failure of this task, /// it has no impact on the integration. None = 2, /// Causes a permanent failure of the event. It is different from NONE /// because this will mark the event as FAILED by shutting down the /// event execution. Fatal = 3, /// The task will be retried from the failed task onwards after a fixed /// delay. A max-retry count is required to be specified with this /// strategy. A jitter is added to each exponential interval so that /// concurrently failing tasks of the same type do not end up retrying /// after the exact same exponential interval. max_retries and /// interval_in_seconds must be specified. FixedInterval = 4, /// The task will be retried from the failed task onwards after a fixed /// delay that linearly increases with each retry attempt. A jitter is /// added to each exponential interval so that concurrently failing tasks /// of the same type do not end up retrying after the exact same /// exponential interval. A max-retry count is required to be specified /// with this strategy. max_retries and interval_in_seconds must be /// specified. LinearBackoff = 5, /// The task will be retried after an exponentially increasing period of /// time with each failure. A jitter is added to each exponential interval /// so that concurrently failing tasks of the same type do not end up /// retrying after the exact same exponential interval. A max-retry count /// is required to be specified with this strategy. `max_retries` and /// `interval_in_seconds` must be specified. ExponentialBackoff = 6, /// The entire integration will be restarted with the initial parameters that /// were set when the event was fired. A max-retry count is required to be /// specified with this strategy. `max_retries` and `interval_in_seconds` /// must be specified. RestartIntegrationWithBackoff = 7, } } /// The task that is next in line to be executed, if the /// condition specified evaluated to true. #[derive(Clone, PartialEq, ::prost::Message)] pub struct NextTask { /// ID of the next task. #[prost(string, tag = "1")] pub task_config_id: ::prost::alloc::string::String, /// Task number of the next task. #[prost(string, tag = "2")] pub task_id: ::prost::alloc::string::String, /// Standard filter expression for this task to become an eligible next task. #[prost(string, tag = "3")] pub condition: ::prost::alloc::string::String, /// User-provided label that is attached to this edge in the UI. #[prost(string, tag = "4")] pub display_name: ::prost::alloc::string::String, } /// Log entry to log execution info for the monitored resource /// `integrations.googleapis.com/IntegrationVersion`. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ExecutionInfo { /// Auto-generated primary key. #[prost(string, tag = "1")] pub event_execution_info_id: ::prost::alloc::string::String, /// Name of the integration. #[prost(string, tag = "2")] pub integration: ::prost::alloc::string::String, /// Pointer to the active version it is executing. #[prost(string, tag = "3")] pub integration_version: ::prost::alloc::string::String, /// The event data user sends as request. #[prost(string, tag = "4")] pub project_id: ::prost::alloc::string::String, /// The trigger id of the integration trigger config. If both trigger_id /// and client_id is present, the integration is executed from the start tasks /// provided by the matching trigger config otherwise it is executed from the /// default start tasks. #[prost(string, tag = "5")] pub trigger_id: ::prost::alloc::string::String, /// Event parameters come in as part of the request. #[prost(map = "string, message", tag = "6")] pub request_params: ::std::collections::HashMap<::prost::alloc::string::String, EventParameter>, /// Event parameters come out as part of the response. #[prost(map = "string, message", tag = "7")] pub response_params: ::std::collections::HashMap<::prost::alloc::string::String, EventParameter>, /// The ways user posts this event. #[prost(enumeration = "execution_info::PostMethod", tag = "8")] pub post_method: i32, /// The execution info about this event. #[prost(message, optional, tag = "9")] pub event_execution_details: ::core::option::Option, /// Errors, warnings, and informationals associated with the workflow/task. /// The order in which the errors were added by the workflow/task is /// maintained. #[prost(message, repeated, tag = "10")] pub errors: ::prost::alloc::vec::Vec, /// Which Google product the execution_info belongs to. If not set, the /// execution_info belongs to Integration Platform by default. #[prost(enumeration = "Product", tag = "11")] pub product: i32, /// This is used to de-dup incoming request. #[prost(string, tag = "12")] pub request_id: ::prost::alloc::string::String, /// The configuration details for a task. #[prost(message, repeated, tag = "13")] pub task_configs: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `ExecutionInfo`. pub mod execution_info { /// PostMethod Enum #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum PostMethod { /// Default value. Unspecified = 0, /// Sync post. Post = 1, /// Async post with schedule time. Schedule = 2, } } /// Contains the details of the execution info of this event: this includes /// the tasks execution details plus the event execution statistics. #[derive(Clone, PartialEq, ::prost::Message)] pub struct EventExecutionDetails { /// The execution state of this event. #[prost(enumeration = "event_execution_details::EventExecutionState", tag = "1")] pub event_execution_state: i32, /// After snapshot migration, this field will no longer be populated, but old /// execution snapshots will still be accessible. #[prost(message, repeated, tag = "2")] pub event_execution_snapshot: ::prost::alloc::vec::Vec, /// Status for the current event execution attempt. #[prost(message, repeated, tag = "3")] pub event_attempt_stats: ::prost::alloc::vec::Vec, /// Next scheduled execution time in case the execution status was /// RETRY_ON_HOLD. #[prost(message, optional, tag = "4")] pub next_execution_time: ::core::option::Option<::prost_types::Timestamp>, /// Indicates the number of times the execution has restarted from the /// beginning. #[prost(int32, tag = "5")] pub event_retries_count: i32, } /// Nested message and enum types in `EventExecutionDetails`. pub mod event_execution_details { /// Enum EventExecutionState. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum EventExecutionState { /// Default value. Unspecified = 0, /// Event is received and waiting for the execution. This happens when /// firing the event via "postToQueue" or "schedule". OnHold = 1, /// Event is under processing. InProcess = 2, /// Event execution successfully finished. There's no more change after /// this state. Succeeded = 3, /// Event execution failed. There's no more change after this state. Failed = 4, /// Event execution canceled by user. There's no more change after this /// state. Cancelled = 5, /// Event execution failed and waiting for retry. RetryOnHold = 6, /// Event execution suspended and waiting for manual intervention. Suspended = 7, } } /// Contains the snapshot of the event execution for a given checkpoint. #[derive(Clone, PartialEq, ::prost::Message)] pub struct EventExecutionSnapshot { /// Indicates "right after which checkpoint task's execution" this snapshot /// is taken. #[prost(string, tag = "1")] pub checkpoint_task_number: ::prost::alloc::string::String, /// Indicates when this snapshot is taken. #[prost(message, optional, tag = "2")] pub snapshot_time: ::core::option::Option<::prost_types::Timestamp>, /// Snapshot metadata. #[prost(message, optional, tag = "3")] pub event_execution_snapshot_metadata: ::core::option::Option, /// All of the task execution details at the given point of time. #[prost(message, repeated, tag = "4")] pub task_execution_details: ::prost::alloc::vec::Vec, /// All of the computed conditions that been calculated. #[prost(message, repeated, tag = "5")] pub condition_results: ::prost::alloc::vec::Vec, /// The parameters in Event object. #[prost(map = "string, message", tag = "6")] pub event_params: ::std::collections::HashMap<::prost::alloc::string::String, EventParameter>, /// The parameters in Event object that differs from last snapshot. #[prost(map = "string, message", tag = "7")] pub diff_params: ::std::collections::HashMap<::prost::alloc::string::String, EventParameter>, } /// Nested message and enum types in `EventExecutionSnapshot`. pub mod event_execution_snapshot { /// Metadata for the event/task retry. #[derive(Clone, PartialEq, ::prost::Message)] pub struct EventExecutionSnapshotMetadata { /// The task number associated with this snapshot. Could be empty. #[prost(string, tag = "1")] pub task_number: ::prost::alloc::string::String, /// the task name associated with this snapshot. Could be empty. #[prost(string, tag = "2")] pub task: ::prost::alloc::string::String, /// the event attempt number this snapshot belongs to. #[prost(int32, tag = "3")] pub event_attempt_num: i32, /// the task attempt number this snapshot belongs to. Could be empty. #[prost(int32, tag = "4")] pub task_attempt_num: i32, } } /// Contains the details of the execution of this task. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TaskExecutionDetails { /// Pointer to the task config it used for execution. #[prost(string, tag = "1")] pub task_number: ::prost::alloc::string::String, /// The execution state of this task. #[prost(enumeration = "task_execution_details::TaskExecutionState", tag = "2")] pub task_execution_state: i32, /// Status for the current task execution attempt. #[prost(message, repeated, tag = "3")] pub task_attempt_stats: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `TaskExecutionDetails`. pub mod task_execution_details { /// Enum TaskExecutionState. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum TaskExecutionState { /// Default value. Unspecified = 0, /// Task is waiting for its precondition tasks to finish to start the /// execution. PendingExecution = 1, /// Task is under processing. InProcess = 2, /// Task execution successfully finished. There's no more change after /// this state. Succeed = 3, /// Task execution failed. There's no more change after this state. Failed = 4, /// Task execution failed and cause the whole event execution to fail /// immediately. There's no more change after this state. Fatal = 5, /// Task execution failed and waiting for retry. RetryOnHold = 6, /// Task execution skipped. This happens when its precondition wasn't met, /// or the event execution been canceled before reach to the task. /// There's no more changes after this state. Skipped = 7, /// Task execution canceled when in progress. This happens when event /// execution been canceled or any other task fall in fatal state. Cancelled = 8, /// Task is waiting for its dependency tasks' rollback to finish to start /// its rollback. PendingRollback = 9, /// Task is rolling back. RollbackInProcess = 10, /// Task is rolled back. This is the state we will set regardless of /// rollback succeeding or failing. Rolledback = 11, /// Task is a SuspensionTask which has executed once, creating a pending /// suspension. Suspended = 12, } } /// Status for the execution attempt. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AttemptStats { /// The start time of the event execution for current attempt. This could be /// in the future if it's been scheduled. #[prost(message, optional, tag = "1")] pub start_time: ::core::option::Option<::prost_types::Timestamp>, /// The end time of the event execution for current attempt. #[prost(message, optional, tag = "2")] pub end_time: ::core::option::Option<::prost_types::Timestamp>, } /// An error, warning, or information message associated with an integration. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ErrorDetail { /// The full text of the error message, including any parameters that were /// thrown along with the exception. #[prost(string, tag = "1")] pub error_message: ::prost::alloc::string::String, /// The task try-number, in which, the error occurred. If zero, the error /// happened at the event level. #[prost(int32, tag = "2")] pub task_number: i32, } /// Contains the combined condition calculation results. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ConditionResult { /// the current task number. #[prost(string, tag = "1")] pub current_task_number: ::prost::alloc::string::String, /// the next task number. #[prost(string, tag = "2")] pub next_task_number: ::prost::alloc::string::String, /// the result comes out after evaluate the combined condition. True if there's /// no combined condition specified. #[prost(bool, tag = "3")] pub result: bool, }