receiver sends reauthorization error

receiver/src/receiver_error.h

@@ -10,6 +10,7 @@ enum class ReceiverErrorType {
     kBadRequest,
     kAuthorizationFailure,
     kInternalServerError,
+    kReAuthorizationFailure,
     kWarningDuplicatedRequest
 };
 
@@ -40,6 +41,10 @@ auto const kAuthorizationFailure = ReceiverErrorTemplate{
     "authorization failure", ReceiverErrorType::kAuthorizationFailure
 };
 
+auto const kReAuthorizationFailure = ReceiverErrorTemplate{
+    "reauthorization for auto beamtime failed", ReceiverErrorType::kReAuthorizationFailure
+};
+
 };
 }
 

receiver/src/request_handler_authorize.cpp

@@ -72,6 +72,13 @@ Error RequestHandlerAuthorize::ProcessAuthorizationRequest(Request* request) con
     return Authorize(request, request->GetMessage());
 }
 
+Error RequestHandlerAuthorize::ProcessReAuthorizeError(const Request* request,Error err) const {
+    if (err == asapo::ReceiverErrorTemplates::kAuthorizationFailure && request->GetBeamtimeId() == "auto") {
+        return asapo::ReceiverErrorTemplates::kReAuthorizationFailure.Generate();
+    }
+    return err;
+}
+
 Error RequestHandlerAuthorize::ProcessOtherRequest(Request* request) const {
     if (cached_source_credentials_.empty()) {
         return ReceiverErrorTemplates::kAuthorizationFailure.Generate();
@@ -82,7 +89,7 @@ Error RequestHandlerAuthorize::ProcessOtherRequest(Request* request) const {
     if (elapsed_ms >= GetReceiverConfig()->authorization_interval_ms) {
         auto err = Authorize(request, cached_source_credentials_.c_str());
         if (err) {
-            return err;
+            return ProcessReAuthorizeError(request, std::move(err));
         }
     }
     request->SetBeamtimeId(beamtime_id_);

receiver/src/request_handler_authorize.h

@@ -31,7 +31,7 @@ class RequestHandlerAuthorize final: public ReceiverRequestHandler {
     Error ProcessOtherRequest(Request* request) const;
     Error Authorize(Request* request, const char* source_credentials) const;
     Error ErrorFromAuthorizationServerResponse(const Error& err, HttpCode code) const;
-
+    Error ProcessReAuthorizeError(const Request* request,Error err) const;
     std::string GetRequestString(const Request* request, const char* source_credentials) const;
 };
 

receiver/src/requests_dispatcher.cpp

@@ -18,6 +18,8 @@ NetworkErrorCode GetNetworkCodeFromError(const Error& err) {
     if (err) {
         if (err == ReceiverErrorTemplates::kAuthorizationFailure) {
             return NetworkErrorCode::kNetAuthorizationError;
+        } else if (err == ReceiverErrorTemplates::kReAuthorizationFailure) {
+            return NetworkErrorCode::kNetErrorReauthorize;
         } else if (err == DBErrorTemplates::kJsonParseError || err == ReceiverErrorTemplates::kBadRequest) {
             return NetworkErrorCode::kNetErrorWrongRequest;
         } else {
@@ -49,7 +51,11 @@ Error RequestsDispatcher::HandleRequest(const std::unique_ptr<Request>& request)
     Error handle_err;
     handle_err = request->Handle(statistics__);
     if (handle_err) {
-        log__->Error("error processing request from " + producer_uri_ + " - " + handle_err->Explain());
+        if (handle_err == ReceiverErrorTemplates::kReAuthorizationFailure) {
+            log__->Warning("warning processing request from " + producer_uri_ + " - " + handle_err->Explain());
+        } else {
+            log__->Error("error processing request from " + producer_uri_ + " - " + handle_err->Explain());
+        }
     }
     return handle_err;
 }

receiver/unittests/test_request_handler_authorizer.cpp

@@ -63,7 +63,6 @@ class AuthorizerHandlerTests : public Test {
     ReceiverConfig config;
 
     NiceMock<asapo::MockLogger> mock_logger;
-    std::string expected_source_credentials = "beamtime_id%stream%token";
     std::string expected_beamtime_id = "beamtime_id";
     std::string expected_stream = "stream";
     std::string expected_beamline = "beamline";
@@ -71,13 +70,16 @@ class AuthorizerHandlerTests : public Test {
     std::string expected_core_path = "/gpfs/blabla";
     std::string expected_producer_uri = "producer_uri";
     std::string expected_authorization_server = "authorizer_host";
-    std::string expect_request_string = std::string("{\"SourceCredentials\":\"") + expected_source_credentials +
-                                        "\",\"OriginHost\":\"" +
-                                        expected_producer_uri + "\"}";
-
+    std::string expect_request_string;
+    std::string expected_source_credentials;
     void MockRequestData();
     void SetUp() override {
         GenericRequestHeader request_header;
+        expected_source_credentials = expected_beamtime_id+"%stream%token";
+        expect_request_string = std::string("{\"SourceCredentials\":\"") + expected_source_credentials +
+            "\",\"OriginHost\":\"" +
+            expected_producer_uri + "\"}";
+
         mock_request.reset(new MockRequest{request_header, 1, expected_producer_uri, nullptr});
         handler.http_client__ = std::unique_ptr<asapo::HttpClient> {&mock_http_client};
         handler.log__ = &mock_logger;
@@ -146,6 +148,12 @@ class AuthorizerHandlerTests : public Test {
         EXPECT_CALL(*mock_request, GetOpCode())
         .WillOnce(Return(asapo::kOpcodeTransferData))
         ;
+
+        if (!error && code == HttpCode::Unauthorized) {
+        EXPECT_CALL(*mock_request, GetBeamtimeId())
+            .WillOnce(ReturnRef(expected_beamtime_id))
+            ;
+        }
         if (!error && code == HttpCode::OK) {
             EXPECT_CALL(*mock_request, SetBeamtimeId(expected_beamtime_id));
             EXPECT_CALL(*mock_request, SetStream(expected_stream));
@@ -236,6 +244,21 @@ TEST_F(AuthorizerHandlerTests, DataTransferRequestAuthorizeReturnsOK) {
     ASSERT_THAT(err, Eq(nullptr));
 }
 
+TEST_F(AuthorizerHandlerTests, RequestAuthorizeReturnsReqauthorize) {
+    expected_beamtime_id="auto";
+    expected_source_credentials = "auto%stream%token";
+    expect_request_string = std::string("{\"SourceCredentials\":\"") + expected_source_credentials +
+        "\",\"OriginHost\":\"" +expected_producer_uri + "\"}";
+
+    MockFirstAuthorization(false);
+
+    auto err = MockRequestAuthorization(false,HttpCode::Unauthorized);
+
+    ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kReAuthorizationFailure));
+}
+
+
+
 TEST_F(AuthorizerHandlerTests, DataTransferRequestAuthorizeUsesCachedValue) {
     config.authorization_interval_ms = 10000;
     SetReceiverConfig(config, "none");

receiver/unittests/test_requests_dispatcher.cpp

@@ -150,17 +150,17 @@ class RequestsDispatcherTests : public Test {
 
 
     }
-    void MockHandleRequest(bool error, Error err = asapo::IOErrorTemplates::kUnknownIOError.Generate() ) {
+    void MockHandleRequest(int error_mode, Error err = asapo::IOErrorTemplates::kUnknownIOError.Generate() ) {
         EXPECT_CALL(mock_logger, Debug(AllOf(HasSubstr("processing request"), HasSubstr(connected_uri))));
 
         EXPECT_CALL(mock_request, Handle_t()).WillOnce(
-            Return(error ? err.release() : nullptr)
+            Return(error_mode>0 ? err.release() : nullptr)
         );
-        if (error) {
+        if (error_mode == 1) {
             EXPECT_CALL(mock_logger, Error(AllOf(HasSubstr("error processing request from"), HasSubstr(connected_uri))));
+        } else if (error_mode == 2) {
+            EXPECT_CALL(mock_logger, Warning(AllOf(HasSubstr("warning processing request from"), HasSubstr(connected_uri))));
         }
-
-
     }
     void MockSendResponse(GenericNetworkResponse* response, bool error ) {
         EXPECT_CALL(mock_logger, Debug(AllOf(HasSubstr("sending response to"), HasSubstr(connected_uri))));
@@ -230,7 +230,7 @@ TEST_F(RequestsDispatcherTests, OkCreatetNextRequest) {
 
 
 TEST_F(RequestsDispatcherTests, ErrorProcessRequestErrorSend) {
-    MockHandleRequest(true);
+    MockHandleRequest(1);
     MockSendResponse(&response, true);
 
     auto err = dispatcher->ProcessRequest(request);
@@ -240,7 +240,7 @@ TEST_F(RequestsDispatcherTests, ErrorProcessRequestErrorSend) {
 
 
 TEST_F(RequestsDispatcherTests, OkProcessRequestErrorSend) {
-    MockHandleRequest(false);
+    MockHandleRequest(0);
     MockSendResponse(&response, true);
 
     auto err = dispatcher->ProcessRequest(request);
@@ -250,7 +250,7 @@ TEST_F(RequestsDispatcherTests, OkProcessRequestErrorSend) {
 
 
 TEST_F(RequestsDispatcherTests, OkProcessRequestSendOK) {
-    MockHandleRequest(false);
+    MockHandleRequest(0);
     MockSendResponse(&response, false);
 
     auto err = dispatcher->ProcessRequest(request);
@@ -260,7 +260,7 @@ TEST_F(RequestsDispatcherTests, OkProcessRequestSendOK) {
 
 
 TEST_F(RequestsDispatcherTests, ProcessRequestReturnsOkWithWarning) {
-    MockHandleRequest(false);
+    MockHandleRequest(0);
     MockSendResponse(&response, false);
     request->SetWarningMessage("duplicate");
 
@@ -272,7 +272,7 @@ TEST_F(RequestsDispatcherTests, ProcessRequestReturnsOkWithWarning) {
 }
 
 TEST_F(RequestsDispatcherTests, ProcessRequestReturnsAuthorizationFailure) {
-    MockHandleRequest(true, asapo::ReceiverErrorTemplates::kAuthorizationFailure.Generate());
+    MockHandleRequest(1, asapo::ReceiverErrorTemplates::kAuthorizationFailure.Generate());
     MockSendResponse(&response, false);
 
     auto err = dispatcher->ProcessRequest(request);
@@ -282,9 +282,20 @@ TEST_F(RequestsDispatcherTests, ProcessRequestReturnsAuthorizationFailure) {
     ASSERT_THAT(std::string(response.message), HasSubstr("authorization"));
 }
 
+TEST_F(RequestsDispatcherTests, ProcessRequestReturnsReAuthorizationFailure) {
+    MockHandleRequest(2, asapo::ReceiverErrorTemplates::kReAuthorizationFailure.Generate());
+    MockSendResponse(&response, false);
+
+    auto err = dispatcher->ProcessRequest(request);
+
+    ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kReAuthorizationFailure));
+    ASSERT_THAT(response.error_code, Eq(asapo::kNetErrorReauthorize));
+    ASSERT_THAT(std::string(response.message), HasSubstr("reauthorization"));
+}
+
 
 TEST_F(RequestsDispatcherTests, ProcessRequestReturnsMetaDataFailure) {
-    MockHandleRequest(true, asapo::DBErrorTemplates::kJsonParseError.Generate());
+    MockHandleRequest(1, asapo::DBErrorTemplates::kJsonParseError.Generate());
     MockSendResponse(&response, false);
 
     auto err = dispatcher->ProcessRequest(request);
@@ -295,7 +306,7 @@ TEST_F(RequestsDispatcherTests, ProcessRequestReturnsMetaDataFailure) {
 }
 
 TEST_F(RequestsDispatcherTests, ProcessRequestReturnsBadRequest) {
-    MockHandleRequest(true, asapo::ReceiverErrorTemplates::kBadRequest.Generate());
+    MockHandleRequest(1, asapo::ReceiverErrorTemplates::kBadRequest.Generate());
     MockSendResponse(&response, false);
 
     auto err = dispatcher->ProcessRequest(request);