RequestPtr ProtocolClient::deserializeCheckRequest(ProtocolFrameHeader &frame) {
std::string clientId, userId, privilegeId;
+
ProtocolDeserialization::deserialize(frame, clientId);
ProtocolDeserialization::deserialize(frame, userId);
ProtocolDeserialization::deserialize(frame, privilegeId);
+
return std::make_shared<CheckRequest>(PolicyKey(clientId, userId, privilegeId),
frame.sequenceNumber());
}
return nullptr;
}
+ResponsePtr ProtocolClient::deserializeCheckResponse(ProtocolFrameHeader &frame) {
+ PolicyType result;
+ PolicyResult::PolicyMetadata additionalInfo;
+
+ ProtocolDeserialization::deserialize(frame, result);
+ ProtocolDeserialization::deserialize(frame, additionalInfo);
+
+ return std::make_shared<CheckResponse>(PolicyResult(result, additionalInfo), frame.sequenceNumber());
+}
+
ResponsePtr ProtocolClient::extractResponseFromBuffer(BinaryQueue &bufferQueue) {
- TODO_USE_ME(bufferQueue);
- return ResponsePtr(nullptr);
+ ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
+
+ if (m_frameHeader.isFrameComplete()) {
+ ProtocolOpCode requestId;
+
+ m_frameHeader.resetState();
+ ProtocolDeserialization::deserialize(m_frameHeader, requestId);
+ switch (requestId) {
+ case OpCheckPolicy:
+ return deserializeCheckResponse(m_frameHeader);
+ default:
+ throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
+ break;
+ }
+ }
+
+ return nullptr;
}
void ProtocolClient::execute(RequestContextPtr context, CheckRequestPtr request) {
public:
const PolicyResult &m_resultRef;
- CheckResponse(const PolicyResult &result) : m_resultRef(result) {
+ CheckResponse(const PolicyResult &result, ProtocolFrameSequenceNumber sequenceNumber) :
+ Response(sequenceNumber), m_resultRef(result) {
}
virtual ~CheckResponse() = default;
#include <response/pointers.h>
#include <response/ResponseTaker.h>
+#include <types/ProtocolFields.h>
namespace Cynara {
class Response {
public:
- Response() = default;
+ Response(ProtocolFrameSequenceNumber sequenceNumber) : m_sequenceNumber(sequenceNumber) {
+ };
virtual ~Response() = default;
virtual void execute(ResponsePtr self, ResponseTakerPtr taker,
RequestContextPtr context) const = 0;
+
+ ProtocolFrameSequenceNumber sequenceNumber(void) const {
+ return m_sequenceNumber;
+ }
+
+private:
+ ProtocolFrameSequenceNumber m_sequenceNumber;
};
} // namespace Cynara
void Logic::execute(RequestContextPtr context, CheckRequestPtr request) {
PolicyResult result(PredefinedPolicyType::DENY);
if (check(context, request->key(), result)) {
- context->returnResponse(context, std::make_shared<CheckResponse>(result));
+ context->returnResponse(context, std::make_shared<CheckResponse>(result, request->sequenceNumber()));
}
}