diff --git a/receiver/CMakeLists.txt b/receiver/CMakeLists.txt
index 66049ae23debe69d12047814f18788622298d801..6d6ac3e8aa5d0fec8c24ef70b42f768fd14cc85f 100644
--- a/receiver/CMakeLists.txt
+++ b/receiver/CMakeLists.txt
@@ -102,8 +102,9 @@ set(TEST_SOURCE_FILES
unittests/request_handler/test_request_handler_db_stream_info.cpp
unittests/request_handler/test_request_handler_db_last_stream.cpp
unittests/request_handler/test_request_handler_db.cpp
- unittests/request_handler/test_request_handler_authorizer.cpp
+ unittests/request_handler/test_authorization_client.cpp
unittests/request_handler/test_request_handler_initial_authorization.cpp
+ unittests/request_handler/test_request_handler_secondary_authorization.cpp
unittests/request_handler/test_request_handler_receive_data.cpp
unittests/request_handler/test_request_handler_receive_metadata.cpp
unittests/request_handler/test_request_handler_delete_stream.cpp
diff --git a/receiver/src/receiver_logger.cpp b/receiver/src/receiver_logger.cpp
index 85945ae94b4eada91432077a0372f7fc92c04cb8..05edc430a5d22542e9d7e6029214fb01a32f8326 100644
--- a/receiver/src/receiver_logger.cpp
+++ b/receiver/src/receiver_logger.cpp
@@ -2,6 +2,8 @@
#include "request.h"
+#include "request_handler/structs.h"
+
namespace asapo {
AbstractLogger* GetDefaultReceiverLogger() {
@@ -9,25 +11,47 @@ AbstractLogger* GetDefaultReceiverLogger() {
return logger.get();
}
-LogMessageWithFields RequestLog(std::string message, const Request* request) {
- LogMessageWithFields msg{std::move(message)};
- msg.Append("beamtime", request->GetBeamtimeId())
- .Append("dataSource", request->GetDataSource())
- .Append("stream", request->GetStream())
- .Append("origin", request->GetOriginHost())
- .Append("operation", OpcodeToString(request->GetOpCode()));
+void AppendIdToLogMessageIfNeeded(const Request* request, LogMessageWithFields* msg) {
switch (request->GetOpCode()) {
case Opcode::kOpcodeTransferData:
- msg.Append("id", request->GetDataID());
+ msg->Append("id", request->GetDataID());
break;
case Opcode::kOpcodeTransferDatasetData:
- msg.Append("id", request->GetDataID());
- msg.Append("substream", request->GetCustomData()[1]);
+ msg->Append("id", request->GetDataID());
+ msg->Append("substream", request->GetCustomData()[1]);
break;
default:
break;
}
+}
+
+LogMessageWithFields AuthorizationLog(std::string message, const Request* request, const AuthorizationData* data) {
+ LogMessageWithFields msg{std::move(message)};
+ msg.Append("beamtime", data->beamtime_id)
+ .Append("dataSource", data->data_source)
+ .Append("beamline", data->beamline)
+ .Append("origin", request->GetOriginHost());
+
+ if (request->GetOpCode() != kOpcodeAuthorize) {
+ msg.Append("stream", request->GetStream());
+ AppendIdToLogMessageIfNeeded(request, &msg);
+ }
+
+ return msg;
+}
+
+
+LogMessageWithFields RequestLog(std::string message, const Request* request) {
+ LogMessageWithFields msg{std::move(message)};
+ msg.Append("beamtime", request->GetBeamtimeId())
+ .Append("beamline", request->GetBeamline())
+ .Append("dataSource", request->GetDataSource())
+ .Append("stream", request->GetStream())
+ .Append("origin", request->GetOriginHost())
+ .Append("operation", OpcodeToString(request->GetOpCode()));
+
+ AppendIdToLogMessageIfNeeded(request, &msg);
return msg;
}
diff --git a/receiver/src/receiver_logger.h b/receiver/src/receiver_logger.h
index 49385f52b9597e929f85d1107e0a30177e415314..e1cd160448d8ff500df6549ee0f8c316f48c535d 100644
--- a/receiver/src/receiver_logger.h
+++ b/receiver/src/receiver_logger.h
@@ -2,12 +2,15 @@
#define ASAPO_RECEIVER_LOGGER_H
#include "asapo/logger/logger.h"
-#include "request.h"
namespace asapo {
+struct AuthorizationData;
+class Request;
+
AbstractLogger* GetDefaultReceiverLogger();
LogMessageWithFields RequestLog(std::string message, const Request* request);
+LogMessageWithFields AuthorizationLog(std::string message, const Request* request, const AuthorizationData* data);
}
diff --git a/receiver/src/request.h b/receiver/src/request.h
index b14979e905bbf6b77968e8bb0c00156154d489a5..47e3eacffb43d6aaaebce476aaa8f9146f741ec6 100644
--- a/receiver/src/request.h
+++ b/receiver/src/request.h
@@ -7,14 +7,6 @@
#include "asapo/common/networking.h"
#include "asapo/io/io.h"
#include "request_handler/request_handler.h"
-/*#include "request_handler/request_handler_file_process.h"
-#include "request_handler/request_handler_db_write.h"
-#include "request_handler/request_handler_authorize.h"
-#include "request_handler/request_handler_db_meta_write.h"
-#include "request_handler/request_handler_receive_data.h"
-#include "request_handler/request_handler_receive_metadata.h"
-#include "request_handler/request_handler_db_check_request.h"
-*/
#include "statistics/receiver_statistics.h"
#include "data_cache.h"
@@ -51,8 +43,8 @@ class Request {
VIRTUAL Opcode GetOpCode() const;
VIRTUAL const char* GetMessage() const;
- const std::string& GetOriginUri() const;
- const std::string& GetOriginHost() const;
+ VIRTUAL const std::string& GetOriginUri() const;
+ VIRTUAL const std::string& GetOriginHost() const;
VIRTUAL const std::string& GetMetaData() const;
VIRTUAL const std::string& GetBeamtimeId() const;
VIRTUAL void SetBeamtimeId(std::string beamtime_id);
diff --git a/receiver/src/request_handler/authorization_client.cpp b/receiver/src/request_handler/authorization_client.cpp
index 5dcc875e4082d8fe91955a661097b401a016d1ce..d709b548d849d4e06b4f3fed7608e8bd0f1a5279 100644
--- a/receiver/src/request_handler/authorization_client.cpp
+++ b/receiver/src/request_handler/authorization_client.cpp
@@ -4,31 +4,28 @@
#include "asapo/json_parser/json_parser.h"
-
-
#include "../receiver_config.h"
#include "../receiver_logger.h"
#include "../request.h"
-
namespace asapo {
-std::string AuthorizationClient::GetRequestString(const Request* request, const std::string& source_credentials) const {
+std::string GetRequestString(const Request* request, const std::string& source_credentials) {
std::string request_string = std::string("{\"SourceCredentials\":\"") +
- source_credentials + "\",\"OriginHost\":\"" + request->GetOriginUri() + "\"}";
+ source_credentials + "\",\"OriginHost\":\"" + request->GetOriginUri() + "\"}";
return request_string;
}
-Error AuthorizationClient::ErrorFromAuthorizationServerResponse(const Error& err, const std::string response,
- HttpCode code) const {
+Error ErrorFromAuthorizationServerResponse(const Error& err, const std::string response,
+ HttpCode code) {
if (err) {
return asapo::ReceiverErrorTemplates::kInternalServerError.Generate(
- "cannot authorize request: " + err->Explain());
+ "cannot authorize request: " + err->Explain());
} else {
if (code != HttpCode::Unauthorized) {
return asapo::ReceiverErrorTemplates::kInternalServerError.Generate(
- response + " return code " + std::to_string(int(
- code)));
+ response + " return code " + std::to_string(int(
+ code)));
}
return asapo::ReceiverErrorTemplates::kAuthorizationFailure.Generate(response);
}
@@ -43,55 +40,83 @@ Error CheckAccessType(SourceType source_type, const std::vector<std::string>& ac
}
}
-LogMessageWithFields AuthErrorLogMsg(const Request* request, const Error& err, const std::string& request_string) {
- return RequestLog("failure authorizing: " + err->Explain(), request)
- .Append("authServer", GetReceiverConfig()->authorization_server)
- .Append("request", request_string);
-}
-
-Error AuthorizationClient::Authorize(const Request* request, AuthorizationData* data) const {
- HttpCode code;
+Error ParseServerResponse(const std::string& response,
+ HttpCode code,
+ std::vector<std::string>* access_types,
+ AuthorizationData* data) {
Error err;
- std::string request_string = GetRequestString(request, data->source_credentials);
- auto response =
- http_client__->Post(GetReceiverConfig()->authorization_server + "/authorize", "", request_string, &code,
- &err);
- if (err || code != HttpCode::OK) {
- auto auth_error = ErrorFromAuthorizationServerResponse(err, response, code);
- log__->Error(AuthErrorLogMsg(request, auth_error, request_string));
- return auth_error;
+ AuthorizationData creds;
+ JsonStringParser parser{response};
+ std::string stype;
+
+ (err = parser.GetString("beamtimeId", &data->beamtime_id)) ||
+ (err = parser.GetString("dataSource", &data->data_source)) ||
+ (err = parser.GetString("corePath", &data->offline_path)) ||
+ (err = parser.GetString("beamline-path", &data->online_path)) ||
+ (err = parser.GetString("source-type", &stype)) ||
+ (err = parser.GetArrayString("access-types", access_types)) ||
+ (err = GetSourceTypeFromString(stype, &data->source_type)) ||
+ (err = parser.GetString("beamline", &data->beamline));
+ if (err) {
+ return ErrorFromAuthorizationServerResponse(err, "", code);
}
+ return nullptr;
+}
+Error UpdateDataFromServerResponse(const std::string& response, HttpCode code, AuthorizationData* data) {
+ Error err;
std::string stype;
std::vector<std::string> access_types;
-
- AuthorizationData creds;
- JsonStringParser parser{response};
- (err = parser.GetString("beamtimeId", &creds.beamtime_id)) ||
- (err = parser.GetString("dataSource", &creds.data_source)) ||
- (err = parser.GetString("corePath", &creds.offline_path)) ||
- (err = parser.GetString("beamline-path", &creds.online_path)) ||
- (err = parser.GetString("source-type", &stype)) ||
- (err = parser.GetArrayString("access-types", &access_types)) ||
- (err = GetSourceTypeFromString(stype, &creds.source_type)) ||
- (err = parser.GetString("beamline", &creds.beamline));
+ AuthorizationData old_data = *data;
+ err = ParseServerResponse(response, code, &access_types, data);
if (err) {
- return ErrorFromAuthorizationServerResponse(err, "", code);
+ *data = old_data;
+ return ErrorFromAuthorizationServerResponse(err, response, code);
}
- err = CheckAccessType(creds.source_type, access_types);
+ err = CheckAccessType(data->source_type, access_types);
if (err) {
- log__->Error(AuthErrorLogMsg(request, err, request_string));
+ *data = old_data;
return err;
}
- log__->Debug(RequestLog("authorized connection",request));
- *data = creds;
data->last_update = std::chrono::system_clock::now();
return nullptr;
}
+Error AuthorizationClient::DoServerRequest(const std::string& request_string,
+ std::string* response,
+ HttpCode* code) const {
+ Error err;
+ *response =
+ http_client__->Post(GetReceiverConfig()->authorization_server + "/authorize", "", request_string, code,
+ &err);
+ if (err || *code != HttpCode::OK) {
+ auto auth_error = ErrorFromAuthorizationServerResponse(err, *response, *code);
+ return auth_error;
+ }
+ return nullptr;
+}
+
+Error AuthorizationClient::Authorize(const Request* request, AuthorizationData* data) const {
+ HttpCode code;
+ std::string response;
+ std::string request_string = GetRequestString(request, data->source_credentials);
+ auto err = DoServerRequest(request_string, &response, &code);
+ if (err != nullptr) {
+ return err;
+ }
+
+ err = UpdateDataFromServerResponse(response, code, data);
+ if (err != nullptr) {
+ return err;
+ }
+ log__->Debug(AuthorizationLog(
+ request->GetOpCode() == kOpcodeAuthorize ? "authorized connection" : "reauthorized connection", request, data));
+ return nullptr;
+}
+
AuthorizationClient::AuthorizationClient() : log__{GetDefaultReceiverLogger()},
- http_client__{DefaultHttpClient()} {
+ http_client__{DefaultHttpClient()} {
}
}
diff --git a/receiver/src/request_handler/authorization_client.h b/receiver/src/request_handler/authorization_client.h
index bb1e8306ccfadbe1cfcca92a54995a9e08749813..2312a41dbbad39b757cd6b29cd0e55fd24736ab2 100644
--- a/receiver/src/request_handler/authorization_client.h
+++ b/receiver/src/request_handler/authorization_client.h
@@ -12,16 +12,15 @@ class Request;
class AbstractLogger;
class AuthorizationClient {
- public:
- AuthorizationClient();
- VIRTUAL Error Authorize(const Request* request, AuthorizationData* data) const;
- const AbstractLogger* log__;
- std::unique_ptr<HttpClient>http_client__;
- VIRTUAL ~AuthorizationClient()=default;
- private:
- Error ErrorFromAuthorizationServerResponse(const Error& err, const std::string response, HttpCode code) const;
- void SetRequestFields(Request* request) const;
- std::string GetRequestString(const Request* request, const std::string& source_credentials) const;
+ public:
+ AuthorizationClient();
+ VIRTUAL Error Authorize(const Request* request, AuthorizationData* data) const;
+ const AbstractLogger* log__;
+ std::unique_ptr<HttpClient> http_client__;
+ VIRTUAL ~AuthorizationClient() = default;
+ private:
+ Error DoServerRequest(const std::string& request_string, std::string* response, HttpCode* code) const;
+
};
}
diff --git a/receiver/src/request_handler/request_handler_authorize.cpp b/receiver/src/request_handler/request_handler_authorize.cpp
index ab33e19b4936d8c97efaac968559cd58639b2c8c..7e0412a961694f1795f13f5546b3d0f4a450a085 100644
--- a/receiver/src/request_handler/request_handler_authorize.cpp
+++ b/receiver/src/request_handler/request_handler_authorize.cpp
@@ -1,5 +1,4 @@
#include "request_handler_authorize.h"
-#include "../receiver_config.h"
#include "../receiver_logger.h"
#include "../request.h"
@@ -22,7 +21,7 @@ Error RequestHandlerAuthorize::CheckVersion(const Request* request) const {
}
RequestHandlerAuthorize::RequestHandlerAuthorize(AuthorizationData* authorization_cache) : log__{GetDefaultReceiverLogger()},
- auth_client__{new AuthorizationClient()},authorization_cache_{authorization_cache} {
+ auth_client__{new AuthorizationClient()}, authorization_cache_{authorization_cache} {
}
StatisticEntity RequestHandlerAuthorize::GetStatisticEntity() const {
diff --git a/receiver/src/request_handler/request_handler_authorize.h b/receiver/src/request_handler/request_handler_authorize.h
index 08c814d2b7fc36b03290089f7846e29294c1911e..5e504fb5a11b66727c9cc2ab5b91e64f9374401c 100644
--- a/receiver/src/request_handler/request_handler_authorize.h
+++ b/receiver/src/request_handler/request_handler_authorize.h
@@ -15,11 +15,11 @@ namespace asapo {
class RequestHandlerAuthorize : public ReceiverRequestHandler {
public:
- RequestHandlerAuthorize()=delete;
+ RequestHandlerAuthorize() = delete;
RequestHandlerAuthorize(AuthorizationData* authorization_cache);
StatisticEntity GetStatisticEntity() const override;
virtual Error ProcessRequest(Request* request) const override = 0;
- virtual ~RequestHandlerAuthorize()=default;
+ virtual ~RequestHandlerAuthorize() = default;
const AbstractLogger* log__;
std::unique_ptr<AuthorizationClient> auth_client__;
protected:
diff --git a/receiver/src/request_handler/request_handler_initial_authorization.cpp b/receiver/src/request_handler/request_handler_initial_authorization.cpp
index 7b0bdc797aee273114b7985bfc316859a27bd9c5..e95c9a3718162880d11ae9ed9ec993a440bae97c 100644
--- a/receiver/src/request_handler/request_handler_initial_authorization.cpp
+++ b/receiver/src/request_handler/request_handler_initial_authorization.cpp
@@ -4,14 +4,14 @@
namespace asapo {
-RequestHandlerInitialAuthorization::RequestHandlerInitialAuthorization(AuthorizationData *authorization_cache)
+RequestHandlerInitialAuthorization::RequestHandlerInitialAuthorization(AuthorizationData* authorization_cache)
: RequestHandlerAuthorize(authorization_cache) {
}
-Error RequestHandlerInitialAuthorization::ProcessRequest(asapo::Request *request) const {
+Error RequestHandlerInitialAuthorization::ProcessRequest(asapo::Request* request) const {
auto err = CheckVersion(request);
- if (err!=nullptr) {
+ if (err != nullptr) {
return err;
}
@@ -20,7 +20,7 @@ Error RequestHandlerInitialAuthorization::ProcessRequest(asapo::Request *request
}
authorization_cache_->source_credentials = request->GetMetaData();
- return auth_client__->Authorize(request,authorization_cache_);
+ return auth_client__->Authorize(request, authorization_cache_);
}
diff --git a/receiver/src/request_handler/request_handler_initial_authorization.h b/receiver/src/request_handler/request_handler_initial_authorization.h
index 13ea82f48b7c67d2cf53527c535a1eb619869652..454a7bcaaa482e056b1d0ff1e2114e7f409bf56c 100644
--- a/receiver/src/request_handler/request_handler_initial_authorization.h
+++ b/receiver/src/request_handler/request_handler_initial_authorization.h
@@ -6,10 +6,10 @@
namespace asapo {
class RequestHandlerInitialAuthorization final: public RequestHandlerAuthorize {
- public:
- RequestHandlerInitialAuthorization(AuthorizationData* authorization_cache);
- Error ProcessRequest(Request* request) const override;
- ~RequestHandlerInitialAuthorization()=default;
+ public:
+ RequestHandlerInitialAuthorization(AuthorizationData* authorization_cache);
+ Error ProcessRequest(Request* request) const override;
+ ~RequestHandlerInitialAuthorization() = default;
};
}
diff --git a/receiver/src/request_handler/request_handler_secondary_authorization.cpp b/receiver/src/request_handler/request_handler_secondary_authorization.cpp
index ac2b2fee5359b4ee62551402fe9d1ab48a54cc33..55ded2f08531dfb3e2d3f05f322e016175f2f24e 100644
--- a/receiver/src/request_handler/request_handler_secondary_authorization.cpp
+++ b/receiver/src/request_handler/request_handler_secondary_authorization.cpp
@@ -11,108 +11,74 @@
using std::chrono::system_clock;
namespace asapo {
-/*
-Error RequestHandlerAuthorize::CheckVersion(const std::string& version_from_client) const {
- int verClient = VersionToNumber(version_from_client);
- int verService = VersionToNumber(GetReceiverApiVersion());
- if (verClient > verService) {
- auto err_string = "client version: " + version_from_client + ", server version: " + GetReceiverApiVersion();
- return asapo::ReceiverErrorTemplates::kUnsupportedClient.Generate(err_string);
- }
- return nullptr;
-}
-
-Error RequestHandlerAuthorize::ProcessAuthorizationRequest(Request* request) const {
- if (!cached_source_credentials_.empty()) {
- Error auth_error = asapo::ReceiverErrorTemplates::kAuthorizationFailure.Generate();
- auth_error->Append("already authorized");
- return auth_error;
- }
-
- auto err = CheckVersion(request->GetApiVersion());
- if (err) {
- return err;
- }
- err = auth_client__->Authorize(request, request->GetMetaData().c_str(),&cached_auth_);
- if (err) {
- return err;
- }
-
- cached_source_credentials_ = request->GetMetaData();
- last_updated_ = system_clock::now();
- return nullptr;
-}
-Error RequestHandlerAuthorize::ProcessReAuthorization(Request* request) const {
- std::string old_beamtimeId = cached_auth_.beamtime_id;
- auto err = auth_client__->Authorize(request, cached_source_credentials_.c_str(),&cached_auth_);
+Error RequestHandlerSecondaryAuthorization::ProcessReAuthorization(const Request* request) const {
+ std::string old_beamtimeId = authorization_cache_->beamtime_id;
+ auto err = auth_client__->Authorize(request, authorization_cache_);
if (err == asapo::ReceiverErrorTemplates::kAuthorizationFailure || (
- err == nullptr && old_beamtimeId != cached_auth_.beamtime_id)) {
+ err == nullptr && old_beamtimeId != authorization_cache_->beamtime_id)) {
+ InvalidateAuthCache();
return asapo::ReceiverErrorTemplates::kReAuthorizationFailure.Generate();
}
- if (err==nullptr) {
- last_updated_ = system_clock::now();
- }
return err;
}
-bool RequestHandlerAuthorize::NeedReauthorize() const {
+bool RequestHandlerSecondaryAuthorization::NeedReauthorize() const {
uint64_t elapsed_ms = (uint64_t) std::chrono::duration_cast<std::chrono::milliseconds>
- (system_clock::now() - last_updated_).count();
+ (system_clock::now() - authorization_cache_->last_update).count();
return elapsed_ms >= GetReceiverConfig()->authorization_interval_ms;
}
-void RequestHandlerAuthorize::SetRequestFields(Request* request) const {
- request->SetBeamtimeId(cached_auth_.beamtime_id);
- request->SetBeamline(cached_auth_.beamline);
- request->SetDataSource(cached_auth_.data_source);
- request->SetOfflinePath(cached_auth_.offline_path);
- request->SetOnlinePath(cached_auth_.online_path);
- request->SetSourceType(cached_auth_.source_type);
+void RequestHandlerSecondaryAuthorization::SetRequestFields(Request* request) const {
+ request->SetBeamtimeId(authorization_cache_->beamtime_id);
+ request->SetBeamline(authorization_cache_->beamline);
+ request->SetDataSource(authorization_cache_->data_source);
+ request->SetOfflinePath(authorization_cache_->offline_path);
+ request->SetOnlinePath(authorization_cache_->online_path);
+ request->SetSourceType(authorization_cache_->source_type);
}
+RequestHandlerSecondaryAuthorization::RequestHandlerSecondaryAuthorization(AuthorizationData* authorization_cache)
+ : RequestHandlerAuthorize(authorization_cache) {
-Error RequestHandlerAuthorize::ProcessOtherRequest(Request* request) const {
- if (cached_source_credentials_.empty()) {
- return ReceiverErrorTemplates::kAuthorizationFailure.Generate();
+}
+
+Error RequestHandlerSecondaryAuthorization::CheckRequest(const Request* request) const {
+ auto err = CheckVersion(request);
+ if (err != nullptr) {
+ return err;
}
- if (NeedReauthorize()) {
- auto err = ProcessReAuthorization(request);
- if (err) {
- return err;
- }
+ if (authorization_cache_->source_credentials.empty()) {
+ return ReceiverErrorTemplates::kAuthorizationFailure.Generate("not authorized");
}
- SetRequestFields(request);
return nullptr;
}
-Error RequestHandlerAuthorize::ProcessRequest(Request* request) const {
- if (request->GetOpCode() == kOpcodeAuthorize) {
- return ProcessAuthorizationRequest(request);
- } else {
- return ProcessOtherRequest(request);
+Error RequestHandlerSecondaryAuthorization::ProcessRequest(asapo::Request* request) const {
+ auto err = CheckRequest(request);
+ if (err != nullptr) {
+ return err;
}
-}
-RequestHandlerAuthorize::RequestHandlerAuthorize() : log__{GetDefaultReceiverLogger()},
- auth_client__{new AuthorizationClient()} {
-}
+ err = ReauthorizeIfNeeded(request);
+ if (err != nullptr) {
+ return err;
+ }
-StatisticEntity RequestHandlerAuthorize::GetStatisticEntity() const {
- return StatisticEntity::kNetwork;
+ SetRequestFields(request);
+ return nullptr;
}
-*/
-
-RequestHandlerSecondaryAuthorization::RequestHandlerSecondaryAuthorization(AuthorizationData *authorization_cache)
- : RequestHandlerAuthorize(authorization_cache) {
+Error RequestHandlerSecondaryAuthorization::ReauthorizeIfNeeded(const Request* request) const {
+ if (!NeedReauthorize()) {
+ return nullptr;
+ }
+ return ProcessReAuthorization(request);
}
-Error RequestHandlerSecondaryAuthorization::ProcessRequest(asapo::Request *request) const {
- (void) request;
- return nullptr;
+void RequestHandlerSecondaryAuthorization::InvalidateAuthCache() const {
+ authorization_cache_->source_credentials = "";
}
}
-
diff --git a/receiver/src/request_handler/request_handler_secondary_authorization.h b/receiver/src/request_handler/request_handler_secondary_authorization.h
index 960596b30f9d0b0110e07427b3f75af189b50339..9d568cf16406d1244e15d4a7f2e928ae3702590e 100644
--- a/receiver/src/request_handler/request_handler_secondary_authorization.h
+++ b/receiver/src/request_handler/request_handler_secondary_authorization.h
@@ -14,21 +14,19 @@
namespace asapo {
class RequestHandlerSecondaryAuthorization final: public RequestHandlerAuthorize {
- public:
- RequestHandlerSecondaryAuthorization() = delete;
- RequestHandlerSecondaryAuthorization(AuthorizationData* authorization_cache);
- virtual Error ProcessRequest(Request* request) const override;
- ~RequestHandlerSecondaryAuthorization()=default;
-/* private:
- mutable AuthorizationData cached_auth_;
- mutable std::string cached_source_credentials_;
- mutable std::chrono::system_clock::time_point last_updated_;
- Error ProcessAuthorizationRequest(Request* request) const;
- Error ProcessOtherRequest(Request* request) const;
- Error ProcessReAuthorization(Request* request) const;
- bool NeedReauthorize() const;
- void SetRequestFields(Request* request) const;
- Error CheckVersion(const std::string& version_from_client) const;*/
+ public:
+ RequestHandlerSecondaryAuthorization() = delete;
+ RequestHandlerSecondaryAuthorization(AuthorizationData* authorization_cache);
+ virtual Error ProcessRequest(Request* request) const override;
+ ~RequestHandlerSecondaryAuthorization() = default;
+ private:
+ bool NeedReauthorize() const;
+ void SetRequestFields(Request* request) const;
+ Error ProcessReAuthorization(const Request* request) const;
+ Error CheckRequest(const Request* request) const;
+ Error ReauthorizeIfNeeded(const Request* request) const;
+ void InvalidateAuthCache() const;
+
};
}
diff --git a/receiver/src/request_handler/structs.h b/receiver/src/request_handler/structs.h
index a0d3ad3820d4685d28604f55f7777d8b7a4e64cc..80bd533af2f92a04247d4c63d0d41851f5ad2235 100644
--- a/receiver/src/request_handler/structs.h
+++ b/receiver/src/request_handler/structs.h
@@ -8,14 +8,14 @@
namespace asapo {
struct AuthorizationData {
- std::string beamtime_id;
- std::string data_source;
- std::string beamline;
- std::string offline_path;
- std::string online_path;
- SourceType source_type;
- std::chrono::system_clock::time_point last_update;
- std::string source_credentials;
+ std::string beamtime_id;
+ std::string data_source;
+ std::string beamline;
+ std::string offline_path;
+ std::string online_path;
+ SourceType source_type;
+ std::chrono::system_clock::time_point last_update;
+ std::string source_credentials;
};
}
diff --git a/receiver/unittests/receiver_mocking.h b/receiver/unittests/receiver_mocking.h
index 4c5be8b5a774317bc9eda362cd662548b41e19a9..79e76f1f68c061aba448bb806f7fbc8ba112db94 100644
--- a/receiver/unittests/receiver_mocking.h
+++ b/receiver/unittests/receiver_mocking.h
@@ -69,6 +69,7 @@ class MockRequest: public Request {
MOCK_CONST_METHOD0(GetFileName, std::string());
MOCK_CONST_METHOD0(GetStream, std::string());
MOCK_CONST_METHOD0(GetApiVersion, std::string());
+ MOCK_CONST_METHOD0(GetOriginUri, const std::string & ());
MOCK_CONST_METHOD0(GetDataSize, uint64_t());
MOCK_CONST_METHOD0(GetDataID, uint64_t());
MOCK_CONST_METHOD0(GetSlotId, uint64_t());
@@ -148,11 +149,11 @@ class MockFileProcessor: public FileProcessor {
class MockAuthorizationClient: public AuthorizationClient {
- public:
- Error Authorize(const Request* request, AuthorizationData* data) const override {
- return Error{Authorize_t(request, data)};
- }
- MOCK_CONST_METHOD2(Authorize_t, ErrorInterface * (const Request*, AuthorizationData* ));
+ public:
+ Error Authorize(const Request* request, AuthorizationData* data) const override {
+ return Error{Authorize_t(request, data)};
+ }
+ MOCK_CONST_METHOD2(Authorize_t, ErrorInterface * (const Request*, AuthorizationData* ));
};
diff --git a/receiver/unittests/request_handler/test_authorization_client.cpp b/receiver/unittests/request_handler/test_authorization_client.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..92028ca4717b19299646ab4f2091078d1922a84f
--- /dev/null
+++ b/receiver/unittests/request_handler/test_authorization_client.cpp
@@ -0,0 +1,179 @@
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "asapo/unittests/MockHttpClient.h"
+#include "asapo/unittests/MockLogger.h"
+
+#include "../../src/receiver_error.h"
+#include "asapo/common/networking.h"
+#include "../mock_receiver_config.h"
+#include "asapo/preprocessor/definitions.h"
+
+#include "../receiver_mocking.h"
+
+#include "../../src/receiver_config.h"
+#include "../../src/request_handler/authorization_client.h"
+#include "../../src/receiver_logger.h"
+
+
+using namespace testing;
+using namespace asapo;
+
+
+namespace {
+
+TEST(Authorizer, Constructor) {
+ AuthorizationClient client;
+ ASSERT_THAT(dynamic_cast<const asapo::AbstractLogger*>(client.log__), Ne(nullptr));
+ ASSERT_THAT(dynamic_cast<asapo::HttpClient*>(client.http_client__.get()), Ne(nullptr));
+}
+
+
+class AuthorizerClientTests : public Test {
+ public:
+ AuthorizationClient client;
+ AuthorizationData expected_auth_data;
+ MockHttpClient mock_http_client;
+ std::unique_ptr<MockRequest> mock_request;
+ ReceiverConfig config;
+
+ NiceMock<asapo::MockLogger> mock_logger;
+ std::string expected_beamtime_id = "beamtime_id";
+ std::string expected_data_source = "source";
+ std::string expected_beamline = "beamline";
+ std::string expected_beamline_path = "/beamline/p01/current";
+ 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 expected_source_credentials;
+ asapo::SourceType expected_source_type = asapo::SourceType::kProcessed;
+
+ std::string expected_source_type_str = "processed";
+ std::string expected_access_type_str = "[\"write\"]";
+ void SetUp() override {
+ GenericRequestHeader request_header;
+ expected_source_credentials = "processed%" + expected_beamtime_id + "%source%token";
+ expected_auth_data.source_credentials = expected_source_credentials;
+ 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});
+ client.http_client__ = std::unique_ptr<asapo::HttpClient> {&mock_http_client};
+ client.log__ = &mock_logger;
+ config.authorization_server = expected_authorization_server;
+ config.authorization_interval_ms = 0;
+ SetReceiverConfig(config, "none");
+ }
+ void TearDown() override {
+ client.http_client__.release();
+ }
+ void MockAuthRequest(bool error, HttpCode code = HttpCode::OK) {
+ EXPECT_CALL(*mock_request,
+ GetOriginUri()).WillOnce(ReturnRef(expected_producer_uri));
+ if (error) {
+ EXPECT_CALL(mock_http_client,
+ Post_t(expected_authorization_server + "/authorize", _, expect_request_string, _, _)).
+ WillOnce(
+ DoAll(SetArgPointee<4>(new asapo::SimpleError("http error")),
+ Return("")
+ ));
+ } else {
+ EXPECT_CALL(mock_http_client,
+ Post_t(expected_authorization_server + "/authorize", _, expect_request_string, _, _)).
+ WillOnce(
+ DoAll(SetArgPointee<4>(nullptr),
+ SetArgPointee<3>(code),
+ Return("{\"beamtimeId\":\"" + expected_beamtime_id +
+ "\",\"dataSource\":" + "\"" + expected_data_source +
+ "\",\"beamline-path\":" + "\"" + expected_beamline_path +
+ "\",\"corePath\":" + "\"" + expected_core_path +
+ "\",\"source-type\":" + "\"" + expected_source_type_str +
+ "\",\"beamline\":" + "\"" + expected_beamline +
+ "\",\"access-types\":" + expected_access_type_str + "}")
+ ));
+ }
+ }
+};
+
+
+TEST_F(AuthorizerClientTests, AuthorizeRequestReturnsInternalerror) {
+ MockAuthRequest(true);
+
+ auto err = client.Authorize(mock_request.get(), &expected_auth_data);
+
+ ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kInternalServerError));
+}
+
+TEST_F(AuthorizerClientTests, AuthorizeRequestReturns401) {
+ MockAuthRequest(false, HttpCode::Unauthorized);
+
+ auto err = client.Authorize(mock_request.get(), &expected_auth_data);
+
+ ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kAuthorizationFailure));
+}
+
+
+TEST_F(AuthorizerClientTests, AuthorizeOk) {
+ MockAuthRequest(false, HttpCode::OK);
+
+ EXPECT_CALL(mock_logger, Debug(AllOf(HasSubstr("authorized"),
+ HasSubstr(expected_beamtime_id)
+ )));
+
+ auto err = client.Authorize(mock_request.get(), &expected_auth_data);
+
+ ASSERT_THAT(err, Eq(nullptr));
+ ASSERT_THAT(expected_auth_data.data_source, Eq(expected_data_source));
+ ASSERT_THAT(expected_auth_data.source_type, Eq(expected_source_type));
+ ASSERT_THAT(expected_auth_data.beamline, Eq(expected_beamline));
+ ASSERT_THAT(expected_auth_data.beamtime_id, Eq(expected_beamtime_id));
+ ASSERT_THAT(expected_auth_data.offline_path, Eq(expected_core_path));
+ ASSERT_THAT(expected_auth_data.online_path, Eq(expected_beamline_path));
+ ASSERT_THAT(expected_auth_data.last_update, Gt(std::chrono::system_clock::time_point{}));
+ ASSERT_THAT(expected_auth_data.source_credentials, Eq(expected_source_credentials));
+
+}
+
+TEST_F(AuthorizerClientTests, AuthorizeFailsOnWrongAccessType) {
+ expected_access_type_str = "[\"read\"]";
+ MockAuthRequest(false, HttpCode::OK);
+
+ auto err = client.Authorize(mock_request.get(), &expected_auth_data);
+
+ ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kAuthorizationFailure));
+}
+
+TEST_F(AuthorizerClientTests, AuthorizeFailsOnWrongAccessTypeForRaw) {
+ expected_access_type_str = "[\"write\"]";
+ expected_source_type_str = "raw";
+ MockAuthRequest(false, HttpCode::OK);
+
+ auto err = client.Authorize(mock_request.get(), &expected_auth_data);
+
+ ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kAuthorizationFailure));
+}
+
+TEST_F(AuthorizerClientTests, AuthorizeFailsOnWrongAccessTypeForProcessed) {
+ expected_access_type_str = "[\"writeraw\"]";
+ expected_source_type_str = "processed";
+ MockAuthRequest(false, HttpCode::OK);
+
+ auto err = client.Authorize(mock_request.get(), &expected_auth_data);
+
+ ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kAuthorizationFailure));
+}
+
+TEST_F(AuthorizerClientTests, AuthorizeOkForRaw) {
+ expected_access_type_str = "[\"writeraw\"]";
+ expected_source_type_str = "raw";
+ expected_source_type = asapo::SourceType::kRaw;
+ MockAuthRequest(false, HttpCode::OK);
+
+ auto err = client.Authorize(mock_request.get(), &expected_auth_data);
+
+ ASSERT_THAT(err, Eq(nullptr));
+}
+
+}
diff --git a/receiver/unittests/request_handler/test_request_factory.cpp b/receiver/unittests/request_handler/test_request_factory.cpp
index c82869d432de679312e86a1d20c955e717df0b82..f2c6179a22a17ad97f823dc5fa11747ea9c5cf06 100644
--- a/receiver/unittests/request_handler/test_request_factory.cpp
+++ b/receiver/unittests/request_handler/test_request_factory.cpp
@@ -54,7 +54,8 @@ TEST_F(FactoryTests, ReturnsDataRequestOnkNetOpcodeSendCode) {
ASSERT_THAT(err, Eq(nullptr));
ASSERT_THAT(dynamic_cast<asapo::Request*>(request.get()), Ne(nullptr));
ASSERT_THAT(request->GetListHandlers().size(), Eq(5));
- ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]), Ne(nullptr));
+ ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]),
+ Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerReceiveMetaData*>(request->GetListHandlers()[1]), Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerReceiveData*>(request->GetListHandlers()[2]), Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerFileProcess*>(request->GetListHandlers()[3]), Ne(nullptr));
@@ -74,7 +75,8 @@ TEST_F(FactoryTests, ReturnsDataRequestOnkNetOpcodeSendCodeLargeFile) {
ASSERT_THAT(err, Eq(nullptr));
ASSERT_THAT(dynamic_cast<asapo::Request*>(request.get()), Ne(nullptr));
ASSERT_THAT(request->GetListHandlers().size(), Eq(4));
- ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]), Ne(nullptr));
+ ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]),
+ Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerReceiveMetaData*>(request->GetListHandlers()[1]), Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerFileProcess*>(request->GetListHandlers()[2]), Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerDbWrite*>(request->GetListHandlers().back()), Ne(nullptr));
@@ -97,7 +99,8 @@ TEST_F(FactoryTests, DoNotAddDiskAndDbWriterIfNotWantedInRequest) {
auto request = factory.GenerateRequest(generic_request_header, 1, origin_uri, &err);
ASSERT_THAT(err, Eq(nullptr));
ASSERT_THAT(request->GetListHandlers().size(), Eq(3));
- ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]), Ne(nullptr));
+ ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]),
+ Ne(nullptr));
}
TEST_F(FactoryTests, DoNotAddDbWriterIfNotWanted) {
@@ -109,7 +112,8 @@ TEST_F(FactoryTests, DoNotAddDbWriterIfNotWanted) {
auto request = factory.GenerateRequest(generic_request_header, 1, origin_uri, &err);
ASSERT_THAT(err, Eq(nullptr));
ASSERT_THAT(request->GetListHandlers().size(), Eq(4));
- ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]), Ne(nullptr));
+ ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]),
+ Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerReceiveMetaData*>(request->GetListHandlers()[1]), Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerReceiveData*>(request->GetListHandlers()[2]), Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerFileProcess*>(request->GetListHandlers()[3]), Ne(nullptr));
@@ -131,7 +135,8 @@ TEST_F(FactoryTests, ReturnsMetaDataRequestOnTransferMetaDataOnly) {
ASSERT_THAT(err, Eq(nullptr));
ASSERT_THAT(dynamic_cast<asapo::Request*>(request.get()), Ne(nullptr));
ASSERT_THAT(request->GetListHandlers().size(), Eq(4));
- ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]), Ne(nullptr));
+ ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]),
+ Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerReceiveMetaData*>(request->GetListHandlers()[1]), Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerReceiveData*>(request->GetListHandlers()[2]), Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerDbWrite*>(request->GetListHandlers()[3]), Ne(nullptr));
@@ -146,7 +151,8 @@ TEST_F(FactoryTests, ReturnsMetaDataRequestOnkOpcodeTransferMetaData) {
ASSERT_THAT(err, Eq(nullptr));
ASSERT_THAT(dynamic_cast<asapo::Request*>(request.get()), Ne(nullptr));
ASSERT_THAT(dynamic_cast<asapo::Request*>(request->cache__), Eq(nullptr));
- ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]), Ne(nullptr));
+ ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]),
+ Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerReceiveData*>(request->GetListHandlers()[1]), Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerDbMetaWrite*>(request->GetListHandlers().back()), Ne(nullptr));
}
@@ -169,7 +175,8 @@ TEST_F(FactoryTests, StreamInfoRequest) {
auto request = factory.GenerateRequest(generic_request_header, 1, origin_uri, &err);
ASSERT_THAT(err, Eq(nullptr));
ASSERT_THAT(request->GetListHandlers().size(), Eq(2));
- ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]), Ne(nullptr));
+ ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]),
+ Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerDbStreamInfo*>(request->GetListHandlers()[1]), Ne(nullptr));
}
@@ -178,7 +185,8 @@ TEST_F(FactoryTests, LastStreamRequest) {
auto request = factory.GenerateRequest(generic_request_header, 1, origin_uri, &err);
ASSERT_THAT(err, Eq(nullptr));
ASSERT_THAT(request->GetListHandlers().size(), Eq(2));
- ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]), Ne(nullptr));
+ ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]),
+ Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerDbLastStream*>(request->GetListHandlers()[1]), Ne(nullptr));
}
@@ -187,7 +195,8 @@ TEST_F(FactoryTests, DeleteStreamRequest) {
auto request = factory.GenerateRequest(generic_request_header, 1, origin_uri, &err);
ASSERT_THAT(err, Eq(nullptr));
ASSERT_THAT(request->GetListHandlers().size(), Eq(2));
- ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]), Ne(nullptr));
+ ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]),
+ Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerDbDeleteStream*>(request->GetListHandlers()[1]), Ne(nullptr));
}
@@ -196,7 +205,8 @@ TEST_F(FactoryTests, GetMetamRequest) {
auto request = factory.GenerateRequest(generic_request_header, 1, origin_uri, &err);
ASSERT_THAT(err, Eq(nullptr));
ASSERT_THAT(request->GetListHandlers().size(), Eq(2));
- ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]), Ne(nullptr));
+ ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerSecondaryAuthorization*>(request->GetListHandlers()[0]),
+ Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerDbGetMeta*>(request->GetListHandlers()[1]), Ne(nullptr));
}
diff --git a/receiver/unittests/request_handler/test_request_handler_authorizer.cpp b/receiver/unittests/request_handler/test_request_handler_authorizer.cpp
deleted file mode 100644
index 0e6d1f7f36629b89bc4b26fb6808145655ebf3d3..0000000000000000000000000000000000000000
--- a/receiver/unittests/request_handler/test_request_handler_authorizer.cpp
+++ /dev/null
@@ -1,342 +0,0 @@
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-
-#include "asapo/unittests/MockHttpClient.h"
-#include "asapo/unittests/MockLogger.h"
-
-#include "../../src/receiver_error.h"
-#include "../../src/request.h"
-#include "../../src/request_handler/request_handler.h"
-#include "../../src/request_handler/request_handler_authorize.h"
-#include "asapo/common/networking.h"
-#include "../mock_receiver_config.h"
-#include "asapo/preprocessor/definitions.h"
-
-#include "../receiver_mocking.h"
-
-#include "../../src/receiver_config.h"
-
-
-using ::testing::Test;
-using ::testing::Return;
-using ::testing::ReturnRef;
-using ::testing::_;
-using ::testing::DoAll;
-using ::testing::SetArgReferee;
-using ::testing::Gt;
-using ::testing::Eq;
-using ::testing::Ne;
-using ::testing::Mock;
-using ::testing::NiceMock;
-using ::testing::InSequence;
-using ::testing::SetArgPointee;
-using ::testing::AllOf;
-using ::testing::HasSubstr;
-
-using asapo::MockRequest;
-using ::asapo::Error;
-using ::asapo::ErrorInterface;
-using ::asapo::FileDescriptor;
-using ::asapo::SocketDescriptor;
-using ::asapo::MockHttpClient;
-using asapo::Request;
-using asapo::RequestHandlerAuthorize;
-using ::asapo::GenericRequestHeader;
-using asapo::ReceiverConfig;
-using asapo::SetReceiverConfig;
-using asapo::HttpCode;
-
-namespace {
-
-/*
-TEST(Authorizer, Constructor) {
- RequestHandlerAuthorize handler;
-// ASSERT_THAT(dynamic_cast<asapo::HttpClient*>(handler.http_client__.get()), Ne(nullptr));
- ASSERT_THAT(dynamic_cast<const asapo::AbstractLogger*>(handler.log__), Ne(nullptr));
-}
-
-
-class AuthorizerHandlerTests : public Test {
- public:
- RequestHandlerAuthorize handler;
- MockHttpClient mock_http_client;
- std::unique_ptr<MockRequest> mock_request;
- ReceiverConfig config;
-
- NiceMock<asapo::MockLogger> mock_logger;
- std::string expected_beamtime_id = "beamtime_id";
- std::string expected_data_source = "source";
- std::string expected_beamline = "beamline";
- std::string expected_beamline_path = "/beamline/p01/current";
- 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 expected_source_credentials;
- std::string expected_api_version = "v0.1";
-
- asapo::SourceType expected_source_type = asapo::SourceType::kProcessed;
- std::string expected_source_type_str = "processed";
- std::string expected_access_type_str = "[\"write\"]";
- void MockRequestData();
- void SetUp() override {
- GenericRequestHeader request_header;
- expected_source_credentials = "processed%" + expected_beamtime_id + "%source%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;
- config.authorization_server = expected_authorization_server;
- config.authorization_interval_ms = 0;
- SetReceiverConfig(config, "none");
- }
- void TearDown() override {
- handler.http_client__.release();
- }
- void MockAuthRequest(bool error, HttpCode code = HttpCode::OK, bool opError = false) {
- if (error) {
- EXPECT_CALL(mock_http_client, Post_t(expected_authorization_server + "/authorize", _, expect_request_string, _, _)).
- WillOnce(
- DoAll(SetArgPointee<4>(new asapo::SimpleError("http error")),
- Return("")
- ));
- EXPECT_CALL(mock_logger, Error(AllOf(HasSubstr("failure authorizing"),
- HasSubstr("http error"),
- HasSubstr(expected_beamtime_id),
- HasSubstr(expected_producer_uri),
- HasSubstr(expected_authorization_server))));
-
- } else {
- EXPECT_CALL(mock_http_client, Post_t(expected_authorization_server + "/authorize", _, expect_request_string, _, _)).
- WillOnce(
- DoAll(SetArgPointee<4>(nullptr),
- SetArgPointee<3>(code),
- Return("{\"beamtimeId\":\"" + expected_beamtime_id +
- "\",\"dataSource\":" + "\"" + expected_data_source +
- "\",\"beamline-path\":" + "\"" + expected_beamline_path +
- "\",\"corePath\":" + "\"" + expected_core_path +
- "\",\"source-type\":" + "\"" + expected_source_type_str +
- "\",\"beamline\":" + "\"" + expected_beamline +
- "\",\"access-types\":" + expected_access_type_str + "}")
- ));
- if (code != HttpCode::OK) {
- EXPECT_CALL(mock_logger, Error(AllOf(HasSubstr("failure authorizing"),
- HasSubstr(expected_source_type_str),
- HasSubstr(expected_beamtime_id),
- HasSubstr(expected_data_source),
- HasSubstr(expected_producer_uri),
- HasSubstr(expected_authorization_server))));
- } else if (!opError) {
- EXPECT_CALL(mock_logger, Debug(AllOf(HasSubstr("authorized"),
- HasSubstr(expected_beamtime_id),
-// HasSubstr(expected_beamline),
-// HasSubstr(expected_source_type_str),
- HasSubstr(expected_data_source),
- HasSubstr(expected_producer_uri))));
- }
- }
- }
- Error MockFirstAuthorization(bool error, HttpCode code = HttpCode::OK, bool opError = false) {
-
- if (!error && code == HttpCode::OK && !opError) {
- EXPECT_CALL(*mock_request, SetBeamtimeId(expected_beamtime_id));
- EXPECT_CALL(*mock_request, SetDataSource(expected_data_source));
- EXPECT_CALL(*mock_request, SetOfflinePath(expected_core_path));
- EXPECT_CALL(*mock_request, SetOnlinePath(expected_beamline_path));
- EXPECT_CALL(*mock_request, SetBeamline(expected_beamline));
- EXPECT_CALL(*mock_request, SetSourceType(expected_source_type));
- }
-
- EXPECT_CALL(*mock_request, GetOpCode())
- .WillRepeatedly(Return(asapo::kOpcodeAuthorize))
- ;
- EXPECT_CALL(*mock_request, GetMetaData())
- .WillOnce(ReturnRef(expected_source_credentials))
- ;
-
- EXPECT_CALL(*mock_request, GetApiVersion())
- .WillOnce(Return(expected_api_version))
- ;
-
- EXPECT_CALL(*mock_request, GetDataSource())
- .WillRepeatedly(ReturnRef(expected_data_source))
- ;
-
- EXPECT_CALL(*mock_request, GetStream())
- .WillRepeatedly(Return("stream"))
- ;
-
- EXPECT_CALL(*mock_request, GetBeamtimeId())
- .WillRepeatedly(ReturnRef(expected_beamtime_id))
- ;
-
- MockAuthRequest(error, code, opError);
- return handler.ProcessRequest(mock_request.get());
- }
- Error MockRequestAuthorization(bool error, HttpCode code = HttpCode::OK, bool set_request = true) {
- EXPECT_CALL(*mock_request, GetOpCode())
- .WillRepeatedly(Return(asapo::kOpcodeTransferData))
- ;
-
- if (!error && code == HttpCode::OK && set_request) {
- EXPECT_CALL(*mock_request, SetBeamtimeId(expected_beamtime_id));
- EXPECT_CALL(*mock_request, SetDataSource(expected_data_source));
- EXPECT_CALL(*mock_request, SetOfflinePath(expected_core_path));
- EXPECT_CALL(*mock_request, SetOnlinePath(expected_beamline_path));
- EXPECT_CALL(*mock_request, SetBeamline(expected_beamline));
- EXPECT_CALL(*mock_request, SetSourceType(expected_source_type));
- }
-
- MockAuthRequest(error, code);
- return handler.ProcessRequest(mock_request.get());
- }
-
-};
-
-TEST_F(AuthorizerHandlerTests, CheckStatisticEntity) {
- auto entity = handler.GetStatisticEntity();
- ASSERT_THAT(entity, Eq(asapo::StatisticEntity::kNetwork));
-}
-
-TEST_F(AuthorizerHandlerTests, ErrorNotAuthorizedYet) {
- EXPECT_CALL(*mock_request, GetOpCode())
- .WillOnce(Return(asapo::kOpcodeTransferData))
- ;
-
- auto err = handler.ProcessRequest(mock_request.get());
-
- ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kAuthorizationFailure));
-}
-
-TEST_F(AuthorizerHandlerTests, ErrorProcessingAuthorizeRequest) {
-
- auto err = MockFirstAuthorization(true);
-
- ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kInternalServerError));
-}
-
-
-TEST_F(AuthorizerHandlerTests, AuthorizeRequestreturns401) {
-
- auto err = MockFirstAuthorization(false, HttpCode::Unauthorized);
-
- ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kAuthorizationFailure));
-}
-
-
-TEST_F(AuthorizerHandlerTests, AuthorizeOk) {
- auto err = MockFirstAuthorization(false);
-
- ASSERT_THAT(err, Eq(nullptr));
-}
-
-
-TEST_F(AuthorizerHandlerTests, AuthorizeFailsOnWrongAccessType) {
- expected_access_type_str = "[\"read\"]";
- auto err = MockFirstAuthorization(false, HttpCode::OK, true);
-
- ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kAuthorizationFailure));
-}
-
-TEST_F(AuthorizerHandlerTests, AuthorizeFailsOnWrongAccessTypeForRaw) {
- expected_access_type_str = "[\"write\"]";
- expected_source_type_str = "raw";
- auto err = MockFirstAuthorization(false, HttpCode::OK, true);
- ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kAuthorizationFailure));
-}
-
-TEST_F(AuthorizerHandlerTests, AuthorizeFailsOnWrongAccessTypeForProcessed) {
- expected_access_type_str = "[\"writeraw\"]";
- expected_source_type_str = "processed";
- auto err = MockFirstAuthorization(false, HttpCode::OK, true);
- ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kAuthorizationFailure));
-}
-
-TEST_F(AuthorizerHandlerTests, AuthorizeOkForRaw) {
- expected_access_type_str = "[\"writeraw\"]";
- expected_source_type_str = "raw";
- expected_source_type = asapo::SourceType::kRaw;
- auto err = MockFirstAuthorization(false, HttpCode::OK, false);
- ASSERT_THAT(err, Eq(nullptr));
-}
-
-TEST_F(AuthorizerHandlerTests, ErrorOnSecondAuthorize) {
- MockFirstAuthorization(false);
- EXPECT_CALL(*mock_request, GetOpCode())
- .WillOnce(Return(asapo::kOpcodeAuthorize));
-
- auto err = handler.ProcessRequest(mock_request.get());
-
- ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kAuthorizationFailure));
-}
-
-TEST_F(AuthorizerHandlerTests, ErrorOnDataTransferRequestAuthorize) {
- MockFirstAuthorization(false);
-
- auto err = MockRequestAuthorization(true);
-
- ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kInternalServerError));
-}
-
-
-TEST_F(AuthorizerHandlerTests, DataTransferRequestAuthorizeReturns401) {
- MockFirstAuthorization(false);
-
- auto err = MockRequestAuthorization(false, HttpCode::Unauthorized);
-
- ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kReAuthorizationFailure));
-}
-
-TEST_F(AuthorizerHandlerTests, DataTransferRequestAuthorizeReturnsSameBeamtimeId) {
- MockFirstAuthorization(false);
- auto err = MockRequestAuthorization(false);
-
- ASSERT_THAT(err, Eq(nullptr));
-}
-
-TEST_F(AuthorizerHandlerTests, RequestAuthorizeReturnsDifferentBeamtimeId) {
- MockFirstAuthorization(false);
- expected_beamtime_id = "different_id";
-
- auto err = MockRequestAuthorization(false, HttpCode::OK, false);
- ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kReAuthorizationFailure));
-}
-
-
-TEST_F(AuthorizerHandlerTests, RequestFromUnsupportedClient) {
- EXPECT_CALL(*mock_request, GetOpCode())
- .WillOnce(Return(asapo::kOpcodeAuthorize))
- ;
- EXPECT_CALL(*mock_request, GetApiVersion())
- .WillOnce(Return("v1000.2"))
- ;
-
- auto err = handler.ProcessRequest(mock_request.get());
- ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kUnsupportedClient));
-}
-
-TEST_F(AuthorizerHandlerTests, DataTransferRequestAuthorizeUsesCachedValue) {
- config.authorization_interval_ms = 10000;
- SetReceiverConfig(config, "none");
- MockFirstAuthorization(false);
- EXPECT_CALL(*mock_request, GetOpCode())
- .WillOnce(Return(asapo::kOpcodeTransferData));
- EXPECT_CALL(mock_http_client, Post_t(_, _, _, _, _)).Times(0);
- EXPECT_CALL(*mock_request, SetBeamtimeId(expected_beamtime_id));
- EXPECT_CALL(*mock_request, SetBeamline(expected_beamline));
- EXPECT_CALL(*mock_request, SetDataSource(expected_data_source));
- EXPECT_CALL(*mock_request, SetOnlinePath(expected_beamline_path));
- EXPECT_CALL(*mock_request, SetOfflinePath(expected_core_path));
- EXPECT_CALL(*mock_request, SetSourceType(expected_source_type));
- auto err = handler.ProcessRequest(mock_request.get());
-
- ASSERT_THAT(err, Eq(nullptr));
-}
-
-
-*/
-
-}
diff --git a/receiver/unittests/request_handler/test_request_handler_initial_authorization.cpp b/receiver/unittests/request_handler/test_request_handler_initial_authorization.cpp
index 26d1e3d2afad81321fdcf3a9de91821afe5ea36b..f135251a54696206a437d5aeee3f983453dc1dc0 100644
--- a/receiver/unittests/request_handler/test_request_handler_initial_authorization.cpp
+++ b/receiver/unittests/request_handler/test_request_handler_initial_authorization.cpp
@@ -1,55 +1,45 @@
#include <gtest/gtest.h>
#include <gmock/gmock.h>
-#include "asapo/unittests/MockLogger.h"
#include "asapo/common/internal/version.h"
#include "asapo/common/networking.h"
#include "../../src/request_handler/request_handler_initial_authorization.h"
#include "../../src/request.h"
#include "../receiver_mocking.h"
-#include "../../src/receiver_logger.h"
using namespace testing;
using namespace asapo;
namespace {
-TEST(Authorizer, Constructor) {
- AuthorizationData data;
- RequestHandlerInitialAuthorization handler{&data};
- ASSERT_THAT(dynamic_cast<const asapo::AbstractLogger *>(handler.log__), Ne(nullptr));
-}
-
class InitialAuthorizationHandlerTests : public Test {
- public:
- AuthorizationData auth_data;
- AuthorizationData *expected_auth_data{&auth_data};
- RequestHandlerInitialAuthorization handler{&auth_data};
- asapo::MockAuthorizationClient mock_authorization_client;
- std::unique_ptr<MockRequest> mock_request;
-
- NiceMock<asapo::MockLogger> mock_logger;
- std::string expected_source_credentials = "source_creds";
-
- void SetUp() override {
- GenericRequestHeader request_header;
- mock_request.reset(new MockRequest{request_header, 1, "", nullptr});
- handler.auth_client__ = std::unique_ptr<asapo::AuthorizationClient>{&mock_authorization_client};
- handler.log__ = &mock_logger;
- }
- void ExpectAuthMocks() {
- EXPECT_CALL(*mock_request,GetApiVersion()).WillRepeatedly(Return(asapo::GetReceiverApiVersion()));
- EXPECT_CALL(*mock_request, GetMetaData())
- .WillOnce(ReturnRef(expected_source_credentials))
- ;
- EXPECT_CALL(mock_authorization_client,
- Authorize_t(mock_request.get(), expected_auth_data)).WillOnce(Return(nullptr));
- ;
- }
- void TearDown() override {
- handler.auth_client__.release();
- }
+ public:
+ AuthorizationData auth_data;
+ AuthorizationData* expected_auth_data{&auth_data};
+ RequestHandlerInitialAuthorization handler{&auth_data};
+ asapo::MockAuthorizationClient mock_authorization_client;
+ std::unique_ptr<MockRequest> mock_request;
+
+ std::string expected_source_credentials = "source_creds";
+
+ void SetUp() override {
+ GenericRequestHeader request_header;
+ mock_request.reset(new MockRequest{request_header, 1, "", nullptr});
+ handler.auth_client__ = std::unique_ptr<asapo::AuthorizationClient> {&mock_authorization_client};
+ }
+ void ExpectAuthMocks() {
+ EXPECT_CALL(*mock_request, GetApiVersion()).WillRepeatedly(Return(asapo::GetReceiverApiVersion()));
+ EXPECT_CALL(*mock_request, GetMetaData())
+ .WillOnce(ReturnRef(expected_source_credentials))
+ ;
+ EXPECT_CALL(mock_authorization_client,
+ Authorize_t(mock_request.get(), expected_auth_data)).WillOnce(Return(nullptr));
+ ;
+ }
+ void TearDown() override {
+ handler.auth_client__.release();
+ }
};
TEST_F(InitialAuthorizationHandlerTests, AuthorizeOk) {
@@ -72,10 +62,16 @@ TEST_F(InitialAuthorizationHandlerTests, ErrorOnSecondAuthorize) {
TEST_F(InitialAuthorizationHandlerTests, RequestFromUnsupportedClient) {
EXPECT_CALL(*mock_request, GetApiVersion())
- .WillOnce(Return("v1000.2"));
+ .WillOnce(Return("v1000.2"));
auto err = handler.ProcessRequest(mock_request.get());
ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kUnsupportedClient));
}
+TEST_F(InitialAuthorizationHandlerTests, CheckStatisticEntity) {
+ auto entity = handler.GetStatisticEntity();
+ ASSERT_THAT(entity, Eq(asapo::StatisticEntity::kNetwork));
+}
+
+
}
diff --git a/receiver/unittests/request_handler/test_request_handler_secondary_authorization.cpp b/receiver/unittests/request_handler/test_request_handler_secondary_authorization.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7cdafb0bb4ac894a31d98e390eea9f8d32cd5396
--- /dev/null
+++ b/receiver/unittests/request_handler/test_request_handler_secondary_authorization.cpp
@@ -0,0 +1,141 @@
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <chrono>
+
+#include "asapo/common/internal/version.h"
+#include "asapo/common/networking.h"
+#include "asapo/common/data_structs.h"
+
+
+#include "../../src/request_handler/request_handler_secondary_authorization.h"
+#include "../../src/request.h"
+#include "../receiver_mocking.h"
+#include "../mock_receiver_config.h"
+#include "../../src/receiver_config.h"
+
+using namespace testing;
+using namespace asapo;
+
+namespace {
+
+class SecondaryAuthorizationHandlerTests : public Test {
+ public:
+ AuthorizationData auth_data;
+ ReceiverConfig config;
+ AuthorizationData* expected_auth_data{&auth_data};
+ RequestHandlerSecondaryAuthorization handler{&auth_data};
+ asapo::MockAuthorizationClient mock_authorization_client;
+ std::unique_ptr<NiceMock<MockRequest>> mock_request;
+
+ std::string expected_source_credentials = "source_creds";
+ std::string expected_beamtime_id = "expected_beamtime";
+ std::string expected_beamline = "expected_beamline";
+ std::string expected_data_source = "expected_data_source";
+ std::string expected_beamline_path = "expected_beamline_path";
+ std::string expected_core_path = "expected_core_path";
+ SourceType expected_source_type = SourceType::kProcessed;
+
+ void SetUp() override {
+ auth_data.data_source = expected_data_source;
+ auth_data.source_credentials = expected_data_source;
+ auth_data.source_type = expected_source_type;
+ auth_data.beamtime_id = expected_beamtime_id;
+ auth_data.last_update = std::chrono::system_clock::now();
+ auth_data.online_path = expected_beamline_path;
+ auth_data.offline_path = expected_core_path;
+ auth_data.beamline = expected_beamline;
+
+ auth_data.source_credentials = expected_source_credentials;
+ GenericRequestHeader request_header;
+ mock_request.reset(new NiceMock<MockRequest> {request_header, 1, "", nullptr});
+ handler.auth_client__ = std::unique_ptr<asapo::AuthorizationClient> {&mock_authorization_client};
+ config.authorization_interval_ms = 10000;
+ SetReceiverConfig(config, "none");
+ ON_CALL(*mock_request, GetApiVersion()).WillByDefault(Return(asapo::GetReceiverApiVersion()));
+ }
+ void ExpectAuth();
+ void ExpectSetRequest() {
+ EXPECT_CALL(*mock_request, SetBeamtimeId(expected_beamtime_id));
+ EXPECT_CALL(*mock_request, SetBeamline(expected_beamline));
+ EXPECT_CALL(*mock_request, SetDataSource(expected_data_source));
+ EXPECT_CALL(*mock_request, SetOnlinePath(expected_beamline_path));
+ EXPECT_CALL(*mock_request, SetOfflinePath(expected_core_path));
+ EXPECT_CALL(*mock_request, SetSourceType(expected_source_type));
+ }
+ void TearDown() override {
+ handler.auth_client__.release();
+ }
+};
+
+ACTION_P(A_WriteCache, beamtime_id) {
+ ((AuthorizationData*)arg1)->beamtime_id = static_cast<std::string>(beamtime_id);
+}
+
+void SecondaryAuthorizationHandlerTests::ExpectAuth() {
+ EXPECT_CALL(mock_authorization_client,
+ Authorize_t(mock_request.get(), expected_auth_data)).WillOnce(DoAll(
+ A_WriteCache(expected_beamtime_id),
+ Return(nullptr)
+ ));
+}
+
+
+TEST_F(SecondaryAuthorizationHandlerTests, AuthorizeWithCacheOk) {
+ ExpectSetRequest();
+
+ auto err = handler.ProcessRequest(mock_request.get());
+ ASSERT_THAT(err, Eq(nullptr));
+ ASSERT_THAT(expected_auth_data->source_credentials, Eq(expected_source_credentials));
+ ASSERT_THAT(expected_auth_data->beamtime_id, Eq(expected_beamtime_id));
+}
+
+TEST_F(SecondaryAuthorizationHandlerTests, ReauthorizeOk) {
+ ExpectAuth();
+ ExpectSetRequest();
+ auth_data.last_update = std::chrono::system_clock::time_point{};
+
+ auto err = handler.ProcessRequest(mock_request.get());
+ ASSERT_THAT(err, Eq(nullptr));
+ ASSERT_THAT(expected_auth_data->source_credentials, Eq(expected_source_credentials));
+ ASSERT_THAT(expected_auth_data->beamtime_id, Eq(expected_beamtime_id));
+}
+
+TEST_F(SecondaryAuthorizationHandlerTests, ReauthorizeWrongBeamtime) {
+ expected_beamtime_id = "new_beamtime";
+ ExpectAuth();
+ auth_data.last_update = std::chrono::system_clock::time_point{};
+
+ auto err = handler.ProcessRequest(mock_request.get());
+ ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kReAuthorizationFailure));
+ ASSERT_THAT(expected_auth_data->source_credentials, Eq(""));
+}
+
+TEST_F(SecondaryAuthorizationHandlerTests, ReauthorizeWithAutherror) {
+ EXPECT_CALL(mock_authorization_client, Authorize_t(_, _)).WillOnce(Return(
+ ReceiverErrorTemplates::kAuthorizationFailure.Generate().release()));
+ auth_data.last_update = std::chrono::system_clock::time_point{};
+
+ auto err = handler.ProcessRequest(mock_request.get());
+ ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kReAuthorizationFailure));
+ ASSERT_THAT(expected_auth_data->source_credentials, Eq(""));
+}
+
+
+TEST_F(SecondaryAuthorizationHandlerTests, ErrorOnEmptyCache) {
+ auth_data.source_credentials = "";
+
+ auto err = handler.ProcessRequest(mock_request.get());
+
+ ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kAuthorizationFailure));
+}
+
+TEST_F(SecondaryAuthorizationHandlerTests, RequestFromUnsupportedClient) {
+ EXPECT_CALL(*mock_request, GetApiVersion())
+ .WillOnce(Return("v1000.2"));
+
+ auto err = handler.ProcessRequest(mock_request.get());
+ ASSERT_THAT(err, Eq(asapo::ReceiverErrorTemplates::kUnsupportedClient));
+}
+
+}