added explicit ExecutionTime expiration

Author: rdeioris

stackslib/src/net/api/fastcallreadonly.rs

@@ -33,8 +33,8 @@ use crate::net::api::callreadonly::{
 };
 use crate::net::http::{
     parse_json, Error, HttpContentType, HttpNotFound, HttpRequest, HttpRequestContents,
-    HttpRequestPreamble, HttpResponse, HttpResponseContents, HttpResponsePayload,
-    HttpResponsePreamble,
+    HttpRequestPreamble, HttpRequestTimeout, HttpResponse, HttpResponseContents,
+    HttpResponsePayload, HttpResponsePreamble,
 };
 use crate::net::httpcore::{
     request, HttpPreambleExtensions, HttpRequestContentsExtensions, RPCRequestHandler,
@@ -288,6 +288,14 @@ impl RPCRequestHandler for RPCFastCallReadOnlyRequestHandler {
                         cause: Some("NotReadOnly".to_string()),
                     }
                 }
+                Unchecked(CheckErrors::ExecutionTimeExpired) => {
+                    return StacksHttpResponse::new_error(
+                        &preamble,
+                        &HttpRequestTimeout::new("ExecutionTime expired".to_string()),
+                    )
+                    .try_into_contents()
+                    .map_err(NetError::from)
+                }
                 _ => CallReadOnlyResponse {
                     okay: false,
                     result: None,

stackslib/src/net/api/tests/fastcallreadonly.rs

@@ -328,23 +328,72 @@ fn test_try_make_response_free_cost_tracker() {
         },
     );
 
-    // confirmed tip
     let response = responses.remove(0);
-    debug!(
-        "Response:\n{}\n",
-        std::str::from_utf8(&response.try_serialize().unwrap()).unwrap()
+    let (preamble, contents) = response.destruct();
+
+    assert_eq!(preamble.status_code, 408);
+
+    let body: String = contents.try_into().unwrap();
+    assert_eq!(body, "ExecutionTime expired");
+}
+
+#[test]
+fn test_wrong_auth() {
+    let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 33333);
+
+    let mut requests = vec![];
+
+    // query confirmed tip
+    let mut request = StacksHttpRequest::new_fastcallreadonlyfunction(
+        addr.into(),
+        StacksAddress::from_string("ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R").unwrap(),
+        "hello-world".try_into().unwrap(),
+        StacksAddress::from_string("ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R")
+            .unwrap()
+            .to_account_principal(),
+        None,
+        "ro-confirmed".try_into().unwrap(),
+        vec![],
+        TipRequest::UseLatestAnchoredTip,
     );
+    request.add_header("authorization".into(), "wrong".into());
 
-    assert_eq!(
-        response.preamble().get_canonical_stacks_tip_height(),
-        Some(1)
+    requests.push(request);
+
+    let mut responses = test_rpc(function_name!(), requests);
+
+    let response = responses.remove(0);
+    let (preamble, contents) = response.destruct();
+
+    assert_eq!(preamble.status_code, 401);
+}
+
+#[test]
+fn test_missing_auth() {
+    let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 33333);
+
+    let mut requests = vec![];
+
+    // query confirmed tip
+    let request = StacksHttpRequest::new_fastcallreadonlyfunction(
+        addr.into(),
+        StacksAddress::from_string("ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R").unwrap(),
+        "hello-world".try_into().unwrap(),
+        StacksAddress::from_string("ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R")
+            .unwrap()
+            .to_account_principal(),
+        None,
+        "ro-confirmed".try_into().unwrap(),
+        vec![],
+        TipRequest::UseLatestAnchoredTip,
     );
 
-    let resp = response.decode_call_readonly_response().unwrap();
+    requests.push(request);
 
-    assert!(!resp.okay);
-    assert!(resp.result.is_none());
-    assert!(resp.cause.is_some());
+    let mut responses = test_rpc(function_name!(), requests);
+
+    let response = responses.remove(0);
+    let (preamble, contents) = response.destruct();
 
-    assert_eq!(resp.cause.unwrap(), "Unchecked(ExecutionTimeExpired)");
+    assert_eq!(preamble.status_code, 401);
 }

stackslib/src/net/http/error.rs

@@ -128,6 +128,7 @@ pub fn http_error_from_code_and_text(code: u16, message: String) -> Box<dyn Http
         402 => Box::new(HttpPaymentRequired::new(message)),
         403 => Box::new(HttpForbidden::new(message)),
         404 => Box::new(HttpNotFound::new(message)),
+        408 => Box::new(HttpRequestTimeout::new(message)),
         500 => Box::new(HttpServerError::new(message)),
         501 => Box::new(HttpNotImplemented::new(message)),
         503 => Box::new(HttpServiceUnavailable::new(message)),
@@ -292,6 +293,33 @@ impl HttpErrorResponse for HttpNotFound {
     }
 }
 
+/// HTTP 408
+pub struct HttpRequestTimeout {
+    error_text: String,
+}
+
+impl HttpRequestTimeout {
+    pub fn new(error_text: String) -> Self {
+        Self { error_text }
+    }
+}
+
+impl HttpErrorResponse for HttpRequestTimeout {
+    fn code(&self) -> u16 {
+        408
+    }
+    fn payload(&self) -> HttpResponsePayload {
+        HttpResponsePayload::Text(self.error_text.clone())
+    }
+    fn try_parse_response(
+        &self,
+        preamble: &HttpResponsePreamble,
+        body: &[u8],
+    ) -> Result<HttpResponsePayload, Error> {
+        try_parse_error_response(preamble.status_code, preamble.content_type, body)
+    }
+}
+
 /// HTTP 500
 pub struct HttpServerError {
     error_text: String,

stackslib/src/net/http/mod.rs

@@ -37,8 +37,8 @@ pub use crate::net::http::common::{
 };
 pub use crate::net::http::error::{
     http_error_from_code_and_text, http_reason, HttpBadRequest, HttpError, HttpErrorResponse,
-    HttpForbidden, HttpNotFound, HttpNotImplemented, HttpPaymentRequired, HttpServerError,
-    HttpServiceUnavailable, HttpUnauthorized,
+    HttpForbidden, HttpNotFound, HttpNotImplemented, HttpPaymentRequired, HttpRequestTimeout,
+    HttpServerError, HttpServiceUnavailable, HttpUnauthorized,
 };
 pub use crate::net::http::request::{
     HttpRequest, HttpRequestContents, HttpRequestPayload, HttpRequestPreamble,