Struct PostgresConnection 

pub struct PostgresConnection { /* private fields */ }

Trait Implementations

impl DbConnection for PostgresConnection

fn get_expired_timers<'life0, 'async_trait>( &'life0 self, at: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ExpiredTimer>, DbErrorGeneric>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get currently expired delays and locks.

fn create<'life0, 'async_trait>( &'life0 self, req: CreateRequest, ) -> Pin<Box<dyn Future<Output = Result<AppendResponse, DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create a new execution log

fn get<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, ) -> Pin<Box<dyn Future<Output = Result<ExecutionLog, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get execution log.

fn append_batch<'life0, 'async_trait>( &'life0 self, current_time: DateTime<Utc>, batch: Vec<AppendRequest>, execution_id: ExecutionId, version: Version, ) -> Pin<Box<dyn Future<Output = Result<AppendBatchResponse, DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Append a batch of events to an existing execution log, and append a response to a parent execution. The batch cannot contain ExecutionRequest::Created.

fn append_batch_create_new_execution<'life0, 'async_trait>( &'life0 self, current_time: DateTime<Utc>, batch: Vec<AppendRequest>, execution_id: ExecutionId, version: Version, child_req: Vec<CreateRequest>, backtraces: Vec<BacktraceInfo>, ) -> Pin<Box<dyn Future<Output = Result<AppendBatchResponse, DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Append one or more events to the parent execution log, and create zero or more child execution logs. The batch cannot contain ExecutionRequest::Created.

fn subscribe_to_next_responses<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, last_response: ResponseCursor, timeout_fut: Pin<Box<dyn Future<Output = TimeoutOutcome> + Send>>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ResponseWithCursor>, DbErrorReadWithTimeout>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Notification mechainism with no strict guarantees for getting notified when a new response arrives. Parameter start_idx must be at most be equal to current size of responses in the execution log. If no response arrives immediately and interrupt_after resolves, DbErrorReadWithTimeout::Timeout is returned. Implementations with no pubsub support should use polling. Callers are expected to call this function in a loop with a reasonable timeout to support less stellar implementations.

fn wait_for_finished_result<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, timeout_fut: Option<Pin<Box<dyn Future<Output = TimeoutOutcome> + Send>>>, ) -> Pin<Box<dyn Future<Output = Result<SupportedFunctionReturnValue, DbErrorReadWithTimeout>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

First, attempt to fetch the finished value. If the execution is not finished yet, poll periodically or subscribe to db changes, racing with timeout_fut. Notification mechainism with no strict guarantees for getting the finished result. Implementations with no pubsub support should use polling. Callers are expected to call this function in a loop with a reasonable timeout to support less stellar implementations.

fn append_delay_response<'life0, 'async_trait>( &'life0 self, created_at: DateTime<Utc>, execution_id: ExecutionId, join_set_id: JoinSetId, delay_id: DelayId, result: Result<(), ()>, ) -> Pin<Box<dyn Future<Output = Result<AppendDelayResponseOutcome, DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn append_backtrace<'life0, 'async_trait>( &'life0 self, append: BacktraceInfo, ) -> Pin<Box<dyn Future<Output = Result<(), DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn append_backtrace_batch<'life0, 'async_trait>( &'life0 self, batch: Vec<BacktraceInfo>, ) -> Pin<Box<dyn Future<Output = Result<(), DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn append_log<'life0, 'async_trait>( &'life0 self, row: LogInfoAppendRow, ) -> Pin<Box<dyn Future<Output = Result<(), DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn append_log_batch<'life0, 'life1, 'async_trait>( &'life0 self, batch: &'life1 [LogInfoAppendRow], ) -> Pin<Box<dyn Future<Output = Result<(), DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_execution_event<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, version: &'life2 Version, ) -> Pin<Box<dyn Future<Output = Result<ExecutionEvent, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get a single event specified by version. Impls may set ExecutionEvent::backtrace_id to None.

fn get_pending_state<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, ) -> Pin<Box<dyn Future<Output = Result<ExecutionWithState, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_create_request<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, ) -> Pin<Box<dyn Future<Output = Result<CreateRequest, DbErrorRead>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

impl DbExecutor for PostgresConnection

