1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
use std::time::Duration;
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use utoipa::ToSchema;
use uuid::Uuid;
use crate::suspend::TemporarySuspendError;
/// Checkpoint status returned by the `/checkpoint_status` endpoint.
#[derive(Clone, Debug, Default, Serialize, Deserialize, ToSchema)]
pub struct CheckpointStatus {
/// Most recently successful checkpoint.
pub success: Option<u64>,
/// Most recently failed checkpoint, and the associated error.
///
/// This tracks transient checkpoint failures (e.g. I/O errors during
/// writing). A subsequent successful checkpoint will not clear this
/// field — it always reflects the *last* failure that occurred.
pub failure: Option<CheckpointFailure>,
}
/// Current checkpoint activity state.
#[derive(Clone, Debug, Default, Serialize, Deserialize, ToSchema)]
#[serde(tag = "status", rename_all = "snake_case")]
pub enum CheckpointActivity {
/// No checkpoint is pending or in progress.
#[default]
Idle,
/// A checkpoint has been requested but is delayed for temporary reasons
/// (e.g. replaying, bootstrapping, transaction in progress, or input
/// endpoint barriers that require the coordinator to run steps).
Delayed {
/// Why the checkpoint cannot proceed yet.
reasons: Vec<TemporarySuspendError>,
/// When the delay started (serialized as ISO 8601).
delayed_since: DateTime<Utc>,
},
/// A checkpoint is currently being written to storage.
InProgress {
/// When the checkpoint write started (serialized as ISO 8601).
started_at: DateTime<Utc>,
},
}
/// Information about a failed checkpoint.
#[derive(Clone, Debug, Default, Serialize, Deserialize, ToSchema)]
pub struct CheckpointFailure {
/// Sequence number of the failed checkpoint.
pub sequence_number: u64,
/// Error message associated with the failure.
pub error: String,
/// When the failure occurred (serialized as ISO 8601).
pub failed_at: DateTime<Utc>,
}
/// Response to a checkpoint request.
#[derive(Clone, Debug, Default, Serialize, Deserialize, ToSchema)]
pub struct CheckpointResponse {
pub checkpoint_sequence_number: u64,
}
impl CheckpointResponse {
pub fn new(checkpoint_sequence_number: u64) -> Self {
Self {
checkpoint_sequence_number,
}
}
}
/// Response to a sync checkpoint request.
#[derive(Clone, Debug, Default, Serialize, Deserialize, ToSchema)]
pub struct CheckpointSyncResponse {
pub checkpoint_uuid: Uuid,
}
impl CheckpointSyncResponse {
pub fn new(checkpoint_uuid: Uuid) -> Self {
Self { checkpoint_uuid }
}
}
/// Checkpoint status returned by the `/checkpoint/sync_status` endpoint.
#[derive(Clone, Debug, Default, Serialize, Deserialize, ToSchema)]
pub struct CheckpointSyncStatus {
/// Most recently successful checkpoint sync.
pub success: Option<Uuid>,
/// Most recently failed checkpoint sync, and the associated error.
pub failure: Option<CheckpointSyncFailure>,
/// Most recently successful automated periodic checkpoint sync.
pub periodic: Option<Uuid>,
}
/// Information about a failed checkpoint sync.
#[derive(Clone, Debug, Default, Serialize, Deserialize, ToSchema)]
pub struct CheckpointSyncFailure {
/// UUID of the failed checkpoint.
pub uuid: Uuid,
/// Error message associated with the failure.
pub error: String,
}
/// Holds meta-data about a checkpoint that was taken for persistent storage
/// and recovery of a circuit's state.
#[derive(Debug, Clone, Default, Serialize, Deserialize, ToSchema, PartialEq, Eq)]
pub struct CheckpointMetadata {
/// A unique identifier for the given checkpoint.
///
/// This is used to identify the checkpoint in the file-system hierarchy.
pub uuid: Uuid,
/// An optional name for the checkpoint.
pub identifier: Option<String>,
/// Fingerprint of the circuit at the time of the checkpoint.
pub fingerprint: u64,
/// Total size of the checkpoint files in bytes.
pub size: Option<u64>,
/// Total number of steps made.
pub steps: Option<u64>,
/// Total number of records processed.
pub processed_records: Option<u64>,
}
/// Format of `pspine-batches-*.dat` in storage.
///
/// These files exist to be a simple format for higher-level code and outside
/// tools to parse. The spine itself writes them for that purpose, but it does
/// not read them.
#[derive(Debug, Serialize, Deserialize)]
pub struct PSpineBatches {
pub files: Vec<String>,
}
#[derive(Debug)]
pub struct CheckpointSyncMetrics {
pub duration: Duration,
pub speed: u64,
pub bytes: u64,
}