Merge #314

314: Add error codes to Hrana errors r=MarinPostma a=honzasp

Error codes are short machine-readable error descriptions.

Co-authored-by: Jan Špaček <[email protected]>

Author: bors[bot]

Cargo.lock

@@ -178,13 +178,14 @@ other hand, the client should always receive messages, to avoid deadlock.
 ```typescript
 type Error = {
     "message": string,
+    "code"?: string | null,
 }
 ```
 
 When a server refuses to accept a client `hello` or fails to process a
 `request`, it responds with a message that describes the error. The `message`
-field contains an English human-readable description of the error. The protocol
-will be extended with machine-readable error codes in the future.
+field contains an English human-readable description of the error. The `code`
+contains a machine-readable error code.
 
 If either peer detects that the protocol has been violated, it should close the
 WebSocket with an appropriate WebSocket close code and reason. Some examples of

docs/HRANA_SPEC.md

@@ -174,6 +174,24 @@ pub fn parse_jwt_key(data: &str) -> Result<jsonwebtoken::DecodingKey> {
     }
 }
 
+impl AuthError {
+    pub fn code(&self) -> &'static str {
+        match self {
+            Self::HttpAuthHeaderMissing => "AUTH_HTTP_HEADER_MISSING",
+            Self::HttpAuthHeaderInvalid => "AUTH_HTTP_HEADER_INVALID",
+            Self::HttpAuthHeaderUnsupportedScheme => "AUTH_HTTP_HEADER_UNSUPPORTED_SCHEME",
+            Self::BasicNotAllowed => "AUTH_BASIC_NOT_ALLOWED",
+            Self::BasicRejected => "AUTH_BASIC_REJECTED",
+            Self::JwtMissing => "AUTH_JWT_MISSING",
+            Self::JwtNotAllowed => "AUTH_JWT_NOT_ALLOWED",
+            Self::JwtInvalid => "AUTH_JWT_INVALID",
+            Self::JwtExpired => "AUTH_JWT_EXPIRED",
+            Self::JwtImmature => "AUTH_JWT_IMMATURE",
+            Self::Other => "AUTH_FAILED",
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

sqld/src/auth.rs

@@ -91,3 +91,11 @@ fn eval_cond(ctx: &Ctx, cond: &proto::BatchCond) -> Result<bool> {
             .try_fold(false, |x, cond| eval_cond(ctx, cond).map(|y| x | y))?,
     })
 }
+
+impl BatchError {
+    pub fn code(&self) -> &'static str {
+        match self {
+            Self::CondBadStep => "BATCH_COND_BAD_STEP",
+        }
+    }
+}

sqld/src/batch/mod.rs

