Chg: update image tag in helm values to v2.7.2

Fixing for build error for 2.7.2

CMakeLists.txt

@@ -83,10 +83,52 @@ add_executable( owgw
         src/framework/orm.h
         src/framework/StorageClass.h
         src/framework/MicroServiceErrorHandler.h
+        src/framework/UI_WebSocketClientServer.cpp
+        src/framework/UI_WebSocketClientServer.h
+        src/framework/UI_WebSocketClientNotifications.cpp
+        src/framework/UI_WebSocketClientNotifications.h
+        src/framework/utils.h
+        src/framework/utils.cpp
+        src/framework/AppServiceRegistry.h
+        src/framework/SubSystemServer.cpp
+        src/framework/SubSystemServer.h
+        src/framework/RESTAPI_utils.h
+        src/framework/AuthClient.cpp
+        src/framework/AuthClient.h
+        src/framework/MicroServiceNames.h
+        src/framework/MicroServiceFuncs.h
+        src/framework/OpenAPIRequests.cpp
+        src/framework/OpenAPIRequests.h
+        src/framework/MicroServiceFuncs.cpp
+        src/framework/ALBserver.cpp
+        src/framework/ALBserver.h
+        src/framework/KafkaManager.cpp
+        src/framework/KafkaManager.h
+        src/framework/RESTAPI_RateLimiter.h
+        src/framework/WebSocketLogger.h
+        src/framework/RESTAPI_GenericServerAccounting.h
+        src/framework/CIDR.h
+        src/framework/RESTAPI_Handler.cpp
+        src/framework/RESTAPI_Handler.h
+        src/framework/RESTAPI_ExtServer.h
+        src/framework/RESTAPI_ExtServer.cpp
+        src/framework/RESTAPI_IntServer.cpp
+        src/framework/RESTAPI_IntServer.h
+        src/framework/RESTAPI_SystemCommand.h
+        src/framework/RESTAPI_WebSocketServer.h
+        src/framework/EventBusManager.cpp
+        src/framework/EventBusManager.h
+        src/framework/RESTAPI_PartHandler.h
+        src/framework/MicroService.cpp
+        src/framework/MicroServiceExtra.h
         src/RESTObjects/RESTAPI_SecurityObjects.h src/RESTObjects/RESTAPI_SecurityObjects.cpp
-        src/RESTObjects/RESTAPI_ProvObjects.cpp src/RESTObjects/RESTAPI_ProvObjects.h
         src/RESTObjects/RESTAPI_GWobjects.h src/RESTObjects/RESTAPI_GWobjects.cpp
         src/RESTObjects/RESTAPI_FMSObjects.h src/RESTObjects/RESTAPI_FMSObjects.cpp
+        src/RESTObjects/RESTAPI_CertObjects.cpp src/RESTObjects/RESTAPI_CertObjects.h
+        src/RESTObjects/RESTAPI_OWLSobjects.cpp src/RESTObjects/RESTAPI_OWLSobjects.h
+        src/RESTObjects/RESTAPI_ProvObjects.cpp src/RESTObjects/RESTAPI_ProvObjects.h
+        src/RESTObjects/RESTAPI_AnalyticsObjects.cpp src/RESTObjects/RESTAPI_AnalyticsObjects.h
+        src/RESTObjects/RESTAPI_SubObjects.cpp src/RESTObjects/RESTAPI_SubObjects.h
         src/RESTAPI/RESTAPI_devices_handler.cpp src/RESTAPI/RESTAPI_devices_handler.h
         src/RESTAPI/RESTAPI_device_handler.cpp src/RESTAPI/RESTAPI_device_handler.h
         src/RESTAPI/RESTAPI_device_commandHandler.cpp src/RESTAPI/RESTAPI_device_commandHandler.h
@@ -110,7 +152,6 @@ add_executable( owgw
         src/Daemon.cpp src/Daemon.h
         src/AP_WS_Server.cpp src/AP_WS_Server.h
         src/StorageService.cpp src/StorageService.h
-#        src/DeviceRegistry.cpp src/DeviceRegistry.h
         src/CommandManager.cpp src/CommandManager.h
         src/CentralConfig.cpp src/CentralConfig.h
         src/FileUploader.cpp src/FileUploader.h
@@ -129,12 +170,36 @@ add_executable( owgw
         src/rttys/RTTYS_ClientConnection.cpp
         src/rttys/RTTYS_ClientConnection.h
         src/rttys/RTTYS_WebServer.cpp
-        src/rttys/RTTYS_WebServer.h src/RESTAPI/RESTAPI_device_helper.h src/SDKcalls.cpp src/SDKcalls.h src/StateUtils.cpp src/StateUtils.h src/AP_WS_ReactorPool.h src/AP_WS_Connection.h src/AP_WS_Connection.cpp src/TelemetryClient.h src/TelemetryClient.cpp src/RESTAPI/RESTAPI_iptocountry_handler.cpp src/RESTAPI/RESTAPI_iptocountry_handler.h src/framework/ow_constants.h src/GwWebSocketClient.cpp src/GwWebSocketClient.h src/framework/WebSocketClientNotifications.h src/RADIUS_proxy_server.cpp src/RADIUS_proxy_server.h src/RESTAPI/RESTAPI_radiusProxyConfig_handler.cpp src/RESTAPI/RESTAPI_radiusProxyConfig_handler.h src/ParseWifiScan.h src/RADIUS_helpers.h src/VenueBroadcaster.h src/sdks/sdk_prov.h
+        src/rttys/RTTYS_WebServer.h src/RESTAPI/RESTAPI_device_helper.h
+        src/SDKcalls.cpp
+        src/SDKcalls.h
+        src/StateUtils.cpp src/StateUtils.h
+        src/AP_WS_ReactorPool.h
+        src/AP_WS_Connection.h
+        src/AP_WS_Connection.cpp
+        src/TelemetryClient.h src/TelemetryClient.cpp
+        src/RESTAPI/RESTAPI_iptocountry_handler.cpp src/RESTAPI/RESTAPI_iptocountry_handler.h
+        src/framework/ow_constants.h
+        src/GwWebSocketClient.cpp src/GwWebSocketClient.h
+        src/RADIUS_proxy_server.cpp src/RADIUS_proxy_server.h
+        src/RESTAPI/RESTAPI_radiusProxyConfig_handler.cpp src/RESTAPI/RESTAPI_radiusProxyConfig_handler.h
+        src/ParseWifiScan.h
+        src/RADIUS_helpers.h
+        src/VenueBroadcaster.h
+        src/sdks/sdk_prov.h
         src/AP_WS_Process_connect.cpp
         src/AP_WS_Process_state.cpp
         src/AP_WS_Process_healthcheck.cpp
         src/AP_WS_Process_log.cpp
-        src/AP_WS_Process_crashlog.cpp src/AP_WS_Process_ping.cpp src/AP_WS_Process_cfgpending.cpp src/AP_WS_Process_recovery.cpp src/AP_WS_Process_deviceupdate.cpp src/AP_WS_Process_telemetry.cpp src/AP_WS_Process_venuebroadcast.cpp src/RADSECserver.h)
+        src/AP_WS_Process_crashlog.cpp
+        src/AP_WS_Process_ping.cpp
+        src/AP_WS_Process_cfgpending.cpp
+        src/AP_WS_Process_recovery.cpp
+        src/AP_WS_Process_deviceupdate.cpp
+        src/AP_WS_Process_telemetry.cpp
+        src/AP_WS_Process_venuebroadcast.cpp
+        src/RADSEC_server.h
+        src/UI_GW_WebSocketNotifications.cpp src/UI_GW_WebSocketNotifications.h)
 
 if(NOT SMALL_BUILD)
 

Dockerfile

@@ -1,6 +1,5 @@
 ARG DEBIAN_VERSION=11.5-slim
 ARG POCO_VERSION=poco-tip-v1
-ARG FMTLIB_VERSION=9.0.0
 ARG CPPKAFKA_VERSION=tip-v1
 ARG JSON_VALIDATOR_VERSION=2.1.0
 
@@ -10,7 +9,7 @@ RUN apt-get update && apt-get install --no-install-recommends -y \
     make cmake g++ git \
     libpq-dev libmariadb-dev libmariadbclient-dev-compat \
     librdkafka-dev libboost-all-dev libssl-dev \
-    zlib1g-dev nlohmann-json3-dev ca-certificates
+    zlib1g-dev nlohmann-json3-dev ca-certificates libfmt-dev
 
 FROM build-base AS poco-build
 
@@ -26,20 +25,6 @@ RUN cmake ..
 RUN cmake --build . --config Release -j8
 RUN cmake --build . --target install
 
-FROM build-base AS fmtlib-build
-
-ARG FMTLIB_VERSION
-
-ADD https://api.github.com/repos/fmtlib/fmt/git/refs/tags/${FMTLIB_VERSION} version.json
-RUN git clone https://github.com/fmtlib/fmt --branch ${FMTLIB_VERSION} /fmtlib
-
-WORKDIR /fmtlib
-RUN mkdir cmake-build
-WORKDIR cmake-build
-RUN cmake ..
-RUN make
-RUN make install
-
 FROM build-base AS cppkafka-build
 
 ARG CPPKAFKA_VERSION
@@ -81,8 +66,6 @@ COPY --from=cppkafka-build /usr/local/include /usr/local/include
 COPY --from=cppkafka-build /usr/local/lib /usr/local/lib
 COPY --from=json-schema-validator-build /usr/local/include /usr/local/include
 COPY --from=json-schema-validator-build /usr/local/lib /usr/local/lib
-COPY --from=fmtlib-build /usr/local/include /usr/local/include
-COPY --from=fmtlib-build /usr/local/lib /usr/local/lib
 
 WORKDIR /owgw
 RUN mkdir cmake-build
@@ -104,7 +87,7 @@ RUN mkdir -p "$OWGW_ROOT" "$OWGW_CONFIG" && \
 
 RUN apt-get update && apt-get install --no-install-recommends -y \
     librdkafka++1 gosu gettext ca-certificates bash jq curl wget \
-    libmariadb-dev-compat libpq5 unixodbc postgresql-client
+    libmariadb-dev-compat libpq5 unixodbc postgresql-client libfmt7 sqlite3
 
 COPY readiness_check /readiness_check
 COPY test_scripts/curl/cli /cli

PROTOCOL.md

@@ -423,44 +423,6 @@ The device should answer:
 - 1 : device cannot flash LEDs because it does not have any.
 - 2 : device rejects the request. `text` should include information as to why.
 
-#### Controller sends a device specific command
-Controller sends this command specific to this device. The command is proprietary and must be agreed upon by the device 
-and the controller.
-```json
-{     "jsonrpc" : "2.0" , 
-      "method" : "perform" , 
-      "params" : {
-          "serial" : <serial number> ,
-          "when" : Optional - <UTC time when to perform this command, 0 mean immediate, this is a suggestion>,
-          "command" : <this is device specific and is TEXT only>,
-          "payload" : <JSON Document: containing additional information about the command>
-      },
-      "id" : <some number>
-}
-```
-
-The device should answer:
-```json
-{     "jsonrpc" : "2.0" , 
-      "result" : {
-          "serial" : <serial number> ,
-          "status" : {
-            "error" : 0 or an error number,
-            "text" : <description of the error or success>,
-            "when" : <in UTC time in seconds>,
-            "resultCode" : <0 or an appropriate error code>,
-            "resultText" : <any text resulting from the command. This is propietary to each command>
-          }
-      },
-      "id" : <same number>
-}
-```
-##### The device answer
-The device should answer with teh above message. The `error` value should be interpreted the following way:
-- 0 : the command was performed as requested and the reults of the command is available in the `resultCode` and `resultText` parameters.
-- 1 : the command will be performed in the future and `when` shows that time. The `resultCode` and `resultText` dod not contain anything relevant.
-- 2 : the command cannot be performed as indicated. `resultCode` and `resultText` may contain some indication as to why.
-
 #### Controller wants the device to perform a trace
 Controller sends this command when it needs the device to perform a trace (i.e. tcpdump).
 ```json

build

@@ -1 +1 @@
-6
+42

helm/values.yaml

@@ -9,7 +9,7 @@ fullnameOverride: ""
 images:
   owgw:
     repository: tip-tip-wlan-cloud-ucentral.jfrog.io/owgw
-    tag: v2.7.1-RC2
+    tag: v2.7.2
     pullPolicy: Always
 #    regcred:
 #      registry: tip-tip-wlan-cloud-ucentral.jfrog.io

src/AP_WS_Connection.cpp

@@ -11,7 +11,7 @@
 #include "Poco/Net/SSLException.h"
 #include "Poco/Net/Context.h"
 #include "Poco/Base64Decoder.h"
-
+#include "Poco/Net/WebSocketImpl.h"
 #include "Poco/zlib.h"
 
 #include "AP_WS_Server.h"
@@ -20,8 +20,14 @@
 #include "ConfigurationCache.h"
 #include "StorageService.h"
 #include "TelemetryStream.h"
-#include "framework/WebSocketClientNotifications.h"
-#include "Poco/Net/WebSocketImpl.h"
+
+#include "framework/KafkaManager.h"
+#include "framework/MicroServiceFuncs.h"
+#include "framework/utils.h"
+#include "UI_GW_WebSocketNotifications.h"
+
+#include "fmt/format.h"
+
 
 #include "RADIUS_proxy_server.h"
 
@@ -35,7 +41,7 @@ namespace OpenWifi {
 
 	AP_WS_Connection::AP_WS_Connection(Poco::Net::HTTPServerRequest &request,
 									   Poco::Net::HTTPServerResponse &response,
-									   std::uint64_t connection_id,
+									   uint64_t connection_id,
 									   Poco::Logger &L,
 									   Poco::Net::SocketReactor &R)
 		: Logger_(L) ,
@@ -100,7 +106,7 @@ namespace OpenWifi {
 			PeerAddress_ = SS->peerAddress().host();
 			CId_ = Utils::FormatIPv6(SS->peerAddress().toString());
 
-			State_.started = OpenWifi::Now();
+			State_.started = Utils::Now();
 
 			if (!SS->secure()) {
 				poco_warning(Logger_,fmt::format("TLS-CONNECTION({}): Session={} Connection is NOT secure. Device is not allowed.", CId_, State_.sessionId ));
@@ -140,7 +146,7 @@ namespace OpenWifi {
 				return false;
 			}
 
-			if (!CN_.empty() && StorageService()->IsBlackListed(SerialNumber_)) {
+			if (!CN_.empty() && StorageService()->IsBlackListed(CN_)) {
 				poco_warning(
 					Logger_,
 					fmt::format("TLS-CONNECTION({}): Session={} Device {} is black listed. Disconnecting.",
@@ -198,7 +204,7 @@ namespace OpenWifi {
 			Poco::JSON::Object Disconnect;
 			Poco::JSON::Object Details;
 			Details.set(uCentralProtocol::SERIALNUMBER, SerialNumber);
-			Details.set(uCentralProtocol::TIMESTAMP, OpenWifi::Now());
+			Details.set(uCentralProtocol::TIMESTAMP, Utils::Now());
 			Disconnect.set(uCentralProtocol::DISCONNECTION, Details);
 			Poco::JSON::Stringifier Stringify;
 			std::ostringstream OS;
@@ -238,8 +244,11 @@ namespace OpenWifi {
 			}
 
 			auto SessionDeleted = AP_WS_Server()->EndSession(State_.sessionId, SerialNumberInt_);
-			if (SessionDeleted)
-				WebSocketClientNotificationDeviceDisconnected(SerialNumber_);
+			if (SessionDeleted) {
+				WebNotificationSingleDevice_t	N;
+				N.content.serialNumber = SerialNumber_;
+				WebSocketClientNotificationDeviceDisconnected(N);
+			}
 		}
 	}
 
@@ -280,7 +289,7 @@ namespace OpenWifi {
 			State_.PendingUUID = D.UUID;
 			GWObjects::CommandDetails Cmd;
 			Cmd.SerialNumber = SerialNumber_;
-			Cmd.UUID = MicroService::CreateUUID();
+			Cmd.UUID = MicroServiceCreateUUID();
 			Cmd.SubmittedBy = uCentralProtocol::SUBMITTED_BY_SYSTEM;
 			Cmd.Status = uCentralProtocol::PENDING;
 			Cmd.Command = uCentralProtocol::CONFIGURE;
@@ -302,7 +311,11 @@ namespace OpenWifi {
 			StorageService()->AddCommand(SerialNumber_, Cmd, Storage::CommandExecutionType::COMMAND_EXECUTED);
 			CommandManager()->PostCommand(CommandManager()->NextRPCId(),SerialNumber_, Cmd.Command, Params, Cmd.UUID, Sent);
 
-			WebSocketClientNotificationDeviceConfigurationChange(D.SerialNumber, UUID, UpgradedUUID);
+			WebNotificationSingleDeviceConfigurationChange_t	Notification;
+			Notification.content.serialNumber = D.SerialNumber;
+			Notification.content.oldUUID = UUID;
+			Notification.content.newUUID = UpgradedUUID;
+			WebSocketClientNotificationDeviceConfigurationChange(Notification);
 
 			return true;
 		}
@@ -436,14 +449,14 @@ namespace OpenWifi {
 		}
 	}
 
-	bool AP_WS_Connection::StartTelemetry(std::uint64_t RPCID) {
+	bool AP_WS_Connection::StartTelemetry(uint64_t RPCID) {
 		poco_information(Logger_, fmt::format("TELEMETRY({}): Starting.", CId_));
 		Poco::JSON::Object StartMessage;
 		StartMessage.set("jsonrpc", "2.0");
 		StartMessage.set("method", "telemetry");
 		Poco::JSON::Object Params;
 		Params.set("serial", SerialNumber_);
-		Params.set("interval", TelemetryInterval_);
+		Params.set("interval", (uint64_t)TelemetryInterval_);
 		Poco::JSON::Array Types;
 		Types.add("wifi-frames");
 		Types.add("dhcp-snooping");
@@ -457,7 +470,7 @@ namespace OpenWifi {
 		return Send(OS.str());
 	}
 
-	bool AP_WS_Connection::StopTelemetry(std::uint64_t RPCID) {
+	bool AP_WS_Connection::StopTelemetry(uint64_t RPCID) {
 		poco_information(Logger_, fmt::format("TELEMETRY({}): Stopping.", CId_));
 		Poco::JSON::Object StopMessage;
 		StopMessage.set("jsonrpc", "2.0");
@@ -480,13 +493,13 @@ namespace OpenWifi {
 		State_.webSocketClients = TelemetryWebSocketRefCount_;
 	}
 
-	bool AP_WS_Connection::SetWebSocketTelemetryReporting(std::uint64_t RPCID, uint64_t Interval,
-													  uint64_t LifeTime) {
+	bool AP_WS_Connection::SetWebSocketTelemetryReporting(uint64_t RPCID, uint64_t Interval,
+														  uint64_t LifeTime) {
 		std::unique_lock Lock(TelemetryMutex_);
 		TelemetryWebSocketRefCount_++;
-		TelemetryInterval_ = TelemetryInterval_ ? std::min(Interval, TelemetryInterval_) : Interval;
-		auto TelemetryWebSocketTimer = LifeTime + OpenWifi::Now();
-		TelemetryWebSocketTimer_ = std::max(TelemetryWebSocketTimer, TelemetryWebSocketTimer_);
+		TelemetryInterval_ = TelemetryInterval_ ? ( Interval< TelemetryInterval_ ? Interval : TelemetryInterval_) : Interval;
+		auto TelemetryWebSocketTimer = LifeTime + Utils::Now();
+		TelemetryWebSocketTimer_ = TelemetryWebSocketTimer > TelemetryWebSocketTimer_ ? TelemetryWebSocketTimer : TelemetryWebSocketTimer_;
 		UpdateCounts();
 		if (!TelemetryReporting_) {
 			TelemetryReporting_ = true;
@@ -495,12 +508,12 @@ namespace OpenWifi {
 		return true;
 	}
 
-	bool AP_WS_Connection::SetKafkaTelemetryReporting(std::uint64_t RPCID, uint64_t Interval, uint64_t LifeTime) {
+	bool AP_WS_Connection::SetKafkaTelemetryReporting(uint64_t RPCID, uint64_t Interval, uint64_t LifeTime) {
 		std::unique_lock Lock(TelemetryMutex_);
 		TelemetryKafkaRefCount_++;
-		TelemetryInterval_ = TelemetryInterval_ ? std::min(Interval, TelemetryInterval_) : Interval;
-		auto TelemetryKafkaTimer = LifeTime + OpenWifi::Now();
-		TelemetryKafkaTimer_ = std::max(TelemetryKafkaTimer, TelemetryKafkaTimer_);
+		TelemetryInterval_ = TelemetryInterval_ ? ( Interval<TelemetryInterval_ ? Interval : TelemetryInterval_) : Interval;
+		auto TelemetryKafkaTimer = LifeTime + Utils::Now();
+		TelemetryKafkaTimer_ = TelemetryKafkaTimer > TelemetryKafkaTimer_ ? TelemetryKafkaTimer : TelemetryKafkaTimer_;
 		UpdateCounts();
 		if (!TelemetryReporting_) {
 			TelemetryReporting_ = true;
@@ -509,7 +522,7 @@ namespace OpenWifi {
 		return true;
 	}
 
-	bool AP_WS_Connection::StopWebSocketTelemetry(std::uint64_t RPCID) {
+	bool AP_WS_Connection::StopWebSocketTelemetry(uint64_t RPCID) {
 		std::unique_lock Lock(TelemetryMutex_);
 		if (TelemetryWebSocketRefCount_)
 			TelemetryWebSocketRefCount_--;
@@ -521,7 +534,7 @@ namespace OpenWifi {
 		return true;
 	}
 
-	bool AP_WS_Connection::StopKafkaTelemetry(std::uint64_t RPCID) {
+	bool AP_WS_Connection::StopKafkaTelemetry(uint64_t RPCID) {
 		std::unique_lock Lock(TelemetryMutex_);
 		if (TelemetryKafkaRefCount_)
 			TelemetryKafkaRefCount_--;
@@ -586,7 +599,7 @@ namespace OpenWifi {
 
 			State_.RX += IncomingSize;
 			State_.MessageCount++;
-			State_.LastContact = OpenWifi::Now();
+			State_.LastContact = Utils::Now();
 
 			switch (Op) {
 				case Poco::Net::WebSocket::FRAME_OP_PING: {
@@ -603,7 +616,7 @@ namespace OpenWifi {
 						PingDetails.set(uCentralProtocol::SERIALNUMBER, SerialNumber_);
 						PingDetails.set(uCentralProtocol::COMPATIBLE, Compatible_);
 						PingDetails.set(uCentralProtocol::CONNECTIONIP, CId_);
-						PingDetails.set(uCentralProtocol::TIMESTAMP, OpenWifi::Now());
+						PingDetails.set(uCentralProtocol::TIMESTAMP, Utils::Now());
 						PingDetails.set("locale", State_.locale );
 						PingObject.set(uCentralProtocol::PING, PingDetails);
 						Poco::JSON::Stringifier Stringify;

src/AP_WS_Connection.h

@@ -24,7 +24,7 @@ namespace OpenWifi {
 	  public:
 		explicit AP_WS_Connection(	Poco::Net::HTTPServerRequest &request,
 									Poco::Net::HTTPServerResponse &response,
-									std::uint64_t connection_id,
+									uint64_t connection_id,
 									Poco::Logger &L,
 									Poco::Net::SocketReactor &R);
 		~AP_WS_Connection();
@@ -48,10 +48,10 @@ namespace OpenWifi {
 		static bool ExtractBase64CompressedData(const std::string & CompressedData, std::string & UnCompressedData, uint64_t compress_sz);
 		void LogException(const Poco::Exception &E);
 		inline Poco::Logger & Logger() { return Logger_; }
-		bool SetWebSocketTelemetryReporting(std::uint64_t RPCID, uint64_t interval, uint64_t TelemetryWebSocketTimer);
-		bool SetKafkaTelemetryReporting(std::uint64_t RPCID, uint64_t interval, uint64_t TelemetryKafkaTimer);
-		bool StopWebSocketTelemetry(std::uint64_t RPCID);
-		bool StopKafkaTelemetry(std::uint64_t RPCID);
+		bool SetWebSocketTelemetryReporting(uint64_t RPCID, uint64_t interval, uint64_t TelemetryWebSocketTimer);
+		bool SetKafkaTelemetryReporting(uint64_t RPCID, uint64_t interval, uint64_t TelemetryKafkaTimer);
+		bool StopWebSocketTelemetry(uint64_t RPCID);
+		bool StopKafkaTelemetry(uint64_t RPCID);
 
 		void Process_connect(Poco::JSON::Object::Ptr ParamsObj, const std::string &Serial);
 		void Process_state(Poco::JSON::Object::Ptr ParamsObj);
@@ -100,14 +100,14 @@ namespace OpenWifi {
 		std::string							CN_;
 		uint64_t 							Errors_=0;
 		Poco::Net::IPAddress				PeerAddress_;
-		std::atomic_bool 					TelemetryReporting_ = false;
-		std::atomic_uint64_t				TelemetryWebSocketRefCount_ = 0;
-		std::atomic_uint64_t				TelemetryKafkaRefCount_ = 0;
-		uint64_t 							TelemetryWebSocketTimer_ = 0;
-		uint64_t 							TelemetryKafkaTimer_ = 0 ;
-		uint64_t 							TelemetryInterval_ = 0;
-		std::atomic_uint64_t				TelemetryWebSocketPackets_=0;
-		std::atomic_uint64_t				TelemetryKafkaPackets_=0;
+		volatile bool 						TelemetryReporting_ = false;
+		volatile uint64_t				TelemetryWebSocketRefCount_ = 0;
+		volatile uint64_t				TelemetryKafkaRefCount_ = 0;
+		volatile uint64_t 				TelemetryWebSocketTimer_ = 0;
+		volatile uint64_t 				TelemetryKafkaTimer_ = 0 ;
+		volatile uint64_t 				TelemetryInterval_ = 0;
+		volatile uint64_t				TelemetryWebSocketPackets_=0;
+		volatile uint64_t				TelemetryKafkaPackets_=0;
 		GWObjects::ConnectionState			State_;
 		std::string        					LastStats_;
 		GWObjects::HealthCheck				LastHealthcheck_;
@@ -120,8 +120,8 @@ namespace OpenWifi {
 
 		static inline std::atomic_uint64_t 	ConcurrentStartingDevices_=0;
 
-		bool StartTelemetry(std::uint64_t RPCID);
-		bool StopTelemetry(std::uint64_t RPCID);
+		bool StartTelemetry(uint64_t RPCID);
+		bool StopTelemetry(uint64_t RPCID);
 		void UpdateCounts();
 	};
 

src/AP_WS_Process_connect.cpp

@@ -6,130 +6,139 @@
 #include "AP_WS_Server.h"
 #include "StorageService.h"
 #include "FindCountry.h"
-#include "framework/WebSocketClientNotifications.h"
 #include "Daemon.h"
 #include "CentralConfig.h"
 
 #include "CommandManager.h"
 
+#include "framework/KafkaManager.h"
+#include "framework/utils.h"
+
+#include "UI_GW_WebSocketNotifications.h"
+
 namespace OpenWifi {
 
-void AP_WS_Connection::Process_connect(Poco::JSON::Object::Ptr ParamsObj, const std::string &Serial) {
-	if (ParamsObj->has(uCentralProtocol::UUID) &&
-		ParamsObj->has(uCentralProtocol::FIRMWARE) &&
-		ParamsObj->has(uCentralProtocol::CAPABILITIES)) {
-		uint64_t UUID = ParamsObj->get(uCentralProtocol::UUID);
-		auto Firmware = ParamsObj->get(uCentralProtocol::FIRMWARE).toString();
-		auto CapabilitiesString = ParamsObj->get(uCentralProtocol::CAPABILITIES).toString();
+	void AP_WS_Connection::Process_connect(Poco::JSON::Object::Ptr ParamsObj, const std::string &Serial) {
+		if (ParamsObj->has(uCentralProtocol::UUID) &&
+			ParamsObj->has(uCentralProtocol::FIRMWARE) &&
+			ParamsObj->has(uCentralProtocol::CAPABILITIES)) {
+			uint64_t UUID = ParamsObj->get(uCentralProtocol::UUID);
+			auto Firmware = ParamsObj->get(uCentralProtocol::FIRMWARE).toString();
+			auto CapabilitiesString = ParamsObj->get(uCentralProtocol::CAPABILITIES).toString();
 
-		Config::Capabilities Caps(CapabilitiesString);
-		Compatible_ = Caps.Compatible();
+			Config::Capabilities Caps(CapabilitiesString);
+			Compatible_ = Caps.Compatible();
 
-		SerialNumber_ = Serial;
-		SerialNumberInt_ = Utils::SerialNumberToInt(SerialNumber_);
+			SerialNumber_ = Serial;
+			SerialNumberInt_ = Utils::SerialNumberToInt(SerialNumber_);
 
-		CommandManager()->ClearQueue(SerialNumberInt_);
+			CommandManager()->ClearQueue(SerialNumberInt_);
 
-		AP_WS_Server()->SetSessionDetails(State_.sessionId,SerialNumberInt_);
-		State_.UUID = UUID;
-		State_.Firmware = Firmware;
-		State_.PendingUUID = 0;
-		State_.Address = Utils::FormatIPv6(WS_->peerAddress().toString());
-		CId_ = SerialNumber_ + "@" + CId_;
+			AP_WS_Server()->SetSessionDetails(State_.sessionId,SerialNumberInt_);
+			State_.UUID = UUID;
+			State_.Firmware = Firmware;
+			State_.PendingUUID = 0;
+			State_.Address = Utils::FormatIPv6(WS_->peerAddress().toString());
+			CId_ = SerialNumber_ + "@" + CId_;
 
-		auto IP = PeerAddress_.toString();
-		if(IP.substr(0,7)=="::ffff:") {
-			IP = IP.substr(7);
-		}
+			auto IP = PeerAddress_.toString();
+			if(IP.substr(0,7)=="::ffff:") {
+				IP = IP.substr(7);
+			}
 
-		State_.locale = FindCountryFromIP()->Get(IP);
-		GWObjects::Device	DeviceInfo;
-		auto DeviceExists = StorageService()->GetDevice(SerialNumber_,DeviceInfo);
-		if (Daemon()->AutoProvisioning() && !DeviceExists) {
-			StorageService()->CreateDefaultDevice(SerialNumber_, CapabilitiesString, Firmware,
-												  Compatible_, PeerAddress_);
-		} else if (DeviceExists) {
-			StorageService()->UpdateDeviceCapabilities(SerialNumber_, CapabilitiesString,
-													   Compatible_);
-			bool Updated = false;
-			if(!Firmware.empty()) {
-				if(Firmware!=DeviceInfo.Firmware) {
-					DeviceInfo.Firmware = Firmware;
-					DeviceInfo.LastFWUpdate = OpenWifi::Now();
-					Updated = true;
-					WebSocketClientNotificationDeviceFirmwareUpdated(SerialNumber_, Firmware);
-				} else if(DeviceInfo.LastFWUpdate==0) {
-					DeviceInfo.LastFWUpdate = OpenWifi::Now();
+			State_.locale = FindCountryFromIP()->Get(IP);
+			GWObjects::Device	DeviceInfo;
+			auto DeviceExists = StorageService()->GetDevice(SerialNumber_,DeviceInfo);
+			if (Daemon()->AutoProvisioning() && !DeviceExists) {
+				StorageService()->CreateDefaultDevice(SerialNumber_, CapabilitiesString, Firmware,
+													  Compatible_, PeerAddress_);
+			} else if (DeviceExists) {
+				StorageService()->UpdateDeviceCapabilities(SerialNumber_, CapabilitiesString,
+														   Compatible_);
+				bool Updated = false;
+				if(!Firmware.empty()) {
+					if(Firmware!=DeviceInfo.Firmware) {
+						DeviceInfo.Firmware = Firmware;
+						DeviceInfo.LastFWUpdate = Utils::Now();
+						Updated = true;
+
+						WebNotificationSingleDeviceFirmwareChange_t	Notification;
+						Notification.content.serialNumber = SerialNumber_;
+						Notification.content.newFirmware = Firmware;
+						WebSocketClientNotificationDeviceFirmwareUpdated(Notification);
+					} else if(DeviceInfo.LastFWUpdate==0) {
+						DeviceInfo.LastFWUpdate = Utils::Now();
+						Updated = true;
+					}
+				}
+
+				if(DeviceInfo.locale != State_.locale) {
+					DeviceInfo.locale = State_.locale;
 					Updated = true;
 				}
+
+				if(Compatible_ != DeviceInfo.DeviceType) {
+					DeviceInfo.DeviceType = Compatible_;
+					Updated = true;
+				}
+
+				if(Updated) {
+					StorageService()->UpdateDevice(DeviceInfo);
+				}
+				uint64_t UpgradedUUID=0;
+				LookForUpgrade(UUID,UpgradedUUID);
+				State_.UUID = UpgradedUUID;
 			}
 
-			if(DeviceInfo.locale != State_.locale) {
-				DeviceInfo.locale = State_.locale;
-				Updated = true;
-			}
+			State_.Compatible = Compatible_;
+			State_.Connected = true;
+			ConnectionCompletionTime_ = std::chrono::high_resolution_clock::now() - ConnectionStart_;
+			State_.connectionCompletionTime = ConnectionCompletionTime_.count();
 
-			if(Compatible_ != DeviceInfo.DeviceType) {
-				DeviceInfo.DeviceType = Compatible_;
-				Updated = true;
-			}
-
-			if(Updated) {
-				StorageService()->UpdateDevice(DeviceInfo);
-			}
-			uint64_t UpgradedUUID=0;
-			LookForUpgrade(UUID,UpgradedUUID);
-			State_.UUID = UpgradedUUID;
-		}
-
-		State_.Compatible = Compatible_;
-		State_.Connected = true;
-		ConnectionCompletionTime_ = std::chrono::high_resolution_clock::now() - ConnectionStart_;
-		State_.connectionCompletionTime = ConnectionCompletionTime_.count();
-
-		if(State_.VerifiedCertificate == GWObjects::VALID_CERTIFICATE) {
-			if ((	Utils::SerialNumberMatch(CN_, SerialNumber_, AP_WS_Server()->MismatchDepth())) ||
-					AP_WS_Server()->IsSimSerialNumber(CN_)) {
-				State_.VerifiedCertificate = GWObjects::VERIFIED;
-				poco_information(Logger_, fmt::format("CONNECT({}): Fully validated and authenticated device. Session={} ConnectionCompletion Time={}",
-													   CId_,
-													   State_.sessionId,
-													   State_.connectionCompletionTime ));
-			} else {
-				State_.VerifiedCertificate = GWObjects::MISMATCH_SERIAL;
-				if(AP_WS_Server()->AllowSerialNumberMismatch()) {
-					poco_information(
-						Logger_, fmt::format("CONNECT({}): Serial number mismatch allowed. CN={} Serial={} Session={} ConnectionCompletion Time={}",
-											 CId_, CN_, SerialNumber_, State_.sessionId,
-											 State_.connectionCompletionTime));
+			if(State_.VerifiedCertificate == GWObjects::VALID_CERTIFICATE) {
+				if ((	Utils::SerialNumberMatch(CN_, SerialNumber_, AP_WS_Server()->MismatchDepth())) ||
+						AP_WS_Server()->IsSimSerialNumber(CN_)) {
+					State_.VerifiedCertificate = GWObjects::VERIFIED;
+					poco_information(Logger_, fmt::format("CONNECT({}): Fully validated and authenticated device. Session={} ConnectionCompletion Time={}",
+														   CId_,
+														   State_.sessionId,
+														   State_.connectionCompletionTime ));
 				} else {
-					poco_information(
-						Logger_, fmt::format("CONNECT({}): Serial number mismatch disallowed. Device rejected. CN={} Serial={} Session={} ConnectionCompletion Time={}",
-											 CId_, CN_, SerialNumber_, State_.sessionId,
-											 State_.connectionCompletionTime));
-					return EndConnection();
+					State_.VerifiedCertificate = GWObjects::MISMATCH_SERIAL;
+					if(AP_WS_Server()->AllowSerialNumberMismatch()) {
+						poco_information(
+							Logger_, fmt::format("CONNECT({}): Serial number mismatch allowed. CN={} Serial={} Session={} ConnectionCompletion Time={}",
+												 CId_, CN_, SerialNumber_, State_.sessionId,
+												 State_.connectionCompletionTime));
+					} else {
+						poco_information(
+							Logger_, fmt::format("CONNECT({}): Serial number mismatch disallowed. Device rejected. CN={} Serial={} Session={} ConnectionCompletion Time={}",
+												 CId_, CN_, SerialNumber_, State_.sessionId,
+												 State_.connectionCompletionTime));
+						return EndConnection();
+					}
 				}
 			}
+
+			WebNotificationSingleDevice_t	Notification;
+			Notification.content.serialNumber = SerialNumber_;
+			WebSocketClientNotificationDeviceConnected(Notification);
+
+			// std::cout << "Serial: " << SerialNumber_ << "Session: " << State_.sessionId << std::endl;
+
+			if (KafkaManager()->Enabled()) {
+				Poco::JSON::Stringifier Stringify;
+				ParamsObj->set(uCentralProtocol::CONNECTIONIP, CId_);
+				ParamsObj->set("locale", State_.locale );
+				ParamsObj->set(uCentralProtocol::TIMESTAMP, Utils::Now());
+				std::ostringstream OS;
+				Stringify.condense(ParamsObj, OS);
+				KafkaManager()->PostMessage(KafkaTopics::CONNECTION, SerialNumber_, OS.str());
+			}
+		} else {
+			poco_warning(Logger_,fmt::format("INVALID-PROTOCOL({}): Missing one of uuid, firmware, or capabilities", CId_));
+			Errors_++;
 		}
-
-		WebSocketClientNotificationDeviceConnected(SerialNumber_);
-
-		// std::cout << "Serial: " << SerialNumber_ << "Session: " << State_.sessionId << std::endl;
-
-		if (KafkaManager()->Enabled()) {
-			Poco::JSON::Stringifier Stringify;
-			ParamsObj->set(uCentralProtocol::CONNECTIONIP, CId_);
-			ParamsObj->set("locale", State_.locale );
-			ParamsObj->set(uCentralProtocol::TIMESTAMP, OpenWifi::Now());
-			std::ostringstream OS;
-			Stringify.condense(ParamsObj, OS);
-			KafkaManager()->PostMessage(KafkaTopics::CONNECTION, SerialNumber_, OS.str());
-		}
-	} else {
-		poco_warning(Logger_,fmt::format("INVALID-PROTOCOL({}): Missing one of uuid, firmware, or capabilities", CId_));
-		Errors_++;
 	}
-}
-
 
 }

src/AP_WS_Process_crashlog.cpp

@@ -5,6 +5,10 @@
 #include "AP_WS_Connection.h"
 #include "StorageService.h"
 
+#include "framework/utils.h"
+#include "framework/ow_constants.h"
+#include "fmt/format.h"
+
 namespace OpenWifi {
 	void AP_WS_Connection::Process_crashlog(Poco::JSON::Object::Ptr ParamsObj) {
 		if (ParamsObj->has(uCentralProtocol::UUID) && ParamsObj->has(uCentralProtocol::LOGLINES)) {

src/AP_WS_Process_deviceupdate.cpp

@@ -5,6 +5,8 @@
 #include "AP_WS_Connection.h"
 #include "StorageService.h"
 
+#include "fmt/format.h"
+
 namespace OpenWifi {
 
 	void AP_WS_Connection::Process_deviceupdate(Poco::JSON::Object::Ptr ParamsObj, std::string &Serial) {

src/AP_WS_Process_healthcheck.cpp

@@ -5,6 +5,10 @@
 #include "AP_WS_Connection.h"
 #include "StorageService.h"
 
+#include "framework/KafkaManager.h"
+#include "framework/utils.h"
+#include "fmt/format.h"
+
 namespace OpenWifi {
 
 void AP_WS_Connection::Process_healthcheck(Poco::JSON::Object::Ptr ParamsObj) {
@@ -42,7 +46,7 @@ void AP_WS_Connection::Process_healthcheck(Poco::JSON::Object::Ptr ParamsObj) {
 		GWObjects::HealthCheck Check;
 
 		Check.SerialNumber = SerialNumber_;
-		Check.Recorded = OpenWifi::Now();
+		Check.Recorded = Utils::Now();
 		Check.UUID = UUID;
 		Check.Data = CheckData;
 		Check.Sanity = Sanity;
@@ -57,7 +61,7 @@ void AP_WS_Connection::Process_healthcheck(Poco::JSON::Object::Ptr ParamsObj) {
 		if (KafkaManager()->Enabled()) {
 			Poco::JSON::Stringifier Stringify;
 			std::ostringstream OS;
-			ParamsObj->set("timestamp", OpenWifi::Now());
+			ParamsObj->set("timestamp", Utils::Now());
 			Stringify.condense(ParamsObj, OS);
 			KafkaManager()->PostMessage(KafkaTopics::HEALTHCHECK, SerialNumber_, OS.str());
 		}

src/AP_WS_Process_log.cpp

@@ -5,6 +5,9 @@
 #include "AP_WS_Connection.h"
 #include "StorageService.h"
 
+#include "framework/ow_constants.h"
+#include "fmt/format.h"
+
 namespace OpenWifi {
 	void AP_WS_Connection::Process_log(Poco::JSON::Object::Ptr ParamsObj) {
 		if (!State_.Connected) {

src/AP_WS_Process_recovery.cpp

@@ -6,6 +6,10 @@
 #include "StorageService.h"
 #include "CommandManager.h"
 
+#include "framework/ow_constants.h"
+#include "framework/MicroServiceFuncs.h"
+#include "fmt/format.h"
+
 namespace OpenWifi {
 	void AP_WS_Connection::Process_recovery(Poco::JSON::Object::Ptr ParamsObj) {
 		if (ParamsObj->has(uCentralProtocol::SERIAL) &&
@@ -36,7 +40,7 @@ namespace OpenWifi {
 			if (ParamsObj->get(uCentralProtocol::REBOOT).toString() == "true") {
 				GWObjects::CommandDetails Cmd;
 				Cmd.SerialNumber = SerialNumber_;
-				Cmd.UUID = MicroService::CreateUUID();
+				Cmd.UUID = MicroServiceCreateUUID();
 				Cmd.SubmittedBy = uCentralProtocol::SUBMITTED_BY_SYSTEM;
 				Cmd.Status = uCentralProtocol::PENDING;
 				Cmd.Command = uCentralProtocol::REBOOT;

src/AP_WS_Process_state.cpp

@@ -4,9 +4,15 @@
 
 #include "AP_WS_Connection.h"
 #include "StorageService.h"
-#include "framework/WebSocketClientNotifications.h"
 #include "StateUtils.h"
 
+#include "UI_GW_WebSocketNotifications.h"
+
+#include "framework/KafkaManager.h"
+#include "framework/utils.h"
+
+#include "fmt/format.h"
+
 namespace OpenWifi {
 	void AP_WS_Connection::Process_state(Poco::JSON::Object::Ptr ParamsObj) {
 		if (!State_.Connected) {
@@ -39,7 +45,7 @@ namespace OpenWifi {
 
 			GWObjects::Statistics Stats{
 				.SerialNumber = SerialNumber_, .UUID = UUID, .Data = StateStr};
-			Stats.Recorded = OpenWifi::Now();
+			Stats.Recorded = Utils::Now();
 			StorageService()->AddStatisticsData(Stats);
 			if (!request_uuid.empty()) {
 				StorageService()->SetCommandResult(request_uuid, StateStr);
@@ -55,10 +61,9 @@ namespace OpenWifi {
 				KafkaManager()->PostMessage(KafkaTopics::STATE, SerialNumber_, OS.str());
 			}
 
-			WebSocketNotification<WebNotificationSingleDevice>	N;
+			WebNotificationSingleDevice_t	N;
 			N.content.serialNumber = SerialNumber_;
-			N.type = "device_statistics";
-			WebSocketClientServer()->SendNotification(N);
+			WebSocketClientNotificationDeviceStatistics(N);
 
 		} else {
 			poco_warning(Logger_, fmt::format("STATE({}): Invalid request. Missing serial, uuid, or state", CId_));

src/AP_WS_Process_telemetry.cpp

@@ -6,6 +6,10 @@
 #include "TelemetryStream.h"
 #include "CommandManager.h"
 
+#include "framework/KafkaManager.h"
+#include "framework/utils.h"
+#include "fmt/format.h"
+
 namespace OpenWifi {
 	void AP_WS_Connection::Process_telemetry(Poco::JSON::Object::Ptr ParamsObj) {
 		if (!State_.Connected) {
@@ -14,19 +18,20 @@ namespace OpenWifi {
 			Errors_++;
 			return;
 		}
+		poco_trace(Logger_,fmt::format("Telemetry data received for {}", SerialNumber_));
 		if (TelemetryReporting_) {
 			if (ParamsObj->has("data")) {
 				auto Payload = ParamsObj->get("data").extract<Poco::JSON::Object::Ptr>();
-				Payload->set("timestamp", OpenWifi::Now());
+				Payload->set("timestamp", Utils::Now());
 				std::ostringstream SS;
 				Payload->stringify(SS);
-				auto now=OpenWifi::Now();
+				auto now=Utils::Now();
 				if (TelemetryWebSocketRefCount_) {
 					if(now<TelemetryWebSocketTimer_) {
 						// std::cout << SerialNumber_ << ": Updating WebSocket telemetry" << std::endl;
 						TelemetryWebSocketPackets_++;
 						State_.websocketPackets = TelemetryWebSocketPackets_;
-						TelemetryStream()->UpdateEndPoint(SerialNumberInt_, SS.str());
+						TelemetryStream()->NotifyEndPoint(SerialNumberInt_, SS.str());
 					} else {
 						StopWebSocketTelemetry(CommandManager()->NextRPCId());
 					}

src/AP_WS_ReactorPool.h

@@ -10,6 +10,8 @@
 #include "Poco/Net/SocketAcceptor.h"
 #include "Poco/Environment.h"
 
+#include "framework/utils.h"
+
 namespace OpenWifi {
 	class AP_WS_ReactorThreadPool {
 	  public:

src/AP_WS_Server.cpp

@@ -7,14 +7,18 @@
 //
 
 #include "Poco/Net/HTTPHeaderStream.h"
-#include "Poco/JSON/Array.h"
 #include "Poco/Net/Context.h"
+#include "Poco/Net/HTTPServerRequest.h"
 
 #include "AP_WS_Server.h"
 #include "AP_WS_Connection.h"
 #include "ConfigurationCache.h"
 #include "TelemetryStream.h"
-#include "framework/WebSocketClientNotifications.h"
+
+#include "framework/MicroServiceFuncs.h"
+#include "framework/utils.h"
+#include "UI_GW_WebSocketNotifications.h"
+#include "fmt/format.h"
 
 namespace OpenWifi {
 
@@ -40,8 +44,8 @@ namespace OpenWifi {
 
 	int AP_WS_Server::Start() {
 
-		AllowSerialNumberMismatch_ = MicroService::instance().ConfigGetBool("openwifi.certificates.allowmismatch",true);
-		MismatchDepth_ = MicroService::instance().ConfigGetInt("openwifi.certificates.mismatchdepth",2);
+		AllowSerialNumberMismatch_ = MicroServiceConfigGetBool("openwifi.certificates.allowmismatch",true);
+		MismatchDepth_ = MicroServiceConfigGetInt("openwifi.certificates.mismatchdepth",2);
 
 		Reactor_pool_ = std::make_unique<AP_WS_ReactorThreadPool>();
 		Reactor_pool_->Start();
@@ -72,11 +76,11 @@ namespace OpenWifi {
 
 			auto Context = Poco::AutoPtr<Poco::Net::Context>(new Poco::Net::Context(Poco::Net::Context::TLS_SERVER_USE, P));
 
-			if(!Svr.KeyFilePassword().empty()) {
+/*			if(!Svr.KeyFilePassword().empty()) {
 				auto PassphraseHandler = Poco::SharedPtr<MyPrivateKeyPassphraseHandler>( new MyPrivateKeyPassphraseHandler(Svr.KeyFilePassword(),Logger()));
 				Poco::Net::SSLManager::instance().initializeServer(PassphraseHandler, nullptr,Context);
 			}
-
+*/
 			Poco::Crypto::X509Certificate Cert(Svr.CertFile());
 			Poco::Crypto::X509Certificate Root(Svr.RootCA());
 
@@ -128,7 +132,7 @@ namespace OpenWifi {
 
 		ReactorThread_.start(Reactor_);
 
-		auto ProvString = MicroService::instance().ConfigGetString("autoprovisioning.process","default");
+		auto ProvString = MicroServiceConfigGetString("autoprovisioning.process","default");
 		if(ProvString!="default") {
 			auto Tokens = Poco::StringTokenizer(ProvString, ",");
 			for (const auto &i : Tokens) {
@@ -141,14 +145,14 @@ namespace OpenWifi {
 			UseDefaultConfig_ = true;
 		}
 
-		SimulatorId_ = MicroService::instance().ConfigGetString("simulatorid","");
+		SimulatorId_ = MicroServiceConfigGetString("simulatorid","");
 		SimulatorEnabled_ = !SimulatorId_.empty();
 		Utils::SetThreadName(ReactorThread_,"dev:react:head");
 
 		GarbageCollectorCallback_ = std::make_unique<Poco::TimerCallback<AP_WS_Server>>(*this,&AP_WS_Server::onGarbageCollecting);
 		Timer_.setStartInterval(10 * 1000);
 		Timer_.setPeriodicInterval(5 * 1000); // every minute
-		Timer_.start(*GarbageCollectorCallback_, MicroService::instance().TimerPool());
+		Timer_.start(*GarbageCollectorCallback_, MicroServiceTimerPool());
 
 		Running_ = true;
 		return 0;
@@ -161,14 +165,14 @@ namespace OpenWifi {
 			Garbage_.clear();
 		}
 
-		static std::uint64_t last_log = OpenWifi::Now();
+		static uint64_t last_log = Utils::Now();
 
 		NumberOfConnectedDevices_ = 0;
 		NumberOfConnectingDevices_ = 0;
 		AverageDeviceConnectionTime_ = 0;
-		std::uint64_t	total_connected_time=0;
+		uint64_t	total_connected_time=0;
 
-		auto now = OpenWifi::Now();
+		auto now = Utils::Now();
 		for (auto connection=SerialNumbers_.begin(); connection!=SerialNumbers_.end();) {
 
 			if(connection->second.second== nullptr) {
@@ -193,9 +197,12 @@ namespace OpenWifi {
 							 fmt::format("Active AP connections: {} Connecting: {} Average connection time: {} seconds",
 										 NumberOfConnectedDevices_, NumberOfConnectingDevices_, AverageDeviceConnectionTime_));
 		}
-		WebSocketClientNotificationNumberOfConnections(NumberOfConnectedDevices_,
-													   AverageDeviceConnectionTime_,
-													   NumberOfConnectingDevices_);
+
+		WebSocketClientNotificationNumberOfConnection_t	Notification;
+		Notification.content.numberOfConnectingDevices = NumberOfConnectingDevices_;
+		Notification.content.numberOfDevices = NumberOfConnectedDevices_;
+		Notification.content.averageConnectedTime = AverageDeviceConnectionTime_;
+		WebSocketClientNotificationNumberOfConnections(Notification);
 	}
 
 	void AP_WS_Server::Stop() {
@@ -213,7 +220,7 @@ namespace OpenWifi {
 		poco_information(Logger(),"Stopped...");
 	}
 
-	bool AP_WS_Server::GetStatistics(std::uint64_t SerialNumber, std::string &Statistics) const {
+	bool AP_WS_Server::GetStatistics(uint64_t SerialNumber, std::string &Statistics) const {
 		std::lock_guard			Lock(LocalMutex_);
 		auto Device = SerialNumbers_.find(SerialNumber);
 		if(Device == SerialNumbers_.end() || Device->second.second==nullptr)
@@ -242,7 +249,7 @@ namespace OpenWifi {
 		return true;
 	}
 
-	void AP_WS_Server::SetSessionDetails(std::uint64_t connection_id, uint64_t SerialNumber) {
+	void AP_WS_Server::SetSessionDetails(uint64_t connection_id, uint64_t SerialNumber) {
 		std::lock_guard			Lock(LocalMutex_);
 
 		auto Conn = Sessions_.find(connection_id);
@@ -257,7 +264,7 @@ namespace OpenWifi {
 		}
 	}
 
-	bool AP_WS_Server::EndSession(std::uint64_t session_id, std::uint64_t serial_number) {
+	bool AP_WS_Server::EndSession(uint64_t session_id, uint64_t serial_number) {
 		std::unique_lock G(LocalMutex_);
 
 		auto Session = Sessions_.find(session_id);
@@ -298,7 +305,7 @@ namespace OpenWifi {
 			return false;
 
 		try {
-			// std::cout << "Device connection pointer: " << (std::uint64_t) Device->second.second << std::endl;
+			// std::cout << "Device connection pointer: " << (uint64_t) Device->second.second << std::endl;
 			return Device->second.second->Send(Payload);
 		} catch (...) {
 			poco_debug(Logger(),fmt::format(": SendFrame: Could not send data to device '{}'", Utils::IntToSerialNumber(SerialNumber)));
@@ -306,7 +313,7 @@ namespace OpenWifi {
 		return false;
 	}
 
-	void AP_WS_Server::StopWebSocketTelemetry(std::uint64_t RPCID, uint64_t SerialNumber) {
+	void AP_WS_Server::StopWebSocketTelemetry(uint64_t RPCID, uint64_t SerialNumber) {
 		std::lock_guard			Lock(LocalMutex_);
 
 		auto Device = SerialNumbers_.find(SerialNumber);
@@ -315,7 +322,7 @@ namespace OpenWifi {
 		Device->second.second->StopWebSocketTelemetry(RPCID);
 	}
 
-	void AP_WS_Server::SetWebSocketTelemetryReporting(std::uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime) {
+	void AP_WS_Server::SetWebSocketTelemetryReporting(uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime) {
 		std::lock_guard			Lock(LocalMutex_);
 
 		auto Device = SerialNumbers_.find(SerialNumber);
@@ -324,7 +331,7 @@ namespace OpenWifi {
 		Device->second.second->SetWebSocketTelemetryReporting(RPCID, Interval, Lifetime);
 	}
 
-	void AP_WS_Server::SetKafkaTelemetryReporting(std::uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime) {
+	void AP_WS_Server::SetKafkaTelemetryReporting(uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime) {
 		std::lock_guard			Lock(LocalMutex_);
 
 		auto Device = SerialNumbers_.find(SerialNumber);
@@ -333,7 +340,7 @@ namespace OpenWifi {
 		Device->second.second->SetKafkaTelemetryReporting(RPCID, Interval, Lifetime);
 	}
 
-	void AP_WS_Server::StopKafkaTelemetry(std::uint64_t RPCID, uint64_t SerialNumber) {
+	void AP_WS_Server::StopKafkaTelemetry(uint64_t RPCID, uint64_t SerialNumber) {
 		std::lock_guard			Lock(LocalMutex_);
 
 		auto Device = SerialNumbers_.find(SerialNumber);

src/AP_WS_Server.h

@@ -13,22 +13,27 @@
 #include <array>
 #include <ctime>
 
-#include "framework/MicroService.h"
-
 #include "Poco/AutoPtr.h"
 #include "Poco/Net/SocketReactor.h"
 #include "Poco/Net/ParallelSocketAcceptor.h"
 #include "Poco/Net/SocketAcceptor.h"
 #include "Poco/Timer.h"
+#include "Poco/Net/HTTPRequestHandler.h"
+#include "Poco/Net/HTTPRequestHandlerFactory.h"
+#include "Poco/Net/HTTPServer.h"
+#include "Poco/Net/HTTPServerRequest.h"
 
 #include "AP_WS_Connection.h"
 #include "AP_WS_ReactorPool.h"
 
+#include "framework/utils.h"
+#include "framework/SubSystemServer.h"
+
 namespace OpenWifi {
 
 	class AP_WS_RequestHandler : public Poco::Net::HTTPRequestHandler {
 	  public:
-		explicit AP_WS_RequestHandler(Poco::Logger &L, std::uint64_t id)
+		explicit AP_WS_RequestHandler(Poco::Logger &L, uint64_t id)
 			: Logger_(L),
 			  id_(id){
 		};
@@ -37,7 +42,7 @@ namespace OpenWifi {
 						   Poco::Net::HTTPServerResponse &response) override;
 	  private:
 		Poco::Logger 				&Logger_;
-		std::uint64_t 				id_=0;
+		uint64_t 				id_=0;
 	};
 
 	class AP_WS_RequestHandlerFactory : public Poco::Net::HTTPRequestHandlerFactory {
@@ -58,7 +63,7 @@ namespace OpenWifi {
 		}
 	  private:
 		Poco::Logger 				&Logger_;
-		inline static std::uint64_t 		id_=1;
+		inline static uint64_t 		id_=1;
 	};
 
 	class AP_WS_Server : public SubSystemServer {
@@ -90,7 +95,7 @@ namespace OpenWifi {
 			return AllowSerialNumberMismatch_;
 		}
 
-		inline std::uint64_t MismatchDepth() const {
+		inline uint64_t MismatchDepth() const {
 			return MismatchDepth_;
 		}
 
@@ -100,12 +105,12 @@ namespace OpenWifi {
 		[[nodiscard]] inline Poco::Net::SocketReactor & NextReactor() { return Reactor_pool_->NextReactor(); }
 		[[nodiscard]] inline bool Running() const { return Running_; }
 
-		inline void AddConnection(std::uint64_t session_id, std::shared_ptr<AP_WS_Connection> Connection ) {
+		inline void AddConnection(uint64_t session_id, std::shared_ptr<AP_WS_Connection> Connection ) {
 			std::lock_guard			Lock(LocalMutex_);
 			Sessions_[session_id] = std::make_pair(std::move(Connection),false);
 		}
 
-		inline std::shared_ptr<AP_WS_Connection> FindConnection(std::uint64_t session_id) const {
+		inline std::shared_ptr<AP_WS_Connection> FindConnection(uint64_t session_id) const {
 			std::lock_guard			Lock(LocalMutex_);
 
 			auto Connection = Sessions_.find(session_id);
@@ -117,17 +122,17 @@ namespace OpenWifi {
 		inline bool GetStatistics(const std::string &SerialNumber, std::string & Statistics) const {
 			return GetStatistics(Utils::SerialNumberToInt(SerialNumber),Statistics);
 		}
-		bool GetStatistics(std::uint64_t SerialNumber, std::string & Statistics) const ;
+		bool GetStatistics(uint64_t SerialNumber, std::string & Statistics) const ;
 
 		inline bool GetState(const std::string & SerialNumber, GWObjects::ConnectionState & State) const {
 			return GetState(Utils::SerialNumberToInt(SerialNumber), State);
 		}
-		bool GetState(std::uint64_t SerialNumber, GWObjects::ConnectionState & State) const;
+		bool GetState(uint64_t SerialNumber, GWObjects::ConnectionState & State) const;
 
 		inline bool GetHealthcheck(const std::string &SerialNumber, GWObjects::HealthCheck & CheckData) const {
 			return GetHealthcheck(Utils::SerialNumberToInt(SerialNumber), CheckData);
 		}
-		bool GetHealthcheck(std::uint64_t SerialNumber, GWObjects::HealthCheck & CheckData) const ;
+		bool GetHealthcheck(uint64_t SerialNumber, GWObjects::HealthCheck & CheckData) const ;
 
 		bool Connected(uint64_t SerialNumber) const ;
 
@@ -135,19 +140,19 @@ namespace OpenWifi {
 			return SendFrame(Utils::SerialNumberToInt(SerialNumber), Payload);
 		}
 
-		bool SendFrame(std::uint64_t SerialNumber, const std::string & Payload) const ;
+		bool SendFrame(uint64_t SerialNumber, const std::string & Payload) const ;
 
 		bool SendRadiusAuthenticationData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size);
 		bool SendRadiusAccountingData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size);
 		bool SendRadiusCoAData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size);
 
-		void SetSessionDetails(std::uint64_t connection_id, uint64_t SerialNumber);
-		bool EndSession(std::uint64_t connection_id, std::uint64_t serial_number);
+		void SetSessionDetails(uint64_t connection_id, uint64_t SerialNumber);
+		bool EndSession(uint64_t connection_id, uint64_t serial_number);
 
-		void SetWebSocketTelemetryReporting(std::uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime);
-		void StopWebSocketTelemetry(std::uint64_t RPCID, uint64_t SerialNumber);
-		void SetKafkaTelemetryReporting(std::uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime);
-		void StopKafkaTelemetry(std::uint64_t RPCID, uint64_t SerialNumber);
+		void SetWebSocketTelemetryReporting(uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime);
+		void StopWebSocketTelemetry(uint64_t RPCID, uint64_t SerialNumber);
+		void SetKafkaTelemetryReporting(uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime);
+		void StopKafkaTelemetry(uint64_t RPCID, uint64_t SerialNumber);
 		void GetTelemetryParameters(uint64_t SerialNumber , bool & TelemetryRunning,
 									uint64_t & TelemetryInterval,
 									uint64_t & TelemetryWebSocketTimer,
@@ -159,7 +164,7 @@ namespace OpenWifi {
 
 		void onGarbageCollecting(Poco::Timer & timer);
 
-		inline void AverageDeviceStatistics( std::uint64_t & Connections, std::uint64_t & AverageConnectionTime, std::uint64_t & NumberOfConnectingDevices) const {
+		inline void AverageDeviceStatistics( uint64_t & Connections, uint64_t & AverageConnectionTime, uint64_t & NumberOfConnectingDevices) const {
 			Connections = NumberOfConnectedDevices_;
 			AverageConnectionTime = AverageDeviceConnectionTime_;
 			NumberOfConnectingDevices = NumberOfConnectingDevices_;
@@ -178,8 +183,8 @@ namespace OpenWifi {
 		bool 														SimulatorEnabled_=false;
 		std::unique_ptr<AP_WS_ReactorThreadPool>					Reactor_pool_;
 		std::atomic_bool 											Running_=false;
-		std::map<std::uint64_t,	std::pair<std::shared_ptr<AP_WS_Connection>,bool>>	Sessions_;
-		std::map<std::uint64_t, std::pair<std::uint64_t,std::shared_ptr<AP_WS_Connection>>>	SerialNumbers_;
+		std::map<uint64_t,	std::pair<std::shared_ptr<AP_WS_Connection>,bool>>	Sessions_;
+		std::map<uint64_t, std::pair<uint64_t,std::shared_ptr<AP_WS_Connection>>>	SerialNumbers_;
 		std::atomic_bool 											AllowSerialNumberMismatch_=true;
 		std::atomic_uint64_t 										MismatchDepth_=2;
 

src/CapabilitiesCache.h

@@ -4,7 +4,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include <string>
+#include <map>
+#include <mutex>
+#include <fstream>
+
+#include "framework/MicroServiceFuncs.h"
 
 #include "nlohmann/json.hpp"
 
@@ -92,8 +97,8 @@ namespace OpenWifi {
 		std::atomic_bool 						CapabilitiesLoaded_=false;
 		std::map<std::string,std::string>		Platforms_;
 		CapabilitiesCache_t						Capabilities_;
-		std::string 							PlatformCacheFileName_{ MicroService::instance().DataDir()+PlatformCacheFileName };
-		std::string 							CapabilitiesCacheFileName_{ MicroService::instance().DataDir()+CapabilitiesCacheFileName };
+		std::string 							PlatformCacheFileName_{ MicroServiceDataDirectory()+PlatformCacheFileName };
+		std::string 							CapabilitiesCacheFileName_{ MicroServiceDataDirectory()+CapabilitiesCacheFileName };
 
 		inline void LoadPlatforms() {
 			try {

src/CentralConfig.cpp

@@ -7,8 +7,6 @@
 //
 #include <fstream>
 
-#include "framework/MicroService.h"
-
 #include "Poco/JSON/Object.h"
 #include "Poco/JSON/Parser.h"
 #include "Poco/File.h"

src/CommandManager.cpp

@@ -8,14 +8,16 @@
 
 #include <algorithm>
 
-#include "framework/MicroService.h"
-
 #include "Poco/JSON/Parser.h"
 
 #include "CommandManager.h"
 #include "AP_WS_Server.h"
 #include "StorageService.h"
 #include "framework/ow_constants.h"
+#include "framework/MicroServiceFuncs.h"
+#include "framework/utils.h"
+
+using namespace std::chrono_literals;
 
 namespace OpenWifi {
 
@@ -83,12 +85,12 @@ namespace OpenWifi {
 		JanitorCallback_ = std::make_unique<Poco::TimerCallback<CommandManager>>(*this,&CommandManager::onJanitorTimer);
 		JanitorTimer_.setStartInterval( 10000 );
 		JanitorTimer_.setPeriodicInterval(10 * 60 * 1000); // 1 hours
-		JanitorTimer_.start(*JanitorCallback_, MicroService::instance().TimerPool());
+		JanitorTimer_.start(*JanitorCallback_, MicroServiceTimerPool());
 
 		CommandRunnerCallback_ = std::make_unique<Poco::TimerCallback<CommandManager>>(*this,&CommandManager::onCommandRunnerTimer);
 		CommandRunnerTimer_.setStartInterval( 10000 );
 		CommandRunnerTimer_.setPeriodicInterval(30 * 1000); // 1 hours
-		CommandRunnerTimer_.start(*CommandRunnerCallback_, MicroService::instance().TimerPool());
+		CommandRunnerTimer_.start(*CommandRunnerCallback_, MicroServiceTimerPool());
 
         return 0;
     }
@@ -168,7 +170,7 @@ namespace OpenWifi {
 						if(IsCommandRunning(Cmd.UUID))
 							continue;
 
-						auto now = OpenWifi::Now();
+						auto now = Utils::Now();
 						// 2 hour timeout for commands
 						if ((now - Cmd.Submitted) > (1 * 60 * 60)) {
 							poco_information(

src/CommandManager.h

@@ -15,12 +15,15 @@
 #include <functional>
 #include <shared_mutex>
 
-#include "framework/MicroService.h"
-
 #include "Poco/JSON/Object.h"
 #include "Poco/Net/HTTPServerRequest.h"
 #include "Poco/Net/HTTPServerResponse.h"
 #include "Poco/Timer.h"
+#include "Poco/Notification.h"
+#include "Poco/NotificationQueue.h"
+
+#include "framework/SubSystemServer.h"
+#include "fmt/format.h"
 
 #include "RESTObjects/RESTAPI_GWobjects.h"
 

src/ConfigurationCache.h

@@ -7,7 +7,6 @@
 #include <map>
 #include <string>
 #include <mutex>
-#include "framework/MicroService.h"
 
 namespace OpenWifi {
 	class ConfigurationCache {

src/Daemon.cpp

@@ -6,8 +6,6 @@
 //	Arilia Wireless Inc.
 //
 
-#include "framework/MicroService.h"
-
 #include "Poco/Util/Application.h"
 #include "Poco/Util/Option.h"
 #include "Poco/Environment.h"
@@ -28,6 +26,7 @@
 #include "VenueBroadcaster.h"
 #include "framework/ConfigurationValidator.h"
 #include "rttys/RTTYS_server.h"
+#include "framework/UI_WebSocketClientServer.h"
 
 namespace OpenWifi {
 	class Daemon *Daemon::instance() {
@@ -40,10 +39,9 @@ namespace OpenWifi {
 										StorageService(),
 										SerialNumberCache(),
 										ConfigurationValidator(),
-								   		WebSocketClientServer(),
+								   		UI_WebSocketClientServer(),
 										OUIServer(),
 										FindCountryFromIP(),
-//										DeviceRegistry(),
 										CommandManager(),
 										FileUploader(),
 										StorageArchiver(),
@@ -104,6 +102,10 @@ namespace OpenWifi {
         }
         return "AP";
     }
+
+	void DaemonPostInitialization(Poco::Util::Application &self) {
+		Daemon()->PostInitialization(self);
+	}
 }
 
 int main(int argc, char **argv) {

src/Daemon.h

@@ -14,18 +14,9 @@
 #include <vector>
 #include <set>
 
+#include "framework/MicroServiceNames.h"
 #include "framework/MicroService.h"
 
-#include "Poco/Util/Application.h"
-#include "Poco/Util/ServerApplication.h"
-#include "Poco/Util/Option.h"
-#include "Poco/Util/OptionSet.h"
-#include "Poco/UUIDGenerator.h"
-#include "Poco/ErrorHandler.h"
-#include "Poco/Crypto/RSAKey.h"
-#include "Poco/Crypto/CipherFactory.h"
-#include "Poco/Crypto/Cipher.h"
-
 #include "Dashboard.h"
 #include "framework/OpenWifiTypes.h"
 #include "GwWebSocketClient.h"
@@ -62,8 +53,6 @@ namespace OpenWifi {
     };
 
 	inline Daemon * Daemon() { return Daemon::instance(); }
-	inline void DaemonPostInitialization(Poco::Util::Application &self) {
-		Daemon()->PostInitialization(self);
-	}
+	void DaemonPostInitialization(Poco::Util::Application &self);
 }
 

src/Dashboard.cpp

@@ -4,10 +4,11 @@
 
 #include "Dashboard.h"
 #include "StorageService.h"
+#include "framework/utils.h"
 
 namespace OpenWifi {
 	void DeviceDashboard::Create() {
-		uint64_t Now = OpenWifi::Now();
+		uint64_t Now = Utils::Now();
 
 		if(LastRun_==0 || (Now-LastRun_)>120) {
 			DB_.reset();

src/DeviceRegistry.cpp

@@ -1,264 +0,0 @@
-//
-//	License type: BSD 3-Clause License
-//	License copy: https://github.com/Telecominfraproject/wlan-cloud-ucentralgw/blob/master/LICENSE
-//
-//	Created by Stephane Bourque on 2021-03-04.
-//	Arilia Wireless Inc.
-//
-
-#include "Poco/JSON/Object.h"
-#include "AP_WS_Server.h"
-#include "DeviceRegistry.h"
-#include "CommandManager.h"
-
-#include "framework/WebSocketClientNotifications.h"
-
-namespace OpenWifi {
-
-	int DeviceRegistry::Start() {
-		std::lock_guard		Guard(Mutex_);
-		poco_notice(Logger(),"Starting");
-
-		ArchiverCallback_ = std::make_unique<Poco::TimerCallback<DeviceRegistry>>(*this,&DeviceRegistry::onConnectionJanitor);
-		Timer_.setStartInterval(60 * 1000);
-		Timer_.setPeriodicInterval(20 * 1000); // every minute
-		Timer_.start(*ArchiverCallback_, MicroService::instance().TimerPool());
-
-		return 0;
-    }
-
-    void DeviceRegistry::Stop() {
-		poco_notice(Logger(),"Stopping...");
-		std::lock_guard		Guard(Mutex_);
-		Timer_.stop();
-		poco_notice(Logger(),"Stopped...");
-    }
-
-	void DeviceRegistry::onConnectionJanitor([[maybe_unused]] Poco::Timer &timer) {
-
-		static std::uint64_t last_log = OpenWifi::Now();
-
-		std::shared_lock Guard(LocalMutex_);
-
-		NumberOfConnectedDevices_ = 0;
-		NumberOfConnectingDevices_ = 0;
-		AverageDeviceConnectionTime_ = 0;
-		std::uint64_t	total_connected_time=0;
-
-		auto now = OpenWifi::Now();
-		for (auto connection=SerialNumbers_.begin(); connection!=SerialNumbers_.end();) {
-
-			if(connection->second.second== nullptr) {
-				connection++;
-				continue;
-			}
-
-			if (connection->second.second->State_.Connected) {
-				NumberOfConnectedDevices_++;
-				total_connected_time += (now - connection->second.second->State_.started);
-				connection++;
-			} else {
-				NumberOfConnectingDevices_++;
-				connection++;
-			}
-		}
-
-		AverageDeviceConnectionTime_ = (NumberOfConnectedDevices_!=0) ? total_connected_time/NumberOfConnectedDevices_ : 0;
-		if((now-last_log)>120) {
-			last_log = now;
-			poco_information(Logger(),
-				fmt::format("Active AP connections: {} Connecting: {} Average connection time: {} seconds",
-							NumberOfConnectedDevices_, NumberOfConnectingDevices_, AverageDeviceConnectionTime_));
-		}
-		WebSocketClientNotificationNumberOfConnections(NumberOfConnectedDevices_,
-													   AverageDeviceConnectionTime_,
-													   NumberOfConnectingDevices_);
-	}
-
-    bool DeviceRegistry::GetStatistics(uint64_t SerialNumber, std::string & Statistics) const {
-		std::shared_lock	Guard(LocalMutex_);
-        auto Device = SerialNumbers_.find(SerialNumber);
-        if(Device == SerialNumbers_.end() || Device->second.second==nullptr)
-			return false;
-		Statistics = Device->second.second->LastStats_;
-		return true;
-    }
-
-    bool DeviceRegistry::GetState(uint64_t SerialNumber, GWObjects::ConnectionState & State) const {
-		std::shared_lock	Guard(LocalMutex_);
-        auto Device = SerialNumbers_.find(SerialNumber);
-        if(Device == SerialNumbers_.end() || Device->second.second==nullptr)
-			return false;
-		State = Device->second.second->State_;
-		return true;
-    }
-
-	bool DeviceRegistry::GetHealthcheck(uint64_t SerialNumber, GWObjects::HealthCheck & CheckData) const {
-		std::shared_lock	Guard(LocalMutex_);
-
-		auto Device = SerialNumbers_.find(SerialNumber);
-		if(Device == SerialNumbers_.end() || Device->second.second==nullptr)
-			return false;
-
-		CheckData = Device->second.second->LastHealthcheck_;
-		return true;
-	}
-
-	bool DeviceRegistry::EndSession(std::uint64_t connection_id, std::uint64_t serial_number) {
-
-		std::unique_lock G(LocalMutex_);
-		auto Connection = SerialNumbers_.find(serial_number);
-		if (Connection == end(SerialNumbers_)) {
-			return false;
-		}
-
-		if (Connection->second.first != connection_id) {
-			return false;
-		}
-
-		SerialNumbers_.erase(Connection);
-
-		return true;
-	}
-
-	void DeviceRegistry::SetSessionDetails(std::uint64_t connection_id, uint64_t SerialNumber) {
-		auto Connection = AP_WS_Server()->FindConnection(connection_id);
-
-		if(Connection== nullptr)
-			return;
-
-		std::unique_lock	G(LocalMutex_);
-		auto CurrentSerialNumber = SerialNumbers_.find(SerialNumber);
-		if(	(CurrentSerialNumber==SerialNumbers_.end())	||
-			(CurrentSerialNumber->second.first<connection_id)) {
-			SerialNumbers_[SerialNumber] = std::make_pair(connection_id, Connection);
-			return;
-		}
-	}
-
-    bool DeviceRegistry::Connected(uint64_t SerialNumber) const {
-		std::shared_lock Guard(LocalMutex_);
-		auto Device = SerialNumbers_.find(SerialNumber);
-		if(Device==end(SerialNumbers_) || Device->second.second== nullptr)
-			return false;
-
-		return  Device->second.second->State_.Connected;
-	}
-
-	bool DeviceRegistry::SendFrame(uint64_t SerialNumber, const std::string & Payload) const {
-		std::shared_lock	Guard(LocalMutex_);
-		auto Device = SerialNumbers_.find(SerialNumber);
-		if(Device==SerialNumbers_.end() || Device->second.second== nullptr)
-			return false;
-
-		try {
-			// std::cout << "Device connection pointer: " << (std::uint64_t) Device->second.second << std::endl;
-			return Device->second.second->Send(Payload);
-		} catch (...) {
-			poco_debug(Logger(),fmt::format(": SendFrame: Could not send data to device '{}'", Utils::IntToSerialNumber(SerialNumber)));
-		}
-		return false;
-	}
-
-	void DeviceRegistry::StopWebSocketTelemetry(std::uint64_t RPCID, uint64_t SerialNumber) {
-		std::shared_lock	Guard(LocalMutex_);
-
-		auto Device = SerialNumbers_.find(SerialNumber);
-		if(Device==end(SerialNumbers_) || Device->second.second==nullptr)
-			return;
-		Device->second.second->StopWebSocketTelemetry(RPCID);
-	}
-
-	void DeviceRegistry::SetWebSocketTelemetryReporting(std::uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime) {
-		std::shared_lock	Guard(LocalMutex_);
-
-		auto Device = SerialNumbers_.find(SerialNumber);
-		if(Device==end(SerialNumbers_) || Device->second.second==nullptr)
-			return;
-		Device->second.second->SetWebSocketTelemetryReporting(RPCID, Interval, Lifetime);
-	}
-
-	void DeviceRegistry::SetKafkaTelemetryReporting(std::uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime) {
-		std::shared_lock	Guard(LocalMutex_);
-
-		auto Device = SerialNumbers_.find(SerialNumber);
-		if(Device==end(SerialNumbers_) || Device->second.second== nullptr)
-			return;
-		Device->second.second->SetKafkaTelemetryReporting(RPCID, Interval, Lifetime);
-	}
-
-	void DeviceRegistry::StopKafkaTelemetry(std::uint64_t RPCID, uint64_t SerialNumber) {
-		std::shared_lock	Guard(LocalMutex_);
-
-		auto Device = SerialNumbers_.find(SerialNumber);
-		if(Device==end(SerialNumbers_) || Device->second.second== nullptr)
-			return;
-		Device->second.second->StopKafkaTelemetry(RPCID);
-	}
-
-	void DeviceRegistry::GetTelemetryParameters(uint64_t SerialNumber , bool & TelemetryRunning,
-								uint64_t & TelemetryInterval,
-								uint64_t & TelemetryWebSocketTimer,
-								uint64_t & TelemetryKafkaTimer,
-								uint64_t & TelemetryWebSocketCount,
-								uint64_t & TelemetryKafkaCount,
-								uint64_t & TelemetryWebSocketPackets,
-								uint64_t & TelemetryKafkaPackets) {
-		std::shared_lock	Guard(LocalMutex_);
-
-		auto Device = SerialNumbers_.find(SerialNumber);
-		if(Device==end(SerialNumbers_)|| Device->second.second== nullptr)
-			return;
-		Device->second.second->GetTelemetryParameters(TelemetryRunning,
-													  TelemetryInterval,
-													  TelemetryWebSocketTimer,
-													  TelemetryKafkaTimer,
-													  TelemetryWebSocketCount,
-													  TelemetryKafkaCount,
-													  TelemetryWebSocketPackets,
-													  TelemetryKafkaPackets);
-	}
-
-	bool DeviceRegistry::SendRadiusAccountingData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size) {
-		std::shared_lock	Guard(LocalMutex_);
-		auto Device = 		SerialNumbers_.find(Utils::SerialNumberToInt(SerialNumber));
-		if(Device==SerialNumbers_.end() || Device->second.second== nullptr)
-			return false;
-
-		try {
-			return Device->second.second->SendRadiusAccountingData(buffer,size);
-		} catch (...) {
-			poco_debug(Logger(),fmt::format(": SendRadiusAuthenticationData: Could not send data to device '{}'", SerialNumber));
-		}
-		return false;
-	}
-
-	bool DeviceRegistry::SendRadiusAuthenticationData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size) {
-		std::shared_lock	Guard(LocalMutex_);
-		auto Device = 		SerialNumbers_.find(Utils::SerialNumberToInt(SerialNumber));
-		if(Device==SerialNumbers_.end() || Device->second.second== nullptr)
-			return false;
-
-		try {
-			return Device->second.second->SendRadiusAuthenticationData(buffer,size);
-		} catch (...) {
-			poco_debug(Logger(),fmt::format(": SendRadiusAuthenticationData: Could not send data to device '{}'", SerialNumber));
-		}
-		return false;
-	}
-
-	bool DeviceRegistry::SendRadiusCoAData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size) {
-		std::shared_lock	Guard(LocalMutex_);
-		auto Device = 		SerialNumbers_.find(Utils::SerialNumberToInt(SerialNumber));
-		if(Device==SerialNumbers_.end() || Device->second.second== nullptr)
-			return false;
-
-		try {
-			return Device->second.second->SendRadiusCoAData(buffer,size);
-		} catch (...) {
-			poco_debug(Logger(),fmt::format(": SendRadiusCoAData: Could not send data to device '{}'", SerialNumber));
-		}
-		return false;
-	}
-
-}  // namespace

src/DeviceRegistry.h

@@ -1,104 +0,0 @@
-//
-//	License type: BSD 3-Clause License
-//	License copy: https://github.com/Telecominfraproject/wlan-cloud-ucentralgw/blob/master/LICENSE
-//
-//	Created by Stephane Bourque on 2021-03-04.
-//	Arilia Wireless Inc.
-//
-
-#pragma once
-
-#include <shared_mutex>
-
-#include "framework/MicroService.h"
-
-#include "Poco/JSON/Object.h"
-#include "Poco/Timer.h"
-#include "RESTObjects//RESTAPI_GWobjects.h"
-
-namespace OpenWifi {
-
-	class AP_WS_Connection;
-    class DeviceRegistry : public SubSystemServer {
-    public:
-
-		DeviceRegistry() noexcept:
-			SubSystemServer("DeviceRegistry", "DevStatus", "devicestatus") {
-		}
-
-        static auto instance() {
-            static auto instance_ = new DeviceRegistry;
-            return instance_;
-        }
-
-		int Start() override;
-		void Stop() override;
-
-		inline bool GetStatistics(const std::string &SerialNumber, std::string & Statistics) const {
-			return GetStatistics(Utils::SerialNumberToInt(SerialNumber),Statistics);
-		}
-		bool GetStatistics(std::uint64_t SerialNumber, std::string & Statistics) const;
-
-		inline bool GetState(const std::string & SerialNumber, GWObjects::ConnectionState & State) const {
-			return GetState(Utils::SerialNumberToInt(SerialNumber), State);
-		}
-		bool GetState(std::uint64_t SerialNumber, GWObjects::ConnectionState & State) const;
-
-		inline bool GetHealthcheck(const std::string &SerialNumber, GWObjects::HealthCheck & CheckData) const {
-			return GetHealthcheck(Utils::SerialNumberToInt(SerialNumber), CheckData);
-		}
-		bool GetHealthcheck(std::uint64_t SerialNumber, GWObjects::HealthCheck & CheckData) const ;
-
-		bool Connected(uint64_t SerialNumber) const ;
-
-		inline bool SendFrame(const std::string & SerialNumber, const std::string & Payload) const {
-			return SendFrame(Utils::SerialNumberToInt(SerialNumber), Payload);
-		}
-
-		bool SendFrame(std::uint64_t SerialNumber, const std::string & Payload) const ;
-
-		bool SendRadiusAuthenticationData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size);
-		bool SendRadiusAccountingData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size);
-		bool SendRadiusCoAData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size);
-
-		void SetSessionDetails(std::uint64_t connection_id, uint64_t SerialNumber);
-		bool EndSession(std::uint64_t connection_id, std::uint64_t serial_number);
-
-		void SetWebSocketTelemetryReporting(std::uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime);
-		void StopWebSocketTelemetry(std::uint64_t RPCID, uint64_t SerialNumber);
-		void SetKafkaTelemetryReporting(std::uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime);
-		void StopKafkaTelemetry(std::uint64_t RPCID, uint64_t SerialNumber);
-		void GetTelemetryParameters(uint64_t SerialNumber , bool & TelemetryRunning,
-									uint64_t & TelemetryInterval,
-									uint64_t & TelemetryWebSocketTimer,
-									uint64_t & TelemetryKafkaTimer,
-									uint64_t & TelemetryWebSocketCount,
-									uint64_t & TelemetryKafkaCount,
-									uint64_t & TelemetryWebSocketPackets,
-									uint64_t & TelemetryKafkaPackets);
-
-		void onConnectionJanitor(Poco::Timer & timer);
-
-		inline void AverageDeviceStatistics( std::uint64_t & Connections, std::uint64_t & AverageConnectionTime, std::uint64_t & NumberOfConnectingDevices) const {
-			Connections = NumberOfConnectedDevices_;
-			AverageConnectionTime = AverageDeviceConnectionTime_;
-			NumberOfConnectingDevices = NumberOfConnectingDevices_;
-		}
-
-	  private:
-		mutable std::shared_mutex									LocalMutex_;
-		std::map<std::uint64_t, std::pair<std::uint64_t,std::shared_ptr<AP_WS_Connection>>>	SerialNumbers_;
-
-		std::unique_ptr<Poco::TimerCallback<DeviceRegistry>>   ArchiverCallback_;
-		Poco::Timer                     		Timer_;
-		Poco::Thread							ConnectionJanitor_;
-		std::atomic_uint64_t 					NumberOfConnectedDevices_=0;
-		std::atomic_uint64_t 					AverageDeviceConnectionTime_=0;
-		std::atomic_uint64_t 					NumberOfConnectingDevices_=0;
-
-	};
-
-	inline auto DeviceRegistry() { return DeviceRegistry::instance(); }
-
-}  // namespace
-

src/FileUploader.cpp

@@ -8,8 +8,6 @@
 
 #include <iostream>
 
-#include "framework/MicroService.h"
-
 #include "Poco/Net/HTTPServerParams.h"
 #include "Poco/Net/HTTPServerResponse.h"
 #include "Poco/DynamicAny.h"
@@ -19,9 +17,16 @@
 #include "Poco/CountingStream.h"
 #include "Poco/StreamCopier.h"
 #include "Poco/Exception.h"
+#include "Poco/File.h"
+#include "Poco/StringTokenizer.h"
+
+#include "framework/MicroServiceFuncs.h"
+#include "framework/ow_constants.h"
+#include "framework/utils.h"
 
 #include "FileUploader.h"
 #include "StorageService.h"
+#include "fmt/format.h"
 
 namespace OpenWifi {
 
@@ -30,7 +35,7 @@ namespace OpenWifi {
     int FileUploader::Start() {
 		poco_notice(Logger(),"Starting.");
 
-        Poco::File UploadsDir(MicroService::instance().ConfigPath("openwifi.fileuploader.path","/tmp"));
+        Poco::File UploadsDir(MicroServiceConfigPath("openwifi.fileuploader.path","/tmp"));
         Path_ = UploadsDir.path();
         if(!UploadsDir.exists()) {
         	try {
@@ -42,7 +47,7 @@ namespace OpenWifi {
         }
 
         for(const auto & Svr: ConfigServersList_) {
-			if(MicroService::instance().NoAPISecurity()) {
+			if(MicroServiceNoAPISecurity()) {
 				poco_notice(Logger(), fmt::format("Starting: {}:{}",Svr.Address(),Svr.Port()));
 
 				auto Sock{Svr.CreateSocket(Logger())};
@@ -54,7 +59,7 @@ namespace OpenWifi {
 
 				if (FullName_.empty()) {
 					std::string TmpName =
-						MicroService::instance().ConfigGetString("openwifi.fileuploader.uri", "");
+						MicroServiceConfigGetString("openwifi.fileuploader.uri", "");
 					if (TmpName.empty()) {
 						FullName_ =
 							"https://" + Svr.Name() + ":" + std::to_string(Svr.Port()) + URI_BASE;
@@ -87,7 +92,7 @@ namespace OpenWifi {
 
 				if (FullName_.empty()) {
 					std::string TmpName =
-						MicroService::instance().ConfigGetString("openwifi.fileuploader.uri", "");
+						MicroServiceConfigGetString("openwifi.fileuploader.uri", "");
 					if (TmpName.empty()) {
 						FullName_ =
 							"https://" + Svr.Name() + ":" + std::to_string(Svr.Port()) + URI_BASE;
@@ -104,13 +109,13 @@ namespace OpenWifi {
 			}
         }
 
-        MaxSize_ = 1000 * MicroService::instance().ConfigGetInt("openwifi.fileuploader.maxsize", 10000);
+        MaxSize_ = 1000 * MicroServiceConfigGetInt("openwifi.fileuploader.maxsize", 10000);
 
         return 0;
     }
 
 	void FileUploader::reinitialize([[maybe_unused]] Poco::Util::Application &self) {
-		MicroService::instance().LoadConfigurationFile();
+		MicroServiceLoadConfigurationFile();
 		poco_information(Logger(),"Reinitializing.");
 		Stop();
 		Start();
@@ -124,7 +129,7 @@ namespace OpenWifi {
     bool FileUploader::AddUUID( const std::string & UUID) {
 		std::lock_guard		Guard(Mutex_);
 
-        uint64_t now = OpenWifi::Now();
+        uint64_t now = Utils::Now();
 
         // remove old stuff...
         for(auto i=OutStandingUploads_.begin();i!=OutStandingUploads_.end();) {

src/FileUploader.h

@@ -8,13 +8,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
-
 #include "Poco/Net/HTTPRequestHandler.h"
 #include "Poco/Net/HTTPRequestHandlerFactory.h"
 #include "Poco/Net/HTTPServer.h"
 #include "Poco/Net/HTTPServerRequest.h"
 
+#include "framework/SubSystemServer.h"
 
 namespace OpenWifi {
 

src/FindCountry.h

@@ -4,9 +4,11 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
-
 #include "Poco/Net/IPAddress.h"
+
+#include "framework/SubSystemServer.h"
+#include "framework/MicroServiceFuncs.h"
+
 #include "nlohmann/json.hpp"
 
 namespace OpenWifi {
@@ -24,7 +26,7 @@ namespace OpenWifi {
 	  public:
 		static std::string Name() { return "ipinfo"; }
 		inline bool Init() override {
-			Key_ = MicroService::instance().ConfigGetString("iptocountry.ipinfo.token", "");
+			Key_ = MicroServiceConfigGetString("iptocountry.ipinfo.token", "");
 			return !Key_.empty();
 		}
 
@@ -56,7 +58,7 @@ namespace OpenWifi {
 	  public:
 		static std::string Name() { return "ipdata"; }
 		inline bool Init() override {
-			Key_ = MicroService::instance().ConfigGetString("iptocountry.ipdata.apikey", "");
+			Key_ = MicroServiceConfigGetString("iptocountry.ipdata.apikey", "");
 			return !Key_.empty();
 		}
 
@@ -86,7 +88,7 @@ namespace OpenWifi {
 	  public:
 		static std::string Name() { return "ip2location"; }
 		inline bool Init() override {
-			Key_ = MicroService::instance().ConfigGetString("iptocountry.ip2location.apikey", "");
+			Key_ = MicroServiceConfigGetString("iptocountry.ip2location.apikey", "");
 			return !Key_.empty();
 		}
 
@@ -135,14 +137,14 @@ namespace OpenWifi {
 
 		inline int Start() final {
 			poco_notice(Logger(),"Starting...");
-			ProviderName_ = MicroService::instance().ConfigGetString("iptocountry.provider","");
+			ProviderName_ = MicroServiceConfigGetString("iptocountry.provider","");
 			if(!ProviderName_.empty()) {
 				Provider_ = IPLocationProvider<IPToCountryProvider, IPInfo, IPData, IP2Location>(ProviderName_);
 				if(Provider_!= nullptr) {
 					Enabled_ = Provider_->Init();
 				}
 			}
-			Default_ = MicroService::instance().ConfigGetString("iptocountry.default", "US");
+			Default_ = MicroServiceConfigGetString("iptocountry.default", "US");
 			return 0;
 		}
 

src/GwWebSocketClient.cpp

@@ -9,11 +9,11 @@ namespace OpenWifi {
 
 	GwWebSocketClient::GwWebSocketClient(Poco::Logger &Logger):
 		 Logger_(Logger){
-		WebSocketClientServer()->SetProcessor(this);
+		UI_WebSocketClientServer()->SetProcessor(this);
 	}
 
 	GwWebSocketClient::~GwWebSocketClient() {
-		WebSocketClientServer()->SetProcessor(nullptr);
+		UI_WebSocketClientServer()->SetProcessor(nullptr);
 	}
 
 	void GwWebSocketClient::Processor(const Poco::JSON::Object::Ptr &O, std::string &Answer, bool &Done ) {
@@ -60,7 +60,4 @@ namespace OpenWifi {
 		Done = false;
 		Answer = std::string{R"lit({ "error" : "invalid command" })lit"};
 	}
-
-
-
 }

src/GwWebSocketClient.h

@@ -4,10 +4,10 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/UI_WebSocketClientServer.h"
 
 namespace OpenWifi {
-	class GwWebSocketClient : public WebSocketClientProcessor {
+	class GwWebSocketClient : public UI_WebSocketClientProcessor {
 	  public:
 		explicit GwWebSocketClient(Poco::Logger &Logger);
 		virtual ~GwWebSocketClient();

src/OUIServer.cpp

@@ -11,15 +11,19 @@
 #include "Poco/StreamCopier.h"
 #include "Poco/File.h"
 
+#include "framework/MicroServiceFuncs.h"
+#include "framework/utils.h"
+
+#include "fmt/format.h"
+
 #include "OUIServer.h"
-#include "framework/MicroService.h"
 
 namespace OpenWifi {
 
 	int OUIServer::Start() {
 		Running_ = true;
-		LatestOUIFileName_ =  MicroService::instance().DataDir() + "/newOUIFile.txt";
-		CurrentOUIFileName_ = MicroService::instance().DataDir() + "/current_oui.txt";
+		LatestOUIFileName_ =  MicroServiceDataDirectory() + "/newOUIFile.txt";
+		CurrentOUIFileName_ = MicroServiceDataDirectory() + "/current_oui.txt";
 
 		bool Recovered = false;
 		Poco::File	OuiFile(CurrentOUIFileName_);
@@ -42,7 +46,7 @@ namespace OpenWifi {
 			Timer_.setStartInterval(30 * 1000); // first run in 5 minutes
 		}
 		Timer_.setPeriodicInterval(7 * 24 * 60 * 60 * 1000);
-		Timer_.start(*UpdaterCallBack_, MicroService::instance().TimerPool());
+		Timer_.start(*UpdaterCallBack_, MicroServiceTimerPool());
 		return 0;
 	}
 
@@ -54,7 +58,7 @@ namespace OpenWifi {
 	}
 
 	void OUIServer::reinitialize([[maybe_unused]] Poco::Util::Application &self) {
-		MicroService::instance().LoadConfigurationFile();
+		MicroServiceLoadConfigurationFile();
 		poco_information(Logger(),"Reinitializing.");
 		Stop();
 		Start();
@@ -62,15 +66,15 @@ namespace OpenWifi {
 
 	bool OUIServer::GetFile(const std::string &FileName) {
 		try {
-			LastUpdate_ = OpenWifi::Now();
-			poco_information(Logger(), fmt::format("Start: Retrieving OUI file: {}",MicroService::instance().ConfigGetString("oui.download.uri")));
+			LastUpdate_ = Utils::Now();
+			poco_information(Logger(), fmt::format("Start: Retrieving OUI file: {}",MicroServiceConfigGetString("oui.download.uri","")));
 			std::unique_ptr<std::istream> pStr(
-				Poco::URIStreamOpener::defaultOpener().open(MicroService::instance().ConfigGetString("oui.download.uri")));
+				Poco::URIStreamOpener::defaultOpener().open(MicroServiceConfigGetString("oui.download.uri","")));
 			std::ofstream OS;
 			OS.open(FileName);
 			Poco::StreamCopier::copyStream(*pStr, OS);
 			OS.close();
-			poco_information(Logger(), fmt::format("Done: Retrieving OUI file: {}",MicroService::instance().ConfigGetString("oui.download.uri")));
+			poco_information(Logger(), fmt::format("Done: Retrieving OUI file: {}",MicroServiceConfigGetString("oui.download.uri","")));
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -125,7 +129,7 @@ namespace OpenWifi {
 		//	fetch data from server, if not available, just use the file we already have.
 		Poco::File	Current(CurrentOUIFileName_);
 		if(Current.exists()) {
-			if((OpenWifi::Now()-Current.getLastModified().epochTime()) < (7*24*60*60)) {
+			if((Utils::Now()-Current.getLastModified().epochTime()) < (7*24*60*60)) {
 				if(!Initialized_) {
 					if(ProcessFile(CurrentOUIFileName_, OUIs_)) {
 						Initialized_ = true;
@@ -144,7 +148,7 @@ namespace OpenWifi {
 		if(GetFile(LatestOUIFileName_) && ProcessFile(LatestOUIFileName_, TmpOUIs)) {
 			std::unique_lock G(LocalMutex_);
 			OUIs_ = std::move(TmpOUIs);
-			LastUpdate_ = OpenWifi::Now();
+			LastUpdate_ = Utils::Now();
 			Poco::File F1(CurrentOUIFileName_);
 			if(F1.exists())
 				F1.remove();
@@ -153,7 +157,7 @@ namespace OpenWifi {
 			poco_information(Logger(), fmt::format("New OUI file {} downloaded.",LatestOUIFileName_));
 		} else if(OUIs_.empty()) {
 			if(ProcessFile(CurrentOUIFileName_, TmpOUIs)) {
-				LastUpdate_ = OpenWifi::Now();
+				LastUpdate_ = Utils::Now();
 				std::unique_lock G(LocalMutex_);
 				OUIs_ = std::move(TmpOUIs);
 			}

src/OUIServer.h

@@ -6,7 +6,8 @@
 
 #include <shared_mutex>
 
-#include "framework/MicroService.h"
+#include "framework/SubSystemServer.h"
+
 #include "Poco/Timer.h"
 
 namespace OpenWifi {

src/ParseWifiScan.h

@@ -4,7 +4,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include <string>
+#include <vector>
+#include <map>
+#include <utility>
+
+#include "nlohmann/json.hpp"
 
 namespace OpenWifi {
 

src/RADIUS_helpers.h

@@ -11,6 +11,7 @@
 
 #include "Poco/HMACEngine.h"
 #include "Poco/MD5Engine.h"
+#include "Poco/StringTokenizer.h"
 
 namespace OpenWifi::RADIUS {
 

src/RADIUS_proxy_server.cpp

@@ -2,9 +2,14 @@
 // Created by stephane bourque on 2022-05-18.
 //
 
+#include "Poco/JSON/Parser.h"
+
 #include "RADIUS_proxy_server.h"
 #include "RADIUS_helpers.h"
 #include "AP_WS_Server.h"
+
+#include "framework/MicroServiceFuncs.h"
+
 namespace OpenWifi {
 
 	const int SMALLEST_RADIUS_PACKET = 20+19+4;
@@ -14,34 +19,38 @@ namespace OpenWifi {
 
 	int RADIUS_proxy_server::Start() {
 
-		ConfigFilename_ = MicroService::instance().DataDir()+"/radius_pool_config.json";
+		ConfigFilename_ = MicroServiceDataDirectory()+"/radius_pool_config.json";
 		Poco::File	Config(ConfigFilename_);
 
-		enabled_ = MicroService::instance().ConfigGetBool("radius.proxy.enable",false);
-		if(!enabled_ && !Config.exists())
+		enabled_ = MicroServiceConfigGetBool("radius.proxy.enable",false);
+		if(!enabled_ && !Config.exists()) {
+			StopRADSECServers();
 			return 0;
+		}
+
+		poco_notice(Logger(),"Starting...");
 
 		enabled_ = true;
 
 		Poco::Net::SocketAddress	AuthSockAddrV4(Poco::Net::AddressFamily::IPv4,
-									   MicroService::instance().ConfigGetInt("radius.proxy.authentication.port",DEFAULT_RADIUS_AUTHENTICATION_PORT));
+									   MicroServiceConfigGetInt("radius.proxy.authentication.port",DEFAULT_RADIUS_AUTHENTICATION_PORT));
 		AuthenticationSocketV4_ = std::make_unique<Poco::Net::DatagramSocket>(AuthSockAddrV4,true);
 		Poco::Net::SocketAddress	AuthSockAddrV6(Poco::Net::AddressFamily::IPv6,
-											  MicroService::instance().ConfigGetInt("radius.proxy.authentication.port",DEFAULT_RADIUS_AUTHENTICATION_PORT));
+											  MicroServiceConfigGetInt("radius.proxy.authentication.port",DEFAULT_RADIUS_AUTHENTICATION_PORT));
 		AuthenticationSocketV6_ = std::make_unique<Poco::Net::DatagramSocket>(AuthSockAddrV6,true);
 
 		Poco::Net::SocketAddress	AcctSockAddrV4(Poco::Net::AddressFamily::IPv4,
-									   MicroService::instance().ConfigGetInt("radius.proxy.accounting.port",DEFAULT_RADIUS_ACCOUNTING_PORT));
+									   MicroServiceConfigGetInt("radius.proxy.accounting.port",DEFAULT_RADIUS_ACCOUNTING_PORT));
 		AccountingSocketV4_ = std::make_unique<Poco::Net::DatagramSocket>(AcctSockAddrV4,true);
 		Poco::Net::SocketAddress	AcctSockAddrV6(Poco::Net::AddressFamily::IPv6,
-											  MicroService::instance().ConfigGetInt("radius.proxy.accounting.port",DEFAULT_RADIUS_ACCOUNTING_PORT));
+											  MicroServiceConfigGetInt("radius.proxy.accounting.port",DEFAULT_RADIUS_ACCOUNTING_PORT));
 		AccountingSocketV6_ = std::make_unique<Poco::Net::DatagramSocket>(AcctSockAddrV6,true);
 
 		Poco::Net::SocketAddress	CoASockAddrV4(Poco::Net::AddressFamily::IPv4,
-												MicroService::instance().ConfigGetInt("radius.proxy.coa.port",DEFAULT_RADIUS_CoA_PORT));
+												MicroServiceConfigGetInt("radius.proxy.coa.port",DEFAULT_RADIUS_CoA_PORT));
 		CoASocketV4_ = std::make_unique<Poco::Net::DatagramSocket>(CoASockAddrV4,true);
 		Poco::Net::SocketAddress	CoASockAddrV6(Poco::Net::AddressFamily::IPv6,
-												MicroService::instance().ConfigGetInt("radius.proxy.coa.port",DEFAULT_RADIUS_CoA_PORT));
+												MicroServiceConfigGetInt("radius.proxy.coa.port",DEFAULT_RADIUS_CoA_PORT));
 		CoASocketV6_ = std::make_unique<Poco::Net::DatagramSocket>(CoASockAddrV6,true);
 
 		RadiusReactor_.addEventHandler(*AuthenticationSocketV4_,Poco::NObserver<RADIUS_proxy_server, Poco::Net::ReadableNotification>(
@@ -63,6 +72,7 @@ namespace OpenWifi {
 		ParseConfig();
 
 		//	start RADSEC servers...
+		StopRADSECServers();
 		StartRADSECServers();
 		RadiusReactorThread_.start(RadiusReactor_);
 
@@ -103,9 +113,7 @@ namespace OpenWifi {
 				Poco::NObserver<RADIUS_proxy_server, Poco::Net::ReadableNotification>(
 					*this, &RADIUS_proxy_server::OnCoASocketReadable));
 
-			for(auto &[_,radsec_server]:RADSECservers_)
-				radsec_server->Stop();
-
+			StopRADSECServers();
 			RadiusReactor_.stop();
 			RadiusReactorThread_.join();
 			enabled_=false;
@@ -124,8 +132,12 @@ namespace OpenWifi {
 		}
 	}
 
+	void RADIUS_proxy_server::StopRADSECServers() {
+		RADSECservers_.clear();
+	}
+
 	void RADIUS_proxy_server::StartRADSECServer(const GWObjects::RadiusProxyServerEntry &E) {
-		RADSECservers_[ Poco::Net::SocketAddress(E.ip,0) ] = std::make_unique<RADSECserver>(RadiusReactor_,E);
+		RADSECservers_[ Poco::Net::SocketAddress(E.ip,0) ] = std::make_unique<RADSEC_server>(RadiusReactor_,E);
 	}
 
 	void RADIUS_proxy_server::OnAccountingSocketReadable(const Poco::AutoPtr<Poco::Net::ReadableNotification>& pNf) {

src/RADIUS_proxy_server.h

@@ -4,13 +4,14 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
 #include "RESTObjects/RESTAPI_GWobjects.h"
 
 #include "Poco/Net/DatagramSocket.h"
 #include "Poco/Net/SocketReactor.h"
 
-#include "RADSECserver.h"
+#include "framework/SubSystemServer.h"
+
+#include "RADSEC_server.h"
 
 namespace OpenWifi {
 
@@ -44,6 +45,7 @@ namespace OpenWifi {
 
 		void StartRADSECServers();
 		void StartRADSECServer(const GWObjects::RadiusProxyServerEntry &E);
+		void StopRADSECServers();
 
 		struct Destination {
 			Poco::Net::SocketAddress 	Addr;
@@ -73,7 +75,7 @@ namespace OpenWifi {
 		GWObjects::RadiusProxyPoolList	PoolList_;
 		std::string 					ConfigFilename_;
 
-		std::map<Poco::Net::SocketAddress, std::unique_ptr<RADSECserver>> RADSECservers_;
+		std::map<Poco::Net::SocketAddress, std::unique_ptr<RADSEC_server>> RADSECservers_;
 
 		struct RadiusPool {
 			std::vector<Destination>	AuthV4;

src/RADSEC_server.h

@@ -7,8 +7,6 @@
 #include <iostream>
 #include <fstream>
 
-#include "framework/MicroService.h"
-
 #include "RESTObjects/RESTAPI_GWobjects.h"
 
 #include "Poco/Net/SocketReactor.h"
@@ -18,14 +16,18 @@
 #include "Poco/Net/NetException.h"
 #include "Poco/TemporaryFile.h"
 
+#include "framework/MicroServiceFuncs.h"
+
+#include "fmt/format.h"
+
 #include "RADIUS_helpers.h"
 #include "AP_WS_Server.h"
 
 namespace OpenWifi {
 
-	class RADSECserver : public Poco::Runnable {
+	class RADSEC_server : public Poco::Runnable {
 	  public:
-		RADSECserver(Poco::Net::SocketReactor & R, GWObjects::RadiusProxyServerEntry E) :
+		RADSEC_server(Poco::Net::SocketReactor & R, GWObjects::RadiusProxyServerEntry E) :
  			Reactor_(R),
 			Server_(std::move(E)),
 			Logger_(Poco::Logger::get(fmt::format("RADSEC: {}@{}:{}",
@@ -33,7 +35,20 @@ namespace OpenWifi {
 								Server_.ip,
 								Server_.port)))
 		{
-			ReconnectorThr_.start(*this);
+			ReconnectThread_.start(*this);
+		}
+
+		~RADSEC_server() {
+			if(ReconnectThread_.isRunning()) {
+				Stop();
+			}
+		}
+
+		inline void Stop() {
+			TryAgain_ = false;
+			Disconnect();
+			ReconnectThread_.wakeUp();
+			ReconnectThread_.join();
 		}
 
 		inline void run() final {
@@ -42,7 +57,7 @@ namespace OpenWifi {
 					std::unique_lock	G(Mutex_);
 					Connect();
 				}
-				Poco::Thread::trySleep(1000);
+				Poco::Thread::trySleep(3000);
 			}
 		}
 
@@ -127,15 +142,15 @@ namespace OpenWifi {
 		inline bool Connect() {
 			if(TryAgain_) {
 
-				Poco::TemporaryFile	CertFile_(MicroService::instance().DataDir());
-				Poco::TemporaryFile	KeyFile_(MicroService::instance().DataDir());
+				Poco::TemporaryFile	CertFile_(MicroServiceDataDirectory());
+				Poco::TemporaryFile	KeyFile_(MicroServiceDataDirectory());
 				std::vector<Poco::TemporaryFile> CaCertFiles_;
 
 				DecodeFile(CertFile_.path(), Server_.radsecCert);
 				DecodeFile(KeyFile_.path(), Server_.radsecKey);
 
 				for(auto &cert:Server_.radsecCacerts) {
-					CaCertFiles_.emplace_back(Poco::TemporaryFile(MicroService::instance().DataDir()));
+					CaCertFiles_.emplace_back(Poco::TemporaryFile(MicroServiceDataDirectory()));
 					DecodeFile(CaCertFiles_[CaCertFiles_.size()-1].path(), cert);
 				}
 
@@ -166,18 +181,19 @@ namespace OpenWifi {
 					Socket_->setBlocking(false);
 					Socket_->setNoDelay(true);
 					Socket_->setKeepAlive(true);
+					Socket_->setReceiveTimeout(Poco::Timespan(1 * 60 * 60,0));
 
 					Reactor_.addEventHandler(
 						*Socket_,
-						Poco::NObserver<RADSECserver, Poco::Net::ReadableNotification>(
-							*this, &RADSECserver::onData));
+						Poco::NObserver<RADSEC_server, Poco::Net::ReadableNotification>(
+							*this, &RADSEC_server::onData));
 					Reactor_.addEventHandler(
-						*Socket_, Poco::NObserver<RADSECserver, Poco::Net::ErrorNotification>(
-										  *this, &RADSECserver::onError));
+						*Socket_, Poco::NObserver<RADSEC_server, Poco::Net::ErrorNotification>(
+										  *this, &RADSEC_server::onError));
 					Reactor_.addEventHandler(
 						*Socket_,
-						Poco::NObserver<RADSECserver, Poco::Net::ShutdownNotification>(
-							*this, &RADSECserver::onShutdown));
+						Poco::NObserver<RADSEC_server, Poco::Net::ShutdownNotification>(
+							*this, &RADSEC_server::onShutdown));
 					Socket_->setBlocking(false);
 					Socket_->setNoDelay(true);
 					Socket_->setKeepAlive(true);
@@ -203,26 +219,19 @@ namespace OpenWifi {
 				std::unique_lock G(Mutex_);
 
 				Reactor_.removeEventHandler(
-					*Socket_, Poco::NObserver<RADSECserver, Poco::Net::ReadableNotification>(
-								  *this, &RADSECserver::onData));
+					*Socket_, Poco::NObserver<RADSEC_server, Poco::Net::ReadableNotification>(
+								  *this, &RADSEC_server::onData));
 				Reactor_.removeEventHandler(
-					*Socket_, Poco::NObserver<RADSECserver, Poco::Net::ErrorNotification>(
-								  *this, &RADSECserver::onError));
+					*Socket_, Poco::NObserver<RADSEC_server, Poco::Net::ErrorNotification>(
+								  *this, &RADSEC_server::onError));
 				Reactor_.removeEventHandler(
-					*Socket_, Poco::NObserver<RADSECserver, Poco::Net::ShutdownNotification>(
-								  *this, &RADSECserver::onShutdown));
+					*Socket_, Poco::NObserver<RADSEC_server, Poco::Net::ShutdownNotification>(
+								  *this, &RADSEC_server::onShutdown));
 				Connected_ = false;
 			}
 			poco_information(Logger_,"Disconnecting.");
 		}
 
-		inline void Stop() {
-			TryAgain_ = false;
-			Disconnect();
-			ReconnectorThr_.wakeUp();
-			ReconnectorThr_.join();
-		}
-
 		static void DecodeFile(const std::string &filename, const std::string &s) {
 			std::ofstream sec_file(filename,std::ios_base::out|std::ios_base::trunc|std::ios_base::binary);
 			std::stringstream is(s);
@@ -250,14 +259,14 @@ namespace OpenWifi {
 		}
 
 	  private:
-		std::shared_mutex									Mutex_;
+		std::recursive_mutex								Mutex_;
 		Poco::Net::SocketReactor							&Reactor_;
 		GWObjects::RadiusProxyServerEntry					Server_;
 		Poco::Logger										&Logger_;
-		std::atomic_bool 									Connected_=false;
-		std::atomic_bool 									TryAgain_=true;
 		std::unique_ptr<Poco::Net::SecureStreamSocket>		Socket_;
-		Poco::Thread										ReconnectorThr_;
+		Poco::Thread										ReconnectThread_;
 		std::unique_ptr<Poco::Crypto::X509Certificate>		Peer_Cert_;
+		volatile bool 										Connected_=false;
+		volatile bool 	 									TryAgain_=true;
 	};
 }

src/RESTAPI/RESTAPI_RPC.cpp

@@ -11,7 +11,9 @@
 #include "AP_WS_Server.h"
 #include "StorageService.h"
 #include "framework/ow_constants.h"
+#include "framework/RESTAPI_Handler.h"
 #include "ParseWifiScan.h"
+#include "framework/utils.h"
 
 namespace OpenWifi::RESTAPI_RPC {
 	void SetCommandStatus(GWObjects::CommandDetails &Cmd,
@@ -57,7 +59,7 @@ namespace OpenWifi::RESTAPI_RPC {
 			return SetCommandStatus(Cmd, Request, Response, Handler, Storage::CommandExecutionType::COMMAND_FAILED, Logger);
 		}
 
-		Cmd.Executed = OpenWifi::Now();
+		Cmd.Executed = Utils::Now();
 
 		bool Sent;
 		std::chrono::time_point<std::chrono::high_resolution_clock> rpc_submitted = std::chrono::high_resolution_clock::now();
@@ -124,7 +126,7 @@ namespace OpenWifi::RESTAPI_RPC {
 			}
 			Cmd.Results = ResultText.str();
 			Cmd.Status = "completed";
-			Cmd.Completed = OpenWifi::Now();
+			Cmd.Completed = Utils::Now();
 			Cmd.executionTime = rpc_execution_time.count();
 
 			if (Cmd.ErrorCode && Cmd.Command == uCentralProtocol::TRACE) {

src/RESTAPI/RESTAPI_RPC.h

@@ -16,7 +16,7 @@
 
 #include "RESTObjects/RESTAPI_GWobjects.h"
 #include "StorageService.h"
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi::RESTAPI_RPC {
 

src/RESTAPI/RESTAPI_blacklist.cpp

@@ -6,13 +6,11 @@
 //	Arilia Wireless Inc.
 //
 
-#include <ctime>
-
 #include "Poco/JSON/Parser.h"
-#include "Poco/JSON/Stringifier.h"
 #include "RESTAPI_blacklist.h"
 #include "StorageService.h"
 #include "framework/ow_constants.h"
+#include "framework/utils.h"
 
 namespace OpenWifi {
 	void RESTAPI_blacklist::DoDelete() {
@@ -68,7 +66,7 @@ namespace OpenWifi {
 		}
 
 		D.author = UserInfo_.userinfo.email;
-		D.created = OpenWifi::Now();
+		D.created = Utils::Now();
 
 		if(StorageService()->AddBlackListDevice(D)) {
 			GWObjects::BlackListedDevice	CreatedDevice;

src/RESTAPI/RESTAPI_blacklist.h

@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 	class RESTAPI_blacklist : public RESTAPIHandler {
 	  public:
-		RESTAPI_blacklist(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server , uint64_t TransactionId , bool Internal)
+		RESTAPI_blacklist(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server , uint64_t TransactionId , bool Internal)
 			: RESTAPIHandler(bindings, L,
 							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
 													  Poco::Net::HTTPRequest::HTTP_POST,

src/RESTAPI/RESTAPI_blacklist_list.h

@@ -4,12 +4,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 	class RESTAPI_blacklist_list : public RESTAPIHandler {
 	  public:
-		RESTAPI_blacklist_list(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server, uint64_t TransactionId, bool Internal)
+		RESTAPI_blacklist_list(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server, uint64_t TransactionId, bool Internal)
 		: RESTAPIHandler(bindings, L,
 						 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
 												  Poco::Net::HTTPRequest::HTTP_OPTIONS},

src/RESTAPI/RESTAPI_capabilities_handler.h

@@ -4,12 +4,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 	class RESTAPI_capabilities_handler : public RESTAPIHandler {
 	  public:
-		RESTAPI_capabilities_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server, uint64_t TransactionId, bool Internal)
+		RESTAPI_capabilities_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server, uint64_t TransactionId, bool Internal)
 		: RESTAPIHandler(bindings, L,
 						 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
 												  Poco::Net::HTTPRequest::HTTP_OPTIONS},

src/RESTAPI/RESTAPI_command.h

@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 class RESTAPI_command : public RESTAPIHandler {
   public:
-	RESTAPI_command(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server, uint64_t TransactionId, bool Internal)
+	RESTAPI_command(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server, uint64_t TransactionId, bool Internal)
 		: RESTAPIHandler(bindings, L,
 						 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
 												  Poco::Net::HTTPRequest::HTTP_DELETE,

src/RESTAPI/RESTAPI_commands.h

@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 	class RESTAPI_commands : public RESTAPIHandler {
 	  public:
-		RESTAPI_commands(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server, uint64_t TransactionId, bool Internal)
+		RESTAPI_commands(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server, uint64_t TransactionId, bool Internal)
 			: RESTAPIHandler(bindings, L,
 							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
 													  Poco::Net::HTTPRequest::HTTP_DELETE,

src/RESTAPI/RESTAPI_default_configuration.cpp

@@ -15,6 +15,7 @@
 #include "framework/ow_constants.h"
 #include "framework/ConfigurationValidator.h"
 #include "framework/orm.h"
+#include "framework/utils.h"
 
 namespace OpenWifi {
 	void RESTAPI_default_configuration::DoGet() {
@@ -66,7 +67,7 @@ namespace OpenWifi {
 			return BadRequest(RESTAPI::Errors::ConfigBlockInvalid);
 		}
 
-		DefConfig.Created = DefConfig.LastModified = OpenWifi::Now();
+		DefConfig.Created = DefConfig.LastModified = Utils::Now();
 		if (StorageService()->CreateDefaultConfiguration(Name, DefConfig)) {
 			return OK();
 		}
@@ -96,7 +97,7 @@ namespace OpenWifi {
 			Existing.Configuration = NewConfig.Configuration;
 		}
 
-		Existing.LastModified = OpenWifi::Now();
+		Existing.LastModified = Utils::Now();
 		AssignIfPresent(Obj,"description",Existing.Description);
 		if(Obj->has("modelIds"))
 			Existing.Models = NewConfig.Models;

src/RESTAPI/RESTAPI_default_configuration.h

@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 	class RESTAPI_default_configuration : public RESTAPIHandler {
 	  public:
-		RESTAPI_default_configuration(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server, uint64_t TransactionId, bool Internal)
+		RESTAPI_default_configuration(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server, uint64_t TransactionId, bool Internal)
 			: RESTAPIHandler(bindings, L,
 							 std::vector<std::string>{
 								 Poco::Net::HTTPRequest::HTTP_GET, Poco::Net::HTTPRequest::HTTP_POST,

src/RESTAPI/RESTAPI_default_configurations.h

@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 class RESTAPI_default_configurations : public RESTAPIHandler {
   public:
-	RESTAPI_default_configurations(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server, uint64_t TransactionId, bool Internal)
+	RESTAPI_default_configurations(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server, uint64_t TransactionId, bool Internal)
 		: RESTAPIHandler(bindings, L,
 						 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
 												  Poco::Net::HTTPRequest::HTTP_OPTIONS},

src/RESTAPI/RESTAPI_deviceDashboardHandler.h

@@ -4,12 +4,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 	class RESTAPI_deviceDashboardHandler : public RESTAPIHandler {
 	  public:
-		RESTAPI_deviceDashboardHandler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server, uint64_t TransactionId, bool Internal)
+		RESTAPI_deviceDashboardHandler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server, uint64_t TransactionId, bool Internal)
 			: RESTAPIHandler(bindings, L,
 							 std::vector<std::string>{
 								 Poco::Net::HTTPRequest::HTTP_GET, Poco::Net::HTTPRequest::HTTP_POST,

src/RESTAPI/RESTAPI_device_commandHandler.cpp

@@ -20,9 +20,14 @@
 #include "StorageService.h"
 #include "TelemetryStream.h"
 #include "CommandManager.h"
+
 #include "framework/ConfigurationValidator.h"
 #include "framework/KafkaTopics.h"
 #include "framework/ow_constants.h"
+#include "framework/KafkaManager.h"
+#include "framework/MicroServiceFuncs.h"
+#include "framework/utils.h"
+
 #include "rttys/RTTYS_server.h"
 
 namespace OpenWifi {
@@ -63,7 +68,7 @@ namespace OpenWifi {
 				CallCanceled(Command_.c_str(), RESTAPI::Errors::DeviceNotConnected);
 				return BadRequest(RESTAPI::Errors::DeviceNotConnected);
 			}
-			auto UUID = MicroService::CreateUUID();
+			auto UUID = MicroServiceCreateUUID();
 			auto RPC = CommandManager()->NextRPCId();
 			poco_debug(Logger_,fmt::format("Command rtty TID={} can proceed. Identified as {} and RPCID as {}. thr_id={}",
 											TransactionId_, UUID, RPC,
@@ -174,7 +179,7 @@ namespace OpenWifi {
 					CallCanceled(Command.Command, RESTAPI::Errors::DeviceIsAlreadyBusy, Extra);
 					return BadRequest(RESTAPI::Errors::DeviceIsAlreadyBusy, Extra);
 				}
-				auto UUID = MicroService::CreateUUID();
+				auto UUID = MicroServiceCreateUUID();
 				auto RPC = CommandManager()->NextRPCId();
 				poco_debug(Logger_,fmt::format("Command {} TID={} can proceed. Identified as {} and RPCID as {}. thr_id={}",
 												Command.Command, TransactionId_, UUID, RPC,
@@ -215,14 +220,14 @@ namespace OpenWifi {
 										Poco::Thread::current()->id()));
 		if (QB_.LastOnly) {
 			std::string Stats;
-			if (AP_WS_Server()->GetStatistics(SerialNumber_, Stats)) {
+			if (AP_WS_Server()->GetStatistics(SerialNumber_, Stats) && !Stats.empty()) {
 				Poco::JSON::Parser P;
 				if (Stats.empty())
 					Stats = uCentralProtocol::EMPTY_JSON_DOC;
 				auto Obj = P.parse(Stats).extract<Poco::JSON::Object::Ptr>();
 				return ReturnObject(*Obj);
 			}
-			return NotFound();
+			return BadRequest(RESTAPI::Errors::DeviceNotConnected);
 		}
 
 		std::vector<GWObjects::Statistics> Stats;
@@ -912,39 +917,39 @@ namespace OpenWifi {
 	void RESTAPI_device_commandHandler::Rtty(const std::string &CMD_UUID, uint64_t CMD_RPC, std::chrono::milliseconds timeout) {
 		Logger_.information(fmt::format("RTTY({},{}): TID={} user={} serial={}", CMD_UUID, CMD_RPC, TransactionId_, Requester(), SerialNumber_));
 
-		poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
-		if (MicroService::instance().ConfigGetBool("rtty.enabled", false)) {
+//		poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+		if (MicroServiceConfigGetBool("rtty.enabled", false)) {
 			GWObjects::Device	Device;
 
-			poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+//			poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
 			if (StorageService()->GetDevice(SerialNumber_, Device)) {
 
-				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+//				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
 				GWObjects::RttySessionDetails Rtty{
 					.SerialNumber = SerialNumber_,
-					.Server = MicroService::instance().ConfigGetString("rtty.server", "localhost"),
-					.Port = MicroService::instance().ConfigGetInt("rtty.port", 5912),
-					.Token = MicroService::instance().ConfigGetString("rtty.token", "nothing"),
-					.TimeOut = MicroService::instance().ConfigGetInt("rtty.timeout", 60),
-					.ConnectionId =  Utils::ComputeHash(SerialNumber_,OpenWifi::Now()).substr(0,32),
-					.Started = OpenWifi::Now(),
+					.Server = MicroServiceConfigGetString("rtty.server", "localhost"),
+					.Port = MicroServiceConfigGetInt("rtty.port", 5912),
+					.Token = MicroServiceConfigGetString("rtty.token", "nothing"),
+					.TimeOut = MicroServiceConfigGetInt("rtty.timeout", 60),
+					.ConnectionId =  Utils::ComputeHash(SerialNumber_,Utils::Now()).substr(0,RTTY_DEVICE_TOKEN_LENGTH),
+					.Started = Utils::Now(),
 					.CommandUUID = CMD_UUID,
-					.ViewPort = MicroService::instance().ConfigGetInt("rtty.viewport", 5913),
+					.ViewPort = MicroServiceConfigGetInt("rtty.viewport", 5913),
 					.DevicePassword = ""
 				};
-				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+//				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
 
 				if(RTTYS_server()->UseInternal()) {
-					poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
-					Rtty.Token = Utils::ComputeHash(UserInfo_.webtoken.refresh_token_,OpenWifi::Now()).substr(0,32);
-					poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+//					poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+					Rtty.Token = Utils::ComputeHash(UserInfo_.webtoken.refresh_token_,Utils::Now()).substr(0,RTTY_DEVICE_TOKEN_LENGTH);
+//					poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
 					if(!RTTYS_server()->CreateEndPoint(Rtty.ConnectionId, Rtty.Token, Requester(), SerialNumber_)) {
-						poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+//						poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
 						return BadRequest(RESTAPI::Errors::MaximumRTTYSessionsReached);
 					}
-					poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+//					poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
 				}
-				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+//				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
 
 				Poco::JSON::Object ReturnedObject;
 				Rtty.to_json(ReturnedObject);
@@ -956,7 +961,7 @@ namespace OpenWifi {
 				Cmd.UUID = CMD_UUID;
 				Cmd.Command = uCentralProtocol::RTTY;
 
-				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+//				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
 				Poco::JSON::Object Params;
 
 				Params.set(uCentralProtocol::METHOD, uCentralProtocol::RTTY);
@@ -969,15 +974,15 @@ namespace OpenWifi {
 				Params.set(uCentralProtocol::TIMEOUT, Rtty.TimeOut);
 				Params.set(uCentralProtocol::PASSWORD, Device.DevicePassword);
 
-				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+//				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
 				std::stringstream ParamStream;
-				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+//				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
 				Params.stringify(ParamStream);
-				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+//				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
 				Cmd.Details = ParamStream.str();
-				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+//				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
 				Logger_.information(fmt::format("RTTY: user={} serial={} rttyid={} token={} cmd={}.", Requester(), SerialNumber_, Rtty.ConnectionId, Rtty.Token, CMD_UUID));
-				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
+//				poco_debug(Logger_,fmt::format("RTTY_DEBUG {} ", __LINE__ ));
 				return RESTAPI_RPC::WaitForCommand(CMD_RPC,false,Cmd, Params, *Request, *Response, timeout, &ReturnedObject, this, Logger_);
 			}
 			return NotFound();
@@ -986,10 +991,13 @@ namespace OpenWifi {
 		return ReturnStatus(Poco::Net::HTTPResponse::HTTP_SERVICE_UNAVAILABLE);
 	}
 
+// #define DBG		{ std::cout << __LINE__ << std::endl; }
+
 	void RESTAPI_device_commandHandler::Telemetry(const std::string &CMD_UUID, uint64_t CMD_RPC, [[maybe_unused]] std::chrono::milliseconds timeout){
 		Logger_.information(fmt::format("TELEMETRY({},{}): TID={} user={} serial={}", CMD_UUID, CMD_RPC, TransactionId_, Requester(), SerialNumber_));
 
 		const auto &Obj = ParsedBody_;
+
 		if (Obj->has(RESTAPI::Protocol::SERIALNUMBER) &&
 			Obj->has(RESTAPI::Protocol::INTERVAL) &&
 			Obj->has(RESTAPI::Protocol::TYPES)) {
@@ -1004,8 +1012,8 @@ namespace OpenWifi {
 			Obj->stringify(oooss);
 			// std::cout << "Payload:" << oooss.str() << std::endl;
 
-			uint64_t Lifetime = 60 * 60 ; // 1 hour
-			uint64_t Interval = 5;
+			std::uint64_t Lifetime = 60 * 60 ; // 1 hour
+			std::uint64_t Interval = 5;
 			bool KafkaOnly = false;
 
 			if(Obj->has("kafka")) {
@@ -1033,7 +1041,7 @@ namespace OpenWifi {
 					}
 				} else {
 					if (Interval) {
-						AP_WS_Server()->SetWebSocketTelemetryReporting(CMD_RPC,IntSerialNumber, Interval,
+						AP_WS_Server()->SetWebSocketTelemetryReporting(CMD_RPC, IntSerialNumber, Interval,
 																				  Lifetime);
 						std::string EndPoint;
 						if (TelemetryStream()->CreateEndpoint(Utils::SerialNumberToInt(SerialNumber_), EndPoint, CMD_UUID)) {
@@ -1054,7 +1062,7 @@ namespace OpenWifi {
 			}
 
 			bool TelemetryRunning;
-			uint64_t TelemetryWebSocketCount, TelemetryKafkaCount, TelemetryInterval,
+			std::uint64_t TelemetryWebSocketCount, TelemetryKafkaCount, TelemetryInterval,
 				TelemetryWebSocketTimer, TelemetryKafkaTimer, TelemetryWebSocketPackets,
 				TelemetryKafkaPackets;
 			AP_WS_Server()->GetTelemetryParameters(IntSerialNumber,TelemetryRunning,

src/RESTAPI/RESTAPI_device_commandHandler.h

@@ -8,13 +8,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
-#include "framework/ow_constants.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 	class RESTAPI_device_commandHandler : public RESTAPIHandler {
 	  public:
-		RESTAPI_device_commandHandler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server, uint64_t TransactionId, bool Internal)
+		RESTAPI_device_commandHandler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server, uint64_t TransactionId, bool Internal)
 			: RESTAPIHandler(bindings, L,
 							 std::vector<std::string>{
 								 Poco::Net::HTTPRequest::HTTP_GET, Poco::Net::HTTPRequest::HTTP_POST,

src/RESTAPI/RESTAPI_device_handler.cpp

@@ -9,11 +9,12 @@
 #include "RESTAPI_device_handler.h"
 #include "CentralConfig.h"
 #include "ConfigurationCache.h"
-#include "Poco/JSON/Parser.h"
 #include "StorageService.h"
+
 #include "framework/ConfigurationValidator.h"
-#include "framework/MicroService.h"
 #include "framework/ow_constants.h"
+#include "framework/utils.h"
+
 #include "RESTAPI_device_helper.h"
 
 namespace OpenWifi {
@@ -131,11 +132,11 @@ namespace OpenWifi {
 
 		for(auto &i:Device.Notes) {
 			i.createdBy = UserInfo_.userinfo.email;
-			i.created = OpenWifi::Now();
+			i.created = Utils::Now();
 		}
 
 		Config::Config NewConfig(Device.Configuration);
-		Device.UUID = OpenWifi::Now();
+		Device.UUID = Utils::Now();
 		NewConfig.SetUUID(Device.UUID);
 		Device.Configuration = NewConfig.get();
 
@@ -174,7 +175,7 @@ namespace OpenWifi {
 				return BadRequest(RESTAPI::Errors::ConfigBlockInvalid);
 			}
 			Config::Config NewConfig(NewDevice.Configuration);
-			uint64_t NewConfigUUID = OpenWifi::Now();
+			uint64_t NewConfigUUID = Utils::Now();
 			NewConfig.SetUUID(NewConfigUUID);
 			Existing.Configuration = NewConfig.get();
 			Existing.UUID = NewConfigUUID;
@@ -188,11 +189,11 @@ namespace OpenWifi {
 
 		for(auto &i:NewDevice.Notes) {
 			i.createdBy = UserInfo_.userinfo.email;
-			i.created = OpenWifi::Now();
+			i.created = Utils::Now();
 			Existing.Notes.push_back(i);
 		}
 
-		Existing.LastConfigurationChange = OpenWifi::Now();
+		Existing.LastConfigurationChange = Utils::Now();
 		if (StorageService()->UpdateDevice(Existing)) {
 			SetCurrentConfigurationID(SerialNumber, Existing.UUID);
 			Poco::JSON::Object DevObj;

src/RESTAPI/RESTAPI_device_handler.h

@@ -8,14 +8,12 @@
 
 #pragma once
 
-#include "Poco/Net/HTTPServerRequest.h"
-#include "Poco/Net/HTTPServerResponse.h"
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 	class RESTAPI_device_handler : public RESTAPIHandler {
 	  public:
-		RESTAPI_device_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server, uint64_t TransactionId, bool Internal)
+		RESTAPI_device_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server, uint64_t TransactionId, bool Internal)
 			: RESTAPIHandler(bindings, L,
 							 std::vector<std::string>{
 								 Poco::Net::HTTPRequest::HTTP_GET, Poco::Net::HTTPRequest::HTTP_POST,

src/RESTAPI/RESTAPI_devices_handler.cpp

@@ -12,7 +12,6 @@
 #include "RESTAPI_devices_handler.h"
 #include "StorageService.h"
 #include "framework/ow_constants.h"
-#include "framework/MicroService.h"
 #include "RESTAPI/RESTAPI_device_helper.h"
 #include "Poco/StringTokenizer.h"
 #include "framework/orm.h"

src/RESTAPI/RESTAPI_devices_handler.h

@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 	class RESTAPI_devices_handler : public RESTAPIHandler {
 	  public:
-		RESTAPI_devices_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server, uint64_t TransactionId, bool Internal)
+		RESTAPI_devices_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server, uint64_t TransactionId, bool Internal)
 			: RESTAPIHandler(bindings, L,
 							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
 													  Poco::Net::HTTPRequest::HTTP_OPTIONS},

src/RESTAPI/RESTAPI_file.h

@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 	class RESTAPI_file : public RESTAPIHandler {
 	  public:
-		RESTAPI_file(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server, uint64_t TransactionId, bool Internal)
+		RESTAPI_file(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server, uint64_t TransactionId, bool Internal)
 			: RESTAPIHandler(bindings, L,
 							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
 													  Poco::Net::HTTPRequest::HTTP_DELETE,

src/RESTAPI/RESTAPI_iptocountry_handler.h

@@ -4,12 +4,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 class RESTAPI_iptocountry_handler : public RESTAPIHandler {
   public:
-	RESTAPI_iptocountry_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server, uint64_t TransactionId, bool Internal)
+	RESTAPI_iptocountry_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting & Server, uint64_t TransactionId, bool Internal)
 		: RESTAPIHandler(bindings, L,
 						 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,
 												  Poco::Net::HTTPRequest::HTTP_OPTIONS},

src/RESTAPI/RESTAPI_ouis.h

@@ -4,12 +4,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 	class RESTAPI_ouis : public RESTAPIHandler {
 	  public:
-		RESTAPI_ouis(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer &Server, uint64_t TransactionId, bool Internal)
+		RESTAPI_ouis(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
 			: RESTAPIHandler(bindings, L,
 							 std::vector<std::string>{
 								 Poco::Net::HTTPRequest::HTTP_GET,

src/RESTAPI/RESTAPI_radiusProxyConfig_handler.cpp

@@ -9,6 +9,9 @@
 namespace OpenWifi {
 
 	void RESTAPI_radiusProxyConfig_handler::DoGet() {
+		Logger_.information(fmt::format("GET-RADIUS-PROXY-CONFIG: TID={} user={} thr_id={}",
+										TransactionId_, Requester(),
+										Poco::Thread::current()->id()));
 		GWObjects::RadiusProxyPoolList	C;
 		RADIUS_proxy_server()->GetConfig(C);
 		Poco::JSON::Object	Answer;
@@ -17,6 +20,9 @@ namespace OpenWifi {
 	}
 
 	void RESTAPI_radiusProxyConfig_handler::DoDelete() {
+		Logger_.information(fmt::format("DELETE-RADIUS-PROXY-CONFIG: TID={} user={} thr_id={}",
+										TransactionId_, Requester(),
+										Poco::Thread::current()->id()));
 		if(!Internal_ && (UserInfo_.userinfo.userRole!=SecurityObjects::ROOT && UserInfo_.userinfo.userRole!=SecurityObjects::ADMIN)) {
 			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
 		}
@@ -25,7 +31,9 @@ namespace OpenWifi {
 	}
 
 	void RESTAPI_radiusProxyConfig_handler::DoPut() {
-
+		Logger_.information(fmt::format("MODIFY-RADIUS-PROXY-CONFIG: TID={} user={} thr_id={}",
+										TransactionId_, Requester(),
+										Poco::Thread::current()->id()));
 		if(!Internal_ && (UserInfo_.userinfo.userRole!=SecurityObjects::ROOT && UserInfo_.userinfo.userRole!=SecurityObjects::ADMIN)) {
 			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
 		}
@@ -65,6 +73,9 @@ namespace OpenWifi {
 			}
 		}
 
+		Logger_.information(fmt::format("MODIFY-RADIUS-PROXY-CONFIG: TID={} user={} thr_id={}. Applying new RADIUS Proxy config.",
+										TransactionId_, Requester(),
+										Poco::Thread::current()->id()));
 		RADIUS_proxy_server()->SetConfig(C);
 		return ReturnObject(*ParsedBody_);
 	}

src/RESTAPI/RESTAPI_radiusProxyConfig_handler.h

@@ -4,13 +4,13 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 	class RESTAPI_radiusProxyConfig_handler : public RESTAPIHandler {
 	  public:
 		RESTAPI_radiusProxyConfig_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L,
-										  RESTAPI_GenericServer &Server, uint64_t TransactionId,
+										  RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId,
 										  bool Internal)
 			: RESTAPIHandler(bindings, L,
 							 std::vector<std::string>{Poco::Net::HTTPRequest::HTTP_GET,

src/RESTAPI/RESTAPI_routers.cpp

@@ -2,8 +2,6 @@
 // Created by stephane bourque on 2021-10-23.
 //
 
-#include "framework/MicroService.h"
-
 #include "RESTAPI/RESTAPI_blacklist.h"
 #include "RESTAPI/RESTAPI_blacklist_list.h"
 #include "RESTAPI/RESTAPI_command.h"
@@ -20,11 +18,13 @@
 #include "RESTAPI/RESTAPI_telemetryWebSocket.h"
 #include "RESTAPI/RESTAPI_iptocountry_handler.h"
 #include "RESTAPI/RESTAPI_radiusProxyConfig_handler.h"
+#include "framework/RESTAPI_SystemCommand.h"
+#include "framework/RESTAPI_WebSocketServer.h"
 
 namespace OpenWifi {
 
     Poco::Net::HTTPRequestHandler * RESTAPI_ExtRouter(const std::string &Path, RESTAPIHandler::BindingMap &Bindings,
-                                                            Poco::Logger & L, RESTAPI_GenericServer & S, uint64_t TransactionId) {
+                                                            Poco::Logger & L, RESTAPI_GenericServerAccounting & S, uint64_t TransactionId) {
 
     	return RESTAPI_Router<
 				RESTAPI_devices_handler,
@@ -47,7 +47,7 @@ namespace OpenWifi {
     }
 
     Poco::Net::HTTPRequestHandler * RESTAPI_IntRouter(const std::string &Path, RESTAPIHandler::BindingMap &Bindings,
-                                                            Poco::Logger & L, RESTAPI_GenericServer & S, uint64_t TransactionId) {
+                                                            Poco::Logger & L, RESTAPI_GenericServerAccounting & S, uint64_t TransactionId) {
 
     	return RESTAPI_Router_I<
 				RESTAPI_devices_handler,

src/RESTAPI/RESTAPI_telemetryWebSocket.cpp

@@ -9,6 +9,8 @@
 
 namespace OpenWifi {
 
+// #define DBG		{ std::cout << __LINE__ << std::endl; }
+
 void RESTAPI_telemetryWebSocket::DoGet() {
 		//	try and upgrade this session to websocket...
 		if (Request->find("Upgrade") != Request->end() &&
@@ -32,16 +34,15 @@ void RESTAPI_telemetryWebSocket::DoGet() {
 				auto SerialNumber = Utils::SerialNumberToInt(SNum);
 
 				if(!TelemetryStream()->IsValidEndPoint(SerialNumber,UUID)) {
-					Logger_.warning(fmt::format("Illegal telemetry request for S: {}, UUID: {}", SerialNumber, UUID));
+					Logger_.warning(fmt::format("Illegal telemetry request for Serial: {}, UUID: {}", SNum, UUID));
 					Response->setStatusAndReason(Poco::Net::HTTPResponse::HTTP_BAD_REQUEST);
 					Response->setContentLength(0);
 					Response->send();
 					return;
 				}
-
 				auto WS = std::make_unique<Poco::Net::WebSocket>(*Request, *Response);
-				new TelemetryClient(UUID, SerialNumber, std::move(WS), TelemetryStream()->NextReactor(), Logger_);
-
+				TelemetryStream()->NewClient(UUID, SerialNumber, std::move(WS) );
+				return;
 			} catch (const Poco::Net::WebSocketException &E) {
 				Logger_.log(E);
 				switch (E.code()) {

src/RESTAPI/RESTAPI_telemetryWebSocket.h

@@ -4,12 +4,12 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_Handler.h"
 
 namespace OpenWifi {
 	class RESTAPI_telemetryWebSocket : public RESTAPIHandler {
 	  public:
-		RESTAPI_telemetryWebSocket(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer &Server, uint64_t TransactionId, bool Internal)
+		RESTAPI_telemetryWebSocket(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServerAccounting &Server, uint64_t TransactionId, bool Internal)
 		: RESTAPIHandler(bindings, L,
 						 std::vector<std::string>{	Poco::Net::HTTPRequest::HTTP_GET,
 													  Poco::Net::HTTPRequest::HTTP_OPTIONS},

src/RESTObjects/RESTAPI_AnalyticsObjects.cpp

@@ -4,7 +4,7 @@
 
 #include "RESTAPI_AnalyticsObjects.h"
 #include "RESTAPI_ProvObjects.h"
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_utils.h"
 
 using OpenWifi::RESTAPI_utils::field_to_json;
 using OpenWifi::RESTAPI_utils::field_from_json;

src/RESTObjects/RESTAPI_AnalyticsObjects.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include "RESTAPI_ProvObjects.h"
+#include "framework/utils.h"
 #include <vector>
 
 namespace OpenWifi {
@@ -375,7 +376,7 @@ namespace OpenWifi {
         };
 
         struct WifiClientHistory {
-            uint64_t        timestamp=OpenWifi::Now();
+            uint64_t        timestamp=Utils::Now();
             std::string     station_id;
             std::string     bssid;
             std::string     ssid;

src/RESTObjects/RESTAPI_CertObjects.cpp

@@ -3,7 +3,7 @@
 //
 
 #include "RESTAPI_CertObjects.h"
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_utils.h"
 
 using OpenWifi::RESTAPI_utils::field_to_json;
 using OpenWifi::RESTAPI_utils::field_from_json;
@@ -154,6 +154,7 @@ namespace OpenWifi::CertObjects {
         field_to_json(Obj,"submitted", submitted);
         field_to_json(Obj,"started", started);
         field_to_json(Obj,"completed", completed);
+        field_to_json(Obj,"requesterUsername", requesterUsername);
     }
 
     bool JobEntry::from_json(const Poco::JSON::Object::Ptr &Obj) {
@@ -171,6 +172,7 @@ namespace OpenWifi::CertObjects {
             field_from_json(Obj,"submitted", submitted);
             field_from_json(Obj,"started", started);
             field_from_json(Obj,"completed", completed);
+            field_from_json(Obj,"requesterUsername", requesterUsername);
             return true;
         } catch (...) {
         }

src/RESTObjects/RESTAPI_CertObjects.h

@@ -91,6 +91,7 @@ namespace OpenWifi::CertObjects {
         uint64_t                        submitted=0;
         uint64_t                        started=0;
         uint64_t                        completed=0;
+        std::string                     requesterUsername;
 
         void to_json(Poco::JSON::Object &Obj) const;
         bool from_json(const Poco::JSON::Object::Ptr &Obj);

src/RESTObjects/RESTAPI_FMSObjects.cpp

@@ -3,7 +3,8 @@
 //
 
 #include "RESTAPI_FMSObjects.h"
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_utils.h"
+#include "framework/utils.h"
 
 using OpenWifi::RESTAPI_utils::field_to_json;
 using OpenWifi::RESTAPI_utils::field_from_json;
@@ -233,7 +234,7 @@ namespace OpenWifi::FMSObjects {
         UnknownFirmwares_.clear();
         totalSecondsOld_.clear();
         numberOfDevices = 0 ;
-        snapshot = OpenWifi::Now();
+        snapshot = Utils::Now();
     }
 
     bool DeviceReport::from_json([[maybe_unused]] const Poco::JSON::Object::Ptr &Obj) {

src/RESTObjects/RESTAPI_GWobjects.cpp

@@ -16,7 +16,8 @@
 #endif
 
 #include "RESTAPI_GWobjects.h"
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_utils.h"
+#include "framework/utils.h"
 
 using OpenWifi::RESTAPI_utils::field_to_json;
 using OpenWifi::RESTAPI_utils::field_from_json;
@@ -206,7 +207,7 @@ namespace OpenWifi::GWObjects {
 		field_to_json(Obj,"started", started);
 		field_to_json(Obj,"sessionId", sessionId);
 		field_to_json(Obj,"connectionCompletionTime", connectionCompletionTime);
-		field_to_json(Obj,"totalConnectionTime", OpenWifi::Now() - started);
+		field_to_json(Obj,"totalConnectionTime", Utils::Now() - started);
 
 		switch(VerifiedCertificate) {
 			case NO_CERTIFICATE:
@@ -285,7 +286,7 @@ namespace OpenWifi::GWObjects {
 		lastContact.clear();
 		associations.clear();
 		numberOfDevices = 0 ;
-		snapshot = OpenWifi::Now();
+		snapshot = Utils::Now();
 	}
 
 	void CapabilitiesModel::to_json(Poco::JSON::Object &Obj) const{

src/RESTObjects/RESTAPI_OWLSobjects.cpp

@@ -0,0 +1,110 @@
+//
+// Created by stephane bourque on 2021-08-31.
+//
+
+#include "framework/RESTAPI_utils.h"
+
+using OpenWifi::RESTAPI_utils::field_to_json;
+using OpenWifi::RESTAPI_utils::field_from_json;
+using OpenWifi::RESTAPI_utils::EmbedDocument;
+
+#include "RESTAPI_OWLSobjects.h"
+
+// SIM -> 0x53/0x073, 0x49/0x69, 0x4d/0x6d
+
+namespace OpenWifi::OWLSObjects {
+
+    void SimulationDetails::to_json(Poco::JSON::Object &Obj) const {
+        field_to_json(Obj,"id", id);
+        field_to_json(Obj,"name", name);
+        field_to_json(Obj,"gateway", gateway);
+        field_to_json(Obj,"certificate", certificate);
+        field_to_json(Obj,"key", key);
+        field_to_json(Obj,"macPrefix", macPrefix);
+        field_to_json(Obj,"deviceType", deviceType);
+        field_to_json(Obj,"devices", devices);
+        field_to_json(Obj,"healthCheckInterval", healthCheckInterval);
+        field_to_json(Obj,"stateInterval", stateInterval);
+        field_to_json(Obj,"minAssociations", minAssociations);
+        field_to_json(Obj,"maxAssociations", maxAssociations);
+        field_to_json(Obj,"minClients", minClients);
+        field_to_json(Obj,"maxClients", maxClients);
+        field_to_json(Obj,"simulationLength", simulationLength);
+        field_to_json(Obj,"threads", threads);
+        field_to_json(Obj,"clientInterval", clientInterval);
+        field_to_json(Obj,"keepAlive", keepAlive);
+        field_to_json(Obj,"reconnectInterval", reconnectInterval);
+        field_to_json(Obj,"concurrentDevices", concurrentDevices);
+    }
+
+    bool SimulationDetails::from_json(const Poco::JSON::Object::Ptr &Obj) {
+        try {
+            field_from_json(Obj,"id", id);
+            field_from_json(Obj,"name", name);
+            field_from_json(Obj,"gateway", gateway);
+            field_from_json(Obj,"certificate", certificate);
+            field_from_json(Obj,"key", key);
+            field_from_json(Obj,"macPrefix", macPrefix);
+            field_from_json(Obj,"deviceType", deviceType);
+            field_from_json(Obj,"devices", devices);
+            field_from_json(Obj,"healthCheckInterval", healthCheckInterval);
+            field_from_json(Obj,"stateInterval", stateInterval);
+            field_from_json(Obj,"minAssociations", minAssociations);
+            field_from_json(Obj,"maxAssociations", maxAssociations);
+            field_from_json(Obj,"minClients", minClients);
+            field_from_json(Obj,"maxClients", maxClients);
+            field_from_json(Obj,"simulationLength", simulationLength);
+            field_from_json(Obj,"threads", threads);
+            field_from_json(Obj,"clientInterval", clientInterval);
+            field_from_json(Obj,"keepAlive", keepAlive);
+            field_from_json(Obj,"reconnectInterval", reconnectInterval);
+            field_from_json(Obj,"concurrentDevices", concurrentDevices);
+            return true;
+        } catch(...) {
+
+        }
+        return false;
+    }
+
+    void SimulationDetailsList::to_json(Poco::JSON::Object &Obj) const {
+        field_to_json(Obj,"list", list);
+    }
+
+    bool SimulationDetailsList::from_json(const Poco::JSON::Object::Ptr &Obj) {
+        try {
+            field_from_json(Obj,"list", list);
+            return true;
+        } catch(...) {
+
+        }
+        return false;
+    }
+
+    void SimulationStatus::to_json(Poco::JSON::Object &Obj) const {
+        field_to_json(Obj,"id", id);
+        field_to_json(Obj,"simulationId", simulationId);
+        field_to_json(Obj,"state", state);
+        field_to_json(Obj,"tx", tx);
+        field_to_json(Obj,"rx", rx);
+        field_to_json(Obj,"msgsTx", msgsTx);
+        field_to_json(Obj,"msgsRx", msgsRx);
+        field_to_json(Obj,"liveDevices", liveDevices);
+        field_to_json(Obj,"timeToFullDevices", timeToFullDevices);
+        field_to_json(Obj,"startTime", startTime);
+        field_to_json(Obj,"endTime", endTime);
+        field_to_json(Obj,"errorDevices", errorDevices);
+        field_to_json(Obj,"owner", owner);
+    }
+
+    void Dashboard::to_json([[maybe_unused]] Poco::JSON::Object &Obj) const {
+
+    }
+
+    bool Dashboard::from_json([[maybe_unused]] const Poco::JSON::Object::Ptr &Obj) {
+        return true;
+    }
+
+    void Dashboard::reset() {
+
+    }
+}

src/RESTObjects/RESTAPI_OWLSobjects.h

@@ -0,0 +1,77 @@
+//
+// Created by stephane bourque on 2021-08-31.
+//
+
+#ifndef UCENTRALSIM_RESTAPI_OWLSOBJECTS_H
+#define UCENTRALSIM_RESTAPI_OWLSOBJECTS_H
+
+#include <vector>
+#include "Poco/JSON/Object.h"
+
+namespace OpenWifi::OWLSObjects {
+
+    struct SimulationDetails {
+        std::string     id;
+        std::string     name;
+        std::string     gateway;
+        std::string     certificate;
+        std::string     key;
+        std::string     macPrefix;
+        std::string     deviceType;
+        uint64_t        devices = 5;
+        uint64_t        healthCheckInterval = 60;
+        uint64_t        stateInterval = 60 ;
+        uint64_t        minAssociations = 1;
+        uint64_t        maxAssociations = 3;
+        uint64_t        minClients = 1 ;
+        uint64_t        maxClients = 3;
+        uint64_t        simulationLength = 60 * 60;
+        uint64_t        threads = 16;
+        uint64_t        clientInterval = 1;
+        uint64_t        keepAlive = 300;
+        uint64_t        reconnectInterval = 30 ;
+        uint64_t        concurrentDevices = 5;
+
+        void to_json(Poco::JSON::Object &Obj) const;
+        bool from_json(const Poco::JSON::Object::Ptr &Obj);
+    };
+
+    struct SimulationDetailsList {
+        std::vector<SimulationDetails>  list;
+
+        void to_json(Poco::JSON::Object &Obj) const;
+        bool from_json(const Poco::JSON::Object::Ptr &Obj);
+    };
+
+    struct SimulationStatus {
+        std::string     id;
+        std::string     simulationId;
+        std::string     state;
+        uint64_t        tx;
+        uint64_t        rx;
+        uint64_t        msgsTx;
+        uint64_t        msgsRx;
+        uint64_t        liveDevices;
+        uint64_t        timeToFullDevices;
+        uint64_t        startTime;
+        uint64_t        endTime;
+        uint64_t        errorDevices;
+        std::string     owner;
+
+        void to_json(Poco::JSON::Object &Obj) const;
+    };
+
+
+    struct Dashboard {
+        int O;
+
+        void to_json(Poco::JSON::Object &Obj) const;
+        bool from_json(const Poco::JSON::Object::Ptr &Obj);
+        void reset();
+
+    };
+
+}
+
+
+#endif //UCENTRALSIM_RESTAPI_OWLSOBJECTS_H

src/RESTObjects/RESTAPI_ProvObjects.cpp

@@ -8,7 +8,9 @@
 
 
 #include "RESTAPI_ProvObjects.h"
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_utils.h"
+#include "framework/MicroServiceFuncs.h"
+#include "framework/utils.h"
 
 using OpenWifi::RESTAPI_utils::field_to_json;
 using OpenWifi::RESTAPI_utils::field_from_json;
@@ -1091,7 +1093,7 @@ namespace OpenWifi::ProvObjects {
     }
 
     bool UpdateObjectInfo(const Poco::JSON::Object::Ptr &O, const SecurityObjects::UserInfo &U, ObjectInfo &I) {
-        uint64_t Now = OpenWifi::Now();
+        uint64_t Now = Utils::Now();
         if(O->has("name"))
             I.name = O->get("name").toString();
 
@@ -1112,7 +1114,7 @@ namespace OpenWifi::ProvObjects {
     }
 
     bool CreateObjectInfo(const Poco::JSON::Object::Ptr &O, const SecurityObjects::UserInfo &U, ObjectInfo &I) {
-        uint64_t Now = OpenWifi::Now();
+        uint64_t Now = Utils::Now();
         if(O->has("name"))
             I.name = O->get("name").toString();
 
@@ -1130,14 +1132,14 @@ namespace OpenWifi::ProvObjects {
         }
         I.notes = N;
         I.modified = I.created = Now;
-        I.id = MicroService::CreateUUID();
+        I.id = MicroServiceCreateUUID();
 
         return true;
     }
 
     bool CreateObjectInfo([[maybe_unused]] const SecurityObjects::UserInfo &U, ObjectInfo &I) {
-        I.modified = I.created = OpenWifi::Now();
-        I.id = MicroService::CreateUUID();
+        I.modified = I.created = Utils::Now();
+        I.id = MicroServiceCreateUUID();
         return true;
     }
 
@@ -1159,5 +1161,40 @@ namespace OpenWifi::ProvObjects {
         return false;
     }
 
+    void RRMAlgorithmDetails::to_json(Poco::JSON::Object &Obj) const {
+        field_to_json(Obj,"name",name);
+        field_to_json(Obj,"parameters",parameters);
+    }
+
+    bool RRMAlgorithmDetails::from_json(const Poco::JSON::Object::Ptr &Obj) {
+        try {
+            field_from_json(Obj,"name",name);
+            field_from_json(Obj,"parameters",parameters);
+            return true;
+        } catch(...) {
+
+        }
+        return false;
+    }
+
+    void RRMDetails::to_json(Poco::JSON::Object &Obj) const {
+        field_to_json(Obj,"vendor",vendor);
+        field_to_json(Obj,"schedule",schedule);
+        field_to_json(Obj,"algorithms",algorithms);
+    }
+
+    bool RRMDetails::from_json(const Poco::JSON::Object::Ptr &Obj) {
+        try {
+            field_from_json(Obj,"vendor",vendor);
+            field_from_json(Obj,"schedule",schedule);
+            field_from_json(Obj,"algorithms",algorithms);
+            return true;
+        } catch(...) {
+
+        }
+        return false;
+    }
+
 }
 
+

src/RESTObjects/RESTAPI_ProvObjects.h

@@ -8,8 +8,7 @@
 
 #pragma once
 
-#include <string>
-#include "RESTAPI_SecurityObjects.h"
+#include "RESTObjects/RESTAPI_SecurityObjects.h"
 
 namespace OpenWifi::ProvObjects {
 
@@ -62,6 +61,21 @@ namespace OpenWifi::ProvObjects {
     };
     typedef std::vector<ManagementPolicy>      ManagementPolicyVec;
 
+    struct RRMAlgorithmDetails {
+        std::string     name;
+        std::string     parameters;
+        void to_json(Poco::JSON::Object &Obj) const;
+        bool from_json(const Poco::JSON::Object::Ptr &Obj);
+    };
+
+    struct RRMDetails {
+        std::string     vendor;
+        std::string     schedule;
+        std::vector<RRMAlgorithmDetails>    algorithms;
+        void to_json(Poco::JSON::Object &Obj) const;
+        bool from_json(const Poco::JSON::Object::Ptr &Obj);
+    };
+
     struct DeviceRules {
         std::string     rcOnly{"inherit"};
         std::string     rrm{"inherit"};

src/RESTObjects/RESTAPI_SecurityObjects.cpp

@@ -9,7 +9,7 @@
 #include "Poco/JSON/Parser.h"
 #include "Poco/JSON/Stringifier.h"
 
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_utils.h"
 #include "RESTAPI_SecurityObjects.h"
 
 using OpenWifi::RESTAPI_utils::field_to_json;
@@ -433,7 +433,7 @@ namespace OpenWifi::SecurityObjects {
 	            SecurityObjects::NoteInfoVec NIV;
 	            NIV = RESTAPI_utils::to_object_array<SecurityObjects::NoteInfo>(Obj->get("notes").toString());
 	            for(auto const &i:NIV) {
-	                SecurityObjects::NoteInfo   ii{.created=(uint64_t)OpenWifi::Now(), .createdBy=UInfo.email, .note=i.note};
+	                SecurityObjects::NoteInfo   ii{.created=(uint64_t)Utils::Now(), .createdBy=UInfo.email, .note=i.note};
 	                Notes.push_back(ii);
 	            }
 	        }
@@ -446,7 +446,7 @@ namespace OpenWifi::SecurityObjects {
 
 	bool MergeNotes(const NoteInfoVec & NewNotes, const UserInfo &UInfo, NoteInfoVec & ExistingNotes) {
 	    for(auto const &i:NewNotes) {
-	        SecurityObjects::NoteInfo   ii{.created=(uint64_t)OpenWifi::Now(), .createdBy=UInfo.email, .note=i.note};
+	        SecurityObjects::NoteInfo   ii{.created=(uint64_t)Utils::Now(), .createdBy=UInfo.email, .note=i.note};
 	        ExistingNotes.push_back(ii);
 	    }
         return true;

src/RESTObjects/RESTAPI_SecurityObjects.h

@@ -14,6 +14,7 @@
 #include "Poco/JSON/Object.h"
 #include "Poco/Data/LOB.h"
 #include "Poco/Data/LOBStream.h"
+#include "framework/utils.h"
 
 namespace OpenWifi {
     uint64_t Now();
@@ -62,7 +63,7 @@ namespace OpenWifi {
         std::string UserTypeToString(USER_ROLE U);
 
         struct NoteInfo {
-            uint64_t    created=0; // = OpenWifi::Now();
+            uint64_t    created=0; // = Utils::Now();
             std::string createdBy;
             std::string note;
 
@@ -101,7 +102,7 @@ namespace OpenWifi {
             std::string uuid;
             std::string question;
             std::string method;
-            uint64_t    created = OpenWifi::Now();
+            uint64_t    created = Utils::Now();
 
             void to_json(Poco::JSON::Object &Obj) const;
             bool from_json(const Poco::JSON::Object::Ptr &Obj);
@@ -251,7 +252,8 @@ namespace OpenWifi {
             VERIFY_EMAIL,
             SUB_FORGOT_PASSWORD,
             SUB_VERIFY_EMAIL,
-            SUB_SIGNUP
+            SUB_SIGNUP,
+            EMAIL_INVITATION
         };
 
         struct ActionLink {
@@ -263,7 +265,7 @@ namespace OpenWifi {
             std::string         locale;
             std::string         message;
             uint64_t            sent=0;
-            uint64_t            created=OpenWifi::Now();
+            uint64_t            created=Utils::Now();
             uint64_t            expires=0;
             uint64_t            completed=0;
             uint64_t            canceled=0;

src/RESTObjects/RESTAPI_SubObjects.cpp

@@ -3,12 +3,11 @@
 //
 
 #include "RESTAPI_SubObjects.h"
-#include "framework/MicroService.h"
+#include "framework/RESTAPI_utils.h"
 
 using OpenWifi::RESTAPI_utils::field_to_json;
 using OpenWifi::RESTAPI_utils::field_from_json;
 
-
 namespace OpenWifi::SubObjects {
 
     void HomeDeviceMode::to_json(Poco::JSON::Object &Obj) const {

src/SDKcalls.cpp

@@ -4,6 +4,9 @@
 
 #include "SDKcalls.h"
 
+#include "framework/OpenAPIRequests.h"
+#include "framework/MicroServiceNames.h"
+
 namespace OpenWifi {
 
 	bool SDKCalls::GetProvisioningConfiguration(const std::string &SerialNumber, std::string & Config) {

src/SDKcalls.h

@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include <string>
 
 namespace OpenWifi {
 	class SDKCalls {

src/SerialNumberCache.cpp

@@ -6,6 +6,7 @@
 
 #include "SerialNumberCache.h"
 #include "StorageService.h"
+#include "framework/utils.h"
 
 namespace OpenWifi {
 

src/SerialNumberCache.h

@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "framework/SubSystemServer.h"
 
 namespace OpenWifi {
 	class SerialNumberCache : public SubSystemServer {

src/StorageArchiver.cpp

@@ -4,16 +4,20 @@
 
 #include <fstream>
 
-#include "framework/MicroService.h"
-
 #include "StorageArchiver.h"
 #include "StorageService.h"
 
+#include "framework/AppServiceRegistry.h"
+#include "framework/utils.h"
+#include "framework/MicroServiceFuncs.h"
+
+#include "fmt/format.h"
+
 namespace OpenWifi {
 
 	void Archiver::onTimer([[maybe_unused]] Poco::Timer &timer){
 		Utils::SetThreadName("strg-archiver");
-		auto now = OpenWifi::Now();
+		auto now = Utils::Now();
 		for(const auto &i:DBs_) {
 			if (!Poco::icompare(i.DBName, "healthchecks")) {
 				poco_information(Logger(),"Archiving HealthChecks...");
@@ -35,7 +39,7 @@ namespace OpenWifi {
 				poco_information(Logger(),fmt::format("Cannot archive DB '{}'", i.DBName));
 			}
 		}
-		AppServiceRegistry().Set("lastStorageArchiverRun", (uint64_t) Now);
+		AppServiceRegistry().Set("lastStorageArchiverRun", (uint64_t) now);
 	}
 
 	static auto CalculateDelta(int H, int M) {
@@ -53,7 +57,7 @@ namespace OpenWifi {
 
 	int StorageArchiver::Start() {
 
-		Enabled_ = MicroService::instance().ConfigGetBool("archiver.enabled",false);
+		Enabled_ = MicroServiceConfigGetBool("archiver.enabled",false);
 		if(!Enabled_) {
 			poco_information(Logger(),"Archiver is disabled.");
 			return 0;
@@ -62,7 +66,7 @@ namespace OpenWifi {
 		Archiver_ = std::make_unique<Archiver>(Logger());
 		ArchiverCallback_ = std::make_unique<Poco::TimerCallback<Archiver>>(*Archiver_,&Archiver::onTimer);
 
-		auto Schedule = MicroService::instance().ConfigGetString("archiver.schedule","03:00");
+		auto Schedule = MicroServiceConfigGetString("archiver.schedule","03:00");
 		auto S = Poco::StringTokenizer(Schedule,":");
 
 		int RunAtHour_, RunAtMin_;
@@ -76,12 +80,12 @@ namespace OpenWifi {
 
 		for(int i=0;i<20;i++) {
 			std::string key = "archiver.db." + std::to_string(i) + ".name";
-			auto DBName = MicroService::instance().ConfigGetString(key,"");
+			auto DBName = MicroServiceConfigGetString(key,"");
 			if(!DBName.empty()) {
 				for(auto const &DB:AllInternalDBNames) {
 					if(Poco::icompare(DBName,DB)==0) {
 						std::string Key = "archiver.db." + std::to_string(i) + ".keep";
-						auto Keep = MicroService::instance().ConfigGetInt(Key,7);
+						auto Keep = MicroServiceConfigGetInt(Key,7);
 						Archiver_->AddDb(Archiver::ArchiverDBEntry{
 							.DBName = DB,
 							.HowManyDays = Keep
@@ -97,7 +101,7 @@ namespace OpenWifi {
 
 		Timer_.setStartInterval( NextRun * 1000);
 		Timer_.setPeriodicInterval(24 * 60 * 60 * 1000); // 1 hours
-		Timer_.start(*ArchiverCallback_, MicroService::instance().TimerPool());
+		Timer_.start(*ArchiverCallback_, MicroServiceTimerPool());
 
 		return 0;
 	}

src/StorageArchiver.h

@@ -5,10 +5,12 @@
 #pragma once
 
 #include <functional>
+#include <list>
 
-#include "framework/MicroService.h"
 #include "Poco/Timer.h"
 
+#include "framework/SubSystemServer.h"
+
 namespace OpenWifi {
 
     static const std::list<std::string>		AllInternalDBNames{"healthchecks", "statistics", "devicelogs" , "commandlist" };

src/StorageService.h

@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
 #include "framework/StorageClass.h"
 #include "RESTObjects//RESTAPI_GWobjects.h"
 #include "Poco/Net/IPAddress.h"

src/TelemetryClient.cpp

@@ -2,14 +2,13 @@
 // Created by stephane bourque on 2022-02-03.
 //
 
-#include "framework/MicroService.h"
-#include "AP_WS_Connection.h"
 #include "AP_WS_Server.h"
 #include "TelemetryClient.h"
 #include "TelemetryStream.h"
 #include "CommandManager.h"
 
 #include "Poco/Net/SSLException.h"
+#include "fmt/format.h"
 
 namespace OpenWifi {
 
@@ -24,55 +23,42 @@ namespace OpenWifi {
 				Reactor_(Reactor),
 				Logger_(Logger),
 				WS_(std::move(WSock)) {
-		try {
-			std::thread T([this]() { this->CompleteStartup(); });
-			T.detach();
-			return;
-		} catch (...) {
-			delete this;
-		}
+		CompleteStartup();
 	}
 
 	void TelemetryClient::CompleteStartup() {
-		try {
-			std::lock_guard Guard(Mutex_);
-			Socket_ = *WS_;
-			CId_ = Utils::FormatIPv6(Socket_.peerAddress().toString());
+		Socket_ = *WS_;
+		CId_ = Utils::FormatIPv6(Socket_.peerAddress().toString());
 
-			if (TelemetryStream()->RegisterClient(UUID_, this)) {
-				auto TS = Poco::Timespan(240, 0);
+		Poco::Timespan TS(1 * 60 * 60, 0);
 
-				WS_->setReceiveTimeout(TS);
-				WS_->setNoDelay(true);
-				WS_->setKeepAlive(true);
-				WS_->setMaxPayloadSize(2048);
-				WS_->setBlocking(false);
-				Reactor_.addEventHandler(
-					*WS_, Poco::NObserver<TelemetryClient, Poco::Net::ReadableNotification>(
-							  *this, &TelemetryClient::OnSocketReadable));
-				Reactor_.addEventHandler(
-					*WS_, Poco::NObserver<TelemetryClient, Poco::Net::ShutdownNotification>(
-							  *this, &TelemetryClient::OnSocketShutdown));
-				Reactor_.addEventHandler(
-					*WS_, Poco::NObserver<TelemetryClient, Poco::Net::ErrorNotification>(
-							  *this, &TelemetryClient::OnSocketError));
-				Registered_ = true;
-				poco_information(Logger(),fmt::format("TELEMETRY-CONNECTION({}): Connection completed.", CId_));
-				return;
-			}
-		} catch (const Poco::Net::SSLException &E) {
-			Logger().log(E);
-		}
-		catch (const Poco::Exception &E) {
-			Logger().log(E);
-		}
-		delete this;
+		WS_->setReceiveTimeout(TS);
+		WS_->setSendTimeout(TS);
+		WS_->setNoDelay(true);
+		WS_->setKeepAlive(true);
+		WS_->setMaxPayloadSize(2048);
+		WS_->setBlocking(false);
+		Reactor_.addEventHandler(
+			*WS_, Poco::NObserver<TelemetryClient, Poco::Net::ReadableNotification>(
+					  *this, &TelemetryClient::OnSocketReadable));
+		Reactor_.addEventHandler(
+			*WS_, Poco::NObserver<TelemetryClient, Poco::Net::ShutdownNotification>(
+					  *this, &TelemetryClient::OnSocketShutdown));
+		Reactor_.addEventHandler(
+			*WS_, Poco::NObserver<TelemetryClient, Poco::Net::ErrorNotification>(
+					  *this, &TelemetryClient::OnSocketError));
+		Registered_ = true;
+		poco_information(Logger(),fmt::format("TELEMETRY-CONNECTION({}): Connection completed.", CId_));
 	}
 
 	TelemetryClient::~TelemetryClient() {
 		poco_information(Logger(),fmt::format("TELEMETRY-CONNECTION({}): Closing connection.", CId_));
-		if(Registered_ && WS_)
-		{
+		DeRegister();
+	}
+
+	void TelemetryClient::DeRegister() {
+		if(Registered_) {
+			Registered_ = false;
 			Reactor_.removeEventHandler(*WS_,
 										Poco::NObserver<TelemetryClient,
 														Poco::Net::ReadableNotification>(*this,&TelemetryClient::OnSocketReadable));
@@ -83,7 +69,6 @@ namespace OpenWifi {
 										Poco::NObserver<TelemetryClient,
 														Poco::Net::ErrorNotification>(*this,&TelemetryClient::OnSocketError));
 		}
-		WS_->close();
 	}
 
 	bool TelemetryClient::Send(const std::string &Payload) {
@@ -94,9 +79,9 @@ namespace OpenWifi {
 
 	void TelemetryClient::SendTelemetryShutdown() {
 		poco_information(Logger(),fmt::format("TELEMETRY-SHUTDOWN({}): Closing.",CId_));
+		DeRegister();
 		AP_WS_Server()->StopWebSocketTelemetry(CommandManager()->NextRPCId(), SerialNumber_);
 		TelemetryStream()->DeRegisterClient(UUID_);
-		delete this;
 	}
 
 	void TelemetryClient::OnSocketShutdown([[maybe_unused]] const Poco::AutoPtr<Poco::Net::ShutdownNotification>& pNf) {
@@ -113,22 +98,20 @@ namespace OpenWifi {
 		try
 		{
 			std::lock_guard Guard(Mutex_);
-			ProcessIncomingFrame();
+			return ProcessIncomingFrame();
 		}
 		catch (const Poco::Exception & E)
 		{
 			Logger().log(E);
-			SendTelemetryShutdown();
 		}
 		catch (const std::exception & E) {
 			std::string W = E.what();
 			poco_information(Logger(),fmt::format("TELEMETRY-std::exception caught: {}. Connection terminated with {}",W,CId_));
-			SendTelemetryShutdown();
 		}
 		catch ( ... ) {
 			poco_information(Logger(),fmt::format("TELEMETRY-Unknown exception for {}. Connection terminated.",CId_));
-			SendTelemetryShutdown();
 		}
+		SendTelemetryShutdown();
 	}
 
 	void TelemetryClient::ProcessIncomingFrame() {

src/TelemetryClient.h

@@ -44,5 +44,6 @@ namespace OpenWifi {
 		bool 									Registered_=false;
 		void SendTelemetryShutdown();
 		void CompleteStartup();
+		void DeRegister();
 	};
 }

src/TelemetryStream.cpp

@@ -3,8 +3,6 @@
 //
 #include <thread>
 
-#include "framework/MicroService.h"
-
 #include "Poco/JSON/Array.h"
 #include "Poco/Net/HTTPHeaderStream.h"
 #include "Poco/URI.h"
@@ -12,24 +10,26 @@
 #include "RESTAPI/RESTAPI_telemetryWebSocket.h"
 #include "TelemetryStream.h"
 
+#include "framework/MicroServiceFuncs.h"
+
 namespace OpenWifi {
 
 	int TelemetryStream::Start() {
 		Running_ = true;
-		Messages_->Readable_ += Poco::delegate(this,&TelemetryStream::onMessage);
-		Thr_.start(Reactor_);
-		Utils::SetThreadName(Thr_,"telemetry-svr");
+		ReactorThr_.start(Reactor_);
+		Utils::SetThreadName(ReactorThr_,"tel:reactor");
+		NotificationMgr_.start(*this);
 		return 0;
 	}
 
 	void TelemetryStream::Stop() {
 		poco_information(Logger(),"Stopping...");
+		Running_ = false;
 		Reactor_.stop();
-		Thr_.join();
-		if(Running_) {
-			Running_ = false;
-			Messages_->Readable_ -= Poco::delegate( this, &TelemetryStream::onMessage);
-		}
+		ReactorThr_.join();
+		MsgQueue_.wakeUpAll();
+		NotificationMgr_.wakeUp();
+		NotificationMgr_.join();
 		poco_information(Logger(),"Stopped...");
 	}
 
@@ -50,7 +50,7 @@ namespace OpenWifi {
 	bool TelemetryStream::CreateEndpoint(uint64_t SerialNumber, std::string &EndPoint, const std::string &UUID) {
 		std::lock_guard	G(Mutex_);
 
-		Poco::URI	Public(MicroService::instance().ConfigGetString("openwifi.system.uri.public"));
+		Poco::URI	Public(MicroServiceConfigGetString("openwifi.system.uri.public",""));
 		Poco::URI	U;
 		U.setScheme("wss");
 		U.setHost(Public.getHost());
@@ -60,76 +60,85 @@ namespace OpenWifi {
 		U.addQueryParameter("uuid", UUID);
 		U.addQueryParameter("serialNumber", Utils::IntToSerialNumber(SerialNumber));
 		EndPoint = U.toString();
-		auto H = SerialNumbers_.find(SerialNumber);
-		if(H == SerialNumbers_.end()) {
-			std::set<std::string>	UUIDs{UUID};
-			SerialNumbers_[SerialNumber] = UUIDs;
-		} else {
-			H->second.insert(UUID);
-		}
+		auto S = SerialNumbers_[SerialNumber];
+		S.insert(UUID);
+		SerialNumbers_[SerialNumber] = S;
 		Clients_[UUID] = nullptr;
 		return true;
 	}
 
-	void TelemetryStream::UpdateEndPoint(uint64_t SerialNumber, const std::string &PayLoad) {
-		{
-			std::lock_guard M(Mutex_);
-			if (SerialNumbers_.find(SerialNumber) == SerialNumbers_.end()) {
-				return;
-			}
-		}
-		Messages_->Write(QueueUpdate{.SerialNumber=SerialNumber, .Payload = PayLoad});
-	}
-
-	void TelemetryStream::onMessage(bool &b){
-		if(b) {
-			QueueUpdate Msg;
-
-			auto S = Messages_->Read(Msg);
-
-			if(S) {
-				std::lock_guard	M(Mutex_);
-				auto H1 = SerialNumbers_.find(Msg.SerialNumber);
-				if (H1 != SerialNumbers_.end()) {
-					for (auto &i : H1->second) {
-						auto H2 = Clients_.find(i);
-						if (H2 != Clients_.end() && H2->second != nullptr) {
-							try {
-								H2->second->Send(Msg.Payload);
-							} catch (...) {
+	void TelemetryStream::run() {
+		Utils::SetThreadName("tel:notifier");
+		Poco::AutoPtr<Poco::Notification> NextNotification(MsgQueue_.waitDequeueNotification());
+		while (NextNotification && Running_) {
+			auto Notification = dynamic_cast<TelemetryNotification *>(NextNotification.get());
+			if (Notification != nullptr) {
+				std::lock_guard 	Lock(Mutex_);
+				switch( Notification->Type_ ) {
+					case TelemetryNotification::NotificationType::data : {
+						auto SerialNumberSetOfUUIDs = SerialNumbers_.find(Notification->SerialNumber_);
+						if (SerialNumberSetOfUUIDs != SerialNumbers_.end()) {
+							for (auto &uuid : SerialNumberSetOfUUIDs->second) {
+								auto Client = Clients_.find(uuid);
+								if (Client != Clients_.end() && Client->second != nullptr) {
+									try {
+										// std::cout << "Sent WS telemetry notification" << std::endl;
+										Client->second->Send(Notification->Data_);
+									} catch (const Poco::Exception &E) {
+										Logger().log(E);
+									} catch (std::exception &E) {
+										poco_warning(Logger(),fmt::format("Std:Ex Cannot send WS telemetry notification: {} for SerialNumber: {}", E.what(), Utils::IntToSerialNumber(Notification->SerialNumber_)));
+									}
+								} else {
+									poco_warning(Logger(),fmt::format("Cannot send WS telemetry notification for SerialNumber: {}", Utils::IntToSerialNumber(Notification->SerialNumber_)));
+								}
 							}
+						} else {
+							poco_warning(Logger(),fmt::format("Cannot find serial: {}", Utils::IntToSerialNumber(Notification->SerialNumber_)));
 						}
-					}
+					} break;
+					case TelemetryNotification::NotificationType::unregister : {
+						std::lock_guard		G(Mutex_);
+
+						auto client = Clients_.find(Notification->Data_);
+						if(client!=Clients_.end()) {
+							for(auto i = SerialNumbers_.begin(); i!= SerialNumbers_.end();) {
+								i->second.erase(Notification->Data_);
+								if(i->second.empty()) {
+									i = SerialNumbers_.erase(i);
+								} else {
+									++i;
+								}
+							}
+							Clients_.erase(client);
+						} else {
+							poco_warning(Logger(),fmt::format("Unknown connection: {}", Notification->Data_));
+						}
+					} break;
+
+					default: {
+
+					} break;
 				}
 			}
+			NextNotification = MsgQueue_.waitDequeueNotification();
 		}
 	}
 
-	bool TelemetryStream::RegisterClient(const std::string &UUID, TelemetryClient *Client) {
+	bool TelemetryStream::NewClient(const std::string &UUID, uint64_t SerialNumber, std::unique_ptr<Poco::Net::WebSocket> Client) {
 		std::lock_guard	G(Mutex_);
-		Clients_[UUID] = Client;
-		return true;
-	}
-
-	void TelemetryStream::DeRegisterClient(const std::string &UUID) {
-		std::lock_guard		G(Mutex_);
-
-		auto Hint = Clients_.find(UUID);
-		if(Hint!=Clients_.end()) {
-			Clients_.erase(Hint);
-			for(const auto &i:SerialNumbers_) {
-				auto S = i.second;
-				S.erase(UUID);
-			}
-
-			//	remove empty slots
-			for( auto i = SerialNumbers_.begin(); i!= SerialNumbers_.end();) {
-				if(i->second.empty()) {
-					i = SerialNumbers_.erase(i);
-				} else {
-					++i;
-				}
-			}
+		try {
+			Clients_[UUID] = std::make_unique<TelemetryClient>(
+				UUID, SerialNumber, std::move(Client), NextReactor(), Logger());
+			auto set = SerialNumbers_[SerialNumber];
+			set.insert(UUID);
+			SerialNumbers_[SerialNumber] = set;
+			return true;
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		} catch (...) {
+			poco_warning(Logger(),fmt::format("Could not create a telemetry client for session {} and serial number {}", UUID, SerialNumber));
 		}
+		return false;
 	}
-}
+}

src/TelemetryStream.h

@@ -6,8 +6,6 @@
 
 #include <iostream>
 
-#include "framework/MicroService.h"
-
 #include "Poco/Net/SocketReactor.h"
 #include "Poco/Net/ParallelSocketAcceptor.h"
 #include "Poco/Net/WebSocket.h"
@@ -20,13 +18,40 @@
 #include "Poco/Timespan.h"
 #include "Poco/URI.h"
 #include "Poco/Net/HTTPServer.h"
+#include "Poco/NotificationQueue.h"
+#include "Poco/Notification.h"
+
+#include "framework/SubSystemServer.h"
 
 #include "AP_WS_ReactorPool.h"
 #include "TelemetryClient.h"
 
 namespace OpenWifi {
 
-	class TelemetryStream : public SubSystemServer {
+	class TelemetryNotification : public Poco::Notification {
+	  public:
+		enum class NotificationType {
+			data,
+			unregister
+		};
+
+		explicit TelemetryNotification(std::uint64_t SerialNumber, const std::string &Payload) :
+			Type_(NotificationType::data),
+			SerialNumber_(SerialNumber),
+			Data_(Payload) {
+		}
+
+		explicit TelemetryNotification(const std::string &UUID) :
+			 Type_(NotificationType::unregister),
+			 Data_(UUID) {
+		}
+
+		NotificationType	Type_;
+		std::uint64_t 		SerialNumber_=0;
+		std::string 		Data_;
+	};
+
+	class TelemetryStream : public SubSystemServer, Poco::Runnable {
 	  public:
 
 		struct QueueUpdate {
@@ -41,23 +66,33 @@ namespace OpenWifi {
 
 		int Start() override;
 		void Stop() override;
+		void run() final;
 
 		bool IsValidEndPoint(uint64_t SerialNumber, const std::string & UUID);
 		bool CreateEndpoint(uint64_t SerialNumber, std::string &EndPoint, const std::string &UUID);
-		void UpdateEndPoint(uint64_t SerialNumber, const std::string &PayLoad);
-		bool RegisterClient(const std::string &UUID, TelemetryClient *Client);
-		void DeRegisterClient(const std::string &UUID);
-		Poco::Net::SocketReactor & NextReactor() { return Reactor_; }
 
-		void onMessage(bool& b);
+		inline void NotifyEndPoint(uint64_t SerialNumber, const std::string &PayLoad) {
+			MsgQueue_.enqueueNotification(new TelemetryNotification(SerialNumber,PayLoad));
+		}
+
+		inline void DeRegisterClient(const std::string &UUID) {
+			MsgQueue_.enqueueNotification(new TelemetryNotification(UUID));
+		}
+
+		bool NewClient(const std::string &UUID, uint64_t SerialNumber,  std::unique_ptr<Poco::Net::WebSocket> Client);
+
+
+		Poco::Net::SocketReactor & NextReactor() { return Reactor_; }
 
 	  private:
 		volatile std::atomic_bool 						Running_=false;
-		std::map<std::string, TelemetryClient *>		Clients_;			// 	uuid -> client
 		std::map<uint64_t, std::set<std::string>>		SerialNumbers_;		//	serialNumber -> uuid
 		Poco::Net::SocketReactor						Reactor_;
-		std::unique_ptr<FIFO<QueueUpdate>>				Messages_=std::make_unique<FIFO<QueueUpdate>>(100);
-		Poco::Thread									Thr_;
+		Poco::Thread									ReactorThr_;
+		Poco::Thread									NotificationMgr_;
+		Poco::NotificationQueue							MsgQueue_;
+
+		std::map<std::string, std::unique_ptr<TelemetryClient> >		Clients_;			// 	uuid -> client
 
 		TelemetryStream() noexcept:
 			SubSystemServer("TelemetryServer", "TELEMETRY-SVR", "openwifi.telemetry") {

src/UI_GW_WebSocketNotifications.cpp

@@ -0,0 +1,134 @@
+//
+// Created by stephane bourque on 2022-10-29.
+//
+
+#include "UI_GW_WebSocketNotifications.h"
+
+namespace OpenWifi {
+	inline void WebNotificationSingleDevice::to_json(Poco::JSON::Object &Obj) const {
+		RESTAPI_utils::field_to_json(Obj,"serialNumber", serialNumber);
+	}
+
+	inline bool WebNotificationSingleDevice::from_json(const Poco::JSON::Object::Ptr &Obj) {
+		try {
+			RESTAPI_utils::field_from_json(Obj,"serialNumber", serialNumber);
+			return true;
+		} catch (...) {
+
+		}
+		return false;
+	}
+
+	inline void WebNotificationSingleDeviceConfigurationChange::to_json(Poco::JSON::Object &Obj) const {
+		RESTAPI_utils::field_to_json(Obj,"serialNumber", serialNumber);
+		RESTAPI_utils::field_to_json(Obj,"oldUUID", oldUUID);
+		RESTAPI_utils::field_to_json(Obj,"newUUID", newUUID);
+	}
+
+	inline bool WebNotificationSingleDeviceConfigurationChange::from_json(const Poco::JSON::Object::Ptr &Obj) {
+		try {
+			RESTAPI_utils::field_from_json(Obj,"serialNumber", serialNumber);
+			RESTAPI_utils::field_from_json(Obj,"oldUUID", oldUUID);
+			RESTAPI_utils::field_from_json(Obj,"newUUID", newUUID);
+			return true;
+		} catch (...) {
+
+		}
+		return false;
+	}
+
+	inline void WebNotificationSingleDeviceFirmwareChange::to_json(Poco::JSON::Object &Obj) const {
+		RESTAPI_utils::field_to_json(Obj,"serialNumber", serialNumber);
+		RESTAPI_utils::field_to_json(Obj,"newFirmware", newFirmware);
+	}
+
+	inline bool WebNotificationSingleDeviceFirmwareChange::from_json(const Poco::JSON::Object::Ptr &Obj) {
+		try {
+			RESTAPI_utils::field_from_json(Obj,"serialNumber", serialNumber);
+			RESTAPI_utils::field_from_json(Obj,"newFirmware", newFirmware);
+			return true;
+		} catch (...) {
+
+		}
+		return false;
+	}
+
+	inline void WebSocketClientNotificationNumberOfConnection::to_json(Poco::JSON::Object &Obj) const {
+		RESTAPI_utils::field_to_json(Obj,"numberOfDevices", numberOfDevices);
+		RESTAPI_utils::field_to_json(Obj,"averageConnectedTime", averageConnectedTime);
+		RESTAPI_utils::field_to_json(Obj,"numberOfConnectingDevices", numberOfConnectingDevices);
+	}
+
+	inline bool WebSocketClientNotificationNumberOfConnection::from_json(const Poco::JSON::Object::Ptr &Obj) {
+		try {
+			RESTAPI_utils::field_from_json(Obj,"numberOfDevices", numberOfDevices);
+			RESTAPI_utils::field_from_json(Obj,"averageConnectedTime", averageConnectedTime);
+			RESTAPI_utils::field_from_json(Obj,"numberOfConnectingDevices", numberOfConnectingDevices);
+			return true;
+		} catch (...) {
+
+		}
+		return false;
+	}
+
+	void WebSocketClientNotificationNumberOfConnections(WebSocketClientNotificationNumberOfConnection_t &N) {
+		N.type = "device_connections_statistics";
+		UI_WebSocketClientServer()->SendNotification(N);
+	}
+	void WebSocketClientNotificationNumberOfConnections(const std::string & User, WebSocketClientNotificationNumberOfConnection_t &N) {
+		N.type = "device_connections_statistics";
+		UI_WebSocketClientServer()->SendUserNotification(User,N);
+	}
+
+	void WebSocketClientNotificationDeviceConfigurationChange(WebNotificationSingleDeviceConfigurationChange_t &N) {
+		N.type = "device_configuration_upgrade";
+		UI_WebSocketClientServer()->SendNotification(N);
+	}
+
+	void WebSocketClientNotificationDeviceConfigurationChange(const std::string & User, WebNotificationSingleDeviceConfigurationChange_t &N) {
+		N.type = "device_configuration_upgrade";
+		UI_WebSocketClientServer()->SendUserNotification(User,N);
+	}
+
+	void WebSocketClientNotificationDeviceFirmwareUpdated(WebNotificationSingleDeviceFirmwareChange_t &N) {
+		N.type = "device_firmware_upgrade";
+		UI_WebSocketClientServer()->SendNotification(N);
+	}
+
+	void WebSocketClientNotificationDeviceFirmwareUpdated(const std::string & User, WebNotificationSingleDeviceFirmwareChange_t &N){
+		N.type = "device_firmware_upgrade";
+		UI_WebSocketClientServer()->SendUserNotification(User,N);
+	}
+
+	void WebSocketClientNotificationDeviceConnected(WebNotificationSingleDevice_t &N){
+		N.type = "device_connection";
+		UI_WebSocketClientServer()->SendNotification(N);
+	}
+
+	void WebSocketClientNotificationDeviceConnected(const std::string & User, WebNotificationSingleDevice_t &N){
+		N.type = "device_connection";
+		UI_WebSocketClientServer()->SendUserNotification(User,N);
+	}
+
+	void WebSocketClientNotificationDeviceDisconnected(const std::string & User, WebNotificationSingleDevice_t &N){
+		N.type = "device_disconnection";
+		UI_WebSocketClientServer()->SendUserNotification(User,N);
+	}
+
+	void WebSocketClientNotificationDeviceDisconnected(WebNotificationSingleDevice_t &N){
+		N.type = "device_disconnection";
+		UI_WebSocketClientServer()->SendNotification(N);
+	}
+
+	void WebSocketClientNotificationDeviceStatistics(const std::string & User, WebNotificationSingleDevice_t &N){
+		N.type = "device_statistics";
+		UI_WebSocketClientServer()->SendUserNotification(User,N);
+	}
+
+	void WebSocketClientNotificationDeviceStatistics(WebNotificationSingleDevice_t &N){
+		N.type = "device_statistics";
+		UI_WebSocketClientServer()->SendNotification(N);
+	}
+
+
+}

src/UI_GW_WebSocketNotifications.h

@@ -0,0 +1,61 @@
+//
+// Created by stephane bourque on 2022-10-29.
+//
+
+#pragma once
+
+#include "framework/UI_WebSocketClientNotifications.h"
+#include "framework/UI_WebSocketClientServer.h"
+
+namespace OpenWifi {
+	struct WebNotificationSingleDevice {
+		std::string		serialNumber;
+		inline void to_json(Poco::JSON::Object &Obj) const ;
+		inline bool from_json(const Poco::JSON::Object::Ptr &Obj);
+	};
+
+	struct WebNotificationSingleDeviceConfigurationChange {
+		std::string		serialNumber;
+		uint64_t 		oldUUID;
+		uint64_t 		newUUID;
+
+		inline void to_json(Poco::JSON::Object &Obj) const ;
+		inline bool from_json(const Poco::JSON::Object::Ptr &Obj);
+	};
+
+	struct WebNotificationSingleDeviceFirmwareChange {
+		std::string		serialNumber;
+		std::string		newFirmware;
+		inline void to_json(Poco::JSON::Object &Obj) const ;
+		inline bool from_json(const Poco::JSON::Object::Ptr &Obj);
+	};
+
+	struct WebSocketClientNotificationNumberOfConnection {
+		std::uint64_t 	numberOfDevices=0;
+		std::uint64_t 	averageConnectedTime=0;
+		std::uint64_t 	numberOfConnectingDevices=0;
+
+		inline void to_json(Poco::JSON::Object &Obj) const ;
+		inline bool from_json(const Poco::JSON::Object::Ptr &Obj);
+	};
+
+	typedef WebSocketNotification<WebNotificationSingleDevice> WebNotificationSingleDevice_t;
+	typedef WebSocketNotification<WebNotificationSingleDeviceConfigurationChange> WebNotificationSingleDeviceConfigurationChange_t;
+	typedef WebSocketNotification<WebNotificationSingleDeviceFirmwareChange> WebNotificationSingleDeviceFirmwareChange_t;
+	typedef WebSocketNotification<WebSocketClientNotificationNumberOfConnection> WebSocketClientNotificationNumberOfConnection_t;
+
+	void WebSocketClientNotificationNumberOfConnections(WebSocketClientNotificationNumberOfConnection_t &N);
+	void WebSocketClientNotificationDeviceConfigurationChange(WebNotificationSingleDeviceConfigurationChange_t &N);
+	void WebSocketClientNotificationDeviceFirmwareUpdated(WebNotificationSingleDeviceFirmwareChange_t &);
+	void WebSocketClientNotificationDeviceConnected(WebNotificationSingleDevice_t &N);
+	void WebSocketClientNotificationDeviceDisconnected(WebNotificationSingleDevice_t &N);
+	void WebSocketClientNotificationDeviceStatistics(WebNotificationSingleDevice_t &N);
+
+	void WebSocketClientNotificationNumberOfConnections(const std::string & User, WebSocketClientNotificationNumberOfConnection_t &N);
+	void WebSocketClientNotificationDeviceConfigurationChange(const std::string & User, WebNotificationSingleDeviceConfigurationChange_t &N);
+	void WebSocketClientNotificationDeviceFirmwareUpdated(const std::string & User, WebNotificationSingleDeviceFirmwareChange_t &);
+	void WebSocketClientNotificationDeviceConnected(const std::string & User, WebNotificationSingleDevice_t &N);
+	void WebSocketClientNotificationDeviceDisconnected(const std::string & User, WebNotificationSingleDevice_t &N);
+	void WebSocketClientNotificationDeviceStatistics(const std::string & User, WebNotificationSingleDevice_t &N);
+
+};

src/VenueBroadcaster.h

@@ -4,10 +4,16 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "Poco/Notification.h"
+#include "Poco/NotificationQueue.h"
+
 #include "sdks/sdk_prov.h"
 #include "AP_WS_Server.h"
 
+#include "framework/MicroServiceFuncs.h"
+#include "framework/SubSystemServer.h"
+#include "framework/utils.h"
+
 namespace OpenWifi {
 
 	class VenueBroadcastNotification : public Poco::Notification {
@@ -20,7 +26,7 @@ namespace OpenWifi {
 		}
 		std::string 	SourceSerialNumber_;
 		std::string 	Data_;
-		uint64_t 		TimeStamp_=OpenWifi::Now();
+		uint64_t 		TimeStamp_=Utils::Now();
 	};
 
 	class VenueBroadcaster : public SubSystemServer, Poco::Runnable {
@@ -31,7 +37,7 @@ namespace OpenWifi {
 		}
 
 		inline int Start() override {
-			Enabled_ = MicroService::instance().ConfigGetBool("venue_broadcast.enabled",true);
+			Enabled_ = MicroServiceConfigGetBool("venue_broadcast.enabled",true);
 			if(Enabled_) {
 				BroadcastManager_.start(*this);
 			}
@@ -54,7 +60,7 @@ namespace OpenWifi {
 
 
 		struct VenueInfo {
-			uint64_t 			timestamp=OpenWifi::Now();
+			uint64_t 			timestamp=Utils::Now();
 			Types::StringVec 	serialNumbers;
 		};
 
@@ -62,7 +68,7 @@ namespace OpenWifi {
 			//	Can we find our serial number in any of the lists so far...
 			for(const auto &venue:Venues_) {
 				auto entry = std::find(venue.second.serialNumbers.begin(),venue.second.serialNumbers.end(),Source);
-				if(entry!=venue.second.serialNumbers.end() && (OpenWifi::Now()-venue.second.timestamp)<600) {
+				if(entry!=venue.second.serialNumbers.end() && (Utils::Now()-venue.second.timestamp)<600) {
 					SerialNumbers = venue.second.serialNumbers;
 					auto entry2 = std::find(SerialNumbers.begin(),SerialNumbers.end(),Source);
 					SerialNumbers.erase(entry2);
@@ -75,7 +81,7 @@ namespace OpenWifi {
 			Types::StringVec 	TmpSerialNumbers;
 			if(OpenWifi::SDK::Prov::GetSerialNumbersForVenueOfSerialNumber(Source,Venue,TmpSerialNumbers,Logger())) {
 				std::sort(TmpSerialNumbers.begin(),TmpSerialNumbers.end());
-				VenueInfo	V{.timestamp=OpenWifi::Now(), .serialNumbers=TmpSerialNumbers};
+				VenueInfo	V{.timestamp=Utils::Now(), .serialNumbers=TmpSerialNumbers};
 				Venues_[Venue] = V;
 				auto p = std::find(TmpSerialNumbers.begin(),TmpSerialNumbers.end(),Source);
 				if(p!=TmpSerialNumbers.end()) {

src/framework/ALBserver.cpp

@@ -0,0 +1,71 @@
+//
+// Created by stephane bourque on 2022-10-25.
+//
+
+#include "ALBserver.h"
+
+#include "framework/utils.h"
+#include "framework/MicroServiceFuncs.h"
+#include "fmt/format.h"
+
+namespace OpenWifi {
+
+	void ALBRequestHandler::handleRequest([[maybe_unused]] Poco::Net::HTTPServerRequest& Request, Poco::Net::HTTPServerResponse& Response) {
+		Utils::SetThreadName("alb-request");
+		try {
+			if((id_ % 100) == 0) {
+				Logger_.debug(fmt::format("ALB-REQUEST({}): ALB Request {}.", Request.clientAddress().toString(), id_));
+			}
+			Response.setChunkedTransferEncoding(true);
+			Response.setContentType("text/html");
+			Response.setDate(Poco::Timestamp());
+			Response.setStatus(Poco::Net::HTTPResponse::HTTP_OK);
+			Response.setKeepAlive(true);
+			Response.set("Connection", "keep-alive");
+			Response.setVersion(Poco::Net::HTTPMessage::HTTP_1_1);
+			std::ostream &Answer = Response.send();
+			Answer << "process Alive and kicking!";
+		} catch (...) {
+
+		}
+	}
+
+	ALBRequestHandlerFactory::ALBRequestHandlerFactory(Poco::Logger & L):
+		Logger_(L) {
+	}
+
+	ALBRequestHandler* ALBRequestHandlerFactory::createRequestHandler(const Poco::Net::HTTPServerRequest& request) {
+		if (request.getURI() == "/")
+			return new ALBRequestHandler(Logger_, req_id_++);
+		else
+			return nullptr;
+	}
+
+	ALBHealthCheckServer::ALBHealthCheckServer() :
+		  SubSystemServer("ALBHealthCheckServer", "ALB-SVR", "alb")
+	{
+	}
+
+	int ALBHealthCheckServer::Start() {
+		if(MicroServiceConfigGetBool("alb.enable",false)) {
+            poco_information(Logger(),"Starting...");
+			Running_=true;
+			Port_ = (int)MicroServiceConfigGetInt("alb.port",15015);
+			Socket_ = std::make_unique<Poco::Net::ServerSocket>(Port_);
+			auto Params = new Poco::Net::HTTPServerParams;
+			Params->setName("ws:alb");
+			Server_ = std::make_unique<Poco::Net::HTTPServer>(new ALBRequestHandlerFactory(Logger()), *Socket_, Params);
+			Server_->start();
+		}
+
+		return 0;
+	}
+
+	void ALBHealthCheckServer::Stop() {
+		poco_information(Logger(),"Stopping...");
+		if(Running_)
+			Server_->stopAll(true);
+		poco_information(Logger(),"Stopped...");
+	}
+
+} // namespace OpenWifi

src/framework/ALBserver.h

@@ -0,0 +1,63 @@
+//
+// Created by stephane bourque on 2022-10-25.
+//
+
+#pragma once
+
+#include "framework/SubSystemServer.h"
+
+#include "Poco/Net/HTTPRequestHandler.h"
+#include "Poco/Net/HTTPServerRequest.h"
+#include "Poco/Net/HTTPServerResponse.h"
+#include "Poco/Net/HTTPRequestHandlerFactory.h"
+#include "Poco/Net/HTTPServer.h"
+
+namespace OpenWifi {
+
+	class ALBRequestHandler: public Poco::Net::HTTPRequestHandler {
+	  public:
+		explicit ALBRequestHandler(Poco::Logger & L, uint64_t id)
+                : Logger_(L), id_(id) {
+        }
+
+		void handleRequest([[maybe_unused]] Poco::Net::HTTPServerRequest& Request, Poco::Net::HTTPServerResponse& Response) override;
+
+	  private:
+		Poco::Logger 	& Logger_;
+		uint64_t 		id_;
+	};
+
+	class ALBRequestHandlerFactory: public Poco::Net::HTTPRequestHandlerFactory
+	{
+	  public:
+		explicit ALBRequestHandlerFactory(Poco::Logger & L);
+		ALBRequestHandler* createRequestHandler(const Poco::Net::HTTPServerRequest& request) override;
+
+	  private:
+		Poco::Logger	                            &Logger_;
+		inline static std::atomic_uint64_t 			req_id_=1;
+	};
+
+	class ALBHealthCheckServer : public SubSystemServer {
+	  public:
+		ALBHealthCheckServer();
+
+		static auto instance() {
+			static auto instance = new ALBHealthCheckServer;
+			return instance;
+		}
+
+		int Start() override;
+		void Stop() override;
+
+	  private:
+		std::unique_ptr<Poco::Net::HTTPServer>   	Server_;
+		std::unique_ptr<Poco::Net::ServerSocket> 	Socket_;
+		int                                     	Port_ = 0;
+		mutable std::atomic_bool                    Running_=false;
+	};
+
+	inline auto ALBHealthCheckServer() { return ALBHealthCheckServer::instance(); }
+
+} // namespace OpenWifi
+

src/framework/API_Proxy.h

@@ -4,8 +4,14 @@
 
 #pragma once
 
-#include "framework/MicroService.h"
+#include "Poco/Logger.h"
 #include "Poco/JSON/Parser.h"
+#include "Poco/Net/HTTPServerRequest.h"
+#include "Poco/Net/HTTPServerResponse.h"
+#include "Poco/Net/HTTPSClientSession.h"
+#include "Poco/URI.h"
+
+#include "framework/MicroServiceFuncs.h"
 
 namespace OpenWifi {
     inline void API_Proxy( Poco::Logger &Logger,
@@ -15,7 +21,7 @@ namespace OpenWifi {
                     const char * PathRewrite,
                     uint64_t msTimeout_ = 10000 ) {
         try {
-            auto Services = MicroService::instance().GetServices(ServiceType);
+            auto Services = MicroServiceGetServices(ServiceType);
             for(auto const &Svc:Services) {
                 Poco::URI   SourceURI(Request->getURI());
                 Poco::URI	DestinationURI(Svc.PrivateEndPoint);
@@ -35,7 +41,7 @@ namespace OpenWifi {
                     ProxyRequest.add("Authorization", Request->get("Authorization"));
                 } else {
                     ProxyRequest.add("X-API-KEY", Svc.AccessKey);
-                    ProxyRequest.add("X-INTERNAL-NAME", MicroService::instance().PublicEndPoint());
+                    ProxyRequest.add("X-INTERNAL-NAME", MicroServicePublicEndPoint());
                 }
 
                 if(Request->getMethod() == Poco::Net::HTTPRequest::HTTP_DELETE) {

src/framework/AppServiceRegistry.h

@@ -0,0 +1,102 @@
+//
+// Created by stephane bourque on 2022-10-25.
+//
+
+#pragma once
+
+#include <string>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+
+#include "Poco/StreamCopier.h"
+#include "Poco/File.h"
+
+#include "framework/MicroServiceFuncs.h"
+
+#include "nlohmann/json.hpp"
+
+namespace OpenWifi {
+
+
+	class AppServiceRegistry {
+	  public:
+		AppServiceRegistry() {
+			FileName = MicroServiceDataDirectory() + "/registry.json";
+			Poco::File F(FileName);
+
+			try {
+				if(F.exists()) {
+					std::ostringstream  OS;
+					std::ifstream       IF(FileName);
+					Poco::StreamCopier::copyStream(IF, OS);
+					Registry_ = nlohmann::json::parse(OS.str());
+				}
+			} catch (...) {
+				Registry_ = nlohmann::json::parse("{}");
+			}
+		}
+
+		static AppServiceRegistry & instance() {
+			static auto instance_= new AppServiceRegistry;
+			return *instance_;
+		}
+
+		inline ~AppServiceRegistry() {
+			Save();
+		}
+
+		inline void Save() {
+			std::istringstream  IS( to_string(Registry_));
+			std::ofstream       OF;
+			OF.open(FileName,std::ios::binary | std::ios::trunc);
+			Poco::StreamCopier::copyStream(IS, OF);
+		}
+
+		inline void Set(const char *Key, uint64_t Value ) {
+			Registry_[Key] = Value;
+			Save();
+		}
+
+		inline void Set(const char *Key, const std::string &Value ) {
+			Registry_[Key] = Value;
+			Save();
+		}
+
+		inline void Set(const char *Key, bool Value ) {
+			Registry_[Key] = Value;
+			Save();
+		}
+
+		inline bool Get(const char *Key, bool & Value ) {
+			if(Registry_[Key].is_boolean()) {
+				Value = Registry_[Key].get<bool>();
+				return true;
+			}
+			return false;
+		}
+
+		inline bool Get(const char *Key, uint64_t & Value ) {
+			if(Registry_[Key].is_number_unsigned()) {
+				Value = Registry_[Key].get<uint64_t>();
+				return true;
+			}
+			return false;
+		}
+
+		inline bool Get(const char *Key, std::string & Value ) {
+			if(Registry_[Key].is_string()) {
+				Value = Registry_[Key].get<std::string>();
+				return true;
+			}
+			return false;
+		}
+
+	  private:
+		std::string         FileName;
+		nlohmann::json      Registry_;
+	};
+
+	inline auto AppServiceRegistry() { return AppServiceRegistry::instance(); }
+
+}

src/framework/AuthClient.cpp

@@ -0,0 +1,71 @@
+//
+// Created by stephane bourque on 2022-10-25.
+//
+
+#include "Poco/Net/HTTPServerResponse.h"
+
+#include "framework/AuthClient.h"
+#include "framework/MicroServiceNames.h"
+#include "framework/OpenAPIRequests.h"
+#include "fmt/format.h"
+
+namespace OpenWifi {
+
+	bool AuthClient::RetrieveTokenInformation(const std::string & SessionToken,
+										 SecurityObjects::UserInfoAndPolicy & UInfo,
+										 std::uint64_t TID,
+										 bool & Expired, bool & Contacted, bool Sub) {
+		try {
+			Types::StringPairVec QueryData;
+			QueryData.push_back(std::make_pair("token",SessionToken));
+			OpenAPIRequestGet	Req(    uSERVICE_SECURITY,
+								  Sub ? "/api/v1/validateSubToken" : "/api/v1/validateToken",
+								  QueryData,
+								  10000);
+			Poco::JSON::Object::Ptr Response;
+
+			auto StatusCode = Req.Do(Response);
+			if(StatusCode==Poco::Net::HTTPServerResponse::HTTP_GATEWAY_TIMEOUT) {
+				Contacted = false;
+				return false;
+			}
+
+			Contacted = true;
+			if(StatusCode==Poco::Net::HTTPServerResponse::HTTP_OK) {
+				if(Response->has("tokenInfo") && Response->has("userInfo")) {
+					UInfo.from_json(Response);
+					if(IsTokenExpired(UInfo.webtoken)) {
+						Expired = true;
+						return false;
+					}
+					Expired = false;
+					Cache_.update(SessionToken, UInfo);
+					return true;
+				} else {
+					return false;
+				}
+			}
+		} catch (...) {
+			poco_error(Logger(),fmt::format("Failed to retrieve token={} for TID={}", SessionToken, TID));
+		}
+		Expired = false;
+		return false;
+	}
+
+	bool AuthClient::IsAuthorized(const std::string &SessionToken, SecurityObjects::UserInfoAndPolicy & UInfo,
+							 std::uint64_t TID,
+							 bool & Expired, bool & Contacted, bool Sub) {
+		auto User = Cache_.get(SessionToken);
+		if(!User.isNull()) {
+			if(IsTokenExpired(User->webtoken)) {
+				Expired = true;
+				return false;
+			}
+			Expired = false;
+			UInfo = *User;
+			return true;
+		}
+		return RetrieveTokenInformation(SessionToken, UInfo, TID, Expired, Contacted, Sub);
+	}
+
+} // namespace OpenWifi

src/framework/AuthClient.h

@@ -0,0 +1,60 @@
+//
+// Created by stephane bourque on 2022-10-25.
+//
+
+#pragma once
+
+#include "framework/SubSystemServer.h"
+#include "RESTObjects/RESTAPI_SecurityObjects.h"
+#include "Poco/ExpireLRUCache.h"
+#include "framework/utils.h"
+
+namespace OpenWifi {
+
+	class AuthClient : public SubSystemServer {
+	  public:
+		explicit AuthClient() noexcept:
+			 SubSystemServer("Authentication", "AUTH-CLNT", "authentication")
+		{
+		}
+
+		static auto instance() {
+			static auto instance_ = new AuthClient;
+			return instance_;
+		}
+
+		inline int Start() override {
+			return 0;
+		}
+
+		inline void Stop() override {
+			poco_information(Logger(),"Stopping...");
+			std::lock_guard	G(Mutex_);
+			Cache_.clear();
+			poco_information(Logger(),"Stopped...");
+		}
+
+		inline void RemovedCachedToken(const std::string &Token) {
+			Cache_.remove(Token);
+		}
+
+		inline static bool IsTokenExpired(const SecurityObjects::WebToken &T) {
+			return ((T.expires_in_+T.created_) < Utils::Now());
+		}
+
+		bool RetrieveTokenInformation(const std::string & SessionToken,
+			SecurityObjects::UserInfoAndPolicy & UInfo,
+			std::uint64_t TID,
+		bool & Expired, bool & Contacted, bool Sub=false);
+		bool IsAuthorized(const std::string &SessionToken, SecurityObjects::UserInfoAndPolicy & UInfo,
+								 std::uint64_t TID,
+								 bool & Expired, bool & Contacted, bool Sub = false);
+
+	  private:
+		Poco::ExpireLRUCache<std::string,OpenWifi::SecurityObjects::UserInfoAndPolicy>      Cache_{512,1200000 };
+	};
+
+	inline auto AuthClient() { return AuthClient::instance(); }
+
+} // namespace OpenWifi
+

src/framework/CIDR.h

@@ -0,0 +1,155 @@
+//
+// Created by stephane bourque on 2022-10-25.
+//
+
+#pragma once
+
+#include <string>
+
+#include "Poco/Net/IPAddress.h"
+#include "Poco/StringTokenizer.h"
+
+#include "framework/OpenWifiTypes.h"
+
+namespace OpenWifi::CIDR {
+
+	static bool cidr_match(const in_addr &addr, const in_addr &net, uint8_t bits) {
+		if (bits == 0) {
+			return true;
+		}
+		return !((addr.s_addr ^ net.s_addr) & htonl(0xFFFFFFFFu << (32 - bits)));
+	}
+
+	static bool cidr6_match(const in6_addr &address, const in6_addr &network, uint8_t bits) {
+	#ifdef __linux__
+		const uint32_t *a = address.s6_addr32;
+		const uint32_t *n = network.s6_addr32;
+	#else
+		const uint32_t *a = address.__u6_addr.__u6_addr32;
+		const uint32_t *n = network.__u6_addr.__u6_addr32;
+	#endif
+		int bits_whole, bits_incomplete;
+		bits_whole = bits >> 5;		   // number of whole u32
+		bits_incomplete = bits & 0x1F; // number of bits in incomplete u32
+		if (bits_whole) {
+			if (memcmp(a, n, bits_whole << 2) != 0) {
+				return false;
+			}
+		}
+		if (bits_incomplete) {
+			uint32_t mask = htonl((0xFFFFFFFFu) << (32 - bits_incomplete));
+			if ((a[bits_whole] ^ n[bits_whole]) & mask) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	static bool ConvertStringToLong(const char *S, unsigned long &L) {
+		char *end;
+		L = std::strtol(S, &end, 10);
+		return end != S;
+	}
+
+	static bool CidrIPinRange(const Poco::Net::IPAddress &IP, const std::string &Range) {
+		Poco::StringTokenizer TimeTokens(Range, "/", Poco::StringTokenizer::TOK_TRIM);
+
+		Poco::Net::IPAddress RangeIP;
+		if (Poco::Net::IPAddress::tryParse(TimeTokens[0], RangeIP)) {
+			if (TimeTokens.count() == 2) {
+				if (RangeIP.family() == Poco::Net::IPAddress::IPv4) {
+					unsigned long MaskLength;
+					if (ConvertStringToLong(TimeTokens[1].c_str(), MaskLength)) {
+						return cidr_match(*static_cast<const in_addr *>(RangeIP.addr()),
+										  *static_cast<const in_addr *>(IP.addr()), MaskLength);
+					}
+				} else if (RangeIP.family() == Poco::Net::IPAddress::IPv6) {
+					unsigned long MaskLength;
+					if (ConvertStringToLong(TimeTokens[1].c_str(), MaskLength)) {
+						return cidr6_match(*static_cast<const in6_addr *>(RangeIP.addr()),
+										   *static_cast<const in6_addr *>(IP.addr()), MaskLength);
+					}
+				}
+			}
+			return false;
+		}
+		return false;
+	}
+
+	//
+	//  Ranges can be a single IP, of IP1-IP2, of A set of IPs: IP1,IP2,IP3, or a cidr IP/24
+	//  These can work for IPv6 too...
+	//
+	static bool ValidateRange(const std::string &R) {
+
+		auto Tokens = Poco::StringTokenizer(R, "-");
+		if (Tokens.count() == 2) {
+			Poco::Net::IPAddress a, b;
+			if (!Poco::Net::IPAddress::tryParse(Tokens[0], a) &&
+				Poco::Net::IPAddress::tryParse(Tokens[1], b))
+				return false;
+			return a.family() == b.family();
+		}
+
+		Tokens = Poco::StringTokenizer(R, ",");
+		if (Tokens.count() > 1) {
+			return std::all_of(Tokens.begin(), Tokens.end(), [](const std::string &A) {
+				Poco::Net::IPAddress a;
+				return Poco::Net::IPAddress::tryParse(A, a);
+			});
+		}
+
+		Tokens = Poco::StringTokenizer(R, "/");
+		if (Tokens.count() == 2) {
+			Poco::Net::IPAddress a;
+			if (!Poco::Net::IPAddress::tryParse(Tokens[0], a))
+				return false;
+			if (std::atoi(Tokens[1].c_str()) == 0)
+				return false;
+			return true;
+		}
+
+		Poco::Net::IPAddress a;
+		return Poco::Net::IPAddress::tryParse(R, a);
+	}
+
+	static bool IpInRange(const Poco::Net::IPAddress &target, const std::string &R) {
+
+		auto Tokens = Poco::StringTokenizer(R, "-");
+		if (Tokens.count() == 2) {
+			auto a = Poco::Net::IPAddress::parse(Tokens[0]);
+			auto b = Poco::Net::IPAddress::parse(Tokens[1]);
+			if (target.family() != a.family())
+				return false;
+			return (a <= target && b >= target);
+		}
+
+		Tokens = Poco::StringTokenizer(R, ",");
+		if (Tokens.count() > 1) {
+			return std::any_of(Tokens.begin(), Tokens.end(), [target](const std::string &Element) {
+				return Poco::Net::IPAddress::parse(Element) == target;
+			});
+		}
+
+		Tokens = Poco::StringTokenizer(R, "/");
+		if (Tokens.count() == 2) {
+			return CidrIPinRange(target, R);
+		}
+
+		return Poco::Net::IPAddress::parse(R) == target;
+	}
+
+	[[nodiscard]] inline bool IpInRanges(const std::string &IP, const Types::StringVec &R) {
+		Poco::Net::IPAddress Target;
+
+		if (!Poco::Net::IPAddress::tryParse(IP, Target))
+			return false;
+
+		return std::any_of(cbegin(R), cend(R),
+						   [Target](const std::string &i) { return IpInRange(Target, i); });
+	}
+
+	[[nodiscard]] inline bool ValidateIpRanges(const Types::StringVec &Ranges) {
+		return std::all_of(cbegin(Ranges), cend(Ranges), ValidateRange);
+	}
+}