scottk/wlan-cloud-ucentralsec
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/wlan-cloud-ucentralsec.git synced 2025-10-30 02:12:32 +00:00
Code Issues Packages Projects Releases 10 Wiki Activity

https://telecominfraproject.atlassian.net/browse/WIFI-12525

Browse Source 
Signed-off-by: stephb9959 <stephane.bourque@gmail.com>
This commit is contained in:
stephb9959
2023-05-18 08:58:11 -07:00
parent 15c2f6a4fc
commit 7c3ae1b5b9
10 changed files with 115 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
build
View File

@@ -1 +1 @@
20 21

2
src/AuthService.cpp
View File

@@ -345,7 +345,7 @@ namespace OpenWifi {
std::stringstream ResultText; std::stringstream ResultText;
Poco::JSON::Stringifier::stringify(Obj, ResultText); Poco::JSON::Stringifier::stringify(Obj, ResultText);
KafkaManager()->PostMessage(KafkaTopics::SERVICE_EVENTS, KafkaManager()->PostMessage(KafkaTopics::SERVICE_EVENTS,
MicroServicePrivateEndPoint(), ResultText.str(), false); MicroServicePrivateEndPoint(), std::make_shared<std::string>(ResultText.str()), false);
} }
} catch (const Poco::Exception &E) { } catch (const Poco::Exception &E) {
Logger().log(E); Logger().log(E);

6
src/framework/EventBusManager.cpp
View File

@@ -14,18 +14,18 @@ namespace OpenWifi {
void EventBusManager::run() { void EventBusManager::run() {
Running_ = true; Running_ = true;
Utils::SetThreadName("fmwk:EventMgr"); Utils::SetThreadName("fmwk:EventMgr");
auto Msg = MicroServiceMakeSystemEventMessage(KafkaTopics::ServiceEvents::EVENT_JOIN); auto Msg = std::make_shared<std::string>(MicroServiceMakeSystemEventMessage(KafkaTopics::ServiceEvents::EVENT_JOIN));
KafkaManager()->PostMessage(KafkaTopics::SERVICE_EVENTS, MicroServicePrivateEndPoint(), Msg, KafkaManager()->PostMessage(KafkaTopics::SERVICE_EVENTS, MicroServicePrivateEndPoint(), Msg,
false); false);
while (Running_) { while (Running_) {
Poco::Thread::trySleep((unsigned long)MicroServiceDaemonBusTimer()); Poco::Thread::trySleep((unsigned long)MicroServiceDaemonBusTimer());
if (!Running_) if (!Running_)
break; break;
Msg = MicroServiceMakeSystemEventMessage(KafkaTopics::ServiceEvents::EVENT_KEEP_ALIVE); Msg = std::make_shared<std::string>(MicroServiceMakeSystemEventMessage(KafkaTopics::ServiceEvents::EVENT_KEEP_ALIVE));
KafkaManager()->PostMessage(KafkaTopics::SERVICE_EVENTS, MicroServicePrivateEndPoint(), KafkaManager()->PostMessage(KafkaTopics::SERVICE_EVENTS, MicroServicePrivateEndPoint(),
Msg, false); Msg, false);
} }
Msg = MicroServiceMakeSystemEventMessage(KafkaTopics::ServiceEvents::EVENT_LEAVE); Msg = std::make_shared<std::string>(MicroServiceMakeSystemEventMessage(KafkaTopics::ServiceEvents::EVENT_LEAVE));
KafkaManager()->PostMessage(KafkaTopics::SERVICE_EVENTS, MicroServicePrivateEndPoint(), Msg, KafkaManager()->PostMessage(KafkaTopics::SERVICE_EVENTS, MicroServicePrivateEndPoint(), Msg,
false); false);
}; };

23
src/framework/KafkaManager.cpp
View File

@@ -180,7 +180,7 @@ namespace OpenWifi {
Consumer.async_commit(Msg); Consumer.async_commit(Msg);
continue; continue;
} }
KafkaManager()->Dispatch(Msg.get_topic(), Msg.get_key(), Msg.get_payload()); KafkaManager()->Dispatch(Msg.get_topic().c_str(), Msg.get_key(), std::make_shared<std::string>(Msg.get_payload()));
if (!AutoCommit) if (!AutoCommit)
Consumer.async_commit(Msg); Consumer.async_commit(Msg);
} }
@@ -212,8 +212,8 @@ namespace OpenWifi {
} }
} }
void KafkaProducer::Produce(const std::string &Topic, const std::string &Key, void KafkaProducer::Produce(const char *Topic, const std::string &Key,
const std::string &Payload) { const std::shared_ptr<std::string> Payload) {
std::lock_guard G(Mutex_); std::lock_guard G(Mutex_);
Queue_.enqueueNotification(new KafkaMessage(Topic, Key, Payload)); Queue_.enqueueNotification(new KafkaMessage(Topic, Key, Payload));
} }
@@ -275,8 +275,8 @@ namespace OpenWifi {
} }
} }
void KafkaDispatcher::Dispatch(const std::string &Topic, const std::string &Key, void KafkaDispatcher::Dispatch(const char *Topic, const std::string &Key,
const std::string &Payload) { const std::shared_ptr<std::string> Payload) {
std::lock_guard G(Mutex_); std::lock_guard G(Mutex_);
auto It = Notifiers_.find(Topic); auto It = Notifiers_.find(Topic);
if (It != Notifiers_.end()) { if (It != Notifiers_.end()) {
@@ -332,20 +332,21 @@ namespace OpenWifi {
} }
} }
void KafkaManager::PostMessage(const std::string &topic, const std::string &key, void KafkaManager::PostMessage(const char *topic, const std::string &key,
const std::string &PayLoad, bool WrapMessage) { const std::shared_ptr<std::string> PayLoad, bool WrapMessage) {
if (KafkaEnabled_) { if (KafkaEnabled_) {
ProducerThr_.Produce(topic, key, WrapMessage ? WrapSystemId(PayLoad) : PayLoad); ProducerThr_.Produce(topic, key, WrapMessage ? WrapSystemId(PayLoad) : PayLoad);
} }
} }
void KafkaManager::Dispatch(const std::string &Topic, const std::string &Key, void KafkaManager::Dispatch(const char *Topic, const std::string &Key,
const std::string &Payload) { const std::shared_ptr<std::string> Payload) {
Dispatcher_.Dispatch(Topic, Key, Payload); Dispatcher_.Dispatch(Topic, Key, Payload);
} }
[[nodiscard]] std::string KafkaManager::WrapSystemId(const std::string &PayLoad) { [[nodiscard]] const std::shared_ptr<std::string> KafkaManager::WrapSystemId(const std::shared_ptr<std::string> PayLoad) {
return SystemInfoWrapper_ + PayLoad + "}"; *PayLoad = SystemInfoWrapper_ + *PayLoad + "}";
return PayLoad;
} }
uint64_t KafkaManager::RegisterTopicWatcher(const std::string &Topic, uint64_t KafkaManager::RegisterTopicWatcher(const std::string &Topic,

24
src/framework/KafkaManager.h
View File

@@ -18,17 +18,17 @@ namespace OpenWifi {
class KafkaMessage : public Poco::Notification { class KafkaMessage : public Poco::Notification {
public: public:
KafkaMessage(const std::string &Topic, const std::string &Key, const std::string &Payload) KafkaMessage(const char * Topic, const std::string &Key, const std::shared_ptr<std::string> Payload)
: Topic_(Topic), Key_(Key), Payload_(Payload) {} : Topic_(Topic), Key_(Key), Payload_(std::move(Payload)) {}
inline const std::string &Topic() { return Topic_; } inline const char * Topic() { return Topic_; }
inline const std::string &Key() { return Key_; } inline const std::string &Key() { return Key_; }
inline const std::string &Payload() { return Payload_; } inline const std::string &Payload() { return *Payload_; }
private: private:
std::string Topic_; const char *Topic_;
std::string Key_; std::string Key_;
std::string Payload_; std::shared_ptr<std::string> Payload_;
}; };
class KafkaProducer : public Poco::Runnable { class KafkaProducer : public Poco::Runnable {
@@ -36,7 +36,7 @@ namespace OpenWifi {
void run() override; void run() override;
void Start(); void Start();
void Stop(); void Stop();
void Produce(const std::string &Topic, const std::string &Key, const std::string &Payload); void Produce(const char *Topic, const std::string &Key, const std::shared_ptr<std::string> Payload);
private: private:
std::recursive_mutex Mutex_; std::recursive_mutex Mutex_;
@@ -63,7 +63,7 @@ namespace OpenWifi {
void Stop(); void Stop();
auto RegisterTopicWatcher(const std::string &Topic, Types::TopicNotifyFunction &F); auto RegisterTopicWatcher(const std::string &Topic, Types::TopicNotifyFunction &F);
void UnregisterTopicWatcher(const std::string &Topic, int Id); void UnregisterTopicWatcher(const std::string &Topic, int Id);
void Dispatch(const std::string &Topic, const std::string &Key, const std::string &Payload); void Dispatch(const char *Topic, const std::string &Key, const std::shared_ptr<std::string> Payload);
void run() override; void run() override;
void Topics(std::vector<std::string> &T); void Topics(std::vector<std::string> &T);
@@ -91,10 +91,10 @@ namespace OpenWifi {
int Start() override; int Start() override;
void Stop() override; void Stop() override;
void PostMessage(const std::string &topic, const std::string &key, void PostMessage(const char *topic, const std::string &key,
const std::string &PayLoad, bool WrapMessage = true); const std::shared_ptr<std::string> PayLoad, bool WrapMessage = true);
void Dispatch(const std::string &Topic, const std::string &Key, const std::string &Payload); void Dispatch(const char *Topic, const std::string &Key, const std::shared_ptr<std::string> Payload);
[[nodiscard]] std::string WrapSystemId(const std::string &PayLoad); [[nodiscard]] const std::shared_ptr<std::string> WrapSystemId(const std::shared_ptr<std::string> PayLoad);
[[nodiscard]] inline bool Enabled() const { return KafkaEnabled_; } [[nodiscard]] inline bool Enabled() const { return KafkaEnabled_; }
uint64_t RegisterTopicWatcher(const std::string &Topic, Types::TopicNotifyFunction &F); uint64_t RegisterTopicWatcher(const std::string &Topic, Types::TopicNotifyFunction &F);
void UnregisterTopicWatcher(const std::string &Topic, uint64_t Id); void UnregisterTopicWatcher(const std::string &Topic, uint64_t Id);

44
src/framework/KafkaTopics.h
View File

@@ -10,32 +10,32 @@
#include <string> #include <string>
namespace OpenWifi::KafkaTopics { namespace OpenWifi::KafkaTopics {
static const std::string HEALTHCHECK{"healthcheck"}; inline const char * HEALTHCHECK = "healthcheck";
static const std::string STATE{"state"}; inline const char * STATE = "state";
static const std::string CONNECTION{"connection"}; inline const char * CONNECTION = "connection";
static const std::string WIFISCAN{"wifiscan"}; inline const char * WIFISCAN = "wifiscan";
static const std::string ALERTS{"alerts"}; inline const char * ALERTS = "alerts";
static const std::string COMMAND{"command"}; inline const char * COMMAND = "command";
static const std::string SERVICE_EVENTS{"service_events"}; inline const char * SERVICE_EVENTS = "service_events";
static const std::string DEVICE_EVENT_QUEUE{"device_event_queue"}; inline const char * DEVICE_EVENT_QUEUE = "device_event_queue";
static const std::string DEVICE_TELEMETRY{"device_telemetry"}; inline const char * DEVICE_TELEMETRY = "device_telemetry";
static const std::string PROVISIONING_CHANGE{"provisioning_change"}; inline const char * PROVISIONING_CHANGE = "provisioning_change";
namespace ServiceEvents { namespace ServiceEvents {
static const std::string EVENT_JOIN{"join"}; inline const char * EVENT_JOIN = "join";
static const std::string EVENT_LEAVE{"leave"}; inline const char * EVENT_LEAVE = "leave";
static const std::string EVENT_KEEP_ALIVE{"keep-alive"}; inline const char * EVENT_KEEP_ALIVE = "keep-alive";
static const std::string EVENT_REMOVE_TOKEN{"remove-token"}; inline const char * EVENT_REMOVE_TOKEN = "remove-token";
namespace Fields { namespace Fields {
static const std::string EVENT{"event"}; inline const char * EVENT = "event";
static const std::string ID{"id"}; inline const char * ID = "id";
static const std::string TYPE{"type"}; inline const char * TYPE = "type";
static const std::string PUBLIC{"publicEndPoint"}; inline const char * PUBLIC = "publicEndPoint";
static const std::string PRIVATE{"privateEndPoint"}; inline const char * PRIVATE = "privateEndPoint";
static const std::string KEY{"key"}; inline const char * KEY = "key";
static const std::string VRSN{"version"}; inline const char * VRSN = "version";
static const std::string TOKEN{"token"}; inline const char * TOKEN = "token";
} // namespace Fields } // namespace Fields
} // namespace ServiceEvents } // namespace ServiceEvents
} // namespace OpenWifi::KafkaTopics } // namespace OpenWifi::KafkaTopics

8
src/framework/MicroServiceFuncs.cpp
View File

@@ -47,11 +47,11 @@ namespace OpenWifi {
void MicroServiceReload(const std::string &Type) { MicroService::instance().Reload(Type); } void MicroServiceReload(const std::string &Type) { MicroService::instance().Reload(Type); }
const Types::StringVec MicroServiceGetLogLevelNames() { Types::StringVec MicroServiceGetLogLevelNames() {
return MicroService::instance().GetLogLevelNames(); return MicroService::instance().GetLogLevelNames();
} }
const Types::StringVec MicroServiceGetSubSystems() { Types::StringVec MicroServiceGetSubSystems() {
return MicroService::instance().GetSubSystems(); return MicroService::instance().GetSubSystems();
} }
@@ -79,7 +79,7 @@ namespace OpenWifi {
std::string MicroServiceGetUIURI() { return MicroService::instance().GetUIURI(); } std::string MicroServiceGetUIURI() { return MicroService::instance().GetUIURI(); }
const SubSystemVec MicroServiceGetFullSubSystems() { SubSystemVec MicroServiceGetFullSubSystems() {
return MicroService::instance().GetFullSubSystems(); return MicroService::instance().GetFullSubSystems();
} }
@@ -87,7 +87,7 @@ namespace OpenWifi {
std::uint64_t MicroServiceDaemonBusTimer() { return MicroService::instance().DaemonBusTimer(); } std::uint64_t MicroServiceDaemonBusTimer() { return MicroService::instance().DaemonBusTimer(); }
std::string MicroServiceMakeSystemEventMessage(const std::string &Type) { std::string MicroServiceMakeSystemEventMessage(const char *Type) {
return MicroService::instance().MakeSystemEventMessage(Type); return MicroService::instance().MakeSystemEventMessage(Type);
} }

8
src/framework/MicroServiceFuncs.h
View File

@@ -31,8 +31,8 @@ namespace OpenWifi {
void MicroServiceLoadConfigurationFile(); void MicroServiceLoadConfigurationFile();
void MicroServiceReload(); void MicroServiceReload();
void MicroServiceReload(const std::string &Type); void MicroServiceReload(const std::string &Type);
const Types::StringVec MicroServiceGetLogLevelNames(); Types::StringVec MicroServiceGetLogLevelNames();
const Types::StringVec MicroServiceGetSubSystems(); Types::StringVec MicroServiceGetSubSystems();
Types::StringPairVec MicroServiceGetLogLevels(); Types::StringPairVec MicroServiceGetLogLevels();
bool MicroServiceSetSubsystemLogLevel(const std::string &SubSystem, const std::string &Level); bool MicroServiceSetSubsystemLogLevel(const std::string &SubSystem, const std::string &Level);
void MicroServiceGetExtraConfiguration(Poco::JSON::Object &Answer); void MicroServiceGetExtraConfiguration(Poco::JSON::Object &Answer);
@@ -40,10 +40,10 @@ namespace OpenWifi {
std::uint64_t MicroServiceUptimeTotalSeconds(); std::uint64_t MicroServiceUptimeTotalSeconds();
std::uint64_t MicroServiceStartTimeEpochTime(); std::uint64_t MicroServiceStartTimeEpochTime();
std::string MicroServiceGetUIURI(); std::string MicroServiceGetUIURI();
const SubSystemVec MicroServiceGetFullSubSystems(); SubSystemVec MicroServiceGetFullSubSystems();
std::string MicroServiceCreateUUID(); std::string MicroServiceCreateUUID();
std::uint64_t MicroServiceDaemonBusTimer(); std::uint64_t MicroServiceDaemonBusTimer();
std::string MicroServiceMakeSystemEventMessage(const std::string &Type); std::string MicroServiceMakeSystemEventMessage(const char *Type);
Poco::ThreadPool &MicroServiceTimerPool(); Poco::ThreadPool &MicroServiceTimerPool();
std::string MicroServiceConfigPath(const std::string &Key, const std::string &DefaultValue); std::string MicroServiceConfigPath(const std::string &Key, const std::string &DefaultValue);
std::string MicroServiceWWWAssetsDir(); std::string MicroServiceWWWAssetsDir();

25
src/framework/ow_constants.h
View File

@@ -397,6 +397,18 @@ namespace OpenWifi::RESTAPI::Errors {
static const struct msg FirmwareBDInProgress { static const struct msg FirmwareBDInProgress {
1170, "Firmware DB update already in progress." 1170, "Firmware DB update already in progress."
}; };
static const struct msg SimulatedDeviceNotSupported {
1171, "Command not supported on simulated device."
};
static const struct msg SimulationDoesNotExist {
7000, "Simulation Instance ID does not exist."
};
static const struct msg SimulationIsAlreadyRunning {
7001, "There is an instance of this simulation already running.."
};
} // namespace OpenWifi::RESTAPI::Errors } // namespace OpenWifi::RESTAPI::Errors
@@ -554,6 +566,7 @@ namespace OpenWifi::uCentralProtocol {
static const char *HEALTHCHECK = "healthcheck"; static const char *HEALTHCHECK = "healthcheck";
static const char *LOG = "log"; static const char *LOG = "log";
static const char *CRASHLOG = "crashlog"; static const char *CRASHLOG = "crashlog";
static const char *REBOOTLOG = "rebootLog";
static const char *PING = "ping"; static const char *PING = "ping";
static const char *CFGPENDING = "cfgpending"; static const char *CFGPENDING = "cfgpending";
static const char *RECOVERY = "recovery"; static const char *RECOVERY = "recovery";
@@ -612,6 +625,8 @@ namespace OpenWifi::uCentralProtocol {
static const char *DEVICEUPDATE = "deviceupdate"; static const char *DEVICEUPDATE = "deviceupdate";
static const char *FWSIGNATURE = "FWsignature"; static const char *FWSIGNATURE = "FWsignature";
static const char *SIGNATURE = "signature"; static const char *SIGNATURE = "signature";
static const char *INFO = "info";
static const char *DATE = "date";
static const char *SERIALNUMBER = "serialNumber"; static const char *SERIALNUMBER = "serialNumber";
static const char *COMPATIBLE = "compatible"; static const char *COMPATIBLE = "compatible";
@@ -642,6 +657,7 @@ namespace OpenWifi::uCentralProtocol::Events {
static const char *HEALTHCHECK = "healthcheck"; static const char *HEALTHCHECK = "healthcheck";
static const char *LOG = "log"; static const char *LOG = "log";
static const char *CRASHLOG = "crashlog"; static const char *CRASHLOG = "crashlog";
static const char *REBOOTLOG = "rebootLog";
static const char *PING = "ping"; static const char *PING = "ping";
static const char *CFGPENDING = "cfgpending"; static const char *CFGPENDING = "cfgpending";
static const char *RECOVERY = "recovery"; static const char *RECOVERY = "recovery";
@@ -665,7 +681,8 @@ namespace OpenWifi::uCentralProtocol::Events {
ET_VENUEBROADCAST, ET_VENUEBROADCAST,
ET_EVENT, ET_EVENT,
ET_WIFISCAN, ET_WIFISCAN,
ET_ALARM ET_ALARM,
ET_REBOOTLOG
}; };
inline EVENT_MSG EventFromString(const std::string &Method) { inline EVENT_MSG EventFromString(const std::string &Method) {
@@ -696,8 +713,10 @@ namespace OpenWifi::uCentralProtocol::Events {
else if (strcmp(WIFISCAN, Method.c_str()) == 0) else if (strcmp(WIFISCAN, Method.c_str()) == 0)
return ET_WIFISCAN; return ET_WIFISCAN;
else if (strcmp(ALARM, Method.c_str()) == 0) else if (strcmp(ALARM, Method.c_str()) == 0)
return ET_WIFISCAN; return ET_ALARM;
return ET_ALARM; else if (strcmp(REBOOTLOG, Method.c_str()) == 0)
return ET_REBOOTLOG;
return ET_UNKNOWN;
}; };
} // namespace OpenWifi::uCentralProtocol::Events } // namespace OpenWifi::uCentralProtocol::Events

34
src/framework/utils.h
View File

@@ -146,4 +146,38 @@ namespace OpenWifi::Utils {
bool ExtractBase64CompressedData(const std::string &CompressedData, bool ExtractBase64CompressedData(const std::string &CompressedData,
std::string &UnCompressedData, uint64_t compress_sz); std::string &UnCompressedData, uint64_t compress_sz);
inline bool match(const char* first, const char* second)
{
// If we reach at the end of both strings, we are done
if (*first == '\0' && *second == '\0')
return true;
// Make sure to eliminate consecutive '*'
if (*first == '*') {
while (*(first + 1) == '*')
first++;
}
// Make sure that the characters after '*' are present
// in second string. This function assumes that the
// first string will not contain two consecutive '*'
if (*first == '*' && *(first + 1) != '\0'
&& *second == '\0')
return false;
// If the first string contains '?', or current
// characters of both strings match
if (*first == '?' || *first == *second)
return match(first + 1, second + 1);
// If there is *, then there are two possibilities
// a) We consider current character of second string
// b) We ignore current character of second string.
if (*first == '*')
return match(first + 1, second)
|| match(first, second + 1);
return false;
}
} // namespace OpenWifi::Utils } // namespace OpenWifi::Utils