diff --git a/services/tunnelbroker/docker-server/contents/server/src/Amqp/AmqpManager.cpp b/services/tunnelbroker/docker-server/contents/server/src/Amqp/AmqpManager.cpp index 5c7675489..4ecde355a 100644 --- a/services/tunnelbroker/docker-server/contents/server/src/Amqp/AmqpManager.cpp +++ b/services/tunnelbroker/docker-server/contents/server/src/Amqp/AmqpManager.cpp @@ -1,143 +1,143 @@ #include "AmqpManager.h" #include "ConfigManager.h" #include "Constants.h" #include "DeliveryBroker.h" #include "Tools.h" #include #include namespace comm { namespace network { static std::unique_ptr amqpChannel; static std::atomic amqpReady; static long long lastConnectionTimestamp; void AMQPConnectInternal() { const std::string amqpUri = config::ConfigManager::getInstance().getParameter( config::ConfigManager::OPTION_AMQP_URI); - const std::string tunnelbrokerId = + const std::string tunnelbrokerID = config::ConfigManager::getInstance().getParameter( config::ConfigManager::OPTION_TUNNELBROKER_ID); const std::string fanoutExchangeName = config::ConfigManager::getInstance().getParameter( config::ConfigManager::OPTION_AMQP_FANOUT_EXCHANGE); std::cout << "AMQP: Connecting to " << amqpUri << std::endl; auto *loop = uv_default_loop(); AMQP::LibUvHandler handler(loop); AMQP::TcpConnection connection(&handler, AMQP::Address(amqpUri)); amqpChannel = std::make_unique(&connection); amqpChannel->onError([](const char *message) { std::cout << "AMQP: channel error: " << message << ", will try to reconnect" << std::endl; amqpReady = false; }); AMQP::Table arguments; arguments["x-message-ttl"] = AMQP_MESSAGE_TTL; arguments["x-expires"] = AMQP_QUEUE_TTL; amqpChannel->declareExchange(fanoutExchangeName, AMQP::fanout); - amqpChannel->declareQueue(tunnelbrokerId, AMQP::durable, arguments) - .onSuccess([tunnelbrokerId, fanoutExchangeName]( + amqpChannel->declareQueue(tunnelbrokerID, AMQP::durable, arguments) + .onSuccess([tunnelbrokerID, fanoutExchangeName]( const std::string &name, uint32_t messagecount, uint32_t consumercount) { std::cout << "AMQP: Queue " << name << " created" << std::endl; - amqpChannel->bindQueue(fanoutExchangeName, tunnelbrokerId, "") - .onError([tunnelbrokerId, fanoutExchangeName](const char *message) { - std::cout << "AMQP: Failed to bind queue: " << tunnelbrokerId + amqpChannel->bindQueue(fanoutExchangeName, tunnelbrokerID, "") + .onError([tunnelbrokerID, fanoutExchangeName](const char *message) { + std::cout << "AMQP: Failed to bind queue: " << tunnelbrokerID << " to exchange: " << fanoutExchangeName << std::endl; amqpReady = false; }); amqpReady = true; - amqpChannel->consume(tunnelbrokerId) + amqpChannel->consume(tunnelbrokerID) .onReceived([&](const AMQP::Message &message, uint64_t deliveryTag, bool redelivered) { try { AMQP::Table headers = message.headers(); const std::string payload(message.body()); const std::string toDeviceID(headers[AMQP_HEADER_TO_DEVICEID]); const std::string fromDeviceID( headers[AMQP_HEADER_FROM_DEVICEID]); - std::cout << "AMQP: Message consumed for deviceId: " + std::cout << "AMQP: Message consumed for deviceID: " << toDeviceID << std::endl; DeliveryBroker::getInstance().push( deliveryTag, toDeviceID, fromDeviceID, payload); } catch (const std::exception &e) { std::cout << "AMQP: Message parsing exception: " << e.what() << std::endl; } }) .onError([](const char *message) { std::cout << "AMQP: Error on message consume: " << message << std::endl; }); }) .onError([](const char *message) { throw std::runtime_error( "AMQP: Queue creation error: " + std::string(message)); }); uv_run(loop, UV_RUN_DEFAULT); }; void AMQPConnect() { while (true) { long long currentTimestamp = getCurrentTimestamp(); if (lastConnectionTimestamp && currentTimestamp - lastConnectionTimestamp < AMQP_SHORTEST_RECONNECTION_ATTEMPT_INTERVAL) { throw std::runtime_error( "AMQP reconnection attempt interval too short, tried to reconnect " "after " + std::to_string(currentTimestamp - lastConnectionTimestamp) + "ms, the shortest allowed interval is " + std::to_string(AMQP_SHORTEST_RECONNECTION_ATTEMPT_INTERVAL) + "ms"); } lastConnectionTimestamp = currentTimestamp; AMQPConnectInternal(); } } bool AMQPSend( std::string toDeviceID, std::string fromDeviceID, std::string payload) { if (!amqpReady) { std::cout << "AMQP: Message send error: channel not ready" << std::endl; return false; } try { AMQP::Envelope env(payload.c_str(), payload.size()); AMQP::Table headers; headers[AMQP_HEADER_FROM_DEVICEID] = fromDeviceID; headers[AMQP_HEADER_TO_DEVICEID] = toDeviceID; // Set delivery mode to: Durable (2) env.setDeliveryMode(2); env.setHeaders(std::move(headers)); amqpChannel->publish( config::ConfigManager::getInstance().getParameter( config::ConfigManager::OPTION_AMQP_FANOUT_EXCHANGE), "", env); } catch (std::runtime_error &e) { std::cout << "AMQP: Error while publishing message: " << e.what() << std::endl; return false; } return true; }; void AMQPAck(uint64_t deliveryTag) { if (!amqpReady) { std::cout << "AMQP: Message ACK error: channel not ready" << std::endl; return; } amqpChannel->ack(deliveryTag); } } // namespace network } // namespace comm diff --git a/services/tunnelbroker/docker-server/contents/server/src/Database/DatabaseManager.cpp b/services/tunnelbroker/docker-server/contents/server/src/Database/DatabaseManager.cpp index b6119b5a3..f15ffb922 100644 --- a/services/tunnelbroker/docker-server/contents/server/src/Database/DatabaseManager.cpp +++ b/services/tunnelbroker/docker-server/contents/server/src/Database/DatabaseManager.cpp @@ -1,165 +1,165 @@ #include "DatabaseManager.h" namespace comm { namespace network { namespace database { DatabaseManager &DatabaseManager::getInstance() { static DatabaseManager instance; return instance; } bool DatabaseManager::isTableAvailable(const std::string &tableName) { Aws::DynamoDB::Model::DescribeTableRequest request; request.SetTableName(tableName); // Check table availability by invoking DescribeTable const Aws::DynamoDB::Model::DescribeTableOutcome &result = getDynamoDBClient()->DescribeTable(request); return result.IsSuccess(); } void DatabaseManager::innerPutItem( std::shared_ptr item, const Aws::DynamoDB::Model::PutItemRequest &request) { const Aws::DynamoDB::Model::PutItemOutcome outcome = getDynamoDBClient()->PutItem(request); if (!outcome.IsSuccess()) { throw std::runtime_error(outcome.GetError().GetMessage()); } } template std::shared_ptr DatabaseManager::innerFindItem(Aws::DynamoDB::Model::GetItemRequest &request) { std::shared_ptr item = createItemByType(); request.SetTableName(item->getTableName()); const Aws::DynamoDB::Model::GetItemOutcome &outcome = getDynamoDBClient()->GetItem(request); if (!outcome.IsSuccess()) { throw std::runtime_error(outcome.GetError().GetMessage()); } const AttributeValues &outcomeItem = outcome.GetResult().GetItem(); if (!outcomeItem.size()) { return nullptr; } item->assignItemFromDatabase(outcomeItem); return std::move(item); } void DatabaseManager::innerRemoveItem( const Item &item, const std::string &key) { Aws::DynamoDB::Model::DeleteItemRequest request; request.SetTableName(item.getTableName()); request.AddKey( item.getPrimaryKey(), Aws::DynamoDB::Model::AttributeValue(key)); const Aws::DynamoDB::Model::DeleteItemOutcome &outcome = getDynamoDBClient()->DeleteItem(request); if (!outcome.IsSuccess()) { throw std::runtime_error(outcome.GetError().GetMessage()); } } void DatabaseManager::putSessionItem(const DeviceSessionItem &item) { Aws::DynamoDB::Model::PutItemRequest request; request.SetTableName(item.getTableName()); request.AddItem( DeviceSessionItem::FIELD_SESSION_ID, - Aws::DynamoDB::Model::AttributeValue(item.getSessionId())); + Aws::DynamoDB::Model::AttributeValue(item.getSessionID())); request.AddItem( DeviceSessionItem::FIELD_DEVICE_ID, - Aws::DynamoDB::Model::AttributeValue(item.getDeviceId())); + Aws::DynamoDB::Model::AttributeValue(item.getDeviceID())); request.AddItem( DeviceSessionItem::FIELD_PUBKEY, Aws::DynamoDB::Model::AttributeValue(item.getPubKey())); request.AddItem( DeviceSessionItem::FIELD_NOTIFY_TOKEN, Aws::DynamoDB::Model::AttributeValue(item.getNotifyToken())); request.AddItem( DeviceSessionItem::FIELD_DEVICE_TYPE, Aws::DynamoDB::Model::AttributeValue(item.getDeviceType())); request.AddItem( DeviceSessionItem::FIELD_APP_VERSION, Aws::DynamoDB::Model::AttributeValue(item.getAppVersion())); request.AddItem( DeviceSessionItem::FIELD_DEVICE_OS, Aws::DynamoDB::Model::AttributeValue(item.getDeviceOs())); request.AddItem( DeviceSessionItem::FIELD_CHECKPOINT_TIME, Aws::DynamoDB::Model::AttributeValue( std::to_string(item.getCheckpointTime()))); request.AddItem( DeviceSessionItem::FIELD_EXPIRE, Aws::DynamoDB::Model::AttributeValue(std::to_string( static_cast(std::time(0)) + SESSION_RECORD_TTL))); this->innerPutItem(std::make_shared(item), request); } std::shared_ptr -DatabaseManager::findSessionItem(const std::string &sessionId) { +DatabaseManager::findSessionItem(const std::string &sessionID) { Aws::DynamoDB::Model::GetItemRequest request; request.AddKey( DeviceSessionItem::FIELD_SESSION_ID, - Aws::DynamoDB::Model::AttributeValue(sessionId)); + Aws::DynamoDB::Model::AttributeValue(sessionID)); return std::move(this->innerFindItem(request)); } void DatabaseManager::putSessionSignItem(const SessionSignItem &item) { Aws::DynamoDB::Model::PutItemRequest request; request.SetTableName(item.getTableName()); request.AddItem( SessionSignItem::FIELD_SESSION_VERIFICATION, Aws::DynamoDB::Model::AttributeValue(item.getSign())); request.AddItem( SessionSignItem::FIELD_DEVICE_ID, - Aws::DynamoDB::Model::AttributeValue(item.getDeviceId())); + Aws::DynamoDB::Model::AttributeValue(item.getDeviceID())); request.AddItem( SessionSignItem::FIELD_EXPIRE, Aws::DynamoDB::Model::AttributeValue(std::to_string( static_cast(std::time(0)) + SESSION_SIGN_RECORD_TTL))); this->innerPutItem(std::make_shared(item), request); } std::shared_ptr -DatabaseManager::findSessionSignItem(const std::string &deviceId) { +DatabaseManager::findSessionSignItem(const std::string &deviceID) { Aws::DynamoDB::Model::GetItemRequest request; request.AddKey( SessionSignItem::FIELD_DEVICE_ID, - Aws::DynamoDB::Model::AttributeValue(deviceId)); + Aws::DynamoDB::Model::AttributeValue(deviceID)); return std::move(this->innerFindItem(request)); } -void DatabaseManager::removeSessionSignItem(const std::string &deviceId) { - this->innerRemoveItem(*(createItemByType()), deviceId); +void DatabaseManager::removeSessionSignItem(const std::string &deviceID) { + this->innerRemoveItem(*(createItemByType()), deviceID); } void DatabaseManager::putPublicKeyItem(const PublicKeyItem &item) { Aws::DynamoDB::Model::PutItemRequest request; request.SetTableName(item.getTableName()); request.AddItem( PublicKeyItem::FIELD_DEVICE_ID, - Aws::DynamoDB::Model::AttributeValue(item.getDeviceId())); + Aws::DynamoDB::Model::AttributeValue(item.getDeviceID())); request.AddItem( PublicKeyItem::FIELD_PUBLIC_KEY, Aws::DynamoDB::Model::AttributeValue(item.getPublicKey())); this->innerPutItem(std::make_shared(item), request); } std::shared_ptr -DatabaseManager::findPublicKeyItem(const std::string &deviceId) { +DatabaseManager::findPublicKeyItem(const std::string &deviceID) { Aws::DynamoDB::Model::GetItemRequest request; request.AddKey( PublicKeyItem::FIELD_DEVICE_ID, - Aws::DynamoDB::Model::AttributeValue(deviceId)); + Aws::DynamoDB::Model::AttributeValue(deviceID)); return std::move(this->innerFindItem(request)); } -void DatabaseManager::removePublicKeyItem(const std::string &deviceId) { - this->innerRemoveItem(*(createItemByType()), deviceId); +void DatabaseManager::removePublicKeyItem(const std::string &deviceID) { + this->innerRemoveItem(*(createItemByType()), deviceID); } } // namespace database } // namespace network } // namespace comm diff --git a/services/tunnelbroker/docker-server/contents/server/src/Database/DatabaseManager.h b/services/tunnelbroker/docker-server/contents/server/src/Database/DatabaseManager.h index 08a6e8597..b4a76c28b 100644 --- a/services/tunnelbroker/docker-server/contents/server/src/Database/DatabaseManager.h +++ b/services/tunnelbroker/docker-server/contents/server/src/Database/DatabaseManager.h @@ -1,55 +1,55 @@ #pragma once #include "AwsTools.h" #include "Constants.h" #include "DatabaseEntitiesTools.h" #include "DeviceSessionItem.h" #include "Tools.h" #include #include #include #include #include #include #include #include #include #include namespace comm { namespace network { namespace database { class DatabaseManager { void innerPutItem( std::shared_ptr item, const Aws::DynamoDB::Model::PutItemRequest &request); template std::shared_ptr innerFindItem(Aws::DynamoDB::Model::GetItemRequest &request); void innerRemoveItem(const Item &item, const std::string &key); public: static DatabaseManager &getInstance(); bool isTableAvailable(const std::string &tableName); void putSessionItem(const DeviceSessionItem &item); std::shared_ptr findSessionItem(const std::string &deviceID); void putSessionSignItem(const SessionSignItem &item); std::shared_ptr - findSessionSignItem(const std::string &deviceId); - void removeSessionSignItem(const std::string &deviceId); + findSessionSignItem(const std::string &deviceID); + void removeSessionSignItem(const std::string &deviceID); void putPublicKeyItem(const PublicKeyItem &item); - std::shared_ptr findPublicKeyItem(const std::string &deviceId); - void removePublicKeyItem(const std::string &deviceId); + std::shared_ptr findPublicKeyItem(const std::string &deviceID); + void removePublicKeyItem(const std::string &deviceID); }; } // namespace database } // namespace network } // namespace comm diff --git a/services/tunnelbroker/docker-server/contents/server/src/Database/DeviceSessionItem.cpp b/services/tunnelbroker/docker-server/contents/server/src/Database/DeviceSessionItem.cpp index f9f339933..ac8b642d4 100644 --- a/services/tunnelbroker/docker-server/contents/server/src/Database/DeviceSessionItem.cpp +++ b/services/tunnelbroker/docker-server/contents/server/src/Database/DeviceSessionItem.cpp @@ -1,113 +1,113 @@ #include "DeviceSessionItem.h" #include "ConfigManager.h" namespace comm { namespace network { namespace database { const std::string DeviceSessionItem::FIELD_SESSION_ID = "SessionId"; const std::string DeviceSessionItem::FIELD_DEVICE_ID = "DeviceId"; const std::string DeviceSessionItem::FIELD_PUBKEY = "PubKey"; const std::string DeviceSessionItem::FIELD_NOTIFY_TOKEN = "NotifyToken"; const std::string DeviceSessionItem::FIELD_DEVICE_TYPE = "DeviceType"; const std::string DeviceSessionItem::FIELD_APP_VERSION = "AppVersion"; const std::string DeviceSessionItem::FIELD_DEVICE_OS = "DeviceOS"; const std::string DeviceSessionItem::FIELD_CHECKPOINT_TIME = "CheckpointTime"; const std::string DeviceSessionItem::FIELD_EXPIRE = "Expire"; DeviceSessionItem::DeviceSessionItem( - const std::string sessionId, - const std::string deviceId, + const std::string sessionID, + const std::string deviceID, const std::string pubKey, const std::string notifyToken, const std::string deviceType, const std::string appVersion, const std::string deviceOs) - : sessionId(sessionId), - deviceId(deviceId), + : sessionID(sessionID), + deviceID(deviceID), pubKey(pubKey), notifyToken(notifyToken), deviceType(deviceType), appVersion(appVersion), deviceOs(deviceOs) { this->validate(); } DeviceSessionItem::DeviceSessionItem(const AttributeValues &itemFromDB) { this->assignItemFromDatabase(itemFromDB); } void DeviceSessionItem::validate() const { - if (!this->sessionId.size()) { - throw std::runtime_error("Error: SessionId is empty."); + if (!this->sessionID.size()) { + throw std::runtime_error("Error: SessionID is empty."); } } void DeviceSessionItem::assignItemFromDatabase( const AttributeValues &itemFromDB) { try { - this->sessionId = itemFromDB.at(DeviceSessionItem::FIELD_SESSION_ID).GetS(); - this->deviceId = itemFromDB.at(DeviceSessionItem::FIELD_DEVICE_ID).GetS(); + this->sessionID = itemFromDB.at(DeviceSessionItem::FIELD_SESSION_ID).GetS(); + this->deviceID = itemFromDB.at(DeviceSessionItem::FIELD_DEVICE_ID).GetS(); this->pubKey = itemFromDB.at(DeviceSessionItem::FIELD_PUBKEY).GetS(); this->notifyToken = itemFromDB.at(DeviceSessionItem::FIELD_NOTIFY_TOKEN).GetS(); this->deviceType = itemFromDB.at(DeviceSessionItem::FIELD_DEVICE_TYPE).GetS(); this->appVersion = itemFromDB.at(DeviceSessionItem::FIELD_APP_VERSION).GetS(); this->deviceOs = itemFromDB.at(DeviceSessionItem::FIELD_DEVICE_OS).GetS(); this->checkpointTime = std::stoll( std::string( itemFromDB.at(DeviceSessionItem::FIELD_CHECKPOINT_TIME).GetS()) .c_str()); } catch (std::logic_error &e) { throw std::runtime_error( "Invalid device session database value " + std::string(e.what())); } this->validate(); } std::string DeviceSessionItem::getTableName() const { return config::ConfigManager::getInstance().getParameter( config::ConfigManager::OPTION_DYNAMODB_SESSIONS_TABLE); } std::string DeviceSessionItem::getPrimaryKey() const { return DeviceSessionItem::FIELD_SESSION_ID; } -std::string DeviceSessionItem::getSessionId() const { - return this->sessionId; +std::string DeviceSessionItem::getSessionID() const { + return this->sessionID; } -std::string DeviceSessionItem::getDeviceId() const { - return this->deviceId; +std::string DeviceSessionItem::getDeviceID() const { + return this->deviceID; } std::string DeviceSessionItem::getPubKey() const { return this->pubKey; } std::string DeviceSessionItem::getNotifyToken() const { return this->notifyToken; } std::string DeviceSessionItem::getDeviceType() const { return this->deviceType; } std::string DeviceSessionItem::getAppVersion() const { return this->appVersion; } std::string DeviceSessionItem::getDeviceOs() const { return this->deviceOs; } long long DeviceSessionItem::getCheckpointTime() const { return this->checkpointTime; } } // namespace database } // namespace network } // namespace comm diff --git a/services/tunnelbroker/docker-server/contents/server/src/Database/DeviceSessionItem.h b/services/tunnelbroker/docker-server/contents/server/src/Database/DeviceSessionItem.h index 7f0a92d82..ea5979120 100644 --- a/services/tunnelbroker/docker-server/contents/server/src/Database/DeviceSessionItem.h +++ b/services/tunnelbroker/docker-server/contents/server/src/Database/DeviceSessionItem.h @@ -1,61 +1,61 @@ #pragma once #include "Item.h" #include namespace comm { namespace network { namespace database { class DeviceSessionItem : public Item { - std::string sessionId; - std::string deviceId; + std::string sessionID; + std::string deviceID; std::string pubKey; std::string notifyToken; std::string deviceType; std::string appVersion; std::string deviceOs; long long checkpointTime = 0; void validate() const override; public: static const std::string FIELD_SESSION_ID; static const std::string FIELD_DEVICE_ID; static const std::string FIELD_PUBKEY; static const std::string FIELD_NOTIFY_TOKEN; static const std::string FIELD_DEVICE_TYPE; static const std::string FIELD_APP_VERSION; static const std::string FIELD_DEVICE_OS; static const std::string FIELD_CHECKPOINT_TIME; static const std::string FIELD_EXPIRE; std::string getPrimaryKey() const override; std::string getTableName() const override; - std::string getSessionId() const; - std::string getDeviceId() const; + std::string getSessionID() const; + std::string getDeviceID() const; std::string getPubKey() const; std::string getNotifyToken() const; std::string getDeviceType() const; std::string getAppVersion() const; std::string getDeviceOs() const; long long getCheckpointTime() const; DeviceSessionItem() { } DeviceSessionItem( - const std::string sessionId, - const std::string deviceId, + const std::string sessionID, + const std::string deviceID, const std::string pubKey, const std::string notifyToken, const std::string deviceType, const std::string appVersion, const std::string deviceOs); DeviceSessionItem(const AttributeValues &itemFromDB); void assignItemFromDatabase(const AttributeValues &itemFromDB) override; }; } // namespace database } // namespace network } // namespace comm diff --git a/services/tunnelbroker/docker-server/contents/server/src/Database/PublicKeyItem.cpp b/services/tunnelbroker/docker-server/contents/server/src/Database/PublicKeyItem.cpp index 4f63e2d47..1b9eb4dfe 100644 --- a/services/tunnelbroker/docker-server/contents/server/src/Database/PublicKeyItem.cpp +++ b/services/tunnelbroker/docker-server/contents/server/src/Database/PublicKeyItem.cpp @@ -1,61 +1,61 @@ #include "PublicKeyItem.h" #include "ConfigManager.h" namespace comm { namespace network { namespace database { const std::string PublicKeyItem::FIELD_DEVICE_ID = "DeviceId"; const std::string PublicKeyItem::FIELD_PUBLIC_KEY = "PublicKey"; PublicKeyItem::PublicKeyItem( - const std::string deviceId, + const std::string deviceID, const std::string publicKey) - : deviceId(deviceId), publicKey(publicKey) { + : deviceID(deviceID), publicKey(publicKey) { this->validate(); } PublicKeyItem::PublicKeyItem(const AttributeValues &itemFromDB) { this->assignItemFromDatabase(itemFromDB); } void PublicKeyItem::validate() const { - if (!this->deviceId.size()) { - throw std::runtime_error("Error: DeviceId is empty"); + if (!this->deviceID.size()) { + throw std::runtime_error("Error: DeviceID is empty"); } if (!this->publicKey.size()) { throw std::runtime_error("Error: PublicKey is empty"); } } void PublicKeyItem::assignItemFromDatabase(const AttributeValues &itemFromDB) { try { this->publicKey = itemFromDB.at(PublicKeyItem::FIELD_PUBLIC_KEY).GetS(); - this->deviceId = itemFromDB.at(PublicKeyItem::FIELD_DEVICE_ID).GetS(); + this->deviceID = itemFromDB.at(PublicKeyItem::FIELD_DEVICE_ID).GetS(); } catch (const std::exception &e) { throw std::runtime_error( "Got an exception at PublicKeyItem: " + std::string(e.what())); } this->validate(); } std::string PublicKeyItem::getTableName() const { return config::ConfigManager::getInstance().getParameter( config::ConfigManager::OPTION_DYNAMODB_SESSIONS_PUBLIC_KEY_TABLE); } std::string PublicKeyItem::getPrimaryKey() const { return PublicKeyItem::FIELD_DEVICE_ID; } -std::string PublicKeyItem::getDeviceId() const { - return this->deviceId; +std::string PublicKeyItem::getDeviceID() const { + return this->deviceID; } std::string PublicKeyItem::getPublicKey() const { return this->publicKey; } } // namespace database } // namespace network } // namespace comm diff --git a/services/tunnelbroker/docker-server/contents/server/src/Database/PublicKeyItem.h b/services/tunnelbroker/docker-server/contents/server/src/Database/PublicKeyItem.h index cb1f25288..5ae48dee7 100644 --- a/services/tunnelbroker/docker-server/contents/server/src/Database/PublicKeyItem.h +++ b/services/tunnelbroker/docker-server/contents/server/src/Database/PublicKeyItem.h @@ -1,35 +1,35 @@ #pragma once #include "Item.h" #include namespace comm { namespace network { namespace database { class PublicKeyItem : public Item { - std::string deviceId; + std::string deviceID; std::string publicKey; void validate() const override; public: static const std::string FIELD_DEVICE_ID; static const std::string FIELD_PUBLIC_KEY; std::string getPrimaryKey() const override; std::string getTableName() const override; - std::string getDeviceId() const; + std::string getDeviceID() const; std::string getPublicKey() const; PublicKeyItem() { } - PublicKeyItem(const std::string deviceId, const std::string publicKey); + PublicKeyItem(const std::string deviceID, const std::string publicKey); PublicKeyItem(const AttributeValues &itemFromDB); void assignItemFromDatabase(const AttributeValues &itemFromDB) override; }; } // namespace database } // namespace network } // namespace comm diff --git a/services/tunnelbroker/docker-server/contents/server/src/Database/SessionSignItem.cpp b/services/tunnelbroker/docker-server/contents/server/src/Database/SessionSignItem.cpp index fc51a5e67..d80e43234 100644 --- a/services/tunnelbroker/docker-server/contents/server/src/Database/SessionSignItem.cpp +++ b/services/tunnelbroker/docker-server/contents/server/src/Database/SessionSignItem.cpp @@ -1,65 +1,65 @@ #include "SessionSignItem.h" #include "ConfigManager.h" namespace comm { namespace network { namespace database { const std::string SessionSignItem::FIELD_SESSION_VERIFICATION = "VerificationMessage"; const std::string SessionSignItem::FIELD_DEVICE_ID = "DeviceId"; const std::string SessionSignItem::FIELD_EXPIRE = "Expire"; SessionSignItem::SessionSignItem( const std::string sign, - const std::string deviceId) - : sign(sign), deviceId(deviceId) { + const std::string deviceID) + : sign(sign), deviceID(deviceID) { this->validate(); } SessionSignItem::SessionSignItem(const AttributeValues &itemFromDB) { this->assignItemFromDatabase(itemFromDB); } void SessionSignItem::validate() const { - if (!this->deviceId.size()) { - throw std::runtime_error("Error: DeviceId is empty"); + if (!this->deviceID.size()) { + throw std::runtime_error("Error: DeviceID is empty"); } if (!this->sign.size()) { throw std::runtime_error("Error: Sign is empty"); } } void SessionSignItem::assignItemFromDatabase( const AttributeValues &itemFromDB) { try { this->sign = itemFromDB.at(SessionSignItem::FIELD_SESSION_VERIFICATION).GetS(); - this->deviceId = itemFromDB.at(SessionSignItem::FIELD_DEVICE_ID).GetS(); + this->deviceID = itemFromDB.at(SessionSignItem::FIELD_DEVICE_ID).GetS(); } catch (const std::exception &e) { throw std::runtime_error( "Got an exception at SessionSignItem: " + std::string(e.what())); } this->validate(); } std::string SessionSignItem::getTableName() const { return config::ConfigManager::getInstance().getParameter( config::ConfigManager::OPTION_DYNAMODB_SESSIONS_VERIFICATION_TABLE); } std::string SessionSignItem::getPrimaryKey() const { return SessionSignItem::FIELD_DEVICE_ID; } std::string SessionSignItem::getSign() const { return this->sign; } -std::string SessionSignItem::getDeviceId() const { - return this->deviceId; +std::string SessionSignItem::getDeviceID() const { + return this->deviceID; } } // namespace database } // namespace network } // namespace comm diff --git a/services/tunnelbroker/docker-server/contents/server/src/Database/SessionSignItem.h b/services/tunnelbroker/docker-server/contents/server/src/Database/SessionSignItem.h index 75094f9a3..d6b0e43cf 100644 --- a/services/tunnelbroker/docker-server/contents/server/src/Database/SessionSignItem.h +++ b/services/tunnelbroker/docker-server/contents/server/src/Database/SessionSignItem.h @@ -1,36 +1,36 @@ #pragma once #include "Item.h" #include namespace comm { namespace network { namespace database { class SessionSignItem : public Item { std::string sign; - std::string deviceId; + std::string deviceID; void validate() const override; public: static const std::string FIELD_SESSION_VERIFICATION; static const std::string FIELD_DEVICE_ID; static const std::string FIELD_EXPIRE; std::string getPrimaryKey() const override; std::string getTableName() const override; std::string getSign() const; - std::string getDeviceId() const; + std::string getDeviceID() const; SessionSignItem() { } - SessionSignItem(const std::string sign, const std::string deviceId); + SessionSignItem(const std::string sign, const std::string deviceID); SessionSignItem(const AttributeValues &itemFromDB); void assignItemFromDatabase(const AttributeValues &itemFromDB) override; }; } // namespace database } // namespace network } // namespace comm diff --git a/services/tunnelbroker/docker-server/contents/server/src/Service/TunnelbrokerServiceImpl.cpp b/services/tunnelbroker/docker-server/contents/server/src/Service/TunnelbrokerServiceImpl.cpp index 2e6cc26b4..282d43bde 100644 --- a/services/tunnelbroker/docker-server/contents/server/src/Service/TunnelbrokerServiceImpl.cpp +++ b/services/tunnelbroker/docker-server/contents/server/src/Service/TunnelbrokerServiceImpl.cpp @@ -1,226 +1,226 @@ #include "TunnelbrokerServiceImpl.h" #include "AmqpManager.h" #include "AwsTools.h" #include "ConfigManager.h" #include "CryptoTools.h" #include "DatabaseManager.h" #include "DeliveryBroker.h" #include "Tools.h" #include #include #include #include namespace comm { namespace network { TunnelBrokerServiceImpl::TunnelBrokerServiceImpl() { Aws::InitAPI({}); // List of AWS DynamoDB tables to check if they are created and can be // accessed before any AWS API methods const std::list tablesList = { config::ConfigManager::getInstance().getParameter( config::ConfigManager::OPTION_DYNAMODB_SESSIONS_TABLE), config::ConfigManager::getInstance().getParameter( config::ConfigManager::OPTION_DYNAMODB_SESSIONS_VERIFICATION_TABLE), config::ConfigManager::getInstance().getParameter( config::ConfigManager::OPTION_DYNAMODB_SESSIONS_PUBLIC_KEY_TABLE)}; for (const std::string &table : tablesList) { if (!database::DatabaseManager::getInstance().isTableAvailable(table)) { throw std::runtime_error( "Error: AWS DynamoDB table '" + table + "' is not available"); } }; }; TunnelBrokerServiceImpl::~TunnelBrokerServiceImpl() { Aws::ShutdownAPI({}); }; grpc::Status TunnelBrokerServiceImpl::SessionSignature( grpc::ServerContext *context, const tunnelbroker::SessionSignatureRequest *request, tunnelbroker::SessionSignatureResponse *reply) { - const std::string deviceId = request->deviceid(); - if (!validateDeviceId(deviceId)) { + const std::string deviceID = request->deviceid(); + if (!validateDeviceID(deviceID)) { std::cout << "gRPC: " - << "Format validation failed for " << deviceId << std::endl; + << "Format validation failed for " << deviceID << std::endl; return grpc::Status( grpc::StatusCode::INVALID_ARGUMENT, "Format validation failed for deviceID"); } const std::string toSign = generateRandomString(SIGNATURE_REQUEST_LENGTH); std::shared_ptr SessionSignItem = - std::make_shared(toSign, deviceId); + std::make_shared(toSign, deviceID); database::DatabaseManager::getInstance().putSessionSignItem(*SessionSignItem); reply->set_tosign(toSign); return grpc::Status::OK; }; grpc::Status TunnelBrokerServiceImpl::NewSession( grpc::ServerContext *context, const tunnelbroker::NewSessionRequest *request, tunnelbroker::NewSessionResponse *reply) { std::shared_ptr deviceSessionItem; std::shared_ptr sessionSignItem; std::shared_ptr publicKeyItem; - const std::string deviceId = request->deviceid(); - if (!validateDeviceId(deviceId)) { + const std::string deviceID = request->deviceid(); + if (!validateDeviceID(deviceID)) { std::cout << "gRPC: " - << "Format validation failed for " << deviceId << std::endl; + << "Format validation failed for " << deviceID << std::endl; return grpc::Status( grpc::StatusCode::INVALID_ARGUMENT, "Format validation failed for deviceID"); } const std::string signature = request->signature(); const std::string publicKey = request->publickey(); const boost::uuids::uuid uuid = boost::uuids::random_generator()(); - const std::string newSessionId = boost::lexical_cast(uuid); + const std::string newSessionID = boost::lexical_cast(uuid); try { deviceSessionItem = - database::DatabaseManager::getInstance().findSessionItem(newSessionId); + database::DatabaseManager::getInstance().findSessionItem(newSessionID); if (deviceSessionItem != nullptr) { std::cout << "gRPC: " - << "Session unique ID " << newSessionId << " already used" + << "Session unique ID " << newSessionID << " already used" << std::endl; return grpc::Status( grpc::StatusCode::INTERNAL, "Session unique ID already used"); } sessionSignItem = - database::DatabaseManager::getInstance().findSessionSignItem(deviceId); + database::DatabaseManager::getInstance().findSessionSignItem(deviceID); if (sessionSignItem == nullptr) { std::cout << "gRPC: " - << "Session sign request not found for deviceId: " << deviceId + << "Session sign request not found for deviceID: " << deviceID << std::endl; return grpc::Status( grpc::StatusCode::NOT_FOUND, "Session sign request not found"); } publicKeyItem = - database::DatabaseManager::getInstance().findPublicKeyItem(deviceId); + database::DatabaseManager::getInstance().findPublicKeyItem(deviceID); if (publicKeyItem == nullptr) { std::shared_ptr newPublicKeyItem = - std::make_shared(deviceId, publicKey); + std::make_shared(deviceID, publicKey); database::DatabaseManager::getInstance().putPublicKeyItem( *newPublicKeyItem); } else if (publicKey != publicKeyItem->getPublicKey()) { std::cout << "gRPC: " - << "The public key doesn't match for deviceId" << std::endl; + << "The public key doesn't match for deviceID" << std::endl; return grpc::Status( grpc::StatusCode::PERMISSION_DENIED, - "The public key doesn't match for deviceId"); + "The public key doesn't match for deviceID"); } const std::string verificationMessage = sessionSignItem->getSign(); if (!comm::network::crypto::rsaVerifyString( publicKey, verificationMessage, signature)) { std::cout << "gRPC: " << "Signature for the verification message is not valid" << std::endl; return grpc::Status( grpc::StatusCode::PERMISSION_DENIED, "Signature for the verification message is not valid"); } - database::DatabaseManager::getInstance().removeSessionSignItem(deviceId); + database::DatabaseManager::getInstance().removeSessionSignItem(deviceID); deviceSessionItem = std::make_shared( - newSessionId, - deviceId, + newSessionID, + deviceID, request->publickey(), request->notifytoken(), tunnelbroker::NewSessionRequest_DeviceTypes_Name(request->devicetype()), request->deviceappversion(), request->deviceos()); database::DatabaseManager::getInstance().putSessionItem(*deviceSessionItem); } catch (std::runtime_error &e) { std::cout << "gRPC: " << "Error while processing 'NewSession' request: " << e.what() << std::endl; return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); } - reply->set_sessionid(newSessionId); + reply->set_sessionid(newSessionID); return grpc::Status::OK; }; grpc::Status TunnelBrokerServiceImpl::Send( grpc::ServerContext *context, const tunnelbroker::SendRequest *request, google::protobuf::Empty *reply) { try { - const std::string sessionId = request->sessionid(); + const std::string sessionID = request->sessionid(); std::shared_ptr sessionItem = - database::DatabaseManager::getInstance().findSessionItem(sessionId); + database::DatabaseManager::getInstance().findSessionItem(sessionID); if (sessionItem == nullptr) { std::cout << "gRPC: " - << "Session " << sessionId << " not found" << std::endl; + << "Session " << sessionID << " not found" << std::endl; return grpc::Status( grpc::StatusCode::PERMISSION_DENIED, - "No such session found. SessionId: " + sessionId); + "No such session found. SessionID: " + sessionID); } - const std::string clientDeviceId = sessionItem->getDeviceId(); + const std::string clientDeviceID = sessionItem->getDeviceID(); if (!AMQPSend( request->todeviceid(), - clientDeviceId, + clientDeviceID, std::string(request->payload()))) { std::cout << "gRPC: " << "Error while publish the message to AMQP" << std::endl; return grpc::Status( grpc::StatusCode::INTERNAL, "Error while publish the message to AMQP"); } } catch (std::runtime_error &e) { std::cout << "gRPC: " << "Error while processing 'Send' request: " << e.what() << std::endl; return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); } return grpc::Status::OK; }; grpc::Status TunnelBrokerServiceImpl::Get( grpc::ServerContext *context, const tunnelbroker::GetRequest *request, grpc::ServerWriter *writer) { try { - const std::string sessionId = request->sessionid(); + const std::string sessionID = request->sessionid(); std::shared_ptr sessionItem = - database::DatabaseManager::getInstance().findSessionItem(sessionId); + database::DatabaseManager::getInstance().findSessionItem(sessionID); if (sessionItem == nullptr) { std::cout << "gRPC: " - << "Session " << sessionId << " not found" << std::endl; + << "Session " << sessionID << " not found" << std::endl; return grpc::Status( grpc::StatusCode::PERMISSION_DENIED, - "No such session found. SessionId: " + sessionId); + "No such session found. SessionID: " + sessionID); } - const std::string clientDeviceId = sessionItem->getDeviceId(); + const std::string clientDeviceID = sessionItem->getDeviceID(); std::vector messagesToDeliver; while (1) { - messagesToDeliver = DeliveryBroker::getInstance().get(clientDeviceId); + messagesToDeliver = DeliveryBroker::getInstance().get(clientDeviceID); for (auto const &message : messagesToDeliver) { tunnelbroker::GetResponse response; response.set_fromdeviceid(message.fromDeviceID); response.set_payload(message.payload); if (!writer->Write(response)) { throw std::runtime_error( "gRPC: 'Get' writer error on sending data to the client"); } AMQPAck(message.deliveryTag); } - if (!DeliveryBroker::getInstance().isEmpty(clientDeviceId)) { - DeliveryBroker::getInstance().remove(clientDeviceId); + if (!DeliveryBroker::getInstance().isEmpty(clientDeviceID)) { + DeliveryBroker::getInstance().remove(clientDeviceID); } - DeliveryBroker::getInstance().wait(clientDeviceId); + DeliveryBroker::getInstance().wait(clientDeviceID); } } catch (std::runtime_error &e) { std::cout << "gRPC: " << "Error while processing 'Get' request: " << e.what() << std::endl; return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); } return grpc::Status::OK; }; } // namespace network } // namespace comm diff --git a/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.cpp b/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.cpp index 013ba9af5..390fb5352 100644 --- a/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.cpp +++ b/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.cpp @@ -1,50 +1,50 @@ #include "Tools.h" #include "ConfigManager.h" #include "Constants.h" #include #include #include namespace comm { namespace network { std::string generateRandomString(std::size_t length) { const std::string CHARACTERS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; std::random_device random_device; std::mt19937 generator(random_device()); std::uniform_int_distribution<> distribution(0, CHARACTERS.size() - 1); std::string random_string; for (std::size_t i = 0; i < length; ++i) { random_string += CHARACTERS[distribution(generator)]; } return random_string; } long long getCurrentTimestamp() { using namespace std::chrono; return duration_cast(system_clock::now().time_since_epoch()) .count(); } -bool validateDeviceId(std::string deviceId) { +bool validateDeviceID(std::string deviceID) { try { - static const std::regex deviceIdKeyserverRegexp("^ks:.*"); - if (std::regex_match(deviceId, deviceIdKeyserverRegexp)) { + static const std::regex deviceIDKeyserverRegexp("^ks:.*"); + if (std::regex_match(deviceID, deviceIDKeyserverRegexp)) { return ( - deviceId == + deviceID == config::ConfigManager::getInstance().getParameter( config::ConfigManager::OPTION_DEFAULT_KEYSERVER_ID)); } - return std::regex_match(deviceId, DEVICEID_FORMAT_REGEX); + return std::regex_match(deviceID, DEVICEID_FORMAT_REGEX); } catch (const std::exception &e) { std::cout << "Tools: " - << "Got an exception at `validateDeviceId`: " << e.what() + << "Got an exception at `validateDeviceID`: " << e.what() << std::endl; return false; } } } // namespace network } // namespace comm diff --git a/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.h b/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.h index 0b40f5553..65beb61d4 100644 --- a/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.h +++ b/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.h @@ -1,14 +1,14 @@ #pragma once #include #include namespace comm { namespace network { std::string generateRandomString(std::size_t length); long long getCurrentTimestamp(); -bool validateDeviceId(std::string deviceId); +bool validateDeviceID(std::string deviceID); } // namespace network } // namespace comm