fn lock_pending_by_ffqns<'life0, 'async_trait>( &'life0 self, batch_size: u32, pending_at_or_sooner: DateTime<Utc>, ffqns: Arc<[FunctionFqn]>, created_at: DateTime<Utc>, component_id: ComponentId, deployment_id: DeploymentId, executor_id: ExecutorId, lock_expires_at: DateTime<Utc>, run_id: RunId, retry_config: ComponentRetryConfig, ) -> Pin<Box<dyn Future<Output = Result<LockPendingResponse, DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn lock_pending_by_component_digest<'life0, 'life1, 'async_trait>( &'life0 self, batch_size: u32, pending_at_or_sooner: DateTime<Utc>, component_id: &'life1 ComponentId, deployment_id: DeploymentId, created_at: DateTime<Utc>, executor_id: ExecutorId, lock_expires_at: DateTime<Utc>, run_id: RunId, retry_config: ComponentRetryConfig, ) -> Pin<Box<dyn Future<Output = Result<LockPendingResponse, DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn append<'life0, 'async_trait>( &'life0 self, execution_id: ExecutionId, version: Version, req: AppendRequest, ) -> Pin<Box<dyn Future<Output = Result<AppendResponse, DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Append a single event to an existing execution log. The request cannot contain ExecutionRequest::Created.

fn append_batch_respond_to_parent<'life0, 'async_trait>( &'life0 self, events: AppendEventsToExecution, response: AppendResponseToExecution, current_time: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<AppendBatchResponse, DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Append a batch of events to an existing execution log, and append a response to a parent execution. The batch cannot contain ExecutionRequest::Created.

fn wait_for_pending_by_ffqn<'life0, 'async_trait>( &'life0 self, pending_at_or_sooner: DateTime<Utc>, ffqns: Arc<[FunctionFqn]>, timeout_fut: Pin<Box<dyn Future<Output = ()> + Send>>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Notification mechainism with no strict guarantees for waiting while there are no pending executions. Return immediately if there are pending notifications at pending_at_or_sooner. Otherwise wait until timeout_fut resolves. Delay requests that expire between pending_at_or_sooner and timeout can be disregarded.

fn wait_for_pending_by_component_digest<'life0, 'life1, 'async_trait>( &'life0 self, pending_at_or_sooner: DateTime<Utc>, component_digest: &'life1 ComponentDigest, timeout_fut: Pin<Box<dyn Future<Output = ()> + Send>>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Notification mechainism with no strict guarantees for waiting while there are no pending executions. Return immediately if there are pending notifications at pending_at_or_sooner. Otherwise wait until timeout_fut resolves. Delay requests that expire between pending_at_or_sooner and timeout can be disregarded.

fn get_last_execution_event<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, ) -> Pin<Box<dyn Future<Output = Result<ExecutionEvent, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get last event. Impls may set ExecutionEvent::backtrace_id to None.

fn cancel_activity_with_retries<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, cancelled_at: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<CancelOutcome, DbErrorWrite>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn cancel_activity<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, cancelled_at: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<CancelOutcome, DbErrorWrite>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

impl DbExternalApi for PostgresConnection

fn get_backtrace<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, filter: BacktraceFilter, ) -> Pin<Box<dyn Future<Output = Result<BacktraceInfo, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the latest backtrace if version is not set.

fn upsert_source_file<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, component_digest: &'life1 ComponentDigest, frame_key: &'life2 str, is_suffix: bool, content: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<(), DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Store a source file associated with a component digest. frame_key is either an exact frame symbol path or a suffix (with leading /) when is_suffix is true. Idempotent — repeated calls for the same key are ignored.

fn get_source_file<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, component_digest: &'life1 ComponentDigest, file: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Look up a source file by component digest and a frame symbol path. Matches either exact keys or suffix keys (where the frame path ends with the stored key). Returns None if not found or if multiple suffix entries match (ambiguous).

fn list_executions<'life0, 'async_trait>( &'life0 self, filter: ListExecutionsFilter, pagination: ExecutionListPagination, ) -> Pin<Box<dyn Future<Output = Result<Vec<ExecutionWithState>, DbErrorGeneric>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns executions sorted in descending order.

fn list_execution_events<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, pagination: Pagination<VersionType>, include_backtrace_id: bool, ) -> Pin<Box<dyn Future<Output = Result<ListExecutionEventsResponse, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns execution events for the given execution.

fn list_responses<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, pagination: Pagination<u32>, ) -> Pin<Box<dyn Future<Output = Result<ListResponsesResponse, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns responses of an execution ordered as they arrived, enabling matching each JoinNext to its corresponding response.

fn list_execution_events_responses<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, req_since: &'life2 Version, req_max_length: VersionType, req_include_backtrace_id: bool, resp_pagination: Pagination<u32>, ) -> Pin<Box<dyn Future<Output = Result<ExecutionWithStateRequestsResponses, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn upgrade_execution_component<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, old: &'life2 ComponentDigest, new: &'life3 ComponentDigest, ) -> Pin<Box<dyn Future<Output = Result<(), DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn list_logs<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, show_derived: bool, filter: LogFilter, pagination: Pagination<DateTime<Utc>>, ) -> Pin<Box<dyn Future<Output = Result<ListLogsResponse, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_deployment_states<'life0, 'async_trait>( &'life0 self, current_time: DateTime<Utc>, pagination: Pagination<Option<DeploymentId>>, include_config_json: bool, ) -> Pin<Box<dyn Future<Output = Result<Vec<DeploymentState>, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn insert_deployment<'life0, 'async_trait>( &'life0 self, record: DeploymentRecord, ) -> Pin<Box<dyn Future<Output = Result<(), DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Insert a new deployment. The record must have status == Inactive and last_active_at == None; activation is a separate step via Self::activate_deployment.

fn activate_deployment<'life0, 'async_trait>( &'life0 self, deployment_id: DeploymentId, now: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<(), DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn enqueue_deployment<'life0, 'async_trait>( &'life0 self, deployment_id: DeploymentId, ) -> Pin<Box<dyn Future<Output = Result<(), DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Mark a deployment as Enqueued (pending next server restart). Returns Err(DbErrorWriteNonRetriable::Conflict) if the deployment is currently Active. Any previously Enqueued deployment is demoted to Inactive.

fn get_deployment<'life0, 'async_trait>( &'life0 self, deployment_id: DeploymentId, ) -> Pin<Box<dyn Future<Output = Result<Option<DeploymentRecord>, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returned DeploymentRecord must contain config_json.

fn get_current_deployment<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<DeploymentRecord>, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Return the most relevant current deployment: Enqueued if present, otherwise Active. Returned DeploymentRecord must contain config_json.

fn list_deployments<'life0, 'async_trait>( &'life0 self, pagination: Pagination<Option<DeploymentId>>, ) -> Pin<Box<dyn Future<Output = Result<Vec<DeploymentRecord>, DbErrorRead>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn pause_execution<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, paused_at: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<AppendResponse, DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Pause an execution. Only pending executions can be paused.

fn unpause_execution<'life0, 'life1, 'async_trait>( &'life0 self, execution_id: &'life1 ExecutionId, unpaused_at: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<AppendResponse, DbErrorWrite>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Unpause an execution. Only paused executions can be unpaused.