Line data Source code
1 : use std::io;
2 :
3 : use thiserror::Error;
4 :
5 : use crate::control_plane::client::ApiLockError;
6 : use crate::control_plane::messages::{self, ControlPlaneErrorMessage, Reason};
7 : use crate::error::{ErrorKind, ReportableError, UserFacingError};
8 : use crate::proxy::retry::CouldRetry;
9 :
10 : /// A go-to error message which doesn't leak any detail.
11 : pub(crate) const REQUEST_FAILED: &str = "Console request failed";
12 :
13 : /// Common console API error.
14 : #[derive(Debug, Error)]
15 : pub(crate) enum ControlPlaneError {
16 : /// Error returned by the console itself.
17 : #[error("{REQUEST_FAILED} with {0}")]
18 : Message(Box<ControlPlaneErrorMessage>),
19 :
20 : /// Various IO errors like broken pipe or malformed payload.
21 : #[error("{REQUEST_FAILED}: {0}")]
22 : Transport(#[from] std::io::Error),
23 : }
24 :
25 : impl ControlPlaneError {
26 : /// Returns HTTP status code if it's the reason for failure.
27 0 : pub(crate) fn get_reason(&self) -> messages::Reason {
28 0 : match self {
29 0 : ControlPlaneError::Message(e) => e.get_reason(),
30 0 : ControlPlaneError::Transport(_) => messages::Reason::Unknown,
31 : }
32 0 : }
33 : }
34 :
35 : impl UserFacingError for ControlPlaneError {
36 0 : fn to_string_client(&self) -> String {
37 0 : match self {
38 : // To minimize risks, only select errors are forwarded to users.
39 0 : ControlPlaneError::Message(c) => c.get_user_facing_message(),
40 0 : ControlPlaneError::Transport(_) => REQUEST_FAILED.to_owned(),
41 : }
42 0 : }
43 : }
44 :
45 : impl ReportableError for ControlPlaneError {
46 3 : fn get_error_kind(&self) -> crate::error::ErrorKind {
47 3 : match self {
48 3 : ControlPlaneError::Message(e) => match e.get_reason() {
49 0 : Reason::RoleProtected => ErrorKind::User,
50 0 : Reason::ResourceNotFound => ErrorKind::User,
51 0 : Reason::ProjectNotFound => ErrorKind::User,
52 0 : Reason::EndpointNotFound => ErrorKind::User,
53 0 : Reason::BranchNotFound => ErrorKind::User,
54 0 : Reason::RateLimitExceeded => ErrorKind::ServiceRateLimit,
55 0 : Reason::NonDefaultBranchComputeTimeExceeded => ErrorKind::Quota,
56 0 : Reason::ActiveTimeQuotaExceeded => ErrorKind::Quota,
57 0 : Reason::ComputeTimeQuotaExceeded => ErrorKind::Quota,
58 0 : Reason::WrittenDataQuotaExceeded => ErrorKind::Quota,
59 0 : Reason::DataTransferQuotaExceeded => ErrorKind::Quota,
60 0 : Reason::LogicalSizeQuotaExceeded => ErrorKind::Quota,
61 0 : Reason::ConcurrencyLimitReached => ErrorKind::ControlPlane,
62 0 : Reason::LockAlreadyTaken => ErrorKind::ControlPlane,
63 0 : Reason::RunningOperations => ErrorKind::ControlPlane,
64 0 : Reason::ActiveEndpointsLimitExceeded => ErrorKind::ControlPlane,
65 3 : Reason::Unknown => ErrorKind::ControlPlane,
66 : },
67 0 : ControlPlaneError::Transport(_) => crate::error::ErrorKind::ControlPlane,
68 : }
69 3 : }
70 : }
71 :
72 : impl CouldRetry for ControlPlaneError {
73 6 : fn could_retry(&self) -> bool {
74 6 : match self {
75 : // retry some transport errors
76 0 : Self::Transport(io) => io.could_retry(),
77 6 : Self::Message(e) => e.could_retry(),
78 : }
79 6 : }
80 : }
81 :
82 : impl From<reqwest::Error> for ControlPlaneError {
83 0 : fn from(e: reqwest::Error) -> Self {
84 0 : io::Error::other(e).into()
85 0 : }
86 : }
87 :
88 : impl From<reqwest_middleware::Error> for ControlPlaneError {
89 0 : fn from(e: reqwest_middleware::Error) -> Self {
90 0 : io::Error::other(e).into()
91 0 : }
92 : }
93 :
94 : #[derive(Debug, Error)]
95 : pub(crate) enum GetAuthInfoError {
96 : // We shouldn't include the actual secret here.
97 : #[error("Console responded with a malformed auth secret")]
98 : BadSecret,
99 :
100 : #[error(transparent)]
101 : ApiError(ControlPlaneError),
102 : }
103 :
104 : // This allows more useful interactions than `#[from]`.
105 : impl<E: Into<ControlPlaneError>> From<E> for GetAuthInfoError {
106 0 : fn from(e: E) -> Self {
107 0 : Self::ApiError(e.into())
108 0 : }
109 : }
110 :
111 : impl UserFacingError for GetAuthInfoError {
112 0 : fn to_string_client(&self) -> String {
113 0 : match self {
114 : // We absolutely should not leak any secrets!
115 0 : Self::BadSecret => REQUEST_FAILED.to_owned(),
116 : // However, API might return a meaningful error.
117 0 : Self::ApiError(e) => e.to_string_client(),
118 : }
119 0 : }
120 : }
121 :
122 : impl ReportableError for GetAuthInfoError {
123 0 : fn get_error_kind(&self) -> crate::error::ErrorKind {
124 0 : match self {
125 0 : Self::BadSecret => crate::error::ErrorKind::ControlPlane,
126 0 : Self::ApiError(_) => crate::error::ErrorKind::ControlPlane,
127 : }
128 0 : }
129 : }
130 :
131 : #[derive(Debug, Error)]
132 : pub(crate) enum WakeComputeError {
133 : #[error("Console responded with a malformed compute address: {0}")]
134 : BadComputeAddress(Box<str>),
135 :
136 : #[error(transparent)]
137 : ControlPlane(ControlPlaneError),
138 :
139 : #[error("Too many connections attempts")]
140 : TooManyConnections,
141 :
142 : #[error("error acquiring resource permit: {0}")]
143 : TooManyConnectionAttempts(#[from] ApiLockError),
144 : }
145 :
146 : // This allows more useful interactions than `#[from]`.
147 : impl<E: Into<ControlPlaneError>> From<E> for WakeComputeError {
148 0 : fn from(e: E) -> Self {
149 0 : Self::ControlPlane(e.into())
150 0 : }
151 : }
152 :
153 : impl UserFacingError for WakeComputeError {
154 0 : fn to_string_client(&self) -> String {
155 0 : match self {
156 : // We shouldn't show user the address even if it's broken.
157 : // Besides, user is unlikely to care about this detail.
158 0 : Self::BadComputeAddress(_) => REQUEST_FAILED.to_owned(),
159 : // However, control plane might return a meaningful error.
160 0 : Self::ControlPlane(e) => e.to_string_client(),
161 :
162 0 : Self::TooManyConnections => self.to_string(),
163 :
164 : Self::TooManyConnectionAttempts(_) => {
165 0 : "Failed to acquire permit to connect to the database. Too many database connection attempts are currently ongoing.".to_owned()
166 : }
167 : }
168 0 : }
169 : }
170 :
171 : impl ReportableError for WakeComputeError {
172 3 : fn get_error_kind(&self) -> crate::error::ErrorKind {
173 3 : match self {
174 0 : Self::BadComputeAddress(_) => crate::error::ErrorKind::ControlPlane,
175 3 : Self::ControlPlane(e) => e.get_error_kind(),
176 0 : Self::TooManyConnections => crate::error::ErrorKind::RateLimit,
177 0 : Self::TooManyConnectionAttempts(e) => e.get_error_kind(),
178 : }
179 3 : }
180 : }
181 :
182 : impl CouldRetry for WakeComputeError {
183 3 : fn could_retry(&self) -> bool {
184 3 : match self {
185 0 : Self::BadComputeAddress(_) => false,
186 3 : Self::ControlPlane(e) => e.could_retry(),
187 0 : Self::TooManyConnections => false,
188 0 : Self::TooManyConnectionAttempts(_) => false,
189 : }
190 3 : }
191 : }
192 :
193 : #[derive(Debug, Error)]
194 : pub enum GetEndpointJwksError {
195 : #[error("endpoint not found")]
196 : EndpointNotFound,
197 :
198 : #[error("failed to build control plane request: {0}")]
199 : RequestBuild(#[source] reqwest::Error),
200 :
201 : #[error("failed to send control plane request: {0}")]
202 : RequestExecute(#[source] reqwest_middleware::Error),
203 :
204 : #[error(transparent)]
205 : ControlPlane(#[from] ControlPlaneError),
206 :
207 : #[cfg(any(test, feature = "testing"))]
208 : #[error(transparent)]
209 : TokioPostgres(#[from] tokio_postgres::Error),
210 :
211 : #[cfg(any(test, feature = "testing"))]
212 : #[error(transparent)]
213 : ParseUrl(#[from] url::ParseError),
214 :
215 : #[cfg(any(test, feature = "testing"))]
216 : #[error(transparent)]
217 : TaskJoin(#[from] tokio::task::JoinError),
218 : }
|
