From 24ee7c050c8e4fab654289a635febc5a19e6c6ba Mon Sep 17 00:00:00 2001
From: Sergey Yakubov <sergey.yakubov@desy.de>
Date: Wed, 26 Feb 2020 12:44:10 +0100
Subject: [PATCH] receiver sends reauthorization error
---
receiver/src/receiver_error.h | 5 +++
receiver/src/request_handler_authorize.cpp | 9 ++++-
receiver/src/request_handler_authorize.h | 2 +-
receiver/src/requests_dispatcher.cpp | 8 ++++-
.../test_request_handler_authorizer.cpp | 33 ++++++++++++++---
.../unittests/test_requests_dispatcher.cpp | 35 ++++++++++++-------
6 files changed, 72 insertions(+), 20 deletions(-)
diff --git a/receiver/src/receiver_error.h b/receiver/src/receiver_error.h
index a25c9e78f..9a2fc4874 100644
--- a/receiver/src/receiver_error.h
+++ b/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
+};
+
};
}
diff --git a/receiver/src/request_handler_authorize.cpp b/receiver/src/request_handler_authorize.cpp
index 899de8e4a..c1d975c62 100644
--- a/receiver/src/request_handler_authorize.cpp
+++ b/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_);
diff --git a/receiver/src/request_handler_authorize.h b/receiver/src/request_handler_authorize.h
index 7fd3613ce..1a5edcf52 100644
--- a/receiver/src/request_handler_authorize.h
+++ b/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;
};
diff --git a/receiver/src/requests_dispatcher.cpp b/receiver/src/requests_dispatcher.cpp
index 93c1cade3..73efb7652 100644
--- a/receiver/src/requests_dispatcher.cpp
+++ b/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;
}
diff --git a/receiver/unittests/test_request_handler_authorizer.cpp b/receiver/unittests/test_request_handler_authorizer.cpp
index d6cad76f5..a08a70921 100644
--- a/receiver/unittests/test_request_handler_authorizer.cpp
+++ b/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");
diff --git a/receiver/unittests/test_requests_dispatcher.cpp b/receiver/unittests/test_requests_dispatcher.cpp
index 12bcc973a..82fb8e6bd 100644
--- a/receiver/unittests/test_requests_dispatcher.cpp
+++ b/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);
--
GitLab