@@ -153,6 +153,53 @@ fn stmt_error_from_sqld_error(sqld_error: SqldError) -> Result<StmtError, SqldEr
 pub fn proto_error_from_stmt_error(error: &StmtError) -> hrana::proto::Error {
     hrana::proto::Error {
         message: error.to_string(),
+        code: error.code().into(),
+    }
+}
+
+impl StmtError {
+    pub fn code(&self) -> &'static str {
+        match self {
+            Self::SqlParse { .. } => "SQL_PARSE_ERROR",
+            Self::SqlNoStmt => "SQL_NO_STATEMENT",
+            Self::SqlManyStmts => "SQL_MANY_STATEMENTS",
+            Self::ArgsInvalid { .. } => "ARGS_INVALID",
+            Self::ArgsBothPositionalAndNamed => "ARGS_BOTH_POSITIONAL_AND_NAMED",
+            Self::TransactionTimeout => "TRANSACTION_TIMEOUT",
+            Self::TransactionBusy => "TRANSACTION_BUSY",
+            Self::SqliteError { source, .. } => sqlite_error_code(source.code),
+            Self::SqlInputError { .. } => "SQL_INPUT_ERROR",
+        }
+    }
+}
+
+fn sqlite_error_code(code: rusqlite::ffi::ErrorCode) -> &'static str {
+    match code {
+        rusqlite::ErrorCode::InternalMalfunction => "SQLITE_INTERNAL",
+        rusqlite::ErrorCode::PermissionDenied => "SQLITE_PERM",
+        rusqlite::ErrorCode::OperationAborted => "SQLITE_ABORT",
+        rusqlite::ErrorCode::DatabaseBusy => "SQLITE_BUSY",
+        rusqlite::ErrorCode::DatabaseLocked => "SQLITE_LOCKED",
+        rusqlite::ErrorCode::OutOfMemory => "SQLITE_NOMEM",
+        rusqlite::ErrorCode::ReadOnly => "SQLITE_READONLY",
+        rusqlite::ErrorCode::OperationInterrupted => "SQLITE_INTERRUPT",
+        rusqlite::ErrorCode::SystemIoFailure => "SQLITE_IOERR",
+        rusqlite::ErrorCode::DatabaseCorrupt => "SQLITE_CORRUPT",
+        rusqlite::ErrorCode::NotFound => "SQLITE_NOTFOUND",
+        rusqlite::ErrorCode::DiskFull => "SQLITE_FULL",
+        rusqlite::ErrorCode::CannotOpen => "SQLITE_CANTOPEN",
+        rusqlite::ErrorCode::FileLockingProtocolFailed => "SQLITE_PROTOCOL",
+        rusqlite::ErrorCode::SchemaChanged => "SQLITE_SCHEMA",
+        rusqlite::ErrorCode::TooBig => "SQLITE_TOOBIG",
+        rusqlite::ErrorCode::ConstraintViolation => "SQLITE_CONSTRAINT",
+        rusqlite::ErrorCode::TypeMismatch => "SQLITE_MISMATCH",
+        rusqlite::ErrorCode::ApiMisuse => "SQLITE_MISUSE",
+        rusqlite::ErrorCode::NoLargeFileSupport => "SQLITE_NOLFS",
+        rusqlite::ErrorCode::AuthorizationForStatementDenied => "SQLITE_AUTH",
+        rusqlite::ErrorCode::ParameterOutOfRange => "SQLITE_RANGE",
+        rusqlite::ErrorCode::NotADatabase => "SQLITE_NOTADB",
+        rusqlite::ErrorCode::Unknown => "SQLITE_UNKNOWN",
+        _ => "SQLITE_UNKNOWN",
     }
 }
 

sqld/src/batch/stmt.rs

@@ -232,6 +232,7 @@ fn downcast_error(err: anyhow::Error) -> Result<proto::Error> {
     match err.downcast_ref::<session::ResponseError>() {
         Some(error) => Ok(proto::Error {
             message: error.to_string(),
+            code: error.code().into(),
         }),
         None => Err(err),
     }

sqld/src/hrana/conn.rs

@@ -79,4 +79,5 @@ pub struct BatchResp {
 #[derive(Serialize, Debug)]
 pub struct Error {
     pub message: String,
+    pub code: String,
 }

sqld/src/hrana/proto.rs

@@ -184,3 +184,16 @@ async fn stream_respond<F>(
     };
     let _: Result<_, _> = stream_hnd.job_tx.send(job).await;
 }
+
+impl ResponseError {
+    pub fn code(&self) -> &'static str {
+        match self {
+            Self::Auth { source } => source.code(),
+            Self::StreamNotFound { .. } => "STREAM_NOT_FOUND",
+            Self::StreamExists { .. } => "STREAM_EXISTS",
+            Self::StreamNotOpen { .. } => "STREAM_NOT_OPEN",
+            Self::Batch(err) => err.code(),
+            Self::Stmt(err) => err.code(),
+        }
+    }
+}

sqld/src/hrana/session.rs

@@ -140,6 +140,7 @@ fn error_response(err: ResponseError) -> hyper::Response<hyper::Body> {
         status,
         &hrana::proto::Error {
             message: err.to_string(),
+            code: err.code().into(),
         },
     )
 }
@@ -155,3 +156,13 @@ fn json_response<T: Serialize>(
         .body(hyper::Body::from(body))
         .unwrap()
 }
+
+impl ResponseError {
+    pub fn code(&self) -> &'static str {
+        match self {
+            Self::BadRequestBody { .. } => "HTTP_BAD_REQUEST_BODY",
+            Self::Stmt(err) => err.code(),
+            Self::Batch(err) => err.code(),
+        }
+    }
+}