src/common/protocol/ProtocolAdmin.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /*
  17  * @file        ProtocolAdmin.cpp
  18  * @author      Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>
  19  * @author      Adam Malinowski <a.malinowsk2@partner.samsung.com>
  20  * @version     1.0
  21  * @brief       This file implements protocol class for administration
  22  */
  23
  24 #include <memory>
  25
  26 #include <exceptions/InvalidProtocolException.h>
  27 #include <log/log.h>
  28 #include <protocol/ProtocolFrame.h>
  29 #include <protocol/ProtocolFrameSerializer.h>
  30 #include <request/InsertOrUpdateBucketRequest.h>
  31 #include <request/RemoveBucketRequest.h>
  32 #include <request/RequestContext.h>
  33 #include <request/SetPoliciesRequest.h>
  34 #include <response/CodeResponse.h>
  35
  36 #include "ProtocolAdmin.h"
  37
  38 namespace Cynara {
  39
  40 ProtocolAdmin::ProtocolAdmin() {
  41 }
  42
  43 ProtocolAdmin::~ProtocolAdmin() {
  44 }
  45
  46 ProtocolPtr ProtocolAdmin::clone(void) {
  47     return std::make_shared<ProtocolAdmin>();
  48 }
  49
  50 RequestPtr ProtocolAdmin::deserializeInsertOrUpdateBucketRequest(ProtocolFrameHeader &frame) {
  51     PolicyBucketId policyBucketId;
  52     PolicyType policyType;
  53     PolicyResult::PolicyMetadata policyMetaData;
  54
  55     ProtocolDeserialization::deserialize(frame, policyBucketId);
  56     ProtocolDeserialization::deserialize(frame, policyType);
  57     ProtocolDeserialization::deserialize(frame, policyMetaData);
  58
  59     LOGD("Deserialized InsertOrUpdateBucketRequest: bucketId <%s>, "
  60          "result.type [%u], result.meta <%s>", policyBucketId.c_str(),
  61          static_cast<unsigned int>(policyType), policyMetaData.c_str());
  62
  63     return std::make_shared<InsertOrUpdateBucketRequest>(policyBucketId,
  64             PolicyResult(policyType, policyMetaData), frame.sequenceNumber());
  65 }
  66
  67 RequestPtr ProtocolAdmin::deserializeRemoveBucketRequest(ProtocolFrameHeader &frame) {
  68     PolicyBucketId policyBucketId;
  69
  70     ProtocolDeserialization::deserialize(frame, policyBucketId);
  71
  72     LOGD("Deserialized RemoveBucketRequest: bucketId <%s>", policyBucketId.c_str());
  73
  74     return std::make_shared<RemoveBucketRequest>(policyBucketId, frame.sequenceNumber());
  75 }
  76
  77 RequestPtr ProtocolAdmin::deserializeSetPoliciesRequest(ProtocolFrameHeader &frame) {
  78     ProtocolFrameFieldsCount toBeInsertedOrUpdatedCount, toBeRemovedCount;
  79     ProtocolFrameFieldsCount policyCount;
  80     PolicyKeyFeature::ValueType clientId, user, privilege;
  81     PolicyType policyType;
  82     PolicyResult::PolicyMetadata metadata;
  83     std::map<PolicyBucketId, std::vector<Policy>> toBeInsertedOrUpdatedPolicies;
  84     std::map<PolicyBucketId, std::vector<PolicyKey>> toBeRemovedPolicies;
  85
  86     ProtocolDeserialization::deserialize(frame, toBeInsertedOrUpdatedCount);
  87     for (ProtocolFrameFieldsCount b = 0; b < toBeInsertedOrUpdatedCount; ++b) {
  88         PolicyBucketId policyBucketId;
  89         ProtocolDeserialization::deserialize(frame, policyBucketId);
  90         ProtocolDeserialization::deserialize(frame, policyCount);
  91         for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
  92             // PolicyKey
  93             ProtocolDeserialization::deserialize(frame, clientId);
  94             ProtocolDeserialization::deserialize(frame, user);
  95             ProtocolDeserialization::deserialize(frame, privilege);
  96             // PolicyResult
  97             ProtocolDeserialization::deserialize(frame, policyType);
  98             ProtocolDeserialization::deserialize(frame, metadata);
  99
 100             toBeInsertedOrUpdatedPolicies[policyBucketId].push_back(
 101                     Policy(PolicyKey(clientId, user, privilege),
 102                     PolicyResult(policyType, metadata)));
 103         }
 104     }
 105
 106     ProtocolDeserialization::deserialize(frame, toBeRemovedCount);
 107     for (ProtocolFrameFieldsCount b = 0; b < toBeRemovedCount; ++b) {
 108         PolicyBucketId policyBucketId;
 109         ProtocolDeserialization::deserialize(frame, policyBucketId);
 110         ProtocolDeserialization::deserialize(frame, policyCount);
 111         for (ProtocolFrameFieldsCount p = 0; p < policyCount; ++p) {
 112             // PolicyKey
 113             ProtocolDeserialization::deserialize(frame, clientId);
 114             ProtocolDeserialization::deserialize(frame, user);
 115             ProtocolDeserialization::deserialize(frame, privilege);
 116
 117             toBeRemovedPolicies[policyBucketId].push_back(PolicyKey(clientId, user, privilege));
 118         }
 119     }
 120
 121     LOGD("Deserialized SetPoliciesRequestPtr: insertOrUpdate count [%u], remove count [%u]",
 122          static_cast<unsigned int>(toBeInsertedOrUpdatedCount),
 123          static_cast<unsigned int>(toBeRemovedCount));
 124
 125     return std::make_shared<SetPoliciesRequest>(toBeInsertedOrUpdatedPolicies,
 126                                                 toBeRemovedPolicies, frame.sequenceNumber());
 127 }
 128
 129 RequestPtr ProtocolAdmin::extractRequestFromBuffer(BinaryQueue &bufferQueue) {
 130     ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
 131
 132     if (m_frameHeader.isFrameComplete()) {
 133         ProtocolOpCode opCode;
 134
 135         m_frameHeader.resetState();
 136         ProtocolDeserialization::deserialize(m_frameHeader, opCode);
 137         LOGD("Deserialized opCode [%u]", static_cast<unsigned int>(opCode));
 138         switch (opCode) {
 139         case OpInsertOrUpdateBucket:
 140             return deserializeInsertOrUpdateBucketRequest(m_frameHeader);
 141         case OpRemoveBucket:
 142             return deserializeRemoveBucketRequest(m_frameHeader);
 143         case OpSetPolicies:
 144             return deserializeSetPoliciesRequest(m_frameHeader);
 145         default:
 146             throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
 147             break;
 148         }
 149     }
 150
 151     return nullptr;
 152 }
 153
 154 ResponsePtr ProtocolAdmin::deserializeCodeResponse(ProtocolFrameHeader &frame) {
 155     ProtocolResponseCode responseCode;
 156     ProtocolDeserialization::deserialize(frame, responseCode);
 157
 158     LOGD("Deserialized CodeResponse: code [%u], ", static_cast<unsigned int>(responseCode));
 159
 160     return std::make_shared<CodeResponse>(static_cast<CodeResponse::Code>(responseCode),
 161                                           frame.sequenceNumber());
 162 }
 163
 164 ResponsePtr ProtocolAdmin::extractResponseFromBuffer(BinaryQueue &bufferQueue) {
 165     ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
 166
 167     if (m_frameHeader.isFrameComplete()) {
 168         ProtocolOpCode opCode;
 169
 170         m_frameHeader.resetState();
 171         ProtocolDeserialization::deserialize(m_frameHeader, opCode);
 172         LOGD("Deserialized opCode [%u]", static_cast<unsigned int>(opCode));
 173         switch (opCode) {
 174         case OpCodeResponse:
 175             return deserializeCodeResponse(m_frameHeader);
 176         default:
 177             throw InvalidProtocolException(InvalidProtocolException::WrongOpCode);
 178             break;
 179         }
 180     }
 181
 182     return nullptr;
 183 }
 184
 185 void ProtocolAdmin::execute(RequestContextPtr context, InsertOrUpdateBucketRequestPtr request) {
 186     LOGD("Serializing InsertOrUpdateBucketRequest: sequenceNumber [%u], bucketId <%s>, "
 187          "result.type [%u], result.meta <%s>",
 188          static_cast<unsigned int>(request->sequenceNumber()),
 189          request->bucketId().c_str(),
 190          static_cast<unsigned int>(request->result().policyType()),
 191          request->result().metadata().c_str());
 192
 193     ProtocolFramePtr frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 194
 195     ProtocolSerialization::serialize(*frame, OpInsertOrUpdateBucket);
 196     ProtocolSerialization::serialize(*frame, request->bucketId());
 197     ProtocolSerialization::serialize(*frame, request->result().policyType());
 198     ProtocolSerialization::serialize(*frame, request->result().metadata());
 199
 200     ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
 201 }
 202
 203 void ProtocolAdmin::execute(RequestContextPtr context, RemoveBucketRequestPtr request) {
 204     LOGD("Serializing RemoveBucketRequest: sequenceNumber [%u], bucketId <%s>",
 205          static_cast<unsigned int>(request->sequenceNumber()), request->bucketId().c_str());
 206
 207     ProtocolFramePtr frame = ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 208
 209     ProtocolSerialization::serialize(*frame, OpRemoveBucket);
 210     ProtocolSerialization::serialize(*frame, request->bucketId());
 211
 212     ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
 213 }
 214
 215 void ProtocolAdmin::execute(RequestContextPtr context, SetPoliciesRequestPtr request) {
 216     LOGD("Serializing SetPoliciesRequestPtr: sequenceNumber [%u], insertOrUpdate count [%zu], "
 217          "remove count [%zu]", static_cast<unsigned int>(request->sequenceNumber()),
 218          request->policiesToBeInsertedOrUpdated().size(),
 219          request->policiesToBeRemoved().size());
 220
 221     ProtocolFramePtr frame =
 222             ProtocolFrameSerializer::startSerialization(request->sequenceNumber());
 223
 224     ProtocolSerialization::serialize(*frame, OpSetPolicies);
 225
 226     ProtocolSerialization::serialize(*frame,
 227             static_cast<ProtocolFrameFieldsCount>(request->policiesToBeInsertedOrUpdated().size()));
 228     for (auto policyBucket : request->policiesToBeInsertedOrUpdated()) {
 229         ProtocolSerialization::serialize(*frame, policyBucket.first);
 230         ProtocolSerialization::serialize(*frame,
 231                     static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
 232         for (auto policy : policyBucket.second) {
 233             // PolicyKey
 234             ProtocolSerialization::serialize(*frame, policy.key().client().value());
 235             ProtocolSerialization::serialize(*frame, policy.key().user().value());
 236             ProtocolSerialization::serialize(*frame, policy.key().privilege().value());
 237             // PolicyResult
 238             ProtocolSerialization::serialize(*frame, policy.result().policyType());
 239             ProtocolSerialization::serialize(*frame, policy.result().metadata());
 240         }
 241     }
 242
 243     ProtocolSerialization::serialize(*frame,
 244             static_cast<ProtocolFrameFieldsCount>(request->policiesToBeRemoved().size()));
 245     for (auto policyBucket : request->policiesToBeRemoved()) {
 246         ProtocolSerialization::serialize(*frame, policyBucket.first);
 247         ProtocolSerialization::serialize(*frame,
 248                     static_cast<ProtocolFrameFieldsCount>(policyBucket.second.size()));
 249         for (auto policyKey : policyBucket.second) {
 250             // PolicyKey
 251             ProtocolSerialization::serialize(*frame, policyKey.client().value());
 252             ProtocolSerialization::serialize(*frame, policyKey.user().value());
 253             ProtocolSerialization::serialize(*frame, policyKey.privilege().value());
 254         }
 255     }
 256
 257     ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
 258 }
 259
 260 void ProtocolAdmin::execute(RequestContextPtr context, CodeResponsePtr response) {
 261     LOGD("Serializing CodeResponse: sequenceNumber [%u], code [%u]",
 262          static_cast<unsigned int>(response->sequenceNumber()),
 263          static_cast<unsigned int>(response->m_code));
 264
 265     ProtocolFramePtr frame = ProtocolFrameSerializer::startSerialization(
 266             response->sequenceNumber());
 267
 268     ProtocolSerialization::serialize(*frame, OpCodeResponse);
 269     ProtocolSerialization::serialize(*frame, static_cast<ProtocolResponseCode>(response->m_code));
 270
 271     ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
 272 }
 273
 274 } // namespace Cynara