diff --git a/.gitignore b/.gitignore
index f1e1d9ba..80f55ec1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -21,10 +21,12 @@ _deps
 /docker-compose/.env
 /docker-compose/.env_*
 /cmake-build/
-/uploads/
 test_scripts/curl/token.json
 .vscode/c_cpp_properties.json
 test_scripts/curl/result.json
 *.swp
 helm/charts/*
 !helm/charts/.gitkeep
+/portal-test/
+/src/ow_version.h
+
diff --git a/.idea/.gitignore b/.idea/.gitignore
index 73f69e09..b0811f16 100644
--- a/.idea/.gitignore
+++ b/.idea/.gitignore
@@ -6,3 +6,5 @@
 /dataSources.local.xml
 # Editor-based HTTP Client requests
 /httpRequests/
+# GitHub Copilot persisted chat sessions
+/copilot/chatSessions
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 89cf9396..501b2dd1 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,5 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.9 (wlan-cloud-ucentralgw)" />
+  </component>
   <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
   <component name="CidrRootsConfiguration">
     <excludeRoots>
diff --git a/BUILDING.md b/BUILDING.md
index b627e06d..17770aec 100644
--- a/BUILDING.md
+++ b/BUILDING.md
@@ -1,5 +1,5 @@
 # Building from source
-In order to build the OWGW, you will need to install its dependencies, which includes the following:
+In order to build OWGW, you will need to install its dependencies, which includes the following:
 - cmake
 - boost
 - POCO 1.10.1 or later
@@ -12,43 +12,43 @@ In order to build the OWGW, you will need to install its dependencies, which inc
 
 The build is done in 2 parts. The first part is to build a local copy of the framework tailored to your environment. This
 framework is called [Poco](https://github.com/pocoproject/poco). The version used in this project has a couple of fixes
-from the master copy needed for cmake. Please use the version of this [Poco fix](https://github.com/AriliaWireless/poco). Building
+from the master copy needed for cmake. Please use the version of this [Poco fix](https://github.com/Telecominfraproject/wlan-cloud-lib-poco). Building
 Poco may take several minutes depending on the platform you are building on.
 
 ## Ubuntu
 These instructions have proven to work on Ubuntu 20.4.
 ```bash
-sudo apt install git cmake g++ libssl-dev libmariadb-dev 
-sudo apt install libpq-dev libaprutil1-dev apache2-dev libboost-all-dev
-sudo apt install librdkafka-dev // default-libmysqlclient-dev
-sudo apt install nlohmann-json-dev
+sudo apt install git cmake g++ libssl-dev libmariadb-dev \
+    libpq-dev libaprutil1-dev apache2-dev libboost-all-dev \
+    librdkafka-dev // default-libmysqlclient-dev \
+    nlohmann-json-dev
 
-cd ~
-git clone https://github.com/AriliaWireless/poco --branch poco-tip-v2
+git clone https://github.com/Telecominfraproject/wlan-cloud-lib-poco --branch poco-tip-v1 poco
 cd poco
 mkdir cmake-build
 cd cmake-build
 cmake ..
 cmake --build . --config Release
 sudo cmake --build . --target install
+cd ../..
 
-cd ~
-git clone https://github.com/AriliaWireless/cppkafka --branch tip-v1
+git clone https://github.com/Telecominfraproject/wlan-cloud-lib-cppkafka --branch tip-v1 cppkafka
 cd cppkafka
 mkdir cmake-build
 cd cmake-build
 cmake ..
 cmake --build . --config Release
 sudo cmake --build . --target install
+cd ../..
 
-cd ~
-git clone https://github.com/AriliaWireless/valijson --branch tip-v1
+git clone https://github.com/Telecominfraproject/wlan-cloud-lib-valijson --branch tip-v1 valijson
 cd valijson
 mkdir cmake-build
 cd cmake-build
 cmake ..
 cmake --build . --config Release
 sudo cmake --build . --target install
+cd ../..
 
 git clone https://github.com/fmtlib/fmt --branch 9.0.0 /fmtlib
 cd fmtlib
@@ -57,56 +57,59 @@ cd cmake-build
 cmake ..
 make
 make install
+cd ../..
 
-cd ~
 git clone https://github.com/Telecominfraproject/wlan-cloud-ucentralgw
 cd wlan-cloud-ucentralgw
 mkdir cmake-build
 cd cmake-build
 cmake ..
 make -j 8
+cd ../..
 ```
 
 ## Fedora
 The following instructions have proven to work on Fedora 33
 ```bash
-sudo yum install cmake g++ openssl-devel mysql-devel mysql apr-util-devel boost boost-devel
-sudo yum install yaml-cpp-devel lua-devel 
+sudo yum install cmake g++ openssl-devel mysql-devel mysql apr-util-devel boost boost-devel \
+    yaml-cpp-devel lua-devel
 sudo dnf install postgresql.x86_64 librdkafka-devel
 sudo dnf install postgresql-devel json-devel
 
-git clone https://github.com/AriliaWireless/poco --branch poco-tip-v2
+git clone https://github.com/Telecominfraproject/wlan-cloud-lib-poco --branch poco-tip-v1 poco
 cd poco
 mkdir cmake-build
 cd cmake-build
 cmake ..
 cmake --build . --config Release
 sudo cmake --build . --target install
+cd ../..
 
-git clone https://github.com/AriliaWireless/cppkafka --branch tip-v1
+git clone https://github.com/Telecominfraproject/wlan-cloud-lib-cppkafka --branch tip-v1 cppkafka
 cd cppkafka
 mkdir cmake-build
 cd cmake-build
 cmake ..
 cmake --build . --config Release
 sudo cmake --build . --target install
+cd ../..
 
-cd ~
-git clone https://github.com/AriliaWireless/valijson --branch tip-v1
+git clone https://github.com/Telecominfraproject/wlan-cloud-lib-valijson --branch tip-v1 valijson
 cd valijson
 mkdir cmake-build
 cd cmake-build
 cmake ..
 cmake --build . --config Release
 sudo cmake --build . --target install
+cd ../..
 
-cd ~
 git clone https://github.com/Telecominfraproject/wlan-cloud-ucentralgw
 cd wlan-cloud-ucentralgw
 mkdir cmake-build
 cd cmake-build
 cmake ..
 make
+cd ../..
 ```
 
 ## macOS Build
@@ -125,7 +128,7 @@ brew install openssl \
 	nlohmann-json \
 	fmt
 
-git clone https://github.com/AriliaWireless/poco --branch poco-tip-v2
+git clone https://github.com/Telecominfraproject/wlan-cloud-lib-poco --branch poco-tip-v1 poco
 pushd poco
 mkdir cmake-build
 push cmake-build
@@ -135,7 +138,7 @@ sudo cmake --build . --target install
 popd
 popd
 
-git clone https://github.com/AriliaWireless/cppkafka --branch tip-v1
+git clone https://github.com/Telecominfraproject/wlan-cloud-lib-cppkafka --branch tip-v1 cppkafka
 pushd cppkafka
 mkdir cmake-build
 pushd cmake-build
@@ -145,10 +148,10 @@ sudo cmake --build . --target install
 popd
 popd
 
-git clone https://github.com/AriliaWireless/valijson --branch tip-v1
-cd valijson
+git clone https://github.com/Telecominfraproject/wlan-cloud-lib-valijson --branch tip-v1 valijson
+pushd valijson
 mkdir cmake-build
-cd cmake-build
+pushd cmake-build
 cmake ..
 cmake --build . --config Release
 sudo cmake --build . --target install
@@ -171,20 +174,23 @@ support. You can build with only SQLite support by not installing the packages f
 adding -DSMALL_BUILD=1 on the cmake build line.
 
 ```bash
-sudo apt install git cmake g++ libssl-dev libaprutil1-dev apache2-dev libboost-all-dev libyaml-cpp-dev
-git clone https://github.com/stephb9959/poco
+sudo apt install git cmake g++ libssl-dev libaprutil1-dev apache2-dev \
+    libboost-all-dev libyaml-cpp-dev
+
+git clone https://github.com/Telecominfraproject/wlan-cloud-lib-poco --branch poco-tip-v1 poco
 cd poco
 mkdir cmake-build
 cd cmake-build
 cmake ..
 cmake --build . --config Release
 sudo cmake --build . --target install
+cd ../..
 
-cd ~
 git clone https://github.com/Telecominfraproject/wlan-cloud-ucentralgw
 cd wlan-cloud-ucentralgw
 mkdir cmake-build
 cd cmake-build
 cmake -DSMALL_BUILD=1 ..
 make
+cd ../..
 ```
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3f0c2947..f9aa74ed 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,7 +1,8 @@
 cmake_minimum_required(VERSION 3.13)
-project(owgw VERSION 3.0.0)
+project(owgw VERSION 3.0.2)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
 
 if(UNIX AND APPLE)
     set(OPENSSL_ROOT_DIR /usr/local/opt/openssl)
@@ -148,6 +149,7 @@ add_executable( owgw
         src/RESTAPI/RESTAPI_script_handler.cpp src/RESTAPI/RESTAPI_script_handler.h
         src/RESTAPI/RESTAPI_regulatory.cpp src/RESTAPI/RESTAPI_regulatory.h
         src/RESTAPI/RESTAPI_radiussessions_handler.cpp src/RESTAPI/RESTAPI_radiussessions_handler.h
+
         src/storage/storage_blacklist.cpp src/storage/storage_tables.cpp src/storage/storage_logs.cpp
         src/storage/storage_command.cpp src/storage/storage_healthcheck.cpp src/storage/storage_statistics.cpp
         src/storage/storage_device.cpp src/storage/storage_capabilities.cpp src/storage/storage_defconfig.cpp
@@ -175,7 +177,7 @@ add_executable( owgw
         src/SDKcalls.cpp
         src/SDKcalls.h
         src/StateUtils.cpp src/StateUtils.h
-        src/AP_WS_ReactorPool.h
+        src/AP_WS_Reactor_Pool.h
         src/AP_WS_Connection.h
         src/AP_WS_Connection.cpp
         src/TelemetryClient.h src/TelemetryClient.cpp
@@ -211,7 +213,8 @@ add_executable( owgw
         src/RegulatoryInfo.cpp src/RegulatoryInfo.h
         src/RADIUSSessionTracker.cpp src/RADIUSSessionTracker.h
         src/libs/Scheduler.h src/libs/InterruptableSleep.h src/libs/ctpl_stl.h src/libs/Cron.h
-        src/GenericScheduler.cpp src/GenericScheduler.h src/framework/default_device_types.h src/AP_WS_Process_rebootLog.cpp src/AP_WS_ConfigAutoUpgrader.cpp src/AP_WS_ConfigAutoUpgrader.h src/RESTAPI/RESTAPI_default_firmwares.cpp src/RESTAPI/RESTAPI_default_firmwares.h src/RESTAPI/RESTAPI_default_firmware.cpp src/RESTAPI/RESTAPI_default_firmware.h src/storage/storage_def_firmware.cpp src/firmware_revision_cache.h src/sdks/sdk_fms.h)
+        src/GenericScheduler.cpp src/GenericScheduler.h src/framework/default_device_types.h src/AP_WS_Process_rebootLog.cpp src/AP_WS_ConfigAutoUpgrader.cpp src/AP_WS_ConfigAutoUpgrader.h src/RESTAPI/RESTAPI_default_firmwares.cpp src/RESTAPI/RESTAPI_default_firmwares.h src/RESTAPI/RESTAPI_default_firmware.cpp src/RESTAPI/RESTAPI_default_firmware.h src/storage/storage_def_firmware.cpp src/firmware_revision_cache.h src/sdks/sdk_fms.h
+        src/AP_WS_LookForUpgrade.cpp)
 
 if(NOT SMALL_BUILD)
 
diff --git a/Dockerfile b/Dockerfile
index 629f9faa..d1eb639e 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -17,8 +17,8 @@ FROM build-base AS poco-build
 
 ARG POCO_VERSION
 
-ADD https://api.github.com/repos/AriliaWireless/poco/git/refs/tags/${POCO_VERSION} version.json
-RUN git clone https://github.com/AriliaWireless/poco --branch ${POCO_VERSION} /poco
+ADD https://api.github.com/repos/Telecominfraproject/wlan-cloud-lib-poco/git/refs/tags/${POCO_VERSION} version.json
+RUN git clone https://github.com/Telecominfraproject/wlan-cloud-lib-poco --branch ${POCO_VERSION} /poco
 
 WORKDIR /poco
 RUN mkdir cmake-build
@@ -31,8 +31,8 @@ FROM build-base AS cppkafka-build
 
 ARG CPPKAFKA_VERSION
 
-ADD https://api.github.com/repos/AriliaWireless/cppkafka/git/refs/tags/${CPPKAFKA_VERSION} version.json
-RUN git clone https://github.com/AriliaWireless/cppkafka --branch ${CPPKAFKA_VERSION} /cppkafka
+ADD https://api.github.com/repos/Telecominfraproject/wlan-cloud-lib-cppkafka/git/refs/tags/${CPPKAFKA_VERSION} version.json
+RUN git clone https://github.com/Telecominfraproject/wlan-cloud-lib-cppkafka --branch ${CPPKAFKA_VERSION} /cppkafka
 
 WORKDIR /cppkafka
 RUN mkdir cmake-build
@@ -45,8 +45,8 @@ FROM build-base AS valijson-build
 
 ARG VALIJASON_VERSION
 
-ADD https://api.github.com/repos/AriliaWireless/valijson/git/refs/tags/${VALIJASON_VERSION} version.json
-RUN git clone https://github.com/AriliaWireless/valijson --branch ${VALIJASON_VERSION} /valijson
+ADD https://api.github.com/repos/Telecominfraproject/wlan-cloud-lib-valijson/git/refs/tags/${VALIJASON_VERSION} version.json
+RUN git clone https://github.com/Telecominfraproject/wlan-cloud-lib-valijson --branch ${VALIJASON_VERSION} /valijson
 
 WORKDIR /valijson
 RUN mkdir cmake-build
diff --git a/PROTOCOL.md b/PROTOCOL.md
index aaf7be1d..c84eb1fc 100644
--- a/PROTOCOL.md
+++ b/PROTOCOL.md
@@ -355,6 +355,39 @@ The device should answer:
 - 1 : the device is busy but will reboot soon. `text` may indicate why.
 - 2 : the device will not reboot. `text` contains information as to why.
 
+#### Controller wants to power-cycle PoE port(s)
+Controller sends this command to power-cycle 1 or more PoE ports
+```json
+{    "jsonrpc" : "2.0" , 
+     "method" : "powercycle" , 
+     "params" : {
+	        "serial" : <serial number> ,
+            "ports" : [ { "name" :  "Ethernet1", "cycle" : 5000}, { "name" :  "Ethernet8", "cycle" : 10000 } ],
+	        "when" : Optional - <UTC time when to reboot, 0 mean immediately, this is a suggestion>
+     },
+     "id" : <some number>
+}
+```
+
+The device should answer:
+```json
+{     "jsonrpc" : "2.0" , 
+      "result" : {
+      "serial" : <serial number> ,
+      "status" : {
+	    "error" : 0 or an error number,
+	    "text" : [ "Error 1" , "Error 2" ],
+	    "when" : <time when this will be performed as UTC seconds>,
+  	},
+  "id" : <same id from request>
+}
+```
+
+###### Error codes
+- 0 : is rebooting at `when` seconds.
+- 1 : the device is busy but will reboot soon. `text` may indicate why.
+- 2 : the device will not reboot. `text` contains information as to why.
+
 #### Controller wants the device to upgrade its firmware
 Controller sends this command when it believes the device should upgrade its firmware.
 ```json
diff --git a/build b/build
index 9a037142..90be1cdd 100644
--- a/build
+++ b/build
@@ -1 +1 @@
-10
\ No newline at end of file
+95
\ No newline at end of file
diff --git a/ols_samples/sample1.json b/ols_samples/sample1.json
new file mode 100644
index 00000000..7a81d088
--- /dev/null
+++ b/ols_samples/sample1.json
@@ -0,0 +1,85 @@
+{
+    "ethernet": [
+        {
+            "select-ports": [
+                "Ethernet0",
+                "Ethernet1",
+                "Ethernet2",
+                "Ethernet3",
+                "Ethernet4",
+                "Ethernet5",
+                "Ethernet6",
+                "Ethernet7"
+            ],
+            "speed": 2500,
+            "duplex": "full",
+            "enabled": true,
+            "poe": {
+                "admin-mode": true,
+                "power-limit": 60000
+            }
+        },
+        {
+            "select-ports": [
+                "Ethernet8",
+                "Ethernet9"
+            ],
+            "speed": 10000,
+            "duplex": "full",
+            "media": "sfp-forced-1000sfp"
+        }
+    ],
+    "interfaces": [
+        {
+            "name": "VLAN1",
+            "vlan": {
+                "id": 1
+            },
+            "ipv4": {
+                "addressing": "dynamic"
+            },
+            "ethernet": [
+                {
+                    "select-ports": [
+                        "Ethernet0",
+                        "Ethernet1",
+                        "Ethernet2",
+                        "Ethernet3",
+                        "Ethernet4",
+                        "Ethernet5",
+                        "Ethernet6",
+                        "Ethernet7",
+                        "Ethernet8",
+                        "Ethernet9"
+                    ],
+                    "vlan-tag": "un-tagged"
+                }
+            ]
+        }
+    ],
+    "metrics": {
+        "dhcp-snooping": {
+            "filters": [
+                "ack",
+                "discover",
+                "offer",
+                "request",
+                "solicit",
+                "reply",
+                "renew"
+            ]
+        },
+        "health": {
+            "interval": 60
+        },
+        "statistics": {
+            "interval": 120,
+            "types": []
+        }
+    },
+    "unit": {
+        "leds-active": true,
+        "usage-threshold": 95
+    },
+    "uuid": 1678263900
+}
\ No newline at end of file
diff --git a/openapi/owgw.yaml b/openapi/owgw.yaml
index 11898726..0f0cee91 100644
--- a/openapi/owgw.yaml
+++ b/openapi/owgw.yaml
@@ -42,12 +42,10 @@ components:
   schemas:
     DeviceType:
       type: string
-      default: AP
+      default: ap
       enum:
-        - AP
-        - SWITCH
-        - IOT
-        - MESH
+        - ap
+        - switch
 
     DeviceRestrictionsKeyInfo:
       type: object
@@ -157,6 +155,9 @@ components:
         lastRecordedContact:
           type: integer
           format: int64
+        blackListed:
+          type: boolean
+          readOnly: true
 
     DeviceWithStatus:
       type: object
@@ -281,6 +282,9 @@ components:
           format: float
         connectReason:
           type: string
+        blackListed:
+          type: boolean
+          readOnly: true
 
     DeviceList:
       type: object
@@ -545,6 +549,12 @@ components:
         lastModified:
           type: integer
           format: int64
+        platform:
+          type: string
+          enum:
+            - ap
+            - switch
+          default: ap
 
     DefaultConfigurationList:
       properties:
@@ -1566,6 +1576,30 @@ components:
           format: base64
           description: This is a base64 encoded string of the certificate bundle (the current bundle .tar.gz file from the PKI portal)
 
+    PowerCycleRequest:
+      type: object
+      properties:
+        serial:
+          type: string
+        when:
+          type: integer
+          format: int64
+        ports:
+          type: array
+          items:
+            type: object
+            properties:
+              name:
+                type: string
+                example:
+                  - Ethernet0
+              cycle:
+                type: integer
+                default: 10000
+                minimum: 1
+                maximum: 60000
+                description: off time in milliseconds
+
 paths:
   /devices:
     get:
@@ -1657,6 +1691,17 @@ paths:
             type: integer
             default: 70
           required: false
+        - in: query
+          description: return only devices matching a certain platform of AP or SWITCH
+          name: platform
+          schema:
+            type: string
+            default: ALL
+            enum:
+              - all
+              - ap
+              - switch
+          required: false
       responses:
         200:
           description: List devices
@@ -3006,6 +3051,34 @@ paths:
         404:
           $ref: '#/components/responses/NotFound'
 
+  /device/{serialNumber}/powercycle:
+    post:
+      tags:
+        - Commands
+      summary: Perform PoE power cycle for some PoE ports.
+      operationId: performPowerCycle
+      parameters:
+        - in: path
+          name: serialNumber
+          schema:
+            type: string
+          required: true
+      requestBody:
+        description: Certificate update details
+        content:
+          application/json:
+            schema:
+              type: array
+              items:
+                $ref: '#/components/schemas/PowerCycleRequest'
+      responses:
+        200:
+          $ref: '#/components/responses/Success'
+        403:
+          $ref: '#/components/responses/Unauthorized'
+        404:
+          $ref: '#/components/responses/NotFound'
+
   /ouis:
     get:
       tags:
diff --git a/owgw.properties.tmpl b/owgw.properties.tmpl
index fd9353c2..15d733b8 100644
--- a/owgw.properties.tmpl
+++ b/owgw.properties.tmpl
@@ -145,7 +145,7 @@ storage.type.sqlite.db = devices.db
 storage.type.sqlite.idletime = 120
 storage.type.sqlite.maxsessions = 128
 
-storage.type.postgresql.maxsessions = 64
+storage.type.postgresql.maxsessions = 250
 storage.type.postgresql.idletime = 60
 storage.type.postgresql.host = ${STORAGE_TYPE_POSTGRESQL_HOST}
 storage.type.postgresql.username = ${STORAGE_TYPE_POSTGRESQL_USERNAME}
diff --git a/src/AP_WS_ConfigAutoUpgrader.cpp b/src/AP_WS_ConfigAutoUpgrader.cpp
index be25df90..5d722b1e 100644
--- a/src/AP_WS_ConfigAutoUpgrader.cpp
+++ b/src/AP_WS_ConfigAutoUpgrader.cpp
@@ -9,14 +9,14 @@
 
 namespace OpenWifi {
 
-	int AP_WS_ConfigAutoUpgrader::Start() {
+	int AP_WS_ConfigAutoUpgradeAgent::Start() {
 		poco_notice(Logger(), "Starting...");
 		QueueManager_.start(*this);
 
 		return 0;
 	}
 
-	void AP_WS_ConfigAutoUpgrader::Stop() {
+	void AP_WS_ConfigAutoUpgradeAgent::Stop() {
 		poco_notice(Logger(), "Stopping...");
 		Running_ = false;
 		Queue_.wakeUpAll();
@@ -24,7 +24,7 @@ namespace OpenWifi {
 		poco_notice(Logger(), "Stopped...");
 	}
 
-	void AP_WS_ConfigAutoUpgrader::run() {
+	void AP_WS_ConfigAutoUpgradeAgent::run() {
 		Utils::SetThreadName("auto:cfgmgr");
 		Running_ = true;
 
diff --git a/src/AP_WS_ConfigAutoUpgrader.h b/src/AP_WS_ConfigAutoUpgrader.h
index b15499dd..be1b3f0a 100644
--- a/src/AP_WS_ConfigAutoUpgrader.h
+++ b/src/AP_WS_ConfigAutoUpgrader.h
@@ -28,14 +28,14 @@ namespace OpenWifi {
 		std::uint64_t pending_config_=0;
 	};
 
-	class AP_WS_ConfigAutoUpgrader : public SubSystemServer, Poco::Runnable {
+	class AP_WS_ConfigAutoUpgradeAgent : public SubSystemServer, Poco::Runnable {
 	  public:
 		int Start() final;
 		void Stop() final;
 		void run() final;
 
 		static auto instance() {
-			static auto instance = new AP_WS_ConfigAutoUpgrader;
+			static auto instance = new AP_WS_ConfigAutoUpgradeAgent;
 			return instance;
 		}
 
@@ -126,12 +126,12 @@ namespace OpenWifi {
 		mutable std::mutex			CacheMutex_;
 		std::map<std::uint64_t, ConfigurationCacheEntry> Cache_;
 
-		AP_WS_ConfigAutoUpgrader() noexcept
+		AP_WS_ConfigAutoUpgradeAgent() noexcept
 			: SubSystemServer("AutoConfigUpgrade", "AUTO-CFG-MGR", "auto.config.updater") {
 		}
 	};
 
-	inline auto AP_WS_ConfigAutoUpgrader() { return AP_WS_ConfigAutoUpgrader::instance(); }
+	inline auto AP_WS_ConfigAutoUpgradeAgent() { return AP_WS_ConfigAutoUpgradeAgent::instance(); }
 
 } // namespace OpenWifi
 
diff --git a/src/AP_WS_Connection.cpp b/src/AP_WS_Connection.cpp
index 216cf75b..bf1979ee 100644
--- a/src/AP_WS_Connection.cpp
+++ b/src/AP_WS_Connection.cpp
@@ -2,45 +2,34 @@
 // Created by stephane bourque on 2022-02-03.
 //
 
-#include "AP_WS_Connection.h"
-
-#include "Poco/Base64Decoder.h"
-#include "Poco/Net/Context.h"
-#include "Poco/Net/HTTPServerRequestImpl.h"
-#include "Poco/Net/HTTPServerResponseImpl.h"
-#include "Poco/Net/NetException.h"
-#include "Poco/Net/SSLException.h"
-#include "Poco/Net/SecureStreamSocketImpl.h"
-#include "Poco/Net/WebSocketImpl.h"
-#include "Poco/zlib.h"
-
-#include "AP_WS_Server.h"
-#include "CentralConfig.h"
-#include "CommandManager.h"
-#include "ConfigurationCache.h"
-#include "StorageService.h"
-#include "TelemetryStream.h"
-
-#include "GWKafkaEvents.h"
-#include "UI_GW_WebSocketNotifications.h"
-#include "framework/KafkaManager.h"
-#include "framework/MicroServiceFuncs.h"
-#include "framework/utils.h"
-
-#include "fmt/format.h"
-
-#include "framework/ow_constants.h"
-
-#include "RADIUSSessionTracker.h"
-#include "RADIUS_proxy_server.h"
 
-namespace OpenWifi {
+#include <Poco/Base64Decoder.h>
+#include <Poco/Net/Context.h>
+#include <Poco/Net/HTTPServerRequestImpl.h>
+#include <Poco/Net/HTTPServerResponseImpl.h>
+#include <Poco/Net/NetException.h>
+#include <Poco/Net/SSLException.h>
+#include <Poco/Net/SecureStreamSocketImpl.h>
+#include <Poco/Net/WebSocketImpl.h>
+
+#include <framework/KafkaManager.h>
+#include <framework/MicroServiceFuncs.h>
+#include <framework/utils.h>
+#include <framework/ow_constants.h>
+
+#include <fmt/format.h>
+
+#include <AP_WS_Connection.h>
+#include <AP_WS_Server.h>
+#include <CentralConfig.h>
+#include <CommandManager.h>
+#include <StorageService.h>
+#include <RADIUSSessionTracker.h>
+#include <RADIUS_proxy_server.h>
+#include <GWKafkaEvents.h>
+#include <UI_GW_WebSocketNotifications.h>
 
-#define DBL                                                                                        \
-	{                                                                                              \
-		std::cout << __LINE__ << "  ID: " << ConnectionId_ << "  Ser: " << SerialNumber_           \
-				  << std::endl;                                                                    \
-	}
+namespace OpenWifi {
 
 	void AP_WS_Connection::LogException(const Poco::Exception &E) {
 		poco_information(Logger_, fmt::format("EXCEPTION({}): {}", CId_, E.displayText()));
@@ -48,10 +37,14 @@ namespace OpenWifi {
 
 	AP_WS_Connection::AP_WS_Connection(Poco::Net::HTTPServerRequest &request,
 									   Poco::Net::HTTPServerResponse &response,
-									   uint64_t connection_id, Poco::Logger &L,
-									   Poco::Net::SocketReactor &R)
-		: Logger_(L), Reactor_(R) {
-		State_.sessionId = connection_id;
+									   uint64_t session_id, Poco::Logger &L,
+									   std::pair<std::shared_ptr<Poco::Net::SocketReactor>, std::shared_ptr<LockedDbSession>> R)
+		: Logger_(L) {
+
+		Reactor_ = R.first;
+		DbSession_ = R.second;
+		State_.sessionId = session_id;
+
 		WS_ = std::make_unique<Poco::Net::WebSocket>(request, response);
 
 		auto TS = Poco::Timespan(360, 0);
@@ -61,29 +54,86 @@ namespace OpenWifi {
 		WS_->setNoDelay(false);
 		WS_->setKeepAlive(true);
 		WS_->setBlocking(false);
+		uuid_ = MicroServiceRandom(std::numeric_limits<std::uint64_t>::max()-1);
 
-		Reactor_.addEventHandler(*WS_,
-								 Poco::NObserver<AP_WS_Connection, Poco::Net::ReadableNotification>(
-									 *this, &AP_WS_Connection::OnSocketReadable));
-		Reactor_.addEventHandler(*WS_,
-								 Poco::NObserver<AP_WS_Connection, Poco::Net::ShutdownNotification>(
-									 *this, &AP_WS_Connection::OnSocketShutdown));
-		Reactor_.addEventHandler(*WS_,
-								 Poco::NObserver<AP_WS_Connection, Poco::Net::ErrorNotification>(
-									 *this, &AP_WS_Connection::OnSocketError));
+		AP_WS_Server()->IncrementConnectionCount();
+	}
+
+	void AP_WS_Connection::Start() {
 		Registered_ = true;
-		Valid_ = true;
-		uuid_ = MicroServiceRandom(std::numeric_limits<std::uint64_t>::max()-1);
+		LastContact_ = Utils::Now();
+
+		Reactor_->addEventHandler(*WS_,
+								  Poco::NObserver<AP_WS_Connection, Poco::Net::ReadableNotification>(
+									  *this, &AP_WS_Connection::OnSocketReadable));
+		Reactor_->addEventHandler(*WS_,
+								  Poco::NObserver<AP_WS_Connection, Poco::Net::ShutdownNotification>(
+									  *this, &AP_WS_Connection::OnSocketShutdown));
+		Reactor_->addEventHandler(*WS_,
+								  Poco::NObserver<AP_WS_Connection, Poco::Net::ErrorNotification>(
+									  *this, &AP_WS_Connection::OnSocketError));
+
+	}
+
+	AP_WS_Connection::~AP_WS_Connection() {
+		std::lock_guard G(ConnectionMutex_);
+		AP_WS_Server()->DecrementConnectionCount();
+		EndConnection();
+		poco_debug(Logger_, fmt::format("TERMINATION({}): Session={}, Connection removed.", SerialNumber_,
+										State_.sessionId));
+	}
+
+	static void NotifyKafkaDisconnect(const std::string &SerialNumber, std::uint64_t uuid) {
+		try {
+			Poco::JSON::Object Disconnect;
+			Poco::JSON::Object Details;
+			Details.set(uCentralProtocol::SERIALNUMBER, SerialNumber);
+			Details.set(uCentralProtocol::TIMESTAMP, Utils::Now());
+			Details.set(uCentralProtocol::UUID,uuid);
+			Disconnect.set(uCentralProtocol::DISCONNECTION, Details);
+			KafkaManager()->PostMessage(KafkaTopics::CONNECTION, SerialNumber, Disconnect);
+		} catch (...) {
+		}
+	}
+
+	void AP_WS_Connection::EndConnection() {
+		bool expectedValue=false;
+		if (Dead_.compare_exchange_strong(expectedValue,true,std::memory_order_release,std::memory_order_relaxed)) {
+
+			if(!SerialNumber_.empty() && State_.LastContact!=0) {
+				StorageService()->SetDeviceLastRecordedContact(SerialNumber_, State_.LastContact);
+			}
+
+			if (Registered_) {
+				Registered_ = false;
+				Reactor_->removeEventHandler(
+					*WS_, Poco::NObserver<AP_WS_Connection, Poco::Net::ReadableNotification>(
+							  *this, &AP_WS_Connection::OnSocketReadable));
+				Reactor_->removeEventHandler(
+					*WS_, Poco::NObserver<AP_WS_Connection, Poco::Net::ShutdownNotification>(
+							  *this, &AP_WS_Connection::OnSocketShutdown));
+				Reactor_->removeEventHandler(
+					*WS_, Poco::NObserver<AP_WS_Connection, Poco::Net::ErrorNotification>(
+							  *this, &AP_WS_Connection::OnSocketError));
+				Registered_=false;
+			}
+			WS_->close();
+
+			if(!SerialNumber_.empty()) {
+				DeviceDisconnectionCleanup(SerialNumber_, uuid_);
+			}
+			AP_WS_Server()->AddCleanupSession(State_.sessionId, SerialNumberInt_);
+		}
 	}
 
 	bool AP_WS_Connection::ValidatedDevice() {
-		if (DeviceValidated_)
-			return true;
 
-		if (!Valid_)
+		if(Dead_)
 			return false;
 
-		std::lock_guard Lock(ConnectionMutex_);
+		if (DeviceValidated_)
+			return true;
+
 		try {
 			auto SockImpl = dynamic_cast<Poco::Net::WebSocketImpl *>(WS_->impl());
 			auto SS =
@@ -98,7 +148,6 @@ namespace OpenWifi {
 				poco_warning(Logger_, fmt::format("TLS-CONNECTION({}): Session={} Connection is "
 												  "NOT secure. Device is not allowed.",
 												  CId_, State_.sessionId));
-				EndConnection();
 				return false;
 			}
 
@@ -111,7 +160,6 @@ namespace OpenWifi {
 					Logger_,
 					fmt::format("TLS-CONNECTION({}): Session={} No certificates available..", CId_,
 								State_.sessionId));
-				EndConnection();
 				return false;
 			}
 
@@ -122,11 +170,19 @@ namespace OpenWifi {
 							 fmt::format("TLS-CONNECTION({}): Session={} Device certificate is not "
 										 "valid. Device is not allowed.",
 										 CId_, State_.sessionId));
-				EndConnection();
 				return false;
 			}
 
 			CN_ = Poco::trim(Poco::toLower(PeerCert.commonName()));
+			if(!Utils::ValidSerialNumber(CN_)) {
+				poco_trace(Logger_,
+						   fmt::format("TLS-CONNECTION({}): Session={} Invalid serial number: CN={}", CId_,
+									   State_.sessionId, CN_));
+				return false;
+			}
+			SerialNumber_ = CN_;
+			SerialNumberInt_ = Utils::SerialNumberToInt(SerialNumber_);
+
 			State_.VerifiedCertificate = GWObjects::VALID_CERTIFICATE;
 			poco_trace(Logger_,
 					   fmt::format("TLS-CONNECTION({}): Session={} Valid certificate: CN={}", CId_,
@@ -136,31 +192,27 @@ namespace OpenWifi {
 				poco_warning(Logger_, fmt::format("TLS-CONNECTION({}): Session={} Sim Device {} is "
 												  "not allowed. Disconnecting.",
 												  CId_, State_.sessionId, CN_));
-				EndConnection();
 				return false;
 			}
 
-			if(AP_WS_Server::IsSim(CN_)) {
+			if(AP_WS_Server::IsSim(SerialNumber_)) {
 				State_.VerifiedCertificate = GWObjects::SIMULATED;
 				Simulated_ = true;
 			}
 
 			std::string reason, author;
 			std::uint64_t created;
-			if (!CN_.empty() && StorageService()->IsBlackListed(CN_, reason, author, created)) {
+			if (!CN_.empty() && StorageService()->IsBlackListed(SerialNumberInt_, reason, author, created)) {
 				DeviceBlacklistedKafkaEvent KE(Utils::SerialNumberToInt(CN_), Utils::Now(), reason, author, created, CId_);
 				poco_warning(
 					Logger_,
 					fmt::format(
 						"TLS-CONNECTION({}): Session={} Device {} is black listed. Disconnecting.",
 						CId_, State_.sessionId, CN_));
-				EndConnection();
 				return false;
 			}
 
 			State_.certificateExpiryDate = PeerCert.expiresOn().timestamp().epochTime();
-			SerialNumber_ = CN_;
-			SerialNumberInt_ = Utils::SerialNumberToInt(SerialNumber_);
 
 			poco_trace(Logger_,
 					   fmt::format("TLS-CONNECTION({}): Session={} CN={} Completed. (t={})", CId_,
@@ -224,149 +276,14 @@ namespace OpenWifi {
 		return false;
 	}
 
-	static void NotifyKafkaDisconnect(const std::string &SerialNumber, std::uint64_t uuid) {
-		try {
-			Poco::JSON::Object Disconnect;
-			Poco::JSON::Object Details;
-			Details.set(uCentralProtocol::SERIALNUMBER, SerialNumber);
-			Details.set(uCentralProtocol::TIMESTAMP, Utils::Now());
-			Details.set(uCentralProtocol::UUID,uuid);
-			Disconnect.set(uCentralProtocol::DISCONNECTION, Details);
-			KafkaManager()->PostMessage(KafkaTopics::CONNECTION, SerialNumber, Disconnect);
-		} catch (...) {
-		}
-	}
-
-	AP_WS_Connection::~AP_WS_Connection() {
-		Valid_ = false;
-		EndConnection();
-	}
-
-	void DeviceDisconnectionCleanup(const std::string &SerialNumber, std::uint64_t uuid) {
+	void AP_WS_Connection::DeviceDisconnectionCleanup(const std::string &SerialNumber, std::uint64_t uuid) {
 		if (KafkaManager()->Enabled()) {
 			NotifyKafkaDisconnect(SerialNumber, uuid);
 		}
 		RADIUSSessionTracker()->DeviceDisconnect(SerialNumber);
-	}
-
-	void AP_WS_Connection::EndConnection(bool DeleteSession) {
-    	Valid_ = false;
-		if (!Dead_.test_and_set()) {
-
-			if(!SerialNumber_.empty() && State_.LastContact!=0) {
-				StorageService()->SetDeviceLastRecordedContact(SerialNumber_, State_.LastContact);
-			}
-
-			if (Registered_) {
-				Registered_ = false;
-				Reactor_.removeEventHandler(
-					*WS_, Poco::NObserver<AP_WS_Connection, Poco::Net::ReadableNotification>(
-							  *this, &AP_WS_Connection::OnSocketReadable));
-				Reactor_.removeEventHandler(
-					*WS_, Poco::NObserver<AP_WS_Connection, Poco::Net::ShutdownNotification>(
-							  *this, &AP_WS_Connection::OnSocketShutdown));
-				Reactor_.removeEventHandler(
-					*WS_, Poco::NObserver<AP_WS_Connection, Poco::Net::ErrorNotification>(
-							  *this, &AP_WS_Connection::OnSocketError));
-			}
-			WS_->close();
-
-			if(!SerialNumber_.empty()) {
-				std::thread	Cleanup(DeviceDisconnectionCleanup,SerialNumber_, uuid_);
-				Cleanup.detach();
-			}
-
-			bool SessionDeleted = false;
-			if(DeleteSession)
-				SessionDeleted = AP_WS_Server()->EndSession(State_.sessionId, SerialNumberInt_);
-
-			if (SessionDeleted || !DeleteSession) {
-				GWWebSocketNotifications::SingleDevice_t N;
-				N.content.serialNumber = SerialNumber_;
-				GWWebSocketNotifications::DeviceDisconnected(N);
-			}
-		}
-	}
-
-	bool AP_WS_Connection::LookForUpgrade(const uint64_t UUID, uint64_t &UpgradedUUID) {
-
-		//	A UUID of zero means ignore updates for that connection.
-		if (UUID == 0)
-			return false;
-
-		uint64_t GoodConfig = ConfigurationCache().CurrentConfig(SerialNumberInt_);
-		if (GoodConfig && (GoodConfig == UUID || GoodConfig == State_.PendingUUID)) {
-			UpgradedUUID = UUID;
-			return false;
-		}
-
-		GWObjects::Device D;
-		if (StorageService()->GetDevice(SerialNumber_, D)) {
-
-			if(D.pendingUUID!=0 && UUID==D.pendingUUID) {
-				//	so we sent an upgrade to a device, and now it is completing now...
-				UpgradedUUID = D.pendingUUID;
-				StorageService()->CompleteDeviceConfigurationChange(SerialNumber_);
-				return true;
-			}
-
-			//	This is the case where the cache is empty after a restart. So GoodConfig will 0. If
-			// the device already 	has the right UUID, we just return.
-			if (D.UUID == UUID) {
-				UpgradedUUID = UUID;
-				ConfigurationCache().Add(SerialNumberInt_, UUID);
-				return false;
-			}
-
-			Config::Config Cfg(D.Configuration);
-			if (UUID > D.UUID) {
-				//	so we have a problem, the device has a newer config than we have. So we need to
-				// make sure our config 	is newer.
-				D.UUID = UUID + 2;
-				UpgradedUUID = D.UUID;
-			}
-
-			Cfg.SetUUID(D.UUID);
-			D.Configuration = Cfg.get();
-			State_.PendingUUID = UpgradedUUID = D.UUID;
-
-			GWObjects::CommandDetails Cmd;
-			Cmd.SerialNumber = SerialNumber_;
-			Cmd.UUID = MicroServiceCreateUUID();
-			Cmd.SubmittedBy = uCentralProtocol::SUBMITTED_BY_SYSTEM;
-			Cmd.Status = uCentralProtocol::PENDING;
-			Cmd.Command = uCentralProtocol::CONFIGURE;
-			Poco::JSON::Parser P;
-			auto ParsedConfig = P.parse(D.Configuration).extract<Poco::JSON::Object::Ptr>();
-			Poco::JSON::Object Params;
-			Params.set(uCentralProtocol::SERIAL, SerialNumber_);
-			Params.set(uCentralProtocol::UUID, D.UUID);
-			Params.set(uCentralProtocol::WHEN, 0);
-			Params.set(uCentralProtocol::CONFIG, ParsedConfig);
-
-			std::ostringstream O;
-			Poco::JSON::Stringifier::stringify(Params, O);
-			Cmd.Details = O.str();
-			poco_information(Logger_,
-							 fmt::format("CFG-UPGRADE({}): Current ID: {}, newer configuration {}.",
-										 CId_, UUID, D.UUID));
-			bool Sent;
-
-			StorageService()->AddCommand(SerialNumber_, Cmd,
-										 Storage::CommandExecutionType::COMMAND_EXECUTED);
-			CommandManager()->PostCommand(
-				CommandManager()->Next_RPC_ID(), APCommands::to_apcommand(Cmd.Command.c_str()),
-				SerialNumber_, Cmd.Command, Params, Cmd.UUID, Sent, false, false);
-
-			GWWebSocketNotifications::SingleDeviceConfigurationChange_t Notification;
-			Notification.content.serialNumber = D.SerialNumber;
-			Notification.content.oldUUID = UUID;
-			Notification.content.newUUID = UpgradedUUID;
-			GWWebSocketNotifications::DeviceConfigurationChange(Notification);
-
-			return true;
-		}
-		return false;
+		GWWebSocketNotifications::SingleDevice_t N;
+		N.content.serialNumber = SerialNumber;
+		GWWebSocketNotifications::DeviceDisconnected(N);
 	}
 
 	void AP_WS_Connection::ProcessJSONRPCResult(Poco::JSON::Object::Ptr Doc) {
@@ -447,7 +364,7 @@ namespace OpenWifi {
 
 		std::string reason, author;
 		std::uint64_t created;
-		if (StorageService()->IsBlackListed(Serial, reason, author, created)) {
+		if (StorageService()->IsBlackListed(SerialNumberInt_, reason, author, created)) {
 			DeviceBlacklistedKafkaEvent KE(Utils::SerialNumberToInt(CN_), Utils::Now(), reason, author, created, CId_);
 			Poco::Exception E(
 				fmt::format("BLACKLIST({}): device is blacklisted and not allowed to connect.",
@@ -578,17 +495,17 @@ namespace OpenWifi {
 	}
 
 	bool AP_WS_Connection::SetWebSocketTelemetryReporting(
-		uint64_t RPCID, uint64_t Interval, uint64_t LifeTime,
+		std::uint64_t RPCID, std::uint64_t Interval, std::uint64_t LifeTime,
 		const std::vector<std::string> &TelemetryTypes) {
 		std::unique_lock Lock(TelemetryMutex_);
 		TelemetryWebSocketRefCount_++;
 		TelemetryInterval_ = TelemetryInterval_
-								 ? (Interval < TelemetryInterval_ ? Interval : TelemetryInterval_)
+								 ? (Interval < (std::uint64_t)TelemetryInterval_ ? Interval : (std::uint64_t )TelemetryInterval_)
 								 : Interval;
 		auto TelemetryWebSocketTimer = LifeTime + Utils::Now();
-		TelemetryWebSocketTimer_ = TelemetryWebSocketTimer > TelemetryWebSocketTimer_
-									   ? TelemetryWebSocketTimer
-									   : TelemetryWebSocketTimer_;
+		TelemetryWebSocketTimer_ = TelemetryWebSocketTimer > (std::uint64_t)TelemetryWebSocketTimer_
+									   ? (std::uint64_t)TelemetryWebSocketTimer
+									   : (std::uint64_t)TelemetryWebSocketTimer_;
 		UpdateCounts();
 		if (!TelemetryReporting_) {
 			TelemetryReporting_ = true;
@@ -604,11 +521,11 @@ namespace OpenWifi {
 		std::unique_lock Lock(TelemetryMutex_);
 		TelemetryKafkaRefCount_++;
 		TelemetryInterval_ = TelemetryInterval_
-								 ? (Interval < TelemetryInterval_ ? Interval : TelemetryInterval_)
+								 ? (Interval < (std::uint64_t)TelemetryInterval_ ? (std::uint64_t)Interval : (std::uint64_t)TelemetryInterval_)
 								 : Interval;
 		auto TelemetryKafkaTimer = LifeTime + Utils::Now();
 		TelemetryKafkaTimer_ =
-			TelemetryKafkaTimer > TelemetryKafkaTimer_ ? TelemetryKafkaTimer : TelemetryKafkaTimer_;
+			TelemetryKafkaTimer > (std::uint64_t)TelemetryKafkaTimer_ ? (std::uint64_t)TelemetryKafkaTimer : (std::uint64_t)TelemetryKafkaTimer_;
 		UpdateCounts();
 		if (!TelemetryReporting_) {
 			TelemetryReporting_ = true;
@@ -644,49 +561,50 @@ namespace OpenWifi {
 	void AP_WS_Connection::OnSocketShutdown(
 		[[maybe_unused]] const Poco::AutoPtr<Poco::Net::ShutdownNotification> &pNf) {
 		poco_trace(Logger_, fmt::format("SOCKET-SHUTDOWN({}): Closing.", CId_));
+//		std::lock_guard	G(ConnectionMutex_);
 		return EndConnection();
 	}
 
 	void AP_WS_Connection::OnSocketError(
 		[[maybe_unused]] const Poco::AutoPtr<Poco::Net::ErrorNotification> &pNf) {
 		poco_trace(Logger_, fmt::format("SOCKET-ERROR({}): Closing.", CId_));
+//		std::lock_guard	G(ConnectionMutex_);
 		return EndConnection();
 	}
 
 	void AP_WS_Connection::OnSocketReadable(
 		[[maybe_unused]] const Poco::AutoPtr<Poco::Net::ReadableNotification> &pNf) {
 
-		if (!Valid_)
+		if (Dead_) //	we are dead, so we do not process anything.
 			return;
 
-		if (!AP_WS_Server()->Running())
-			return EndConnection();
-
-		if (!ValidatedDevice())
-			return;
+		std::lock_guard	G(ConnectionMutex_);
 
-		try {
-			return ProcessIncomingFrame();
-		} catch (const Poco::Exception &E) {
-			Logger_.log(E);
-			return EndConnection();
-		} catch (const std::exception &E) {
-			std::string W = E.what();
-			poco_information(
-				Logger_,
-				fmt::format("std::exception caught: {}. Connection terminated with {}", W, CId_));
-			return EndConnection();
-		} catch (...) {
-			poco_information(Logger_,
-							 fmt::format("Unknown exception for {}. Connection terminated.", CId_));
-			return EndConnection();
+		State_.LastContact = LastContact_ = Utils::Now();
+		if (AP_WS_Server()->Running() && (DeviceValidated_ || ValidatedDevice())) {
+			try {
+				return ProcessIncomingFrame();
+			} catch (const Poco::Exception &E) {
+				Logger_.log(E);
+			} catch (const std::exception &E) {
+				std::string W = E.what();
+				poco_information(
+					Logger_, fmt::format("std::exception caught: {}. Connection terminated with {}",
+										 W, CId_));
+			} catch (...) {
+				poco_information(
+					Logger_, fmt::format("Unknown exception for {}. Connection terminated.", CId_));
+			}
 		}
+		EndConnection();
 	}
 
 	void AP_WS_Connection::ProcessIncomingFrame() {
 		Poco::Buffer<char> IncomingFrame(0);
+
+		bool	KillConnection=false;
 		try {
-			int Op, flags;
+			int 	Op, flags;
 			auto IncomingSize = WS_->receiveFrame(IncomingFrame, flags);
 
 			Op = flags & Poco::Net::WebSocket::FRAME_OP_BITMASK;
@@ -706,83 +624,81 @@ namespace OpenWifi {
 			State_.LastContact = Utils::Now();
 
 			switch (Op) {
-			case Poco::Net::WebSocket::FRAME_OP_PING: {
-				poco_trace(Logger_, fmt::format("WS-PING({}): received. PONG sent back.", CId_));
-				WS_->sendFrame("", 0,
-							   (int)Poco::Net::WebSocket::FRAME_OP_PONG |
-								   (int)Poco::Net::WebSocket::FRAME_FLAG_FIN);
-
-				if (KafkaManager()->Enabled()) {
-					Poco::JSON::Object PingObject;
-					Poco::JSON::Object PingDetails;
-					PingDetails.set(uCentralProtocol::FIRMWARE, State_.Firmware);
-					PingDetails.set(uCentralProtocol::SERIALNUMBER, SerialNumber_);
-					PingDetails.set(uCentralProtocol::COMPATIBLE, Compatible_);
-					PingDetails.set(uCentralProtocol::CONNECTIONIP, CId_);
-					PingDetails.set(uCentralProtocol::TIMESTAMP, Utils::Now());
-					PingDetails.set(uCentralProtocol::UUID, uuid_);
-					PingDetails.set("locale", State_.locale);
-					PingObject.set(uCentralProtocol::PING, PingDetails);
-					poco_trace(Logger_,fmt::format("Sending PING for {}", SerialNumber_));
-					KafkaManager()->PostMessage(KafkaTopics::CONNECTION, SerialNumber_,PingObject);
-				}
-				return;
-			} break;
+				case Poco::Net::WebSocket::FRAME_OP_PING: {
+					poco_trace(Logger_, fmt::format("WS-PING({}): received. PONG sent back.", CId_));
+					WS_->sendFrame("", 0,
+								   (int)Poco::Net::WebSocket::FRAME_OP_PONG |
+									   (int)Poco::Net::WebSocket::FRAME_FLAG_FIN);
+
+					if (KafkaManager()->Enabled()) {
+						Poco::JSON::Object PingObject;
+						Poco::JSON::Object PingDetails;
+						PingDetails.set(uCentralProtocol::FIRMWARE, State_.Firmware);
+						PingDetails.set(uCentralProtocol::SERIALNUMBER, SerialNumber_);
+						PingDetails.set(uCentralProtocol::COMPATIBLE, Compatible_);
+						PingDetails.set(uCentralProtocol::CONNECTIONIP, CId_);
+						PingDetails.set(uCentralProtocol::TIMESTAMP, Utils::Now());
+						PingDetails.set(uCentralProtocol::UUID, uuid_);
+						PingDetails.set("locale", State_.locale);
+						PingObject.set(uCentralProtocol::PING, PingDetails);
+						poco_trace(Logger_,fmt::format("Sending PING for {}", SerialNumber_));
+						KafkaManager()->PostMessage(KafkaTopics::CONNECTION, SerialNumber_,PingObject);
+					}
+				} break;
 
-			case Poco::Net::WebSocket::FRAME_OP_PONG: {
-				poco_trace(Logger_, fmt::format("PONG({}): received and ignored.", CId_));
-				return;
-			} break;
+				case Poco::Net::WebSocket::FRAME_OP_PONG: {
+					poco_trace(Logger_, fmt::format("PONG({}): received and ignored.", CId_));
+				} break;
 
-			case Poco::Net::WebSocket::FRAME_OP_TEXT: {
-				poco_trace(Logger_,
-						   fmt::format("FRAME({}): Frame received (length={}, flags={}). Msg={}",
-									   CId_, IncomingSize, flags, IncomingFrame.begin()));
-
-				Poco::JSON::Parser parser;
-				auto ParsedMessage = parser.parse(IncomingFrame.begin());
-				auto IncomingJSON = ParsedMessage.extract<Poco::JSON::Object::Ptr>();
-
-				if (IncomingJSON->has(uCentralProtocol::JSONRPC)) {
-					if (IncomingJSON->has(uCentralProtocol::METHOD) &&
-						IncomingJSON->has(uCentralProtocol::PARAMS)) {
-						ProcessJSONRPCEvent(IncomingJSON);
-					} else if (IncomingJSON->has(uCentralProtocol::RESULT) &&
-							   IncomingJSON->has(uCentralProtocol::ID)) {
-						poco_trace(Logger_, fmt::format("RPC-RESULT({}): payload: {}", CId_,
-														IncomingFrame.begin()));
-						ProcessJSONRPCResult(IncomingJSON);
+				case Poco::Net::WebSocket::FRAME_OP_TEXT: {
+					poco_trace(Logger_,
+							   fmt::format("FRAME({}): Frame received (length={}, flags={}). Msg={}",
+										   CId_, IncomingSize, flags, IncomingFrame.begin()));
+
+					Poco::JSON::Parser parser;
+					auto ParsedMessage = parser.parse(IncomingFrame.begin());
+					auto IncomingJSON = ParsedMessage.extract<Poco::JSON::Object::Ptr>();
+
+					if (IncomingJSON->has(uCentralProtocol::JSONRPC)) {
+						if (IncomingJSON->has(uCentralProtocol::METHOD) &&
+							IncomingJSON->has(uCentralProtocol::PARAMS)) {
+							ProcessJSONRPCEvent(IncomingJSON);
+						} else if (IncomingJSON->has(uCentralProtocol::RESULT) &&
+								   IncomingJSON->has(uCentralProtocol::ID)) {
+							poco_trace(Logger_, fmt::format("RPC-RESULT({}): payload: {}", CId_,
+															IncomingFrame.begin()));
+							ProcessJSONRPCResult(IncomingJSON);
+						} else {
+							poco_warning(
+								Logger_,
+								fmt::format("INVALID-PAYLOAD({}): Payload is not JSON-RPC 2.0: {}",
+											CId_, IncomingFrame.begin()));
+						}
+					} else if (IncomingJSON->has(uCentralProtocol::RADIUS)) {
+						ProcessIncomingRadiusData(IncomingJSON);
 					} else {
+						std::ostringstream iS;
+						IncomingJSON->stringify(iS);
 						poco_warning(
 							Logger_,
-							fmt::format("INVALID-PAYLOAD({}): Payload is not JSON-RPC 2.0: {}",
-										CId_, IncomingFrame.begin()));
+							fmt::format("FRAME({}): illegal transaction header, missing 'jsonrpc': {}",
+										CId_, iS.str()));
+						Errors_++;
 					}
-				} else if (IncomingJSON->has(uCentralProtocol::RADIUS)) {
-					ProcessIncomingRadiusData(IncomingJSON);
-				} else {
-					std::ostringstream iS;
-					IncomingJSON->stringify(iS);
-					std::cout << iS.str() << std::endl;
-					poco_warning(
-						Logger_,
-						fmt::format("FRAME({}): illegal transaction header, missing 'jsonrpc'",
-									CId_));
-					Errors_++;
-				}
-				return;
-			} break;
+				} break;
 
-			case Poco::Net::WebSocket::FRAME_OP_CLOSE: {
-				poco_information(Logger_,
-								 fmt::format("CLOSE({}): Device is closing its connection.", CId_));
-				return EndConnection();
-			} break;
+				case Poco::Net::WebSocket::FRAME_OP_CLOSE: {
+					poco_information(Logger_,
+									 fmt::format("CLOSE({}): Device is closing its connection.", CId_));
+					KillConnection=true;
+				} break;
 
-			default: {
-				poco_warning(Logger_, fmt::format("UNKNOWN({}): unknown WS Frame operation: {}",
-												  CId_, std::to_string(Op)));
-			} break;
+				default: {
+					poco_warning(Logger_, fmt::format("UNKNOWN({}): unknown WS Frame operation: {}",
+													  CId_, std::to_string(Op)));
+					Errors_++;
+					return;
+				}
 			}
 		} catch (const Poco::Net::ConnectionResetException &E) {
 			poco_warning(Logger_,
@@ -790,21 +706,21 @@ namespace OpenWifi {
 									 CId_, E.displayText(),
 									 IncomingFrame.begin() == nullptr ? "" : IncomingFrame.begin(),
 									 State_.sessionId));
-			return EndConnection();
+			KillConnection=true;
 		} catch (const Poco::JSON::JSONException &E) {
 			poco_warning(Logger_,
 						 fmt::format("JSONException({}): Text:{} Payload:{} Session:{}", CId_,
 									 E.displayText(),
 									 IncomingFrame.begin() == nullptr ? "" : IncomingFrame.begin(),
 									 State_.sessionId));
-			return EndConnection();
+			KillConnection=true;
 		} catch (const Poco::Net::WebSocketException &E) {
 			poco_warning(Logger_,
 						 fmt::format("WebSocketException({}): Text:{} Payload:{} Session:{}", CId_,
 									 E.displayText(),
 									 IncomingFrame.begin() == nullptr ? "" : IncomingFrame.begin(),
 									 State_.sessionId));
-			return EndConnection();
+			KillConnection=true;
 		} catch (const Poco::Net::SSLConnectionUnexpectedlyClosedException &E) {
 			poco_warning(
 				Logger_,
@@ -813,54 +729,54 @@ namespace OpenWifi {
 					CId_, E.displayText(),
 					IncomingFrame.begin() == nullptr ? "" : IncomingFrame.begin(),
 					State_.sessionId));
-			return EndConnection();
+			KillConnection=true;
 		} catch (const Poco::Net::SSLException &E) {
 			poco_warning(Logger_,
 						 fmt::format("SSLException({}): Text:{} Payload:{} Session:{}", CId_,
 									 E.displayText(),
 									 IncomingFrame.begin() == nullptr ? "" : IncomingFrame.begin(),
 									 State_.sessionId));
-			return EndConnection();
+			KillConnection=true;
 		} catch (const Poco::Net::NetException &E) {
 			poco_warning(Logger_,
 						 fmt::format("NetException({}): Text:{} Payload:{} Session:{}", CId_,
 									 E.displayText(),
 									 IncomingFrame.begin() == nullptr ? "" : IncomingFrame.begin(),
 									 State_.sessionId));
-			return EndConnection();
+			KillConnection=true;
 		} catch (const Poco::IOException &E) {
 			poco_warning(Logger_,
 						 fmt::format("IOException({}): Text:{} Payload:{} Session:{}", CId_,
 									 E.displayText(),
 									 IncomingFrame.begin() == nullptr ? "" : IncomingFrame.begin(),
 									 State_.sessionId));
-			return EndConnection();
+			KillConnection=true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger_,
 						 fmt::format("Exception({}): Text:{} Payload:{} Session:{}", CId_,
 									 E.displayText(),
 									 IncomingFrame.begin() == nullptr ? "" : IncomingFrame.begin(),
 									 State_.sessionId));
-			return EndConnection();
+			KillConnection=true;
 		} catch (const std::exception &E) {
 			poco_warning(Logger_,
 						 fmt::format("std::exception({}): Text:{} Payload:{} Session:{}", CId_,
 									 E.what(),
 									 IncomingFrame.begin() == nullptr ? "" : IncomingFrame.begin(),
 									 State_.sessionId));
-			return EndConnection();
+			KillConnection=true;
 		} catch (...) {
 			poco_error(Logger_, fmt::format("UnknownException({}): Device must be disconnected. "
 											"Unknown exception.  Session:{}",
 											CId_, State_.sessionId));
-			return EndConnection();
+			KillConnection=true;
 		}
 
-		if (Errors_ < 10)
+		if (!KillConnection && Errors_ < 10)
 			return;
 
-		poco_warning(Logger_, fmt::format("DISCONNECTING({}): Too many errors", CId_));
-		return EndConnection();
+		poco_warning(Logger_, fmt::format("DISCONNECTING({}): ConnectionException: {} Errors: {}", CId_, KillConnection, Errors_ ));
+		EndConnection();
 	}
 
 	bool AP_WS_Connection::Send(const std::string &Payload) {
@@ -972,4 +888,36 @@ namespace OpenWifi {
 			}
 		}
 	}
+
+	void AP_WS_Connection::SetLastStats(const std::string &LastStats) {
+		RawLastStats_ = LastStats;
+		try {
+			Poco::JSON::Parser P;
+			auto Stats = P.parse(LastStats).extract<Poco::JSON::Object::Ptr>();
+			State_.hasGPS = Stats->isObject("gps");
+			auto Unit = Stats->getObject("unit");
+			auto Memory = Unit->getObject("memory");
+			std::uint64_t TotalMemory = Memory->get("total");
+			std::uint64_t FreeMemory = Memory->get("free");
+			if (TotalMemory > 0) {
+				State_.memoryUsed =
+					(100.0 * ((double)TotalMemory - (double)FreeMemory)) / (double)TotalMemory;
+			}
+			if (Unit->isArray("load")) {
+				Poco::JSON::Array::Ptr Load = Unit->getArray("load");
+				if (Load->size() > 1) {
+					State_.load = Load->get(1);
+				}
+			}
+			if (Unit->isArray("temperature")) {
+				Poco::JSON::Array::Ptr Temperature = Unit->getArray("temperature");
+				if (Temperature->size() > 1) {
+					State_.temperature = Temperature->get(0);
+				}
+			}
+		} catch (const Poco::Exception &E) {
+			poco_error(Logger_, "Failed to parse last stats: " + E.displayText());
+		}
+	}
+
 } // namespace OpenWifi
\ No newline at end of file
diff --git a/src/AP_WS_Connection.h b/src/AP_WS_Connection.h
index e56a9d99..4acd5657 100644
--- a/src/AP_WS_Connection.h
+++ b/src/AP_WS_Connection.h
@@ -14,8 +14,10 @@
 #include "Poco/Net/SocketReactor.h"
 #include "Poco/Net/StreamSocket.h"
 #include "Poco/Net/WebSocket.h"
+#include <Poco/Data/Session.h>
 
 #include "RESTObjects/RESTAPI_GWobjects.h"
+#include <AP_WS_Reactor_Pool.h>
 
 namespace OpenWifi {
 
@@ -25,16 +27,17 @@ namespace OpenWifi {
 	  public:
 		explicit AP_WS_Connection(Poco::Net::HTTPServerRequest &request,
 								  Poco::Net::HTTPServerResponse &response, uint64_t connection_id,
-								  Poco::Logger &L, Poco::Net::SocketReactor &R);
+								  Poco::Logger &L, std::pair<std::shared_ptr<Poco::Net::SocketReactor>, std::shared_ptr<LockedDbSession>> R);
 		~AP_WS_Connection();
 
-		void EndConnection(bool DeleteSession=true);
+		void EndConnection();
 		void ProcessJSONRPCEvent(Poco::JSON::Object::Ptr &Doc);
 		void ProcessJSONRPCResult(Poco::JSON::Object::Ptr Doc);
 		void ProcessIncomingFrame();
 		void ProcessIncomingRadiusData(const Poco::JSON::Object::Ptr &Doc);
 
 		[[nodiscard]] bool Send(const std::string &Payload);
+		[[nodiscard]] inline bool MustBeSecureRTTY() const { return RTTYMustBeSecure_; }
 
 		bool SendRadiusAuthenticationData(const unsigned char *buffer, std::size_t size);
 		bool SendRadiusAccountingData(const unsigned char *buffer, std::size_t size);
@@ -43,10 +46,7 @@ namespace OpenWifi {
 		void OnSocketReadable(const Poco::AutoPtr<Poco::Net::ReadableNotification> &pNf);
 		void OnSocketShutdown(const Poco::AutoPtr<Poco::Net::ShutdownNotification> &pNf);
 		void OnSocketError(const Poco::AutoPtr<Poco::Net::ErrorNotification> &pNf);
-		bool LookForUpgrade(uint64_t UUID, uint64_t &UpgradedUUID);
-		static bool ExtractBase64CompressedData(const std::string &CompressedData,
-												std::string &UnCompressedData,
-												uint64_t compress_sz);
+		bool LookForUpgrade(Poco::Data::Session &Session, uint64_t UUID, uint64_t &UpgradedUUID);
 		void LogException(const Poco::Exception &E);
 		inline Poco::Logger &Logger() { return Logger_; }
 		bool SetWebSocketTelemetryReporting(uint64_t RPCID, uint64_t interval,
@@ -59,81 +59,33 @@ namespace OpenWifi {
 		bool StopKafkaTelemetry(uint64_t RPCID);
 
 		inline void GetLastStats(std::string &LastStats) {
-			std::lock_guard G(ConnectionMutex_);
-			LastStats = RawLastStats_;
-		}
-
-		inline void SetLastStats(const std::string &LastStats) {
-			std::lock_guard G(ConnectionMutex_);
-			RawLastStats_ = LastStats;
-			try {
-				Poco::JSON::Parser P;
-				auto Stats = P.parse(LastStats).extract<Poco::JSON::Object::Ptr>();
-				hasGPS = Stats->isObject("gps");
-				auto Unit = Stats->getObject("unit");
-				auto Memory = Unit->getObject("memory");
-				std::uint64_t TotalMemory = Memory->get("total");
-				std::uint64_t FreeMemory = Memory->get("free");
-				if(TotalMemory>0) {
-					memory_used_ =
-						(100.0 * ((double)TotalMemory - (double)FreeMemory)) / (double)TotalMemory;
-				}
-				if(Unit->isArray("load")) {
-					Poco::JSON::Array::Ptr Load = Unit->getArray("load");
-					if(Load->size()>1) {
-						cpu_load_ = Load->get(1);
-					}
-				}
-				if(Unit->isArray("temperature")) {
-					Poco::JSON::Array::Ptr Temperature = Unit->getArray("temperature");
-					if(Temperature->size()>1) {
-						temperature_ = Temperature->get(0);
-					}
-				}
-			} catch (...) {
-
+			if(!Dead_) {
+				std::lock_guard G(ConnectionMutex_);
+				LastStats = RawLastStats_;
 			}
 		}
 
-		inline void SetLastHealthCheck(const GWObjects::HealthCheck &H) {
-			std::lock_guard G(ConnectionMutex_);
-			RawLastHealthcheck_ = H;
-		}
-
 		inline void GetLastHealthCheck(GWObjects::HealthCheck &H) {
-			std::lock_guard G(ConnectionMutex_);
-			H = RawLastHealthcheck_;
+			if(!Dead_) {
+				std::lock_guard G(ConnectionMutex_);
+				H = RawLastHealthcheck_;
+			}
 		}
 
-		inline void GetState(GWObjects::ConnectionState &State) const {
-			std::lock_guard G(ConnectionMutex_);
-			State = State_;
+		inline void GetState(GWObjects::ConnectionState &State) {
+			if(!Dead_) {
+				std::lock_guard G(ConnectionMutex_);
+				State = State_;
+			}
 		}
 
-		inline bool HasGPS() { return hasGPS; }
-
-		inline void GetRestrictions(GWObjects::DeviceRestrictions &R) const {
+		inline GWObjects::DeviceRestrictions GetRestrictions() {
 			std::lock_guard G(ConnectionMutex_);
-			R = Restrictions_;
+			return Restrictions_;
 		}
 
-		void Process_connect(Poco::JSON::Object::Ptr ParamsObj, const std::string &Serial);
-		void Process_state(Poco::JSON::Object::Ptr ParamsObj);
-		void Process_healthcheck(Poco::JSON::Object::Ptr ParamsObj);
-		void Process_log(Poco::JSON::Object::Ptr ParamsObj);
-		void Process_crashlog(Poco::JSON::Object::Ptr ParamsObj);
-		void Process_ping(Poco::JSON::Object::Ptr ParamsObj);
-		void Process_cfgpending(Poco::JSON::Object::Ptr ParamsObj);
-		void Process_recovery(Poco::JSON::Object::Ptr ParamsObj);
-		void Process_deviceupdate(Poco::JSON::Object::Ptr ParamsObj, std::string &Serial);
-		void Process_telemetry(Poco::JSON::Object::Ptr ParamsObj);
-		void Process_venuebroadcast(Poco::JSON::Object::Ptr ParamsObj);
-		void Process_event(Poco::JSON::Object::Ptr ParamsObj);
-		void Process_wifiscan(Poco::JSON::Object::Ptr ParamsObj);
-		void Process_alarm(Poco::JSON::Object::Ptr ParamsObj);
-		void Process_rebootLog(Poco::JSON::Object::Ptr ParamsObj);
-
-		bool ValidatedDevice();
+		[[nodiscard]] inline bool HasGPS() const { return hasGPS_; }
+		[[nodiscard]] bool ValidatedDevice();
 
 		inline bool GetTelemetryParameters(bool &Reporting, uint64_t &Interval,
 										   uint64_t &WebSocketTimer, uint64_t &KafkaTimer,
@@ -153,18 +105,14 @@ namespace OpenWifi {
 
 		friend class AP_WS_Server;
 
-		inline GWObjects::DeviceRestrictions Restrictions() const {
-			std::lock_guard G(ConnectionMutex_);
-			return Restrictions_;
-		}
-
-		inline bool MustBeSecureRtty() const { return RttyMustBeSecure_; }
+		void Start();
 
 	  private:
-		mutable std::mutex ConnectionMutex_;
+		mutable std::recursive_mutex ConnectionMutex_;
 		std::mutex TelemetryMutex_;
 		Poco::Logger &Logger_;
-		Poco::Net::SocketReactor &Reactor_;
+		std::shared_ptr<Poco::Net::SocketReactor> 	Reactor_;
+		std::shared_ptr<LockedDbSession> 	DbSession_;
 		std::unique_ptr<Poco::Net::WebSocket> WS_;
 		std::string SerialNumber_;
 		uint64_t SerialNumberInt_ = 0;
@@ -175,34 +123,56 @@ namespace OpenWifi {
 		uint64_t Errors_ = 0;
 		Poco::Net::IPAddress PeerAddress_;
 		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;
+		std::atomic_uint64_t TelemetryWebSocketRefCount_ = 0;
+		std::atomic_uint64_t TelemetryKafkaRefCount_ = 0;
+		std::atomic_uint64_t TelemetryWebSocketTimer_ = 0;
+		std::atomic_uint64_t TelemetryKafkaTimer_ = 0;
+		std::atomic_uint64_t TelemetryInterval_ = 0;
+		std::atomic_uint64_t TelemetryWebSocketPackets_ = 0;
+		std::atomic_uint64_t TelemetryKafkaPackets_ = 0;
 		GWObjects::ConnectionState State_;
-		std::string RawLastStats_;
+		Utils::CompressedString RawLastStats_;
 		GWObjects::HealthCheck RawLastHealthcheck_;
 		std::chrono::time_point<std::chrono::high_resolution_clock> ConnectionStart_ =
 			std::chrono::high_resolution_clock::now();
 		std::chrono::duration<double, std::milli> ConnectionCompletionTime_{0.0};
-		std::atomic_flag Dead_ = false;
+		std::atomic<bool> 	Dead_ = false;
 		std::atomic_bool DeviceValidated_ = false;
-		std::atomic_bool Valid_ = false;
 		OpenWifi::GWObjects::DeviceRestrictions Restrictions_;
-		bool 			RttyMustBeSecure_ = false;
+		bool 			RTTYMustBeSecure_ = false;
+		bool hasGPS_=false;
+		std::double_t 	memory_used_=0.0, cpu_load_ = 0.0, temperature_ = 0.0;
+		std::uint64_t 	uuid_=0;
+		bool	Simulated_=false;
+		std::atomic_uint64_t 	LastContact_=0;
 
 		static inline std::atomic_uint64_t ConcurrentStartingDevices_ = 0;
 
 		bool StartTelemetry(uint64_t RPCID, const std::vector<std::string> &TelemetryTypes);
 		bool StopTelemetry(uint64_t RPCID);
 		void UpdateCounts();
-		bool hasGPS=false;
-		std::double_t 	memory_used_=0.0, cpu_load_ = 0.0, temperature_ = 0.0;
-		std::uint64_t 	uuid_=0;
-		bool	Simulated_=false;
+		static void DeviceDisconnectionCleanup(const std::string &SerialNumber, std::uint64_t uuid);
+		void SetLastStats(const std::string &LastStats);
+		void Process_connect(Poco::JSON::Object::Ptr ParamsObj, const std::string &Serial);
+		void Process_state(Poco::JSON::Object::Ptr ParamsObj);
+		void Process_healthcheck(Poco::JSON::Object::Ptr ParamsObj);
+		void Process_log(Poco::JSON::Object::Ptr ParamsObj);
+		void Process_crashlog(Poco::JSON::Object::Ptr ParamsObj);
+		void Process_ping(Poco::JSON::Object::Ptr ParamsObj);
+		void Process_cfgpending(Poco::JSON::Object::Ptr ParamsObj);
+		void Process_recovery(Poco::JSON::Object::Ptr ParamsObj);
+		void Process_deviceupdate(Poco::JSON::Object::Ptr ParamsObj, std::string &Serial);
+		void Process_telemetry(Poco::JSON::Object::Ptr ParamsObj);
+		void Process_venuebroadcast(Poco::JSON::Object::Ptr ParamsObj);
+		void Process_event(Poco::JSON::Object::Ptr ParamsObj);
+		void Process_wifiscan(Poco::JSON::Object::Ptr ParamsObj);
+		void Process_alarm(Poco::JSON::Object::Ptr ParamsObj);
+		void Process_rebootLog(Poco::JSON::Object::Ptr ParamsObj);
+
+		inline void SetLastHealthCheck(const GWObjects::HealthCheck &H) {
+			RawLastHealthcheck_ = H;
+		}
+
 	};
 
 } // namespace OpenWifi
\ No newline at end of file
diff --git a/src/AP_WS_LookForUpgrade.cpp b/src/AP_WS_LookForUpgrade.cpp
new file mode 100644
index 00000000..9e783e99
--- /dev/null
+++ b/src/AP_WS_LookForUpgrade.cpp
@@ -0,0 +1,111 @@
+
+#include <AP_WS_Connection.h>
+#include "ConfigurationCache.h"
+#include "UI_GW_WebSocketNotifications.h"
+#include "CommandManager.h"
+
+namespace OpenWifi {
+	bool AP_WS_Connection::LookForUpgrade(Poco::Data::Session &Session, const uint64_t UUID, uint64_t &UpgradedUUID) {
+
+		//	A UUID of zero means ignore updates for that connection.
+		if (UUID == 0)
+			return false;
+
+		uint64_t GoodConfig = GetCurrentConfigurationID(SerialNumberInt_);
+		if (GoodConfig && (GoodConfig == UUID || GoodConfig == State_.PendingUUID)) {
+			UpgradedUUID = UUID;
+			State_.PendingUUID = 0;
+			return false;
+		}
+
+		GWObjects::Device D;
+		if (!StorageService()->GetDevice(Session,SerialNumber_, D)) {
+			return false;
+		}
+
+		if(State_.PendingUUID!=0 && UUID==State_.PendingUUID) {
+			//	so we sent an upgrade to a device, and now it is completing now...
+			UpgradedUUID = UUID;
+			StorageService()->CompleteDeviceConfigurationChange(Session, SerialNumber_);
+			State_.PendingUUID = 0;
+			return true;
+		}
+
+		// dont upgrade a switch if it does not have a real config. Config will always be more than 20 characters
+		if (D.DeviceType==Platforms::SWITCH && D.Configuration.size()<20) {
+			return false;
+		}
+
+		Config::Config Cfg(D.Configuration);
+		//	if this is a broken device (UUID==0) just fix it
+		auto StoredConfigurationUUID = Cfg.UUID();
+		if(D.UUID==0) {
+			D.UUID = StoredConfigurationUUID;
+		}
+
+
+		if (D.UUID == UUID) {
+			D.UUID = UpgradedUUID = UUID;
+			State_.PendingUUID = D.pendingUUID = 0;
+			D.pendingConfiguration.clear();
+			D.pendingConfigurationCmd.clear();
+			StorageService()->UpdateDevice(Session, D);
+			SetCurrentConfigurationID(SerialNumberInt_, UUID);
+//			std::cout << __LINE__ << ": " << SerialNumber_ << "  GoodConfig: " << GoodConfig << "   UUID:" << UUID << "  Pending:" << State_.PendingUUID << std::endl;
+			return false;
+		}
+
+		if (UUID > D.UUID) {
+			//	so we have a problem, the device has a newer config than we have. So we need to
+			// 	make sure our config 	is newer.
+			D.UUID = UUID + 2;
+			UpgradedUUID = D.UUID;
+//			std::cout << __LINE__ << ": " << SerialNumber_  << "  GoodConfig: " << GoodConfig << "   UUID:" << UUID << "  Pending:" << State_.PendingUUID << std::endl;
+		}
+
+		Cfg.SetUUID(D.UUID);
+		D.Configuration = Cfg.get();
+		D.pendingUUID = State_.PendingUUID = UpgradedUUID = D.UUID;
+		StorageService()->UpdateDevice(Session, D);
+
+		GWObjects::CommandDetails Cmd;
+		Cmd.SerialNumber = SerialNumber_;
+		Cmd.UUID = MicroServiceCreateUUID();
+		Cmd.SubmittedBy = uCentralProtocol::SUBMITTED_BY_SYSTEM;
+		Cmd.Status = uCentralProtocol::PENDING;
+		Cmd.Command = uCentralProtocol::CONFIGURE;
+		Poco::JSON::Parser P;
+		auto ParsedConfig = P.parse(D.Configuration).extract<Poco::JSON::Object::Ptr>();
+		Poco::JSON::Object Params;
+		Params.set(uCentralProtocol::SERIAL, SerialNumber_);
+		Params.set(uCentralProtocol::UUID, D.UUID);
+		Params.set(uCentralProtocol::WHEN, 0);
+		Params.set(uCentralProtocol::CONFIG, ParsedConfig);
+
+		std::ostringstream O;
+		Poco::JSON::Stringifier::stringify(Params, O);
+		Cmd.Details = O.str();
+		poco_information(Logger_,
+						 fmt::format("CFG-UPGRADE({}): Current ID: {}, newer configuration {}.",
+									 CId_, UUID, D.UUID));
+		bool Sent;
+
+		StorageService()->AddCommand(SerialNumber_, Cmd,
+									 Storage::CommandExecutionType::COMMAND_EXECUTED);
+		CommandManager()->PostCommand(
+			CommandManager()->Next_RPC_ID(), APCommands::to_apcommand(Cmd.Command.c_str()),
+			SerialNumber_, Cmd.Command, Params, Cmd.UUID, Sent, false, false);
+
+		GWWebSocketNotifications::SingleDeviceConfigurationChange_t Notification;
+		Notification.content.serialNumber = D.SerialNumber;
+		Notification.content.oldUUID = UUID;
+		Notification.content.newUUID = UpgradedUUID;
+		GWWebSocketNotifications::DeviceConfigurationChange(Notification);
+
+//		std::cout << __LINE__ << ": " << SerialNumber_ << "  GoodConfig: " << GoodConfig << "   UUID:" << UUID <<
+//			"  Pending:" << State_.PendingUUID << "  Upgraded:" << UpgradedUUID << std::endl;
+
+		return true;
+	}
+
+}
\ No newline at end of file
diff --git a/src/AP_WS_Process_connect.cpp b/src/AP_WS_Process_connect.cpp
index e5af1409..70cd61e8 100644
--- a/src/AP_WS_Process_connect.cpp
+++ b/src/AP_WS_Process_connect.cpp
@@ -71,9 +71,8 @@ namespace OpenWifi {
 
 			CommandManager()->ClearQueue(SerialNumberInt_);
 
-			AP_WS_Server()->SetSessionDetails(State_.sessionId, SerialNumberInt_);
+			AP_WS_Server()->StartSession(State_.sessionId, SerialNumberInt_);
 
-			std::lock_guard Lock(ConnectionMutex_);
 			Config::Capabilities Caps(Capabilities);
 
 			Compatible_ = Caps.Compatible();
@@ -84,6 +83,8 @@ namespace OpenWifi {
 			State_.Address = Utils::FormatIPv6(WS_->peerAddress().toString());
 			CId_ = SerialNumber_ + "@" + CId_;
 
+			auto &Platform = Caps.Platform();
+
 			if(ParamsObj->has("reason")) {
 				State_.connectReason = ParamsObj->get("reason").toString();
 			}
@@ -100,36 +101,24 @@ namespace OpenWifi {
 				Restrictions_.from_json(RestrictionObject);
 			}
 
-			if (Capabilities->has("developer")) {
+			if (Capabilities->has("developer") && !Capabilities->isNull("developer")) {
 				Restrictions_.developer = Capabilities->getValue<bool>("developer");
 			}
 
 			if(Capabilities->has("secure-rtty")) {
-				RttyMustBeSecure_ = Capabilities->getValue<bool>("secure-rtty");
+				RTTYMustBeSecure_ = Capabilities->getValue<bool>("secure-rtty");
 			}
 
 			State_.locale = FindCountryFromIP()->Get(IP);
 			GWObjects::Device DeviceInfo;
-			auto DeviceExists = StorageService()->GetDevice(SerialNumber_, DeviceInfo);
+			std::lock_guard DbSessionLock(DbSession_->Mutex());
+
+			auto DeviceExists = StorageService()->GetDevice(DbSession_->Session(), SerialNumber_, DeviceInfo);
 			if (Daemon()->AutoProvisioning() && !DeviceExists) {
 				//	check the firmware version. if this is too old, we cannot let that device connect yet, we must
 				//	force a firmware upgrade
 				GWObjects::DefaultFirmware	MinimumFirmware;
 				if(FirmwareRevisionCache()->DeviceMustUpgrade(Compatible_, Firmware, MinimumFirmware)) {
-/*
-
-					{    "jsonrpc" : "2.0" ,
-						 "method" : "upgrade" ,
-						 "params" : {
-								"serial" : <serial number> ,
-								"when"  : Optional - <UTC time when to upgrade the firmware, 0 mean immediate, this is a suggestion>,
-								"uri"   : <URI to download the firmware>,
-								"FWsignature" : <string representation of the signature for the FW> (optional)
-						 },
-						 "id" : <some number>
-					}
-
- */
 					Poco::JSON::Object	UpgradeCommand, Params;
 					UpgradeCommand.set(uCentralProtocol::JSONRPC,uCentralProtocol::JSONRPC_VERSION);
 					UpgradeCommand.set(uCentralProtocol::METHOD,uCentralProtocol::UPGRADE);
@@ -157,7 +146,7 @@ namespace OpenWifi {
 					}
 					return;
 				} else {
-					StorageService()->CreateDefaultDevice(
+					StorageService()->CreateDefaultDevice( DbSession_->Session(),
 						SerialNumber_, Caps, Firmware, PeerAddress_,
 						State_.VerifiedCertificate == GWObjects::SIMULATED);
 				}
@@ -166,7 +155,7 @@ namespace OpenWifi {
 				poco_warning(Logger(),fmt::format("Device {} is a {} from {} and cannot be provisioned.",SerialNumber_,Compatible_, CId_));
 				return EndConnection();
 			} else if (DeviceExists) {
-				StorageService()->UpdateDeviceCapabilities(SerialNumber_, Caps);
+				StorageService()->UpdateDeviceCapabilities(DbSession_->Session(), SerialNumber_, Caps);
 				int Updated{0};
 				if (!Firmware.empty()) {
 					if (Firmware != DeviceInfo.Firmware) {
@@ -217,8 +206,13 @@ namespace OpenWifi {
 					++Updated;
 				}
 
-				if (Compatible_ != DeviceInfo.DeviceType) {
-					DeviceInfo.DeviceType = Compatible_;
+				if (Compatible_ != DeviceInfo.Compatible) {
+					DeviceInfo.Compatible = Compatible_;
+					++Updated;
+				}
+
+				if (Platform != DeviceInfo.DeviceType) {
+					DeviceInfo.DeviceType = Platform;
 					++Updated;
 				}
 
@@ -238,12 +232,13 @@ namespace OpenWifi {
 				}
 
 				if (Updated) {
-					StorageService()->UpdateDevice(DeviceInfo);
+					StorageService()->UpdateDevice(DbSession_->Session(), DeviceInfo);
 				}
+			}
 
-				if(!Simulated_) {
-					uint64_t UpgradedUUID = 0;
-					LookForUpgrade(UUID, UpgradedUUID);
+			if(!Simulated_) {
+				uint64_t UpgradedUUID = 0;
+				if (LookForUpgrade(DbSession_->Session(), UUID, UpgradedUUID)) {
 					State_.UUID = UpgradedUUID;
 				}
 			}
diff --git a/src/AP_WS_Process_crashlog.cpp b/src/AP_WS_Process_crashlog.cpp
index 9b8773c3..c56ea198 100644
--- a/src/AP_WS_Process_crashlog.cpp
+++ b/src/AP_WS_Process_crashlog.cpp
@@ -29,7 +29,7 @@ namespace OpenWifi {
 										   .Recorded = Utils::Now(),
 										   .LogType = 1,
 										   .UUID = ParamsObj->get(uCentralProtocol::UUID)};
-			StorageService()->AddLog(DeviceLog);
+			StorageService()->AddLog(*DbSession_, DeviceLog);
 			DeviceLogKafkaEvent	E(DeviceLog);
 		} else {
 			poco_warning(Logger_, fmt::format("LOG({}): Missing parameters.", CId_));
diff --git a/src/AP_WS_Process_deviceupdate.cpp b/src/AP_WS_Process_deviceupdate.cpp
index b48c3cea..c1056d29 100644
--- a/src/AP_WS_Process_deviceupdate.cpp
+++ b/src/AP_WS_Process_deviceupdate.cpp
@@ -21,7 +21,7 @@ namespace OpenWifi {
 		if (ParamsObj->has("currentPassword")) {
 			auto Password = ParamsObj->get("currentPassword").toString();
 
-			StorageService()->SetDevicePassword(Serial, Password);
+			StorageService()->SetDevicePassword(*DbSession_,Serial, Password);
 			poco_trace(
 				Logger_,
 				fmt::format("DEVICE-UPDATE({}): Device is updating its login password.", Serial));
diff --git a/src/AP_WS_Process_healthcheck.cpp b/src/AP_WS_Process_healthcheck.cpp
index 14b2cf30..46be7ba1 100644
--- a/src/AP_WS_Process_healthcheck.cpp
+++ b/src/AP_WS_Process_healthcheck.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "AP_WS_Connection.h"
+#include "AP_WS_Server.h"
 #include "StorageService.h"
 
 #include "fmt/format.h"
@@ -25,6 +26,7 @@ namespace OpenWifi {
 
 			uint64_t UUID = ParamsObj->get(uCentralProtocol::UUID);
 			auto Sanity = ParamsObj->get(uCentralProtocol::SANITY);
+			State_.sanity = Sanity;
 			auto CheckData = ParamsObj->get(uCentralProtocol::DATA).toString();
 			if (CheckData.empty())
 				CheckData = uCentralProtocol::EMPTY_JSON_DOC;
@@ -48,14 +50,14 @@ namespace OpenWifi {
 			Check.Data = CheckData;
 			Check.Sanity = Sanity;
 
-			StorageService()->AddHealthCheckData(Check);
+			StorageService()->AddHealthCheckData(*DbSession_, Check);
 
 			if (!request_uuid.empty()) {
 				StorageService()->SetCommandResult(request_uuid, CheckData);
 			}
 
 			SetLastHealthCheck(Check);
-			if (KafkaManager()->Enabled()) {
+			if (KafkaManager()->Enabled() && !AP_WS_Server()->KafkaDisableHealthChecks()) {
 				KafkaManager()->PostMessage(KafkaTopics::HEALTHCHECK, SerialNumber_, *ParamsObj);
 			}
 		} else {
diff --git a/src/AP_WS_Process_log.cpp b/src/AP_WS_Process_log.cpp
index 20fe77df..64c7f265 100644
--- a/src/AP_WS_Process_log.cpp
+++ b/src/AP_WS_Process_log.cpp
@@ -36,7 +36,7 @@ namespace OpenWifi {
 										   .Recorded = (uint64_t)time(nullptr),
 										   .LogType = 0,
 										   .UUID = State_.UUID};
-			StorageService()->AddLog(DeviceLog);
+			StorageService()->AddLog(*DbSession_, DeviceLog);
 			DeviceLogKafkaEvent	E(DeviceLog);
 		} else {
 			poco_warning(Logger_, fmt::format("LOG({}): Missing parameters.", CId_));
diff --git a/src/AP_WS_Process_rebootLog.cpp b/src/AP_WS_Process_rebootLog.cpp
index 070aafd9..871d4422 100644
--- a/src/AP_WS_Process_rebootLog.cpp
+++ b/src/AP_WS_Process_rebootLog.cpp
@@ -35,7 +35,7 @@ namespace OpenWifi {
 										   .Recorded = ParamsObj->get(uCentralProtocol::DATE),
 										   .LogType = 2,
 										   .UUID = ParamsObj->get(uCentralProtocol::UUID)};
-			StorageService()->AddLog(DeviceLog);
+			StorageService()->AddLog(*DbSession_, DeviceLog);
 			DeviceLogKafkaEvent	E(DeviceLog);
 		} else {
 			poco_warning(Logger_, fmt::format("REBOOT-LOG({}): Missing parameters.", CId_));
diff --git a/src/AP_WS_Process_recovery.cpp b/src/AP_WS_Process_recovery.cpp
index a9100b2c..8871c654 100644
--- a/src/AP_WS_Process_recovery.cpp
+++ b/src/AP_WS_Process_recovery.cpp
@@ -35,7 +35,7 @@ namespace OpenWifi {
 										   .LogType = 1,
 										   .UUID = 0};
 
-			StorageService()->AddLog(DeviceLog);
+			StorageService()->AddLog(*DbSession_, DeviceLog);
 
 			if (ParamsObj->get(uCentralProtocol::REBOOT).toString() == "true") {
 				GWObjects::CommandDetails Cmd;
diff --git a/src/AP_WS_Process_state.cpp b/src/AP_WS_Process_state.cpp
index 646b37de..ca110c52 100644
--- a/src/AP_WS_Process_state.cpp
+++ b/src/AP_WS_Process_state.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "AP_WS_Connection.h"
+#include "AP_WS_Server.h"
 #include "StateUtils.h"
 #include "StorageService.h"
 
@@ -39,25 +40,27 @@ namespace OpenWifi {
 												UUID, request_uuid));
 			}
 
+			std::lock_guard	Guard(DbSession_->Mutex());
 			if(!Simulated_) {
 				uint64_t UpgradedUUID;
-				LookForUpgrade(UUID, UpgradedUUID);
+				LookForUpgrade(DbSession_->Session(), UUID, UpgradedUUID);
 				State_.UUID = UpgradedUUID;
 			}
+
 			SetLastStats(StateStr);
 
 			GWObjects::Statistics Stats{
 				.SerialNumber = SerialNumber_, .UUID = UUID, .Data = StateStr};
 			Stats.Recorded = Utils::Now();
-			StorageService()->AddStatisticsData(Stats);
+			StorageService()->AddStatisticsData(DbSession_->Session(),Stats);
 			if (!request_uuid.empty()) {
 				StorageService()->SetCommandResult(request_uuid, StateStr);
 			}
 
 			StateUtils::ComputeAssociations(StateObj, State_.Associations_2G,
-											State_.Associations_5G, State_.Associations_6G);
+											State_.Associations_5G, State_.Associations_6G, State_.uptime);
 
-			if (KafkaManager()->Enabled()) {
+			if (KafkaManager()->Enabled() && !AP_WS_Server()->KafkaDisableState()) {
 				KafkaManager()->PostMessage(KafkaTopics::STATE, SerialNumber_, *ParamsObj);
 			}
 
diff --git a/src/AP_WS_Process_telemetry.cpp b/src/AP_WS_Process_telemetry.cpp
index d5827237..9ea35cb7 100644
--- a/src/AP_WS_Process_telemetry.cpp
+++ b/src/AP_WS_Process_telemetry.cpp
@@ -35,8 +35,7 @@ namespace OpenWifi {
 				}
 				if (TelemetryWebSocketRefCount_) {
 					if (now < TelemetryWebSocketTimer_) {
-						// std::cout << SerialNumber_ << ": Updating WebSocket telemetry" <<
-						// std::endl;
+
 						TelemetryWebSocketPackets_++;
 						State_.websocketPackets = TelemetryWebSocketPackets_;
 						TelemetryStream()->NotifyEndPoint(SerialNumberInt_, KafkaPayload);
@@ -46,7 +45,6 @@ namespace OpenWifi {
 				}
 				if (TelemetryKafkaRefCount_) {
 					if (KafkaManager()->Enabled() && now < TelemetryKafkaTimer_) {
-						// std::cout << SerialNumber_ << ": Updating Kafka telemetry" << std::endl;
 						TelemetryKafkaPackets_++;
 						State_.kafkaPackets = TelemetryKafkaPackets_;
 						KafkaManager()->PostMessage(KafkaTopics::DEVICE_TELEMETRY, SerialNumber_,
diff --git a/src/AP_WS_ReactorPool.h b/src/AP_WS_ReactorPool.h
deleted file mode 100644
index 205c29dc..00000000
--- a/src/AP_WS_ReactorPool.h
+++ /dev/null
@@ -1,62 +0,0 @@
-//
-// Created by stephane bourque on 2022-02-03.
-//
-
-#pragma once
-
-#include <mutex>
-#include <string>
-
-#include "Poco/Environment.h"
-#include "Poco/Net/SocketAcceptor.h"
-
-#include "framework/utils.h"
-
-namespace OpenWifi {
-	class AP_WS_ReactorThreadPool {
-	  public:
-		explicit AP_WS_ReactorThreadPool() {
-			NumberOfThreads_ = Poco::Environment::processorCount() * 4;
-			if (NumberOfThreads_ == 0)
-				NumberOfThreads_ = 4;
-		}
-
-		~AP_WS_ReactorThreadPool() { Stop(); }
-
-		void Start() {
-			for (uint64_t i = 0; i < NumberOfThreads_; ++i) {
-				auto NewReactor = std::make_unique<Poco::Net::SocketReactor>();
-				auto NewThread = std::make_unique<Poco::Thread>();
-				NewThread->start(*NewReactor);
-				std::string ThreadName{"ap:react:" + std::to_string(i)};
-				Utils::SetThreadName(*NewThread, ThreadName.c_str());
-				Reactors_.emplace_back(std::move(NewReactor));
-				Threads_.emplace_back(std::move(NewThread));
-			}
-		}
-
-		void Stop() {
-			for (auto &i : Reactors_)
-				i->stop();
-			for (auto &i : Threads_) {
-				i->join();
-			}
-			Reactors_.clear();
-			Threads_.clear();
-		}
-
-		Poco::Net::SocketReactor &NextReactor() {
-			std::lock_guard Lock(Mutex_);
-			NextReactor_++;
-			NextReactor_ %= NumberOfThreads_;
-			return *Reactors_[NextReactor_];
-		}
-
-	  private:
-		std::mutex Mutex_;
-		uint64_t NumberOfThreads_;
-		uint64_t NextReactor_ = 0;
-		std::vector<std::unique_ptr<Poco::Net::SocketReactor>> Reactors_;
-		std::vector<std::unique_ptr<Poco::Thread>> Threads_;
-	};
-} // namespace OpenWifi
\ No newline at end of file
diff --git a/src/AP_WS_Reactor_Pool.h b/src/AP_WS_Reactor_Pool.h
new file mode 100644
index 00000000..07b03293
--- /dev/null
+++ b/src/AP_WS_Reactor_Pool.h
@@ -0,0 +1,77 @@
+//
+// Created by stephane bourque on 2022-02-03.
+//
+
+#pragma once
+
+#include <mutex>
+#include <string>
+
+#include <framework/utils.h>
+
+#include <Poco/Environment.h>
+#include <Poco/Net/SocketAcceptor.h>
+#include <Poco/Data/SessionPool.h>
+
+#include <StorageService.h>
+
+namespace OpenWifi {
+
+	class AP_WS_ReactorThreadPool {
+	  public:
+		explicit AP_WS_ReactorThreadPool(Poco::Logger &Logger) : Logger_(Logger) {
+			NumberOfThreads_ = Poco::Environment::processorCount() * 4;
+			if (NumberOfThreads_ == 0)
+				NumberOfThreads_ = 8;
+			NumberOfThreads_ = std::min(NumberOfThreads_, (std::uint64_t) 128);
+		}
+
+		~AP_WS_ReactorThreadPool() { Stop(); }
+
+		void Start() {
+			Reactors_.reserve(NumberOfThreads_);
+			DbSessions_.reserve(NumberOfThreads_);
+			Threads_.reserve(NumberOfThreads_);
+			Logger_.information(fmt::format("WebSocket Processor: starting {} threads.", NumberOfThreads_));
+			for (uint64_t i = 0; i < NumberOfThreads_; ++i) {
+				auto NewReactor = std::make_shared<Poco::Net::SocketReactor>();
+				auto NewThread = std::make_unique<Poco::Thread>();
+				NewThread->start(*NewReactor);
+				std::string ThreadName{"ap:react:" + std::to_string(i)};
+				Utils::SetThreadName(*NewThread, ThreadName.c_str());
+				Reactors_.emplace_back(std::move(NewReactor));
+				Threads_.emplace_back(std::move(NewThread));
+				DbSessions_.emplace_back(std::make_shared<LockedDbSession>());
+			}
+			Logger_.information(fmt::format("WebSocket Processor: {} threads started.", NumberOfThreads_));
+		}
+
+		void Stop() {
+			for (auto &i : Reactors_)
+				i->stop();
+			for (auto &i : Threads_) {
+				i->join();
+			}
+			Reactors_.clear();
+			Threads_.clear();
+			DbSessions_.clear();
+		}
+
+		auto NextReactor() {
+			std::lock_guard Lock(Mutex_);
+			NextReactor_++;
+			NextReactor_ %= NumberOfThreads_;
+			return std::make_pair(Reactors_[NextReactor_], DbSessions_[NextReactor_]);
+		}
+
+	  private:
+		std::mutex Mutex_;
+		uint64_t NumberOfThreads_;
+		uint64_t NextReactor_ = 0;
+		std::vector<std::shared_ptr<Poco::Net::SocketReactor>> 	Reactors_;
+		std::vector<std::unique_ptr<Poco::Thread>> 				Threads_;
+		std::vector<std::shared_ptr<LockedDbSession>>			DbSessions_;
+		Poco::Logger &Logger_;
+
+	};
+} // namespace OpenWifi
\ No newline at end of file
diff --git a/src/AP_WS_Server.cpp b/src/AP_WS_Server.cpp
index a99b7a57..3b424019 100644
--- a/src/AP_WS_Server.cpp
+++ b/src/AP_WS_Server.cpp
@@ -6,32 +6,66 @@
 //	Arilia Wireless Inc.
 //
 
-#include "Poco/Net/Context.h"
-#include "Poco/Net/HTTPHeaderStream.h"
-#include "Poco/Net/HTTPServerRequest.h"
-
-#include "AP_WS_Connection.h"
-#include "AP_WS_Server.h"
-#include "ConfigurationCache.h"
-#include "TelemetryStream.h"
-
-#include "UI_GW_WebSocketNotifications.h"
-#include "fmt/format.h"
-#include "framework/MicroServiceFuncs.h"
-#include "framework/utils.h"
+#include <Poco/Net/Context.h>
+#include <Poco/Net/HTTPHeaderStream.h>
+#include <Poco/Net/HTTPServerRequest.h>
+
+#include <AP_WS_Connection.h>
+#include <AP_WS_Server.h>
+#include <ConfigurationCache.h>
+#include <TelemetryStream.h>
+
+#include <fmt/format.h>
+
+#include <framework/MicroServiceFuncs.h>
+#include <framework/utils.h>
 #include <framework/KafkaManager.h>
 
+#include <UI_GW_WebSocketNotifications.h>
+
 namespace OpenWifi {
 
-	void AP_WS_RequestHandler::handleRequest(Poco::Net::HTTPServerRequest &request,
-											 Poco::Net::HTTPServerResponse &response) {
-		try {
-			AP_WS_Server()->AddConnection(
-				id_, std::make_shared<AP_WS_Connection>(request, response, id_, Logger_,
-														AP_WS_Server()->NextReactor()));
-		} catch (...) {
-			poco_warning(Logger_, "Exception during WS creation");
+	class AP_WS_RequestHandler : public Poco::Net::HTTPRequestHandler {
+	  public:
+		explicit AP_WS_RequestHandler(Poco::Logger &L, std::uint64_t session_id) : Logger_(L),
+								   		session_id_(session_id) {
+		 };
+
+		void handleRequest(	Poco::Net::HTTPServerRequest &request,
+						 	Poco::Net::HTTPServerResponse &response) override {
+			try {
+				auto NewConnection = std::make_shared<AP_WS_Connection>(request, response, session_id_, Logger_,
+																		AP_WS_Server()->NextReactor());
+				AP_WS_Server()->AddConnection(NewConnection);
+				NewConnection->Start();
+			} catch (...) {
+				poco_warning(Logger_, "Exception during WS creation");
+			}
+		};
+
+	  private:
+		Poco::Logger &Logger_;
+		std::uint64_t session_id_;
+	};
+
+	class AP_WS_RequestHandlerFactory : public Poco::Net::HTTPRequestHandlerFactory {
+	  public:
+		inline explicit AP_WS_RequestHandlerFactory(Poco::Logger &L) : Logger_(L) {}
+
+		inline Poco::Net::HTTPRequestHandler *
+		createRequestHandler(const Poco::Net::HTTPServerRequest &request) override {
+			if (request.find("Upgrade") != request.end() &&
+				Poco::icompare(request["Upgrade"], "websocket") == 0) {
+				Utils::SetThreadName("ws:conn-init");
+				session_id_++;
+				return new AP_WS_RequestHandler(Logger_, session_id_);
+			} else {
+				return nullptr;
+			}
 		}
+	  private:
+		Poco::Logger &Logger_;
+		inline static std::atomic_uint64_t session_id_ = 0;
 	};
 
 	bool AP_WS_Server::ValidateCertificate(const std::string &ConnectionId,
@@ -57,7 +91,7 @@ namespace OpenWifi {
 
 		SessionTimeOut_ = MicroServiceConfigGetInt("openwifi.session.timeout", 10*60);
 
-		Reactor_pool_ = std::make_unique<AP_WS_ReactorThreadPool>();
+		Reactor_pool_ = std::make_unique<AP_WS_ReactorThreadPool>(Logger());
 		Reactor_pool_->Start();
 
 		for (const auto &Svr : ConfigServersList_) {
@@ -135,6 +169,9 @@ namespace OpenWifi {
 					WebServerHttpParams);
 				WebServers_.push_back(std::move(NewWebServer));
 			}
+
+			KafkaDisableState_ = MicroServiceConfigGetBool("openwifi.kafka.disablestate", false);
+			KafkaDisableHealthChecks_ = MicroServiceConfigGetBool("openwifi.kafka.disablehealthchecks", false);
 		}
 
 		for (auto &server : WebServers_) {
@@ -156,243 +193,398 @@ namespace OpenWifi {
 			UseDefaultConfig_ = true;
 		}
 
-		SimulatorId_ = MicroServiceConfigGetString("simulatorid", "");
+		SimulatorId_ = Poco::toLower(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(10 * 1000); // every minute
-		Timer_.start(*GarbageCollectorCallback_, MicroServiceTimerPool());
-
 		Running_ = true;
+		GarbageCollector_.setName("ws:garbage");
+		GarbageCollector_.start(*this);
+
+		std::thread CleanupThread([this](){ CleanupSessions(); });
+		CleanupThread.detach();
+
 		return 0;
 	}
 
-	void AP_WS_Server::onGarbageCollecting([[maybe_unused]] Poco::Timer &timer) {
-		static uint64_t last_log = Utils::Now(), last_zombie_run = 0;
-		auto now = Utils::Now();
+	void AP_WS_Server::CleanupSessions() {
 
-		{
-			{
-				std::lock_guard SessionLock(SessionMutex_);
-				if (!Garbage_.empty()) {
-					Garbage_.clear();
+		while(Running_) {
+			std::this_thread::sleep_for(std::chrono::seconds(10));
+
+			while(Running_ && !CleanupSessions_.empty()) {
+				std::pair<uint64_t, uint64_t> Session;
+				{
+					std::lock_guard G(CleanupMutex_);
+					Session = CleanupSessions_.front();
+					CleanupSessions_.pop_front();
 				}
+				poco_trace(this->Logger(),fmt::format("Cleaning up session: {} for device: {}", Session.first, Utils::IntToSerialNumber(Session.second)));
+				EndSession(Session.first, Session.second);
 			}
+		}
+	}
+
+	void AP_WS_Server::run() {
+		uint64_t last_log = Utils::Now(),
+				 last_zombie_run = 0,
+				 last_garbage_run = 0;
+
+		Poco::Logger &LocalLogger = Poco::Logger::create(
+			"WS-Session-Janitor", Poco::Logger::root().getChannel(), Poco::Logger::root().getLevel());
+
+		while(Running_) {
 
-			uint64_t total_connected_time = 0;
-
-			if(now-last_zombie_run > 20) {
-				poco_information(Logger(), fmt::format("Garbage collecting..."));
-				std::vector<std::uint64_t> SessionsToRemove;
-				NumberOfConnectedDevices_ = 0;
-				NumberOfConnectingDevices_ = 0;
-				AverageDeviceConnectionTime_ = 0;
-				last_zombie_run = now;
-				for(int hashIndex=0;hashIndex<256;hashIndex++) {
-					std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-					auto hint = SerialNumbers_[hashIndex].begin();
-					while (hint != end(SerialNumbers_[hashIndex])) {
-						if (hint->second.second == nullptr) {
-							hint = SerialNumbers_[hashIndex].erase(hint);
-						} else if ((now - hint->second.second->State_.LastContact) >
-								   SessionTimeOut_) {
-							hint->second.second->EndConnection(false);
-							poco_information(
-								Logger(),
-								fmt::format(
-									"{}: Session seems idle. Controller disconnecting device.",
-									hint->second.second->SerialNumber_));
-							SessionsToRemove.emplace_back(hint->second.first);
-							Garbage_.push_back(hint->second.second);
-							hint = SerialNumbers_[hashIndex].erase(hint);
-						} else if (hint->second.second->State_.Connected) {
-							NumberOfConnectedDevices_++;
-							total_connected_time += (now - hint->second.second->State_.started);
-							hint++;
-						} else {
-							NumberOfConnectingDevices_++;
-							hint++;
+			if(!Poco::Thread::trySleep(30000)) {
+				break;
+			}
+
+			LocalLogger.information(fmt::format("Garbage collecting starting run."	));
+
+			uint64_t total_connected_time = 0, now = Utils::Now();
+
+			if(now-last_zombie_run > 60) {
+				try {
+					poco_information(LocalLogger,
+									 fmt::format("Garbage collecting zombies... (step 1)"));
+					NumberOfConnectingDevices_ = 0;
+					AverageDeviceConnectionTime_ = 0;
+					int waits = 0;
+					for (int hashIndex = 0; hashIndex < MACHash::HashMax(); hashIndex++) {
+						last_zombie_run = now;
+						waits = 0;
+						while (true) {
+							if (SerialNumbersMutex_[hashIndex].try_lock()) {
+								waits = 0;
+								auto hint = SerialNumbers_[hashIndex].begin();
+								while (hint != end(SerialNumbers_[hashIndex])) {
+									if (hint->second == nullptr) {
+										poco_information(
+											LocalLogger,
+											fmt::format("Dead device found in hash index {}", hashIndex));
+										hint = SerialNumbers_[hashIndex].erase(hint);
+									} else {
+										auto Device = hint->second;
+										auto RightNow = Utils::Now();
+										if (Device->Dead_) {
+											AddCleanupSession(Device->State_.sessionId, Device->SerialNumberInt_);
+											++hint;
+											// hint = SerialNumbers_[hashIndex].erase(hint);
+										} else if (RightNow > Device->LastContact_ &&
+												   (RightNow - Device->LastContact_) > SessionTimeOut_) {
+											poco_information(
+												LocalLogger,
+												fmt::format(
+													"{}: Session seems idle. Controller disconnecting device.",
+													Device->SerialNumber_));
+											// hint = SerialNumbers_[hashIndex].erase(hint);
+											AddCleanupSession(Device->State_.sessionId, Device->SerialNumberInt_);
+											++hint;
+										} else {
+											if (Device->State_.Connected) {
+												total_connected_time +=
+													(RightNow - Device->State_.started);
+											}
+											++hint;
+										}
+									}
+								}
+								SerialNumbersMutex_[hashIndex].unlock();
+								break;
+							} else if (waits < 5) {
+								waits++;
+								Poco::Thread::trySleep(10);
+							} else {
+								break;
+							}
 						}
 					}
-				}
 
-				if(SessionsToRemove.empty()) {
-					poco_information(Logger(), fmt::format("Removing {} sessions.", SessionsToRemove.size()));
-					std::lock_guard Lock(SessionMutex_);
-					for (const auto &Session : SessionsToRemove) {
-						Sessions_.erase(Session);
+					poco_information(LocalLogger, fmt::format("Garbage collecting zombies... (step 2)"));
+					LeftOverSessions_ = 0;
+					for (int i = 0; i < SessionHash::HashMax(); i++) {
+						waits = 0;
+						while (true) {
+							if (SessionMutex_[i].try_lock()) {
+								waits = 0;
+								auto hint = Sessions_[i].begin();
+								auto RightNow = Utils::Now();
+								while (hint != end(Sessions_[i])) {
+									if (hint->second == nullptr) {
+										hint = Sessions_[i].erase(hint);
+									} else if (hint->second->Dead_) {
+										// hint = Sessions_[i].erase(hint);
+										AddCleanupSession(hint->second->State_.sessionId, hint->second->SerialNumberInt_);
+										++hint;
+									} else if (RightNow > hint->second->LastContact_ &&
+											   (RightNow - hint->second->LastContact_) >
+												   SessionTimeOut_) {
+										poco_information(
+											LocalLogger,
+											fmt::format("{}: Session seems idle. Controller disconnecting device.",
+														hint->second->SerialNumber_));
+										AddCleanupSession(hint->second->State_.sessionId, hint->second->SerialNumberInt_);
+										++hint;
+										// hint = Sessions_[i].erase(hint);
+									} else {
+										++LeftOverSessions_;
+										++hint;
+									}
+								}
+								SessionMutex_[i].unlock();
+								break;
+							} else if (waits < 5) {
+								Poco::Thread::trySleep(10);
+								waits++;
+							} else {
+								break;
+							}
+						}
 					}
-				}
 
-				AverageDeviceConnectionTime_ =
-				NumberOfConnectedDevices_ > 0 ? total_connected_time / NumberOfConnectedDevices_
-											  : 0;
+					AverageDeviceConnectionTime_ = NumberOfConnectedDevices_ > 0
+													   ? total_connected_time / NumberOfConnectedDevices_
+													   : 0;
+					poco_information(LocalLogger, fmt::format("Garbage collecting zombies done..."));
+				} catch (const Poco::Exception &E) {
+					poco_error(LocalLogger, fmt::format("Poco::Exception: Garbage collecting zombies failed: {}", E.displayText()));
+				} catch (const std::exception &E) {
+					poco_error(LocalLogger, fmt::format("std::exception: Garbage collecting zombies failed: {}", E.what()));
+				} catch (...) {
+					poco_error(LocalLogger, fmt::format("exception:Garbage collecting zombies failed: {}", "unknown"));
+				}
 
-				poco_information(Logger(), fmt::format("Garbage collecting done..."));
-			} else {
-				std::lock_guard SessionLock(SessionMutex_);
-				NumberOfConnectedDevices_ = Sessions_.size();
-				AverageDeviceConnectionTime_ += 10;
 			}
 
-			if ((now - last_log) > 120) {
-				last_log = now;
-				poco_information(Logger(),
-								 fmt::format("Active AP connections: {} Connecting: {} Average connection time: {} seconds",
-											 NumberOfConnectedDevices_, NumberOfConnectingDevices_,
-											 AverageDeviceConnectionTime_));
+			if(NumberOfConnectedDevices_) {
+				if (last_garbage_run > 0) {
+					AverageDeviceConnectionTime_ += (now - last_garbage_run);
+				}
 			}
-		}
-
-		GWWebSocketNotifications::NumberOfConnection_t Notification;
-		Notification.content.numberOfConnectingDevices = NumberOfConnectingDevices_;
-		Notification.content.numberOfDevices = NumberOfConnectedDevices_;
-		Notification.content.averageConnectedTime = AverageDeviceConnectionTime_;
-		GetTotalDataStatistics(Notification.content.tx,Notification.content.rx);
-		GWWebSocketNotifications::NumberOfConnections(Notification);
-
-		Poco::JSON::Object	KafkaNotification;
-		Notification.to_json(KafkaNotification);
 
-		Poco::JSON::Object FullEvent;
-		FullEvent.set("type", "load-update");
-		FullEvent.set("timestamp", now);
-		FullEvent.set("payload", KafkaNotification);
+			try {
+				if ((now - last_log) > 60) {
+					last_log = now;
+					poco_information(
+						LocalLogger,
+						fmt::format("Active AP connections: {} Connecting: {} Average connection time: {} seconds. Left Over Sessions: {}",
+									NumberOfConnectedDevices_, NumberOfConnectingDevices_,
+									AverageDeviceConnectionTime_, LeftOverSessions_));
+				}
 
-		KafkaManager()->PostMessage(KafkaTopics::DEVICE_EVENT_QUEUE, "system", FullEvent);
+				GWWebSocketNotifications::NumberOfConnection_t Notification;
+				Notification.content.numberOfConnectingDevices = NumberOfConnectingDevices_;
+				Notification.content.numberOfDevices = NumberOfConnectedDevices_;
+				Notification.content.averageConnectedTime = AverageDeviceConnectionTime_;
+				GetTotalDataStatistics(Notification.content.tx, Notification.content.rx);
+				GWWebSocketNotifications::NumberOfConnections(Notification);
+
+				Poco::JSON::Object KafkaNotification;
+				Notification.to_json(KafkaNotification);
+
+				Poco::JSON::Object FullEvent;
+				FullEvent.set("type", "load-update");
+				FullEvent.set("timestamp", now);
+				FullEvent.set("payload", KafkaNotification);
+
+				KafkaManager()->PostMessage(KafkaTopics::DEVICE_EVENT_QUEUE, "system", FullEvent);
+				LocalLogger.information(fmt::format("Garbage collection finished run."));
+				last_garbage_run = now;
+			} catch (const Poco::Exception &E) {
+				LocalLogger.error(fmt::format("Poco::Exception: Garbage collecting failed: {}", E.displayText()));
+			} catch (const std::exception &E) {
+				LocalLogger.error(fmt::format("std::exception: Garbage collecting failed: {}", E.what()));
+			} catch (...) {
+				LocalLogger.error(fmt::format("exception:Garbage collecting failed: {}", "unknown"));
+			}
+		}
+		LocalLogger.information(fmt::format("Garbage collector done for the day."	));
 	}
 
 	void AP_WS_Server::Stop() {
 		poco_information(Logger(), "Stopping...");
 		Running_ = false;
 
-		Timer_.stop();
+		GarbageCollector_.wakeUp();
+		GarbageCollector_.join();
 
 		for (auto &server : WebServers_) {
 			server->stopAll();
 		}
+
 		Reactor_pool_->Stop();
 		Reactor_.stop();
 		ReactorThread_.join();
 		poco_information(Logger(), "Stopped...");
 	}
 
-	bool AP_WS_Server::GetStatistics(uint64_t SerialNumber, std::string &Statistics) const {
-
-		auto hashIndex = Utils::CalculateMacAddressHash(SerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
-		if (Device == SerialNumbers_[hashIndex].end() || Device->second.second == nullptr) {
-			return false;
+	bool AP_WS_Server::GetHealthDevices(std::uint64_t lowLimit, std::uint64_t  highLimit, std::vector<std::string> & SerialNumbers) {
+		SerialNumbers.clear();
+		for(int i=0;i<SessionHash::HashMax();i++) {
+			std::lock_guard Lock(SessionMutex_[i]);
+			for (const auto &connection : Sessions_[i]) {
+				if (connection.second->RawLastHealthcheck_.Sanity >= lowLimit &&
+					connection.second->RawLastHealthcheck_.Sanity <= highLimit) {
+					SerialNumbers.push_back(connection.second->SerialNumber_);
+				}
+			}
 		}
-		Device->second.second->GetLastStats(Statistics);
+		return true;
+	}
 
+	bool AP_WS_Server::GetStatistics(uint64_t SerialNumber, std::string &Statistics) const {
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			auto hashIndex = MACHash::Hash(SerialNumber);
+			std::lock_guard DeviceLock(SerialNumbersMutex_[hashIndex]);
+			auto DeviceHint = SerialNumbers_[hashIndex].find(SerialNumber);
+			if (DeviceHint == SerialNumbers_[hashIndex].end() || DeviceHint->second == nullptr) {
+				return false;
+			}
+			Connection = DeviceHint->second;
+		}
+		Connection->GetLastStats(Statistics);
 		return true;
 	}
 
 	bool AP_WS_Server::GetState(uint64_t SerialNumber, GWObjects::ConnectionState &State) const {
-		auto hashIndex = Utils::CalculateMacAddressHash(SerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
-		if (Device == SerialNumbers_[hashIndex].end() || Device->second.second == nullptr) {
-			return false;
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			auto hashIndex = MACHash::Hash(SerialNumber);
+			std::lock_guard DeviceLock(SerialNumbersMutex_[hashIndex]);
+			auto DeviceHint = SerialNumbers_[hashIndex].find(SerialNumber);
+			if (DeviceHint == SerialNumbers_[hashIndex].end() ||
+				DeviceHint->second == nullptr) {
+				return false;
+			}
+			Connection = DeviceHint->second;
 		}
-		Device->second.second->GetState(State);
+		Connection->GetState(State);
 		return true;
 	}
 
 	bool AP_WS_Server::GetHealthcheck(uint64_t SerialNumber,
 									  GWObjects::HealthCheck &CheckData) const {
-
-		auto hashIndex = Utils::CalculateMacAddressHash(SerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
-		if (Device == SerialNumbers_[hashIndex].end() || Device->second.second == nullptr) {
-			return false;
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			auto hashIndex = MACHash::Hash(SerialNumber);
+			std::lock_guard DeviceLock(SerialNumbersMutex_[hashIndex]);
+			auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
+			if (Device == SerialNumbers_[hashIndex].end() || Device->second == nullptr) {
+				return false;
+			}
+			Connection = Device->second;
 		}
-		Device->second.second->GetLastHealthCheck(CheckData);
+		Connection->GetLastHealthCheck(CheckData);
 		return true;
 
 	}
 
-	void AP_WS_Server::SetSessionDetails(uint64_t connection_id, uint64_t SerialNumber) {
-		std::lock_guard SessionLock(SessionMutex_);
-		auto Conn = Sessions_.find(connection_id);
-		if (Conn == end(Sessions_))
-			return;
-
-		auto hashIndex = Utils::CalculateMacAddressHash(SerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto CurrentSerialNumber = SerialNumbers_[hashIndex].find(SerialNumber);
-		if ((CurrentSerialNumber == SerialNumbers_[hashIndex].end()) ||
-			(CurrentSerialNumber->second.first < connection_id)) {
-			SerialNumbers_[hashIndex][SerialNumber] = std::make_pair(connection_id, Conn->second);
-			return;
+	void AP_WS_Server::StartSession(uint64_t session_id, uint64_t SerialNumber) {
+		auto sessionHash = SessionHash::Hash(session_id);
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			std::lock_guard SessionLock(SessionMutex_[sessionHash]);
+			auto SessionHint = Sessions_[sessionHash].find(session_id);
+			if (SessionHint == end(Sessions_[sessionHash])) {
+				return;
+			}
+			Connection = SessionHint->second;
+			Sessions_[sessionHash].erase(SessionHint);
 		}
+
+		auto deviceHash = MACHash::Hash(SerialNumber);
+		std::lock_guard DeviceLock(SerialNumbersMutex_[deviceHash]);
+		SerialNumbers_[deviceHash][SerialNumber] = Connection;
 	}
 
 	bool AP_WS_Server::EndSession(uint64_t session_id, uint64_t SerialNumber) {
-		std::lock_guard SessionLock(SessionMutex_);
-		auto Session = Sessions_.find(session_id);
-		if (Session == end(Sessions_))
-			return false;
-
-		Garbage_.push_back(Session->second);
-
-		auto hashIndex = Utils::CalculateMacAddressHash(SerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
-		if (Device == end(SerialNumbers_[hashIndex])) {
-			Sessions_.erase(Session);
-			return false;
+		{
+			poco_trace(Logger(), fmt::format("Ending session 1: {} for device: {}", session_id, Utils::IntToSerialNumber(SerialNumber)));
+			auto sessionHash = SessionHash::Hash(session_id);
+			std::lock_guard SessionLock(SessionMutex_[sessionHash]);
+			Sessions_[sessionHash].erase(session_id);
+			poco_trace(Logger(), fmt::format("Ended session 1: {} for device: {}", session_id, Utils::IntToSerialNumber(SerialNumber)));
 		}
 
-		if (Device->second.first == session_id) {
-			Sessions_.erase(Session);
-			SerialNumbers_[hashIndex].erase(Device);
-			return true;
+		{
+			auto hashIndex = MACHash::Hash(SerialNumber);
+			poco_trace(Logger(), fmt::format("Ending session 2.0: {} for device: {} hi:{}", session_id, Utils::IntToSerialNumber(SerialNumber), hashIndex));
+			std::lock_guard DeviceLock(SerialNumbersMutex_[hashIndex]);
+			poco_trace(Logger(), fmt::format("Ending session 2.1: {} for device: {} hi:{}", session_id, Utils::IntToSerialNumber(SerialNumber), hashIndex));
+			auto DeviceHint = SerialNumbers_[hashIndex].find(SerialNumber);
+			poco_trace(Logger(), fmt::format("Ending session 2.2: {} for device: {} hi:{}", session_id, Utils::IntToSerialNumber(SerialNumber), hashIndex));
+			if (DeviceHint == SerialNumbers_[hashIndex].end()
+				|| DeviceHint->second == nullptr
+				|| DeviceHint->second->State_.sessionId != session_id) {
+				poco_trace(Logger(), fmt::format("Did not end session 2: {} for device: {}", session_id, Utils::IntToSerialNumber(SerialNumber)));
+				return false;
+			}
+			SerialNumbers_[hashIndex].erase(DeviceHint);
+			poco_trace(Logger(), fmt::format("Ended session 2: {} for device: {}", session_id, Utils::IntToSerialNumber(SerialNumber)));
 		}
-
-		Sessions_.erase(Session);
-
-		return false;
+		return true;
 	}
 
+
 	bool AP_WS_Server::Connected(uint64_t SerialNumber,
 								 GWObjects::DeviceRestrictions &Restrictions) const {
-		auto hashIndex = Utils::CalculateMacAddressHash(SerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
-		if (Device == end(SerialNumbers_[hashIndex]) || Device->second.second == nullptr) {
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			auto hashIndex = MACHash::Hash(SerialNumber);
+			std::lock_guard DeviceLock(SerialNumbersMutex_[hashIndex]);
+			auto DeviceHint = SerialNumbers_[hashIndex].find(SerialNumber);
+			if (DeviceHint == end(SerialNumbers_[hashIndex]) || DeviceHint->second == nullptr) {
+				return false;
+			}
+			Connection = DeviceHint->second;
+		}
+
+		if(Connection->Dead_) {
 			return false;
 		}
-		Device->second.second->GetRestrictions(Restrictions);
-		return Device->second.second->State_.Connected;
+		Restrictions = Connection->GetRestrictions();
+		return Connection->State_.Connected;
 	}
 
+
 	bool AP_WS_Server::Connected(uint64_t SerialNumber) const {
-		auto hashIndex = Utils::CalculateMacAddressHash(SerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
-		if (Device == end(SerialNumbers_[hashIndex]) || Device->second.second == nullptr) {
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			auto hashIndex = MACHash::Hash(SerialNumber);
+			std::lock_guard DeviceLock(SerialNumbersMutex_[hashIndex]);
+			auto DeviceHint = SerialNumbers_[hashIndex].find(SerialNumber);
+			if (DeviceHint == end(SerialNumbers_[hashIndex]) || DeviceHint->second == nullptr) {
+				return false;
+			}
+			Connection = DeviceHint->second;
+		}
+
+		if(Connection->Dead_) {
 			return false;
 		}
-		return Device->second.second->State_.Connected;
+		return Connection->State_.Connected;
 	}
 
 	bool AP_WS_Server::SendFrame(uint64_t SerialNumber, const std::string &Payload) const {
-		auto hashIndex = Utils::CalculateMacAddressHash(SerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
-		if (Device == end(SerialNumbers_[hashIndex]) || Device->second.second == nullptr) {
+		auto hashIndex = MACHash::Hash(SerialNumber);
+
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			std::lock_guard DeviceLock(SerialNumbersMutex_[hashIndex]);
+			auto DeviceHint = SerialNumbers_[hashIndex].find(SerialNumber);
+			if (DeviceHint == end(SerialNumbers_[hashIndex]) || DeviceHint->second == nullptr) {
+				return false;
+			}
+			Connection = DeviceHint->second;
+		}
+
+		if(Connection->Dead_) {
 			return false;
 		}
 
 		try {
-			return Device->second.second->Send(Payload);
+			return Connection->Send(Payload);
 		} catch (...) {
 			poco_debug(Logger(), fmt::format(": SendFrame: Could not send data to device '{}'",
 											 Utils::IntToSerialNumber(SerialNumber)));
@@ -401,48 +593,64 @@ namespace OpenWifi {
 	}
 
 	void AP_WS_Server::StopWebSocketTelemetry(uint64_t RPCID, uint64_t SerialNumber) {
-		auto hashIndex = Utils::CalculateMacAddressHash(SerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
-		if (Device == end(SerialNumbers_[hashIndex]) || Device->second.second == nullptr) {
-			return;
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			auto hashIndex = MACHash::Hash(SerialNumber);
+			std::lock_guard DeviceLock(SerialNumbersMutex_[hashIndex]);
+			auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
+			if (Device == end(SerialNumbers_[hashIndex]) || Device->second == nullptr) {
+				return;
+			}
+			Connection = Device->second;
 		}
-		Device->second.second->StopWebSocketTelemetry(RPCID);
+		Connection->StopWebSocketTelemetry(RPCID);
 	}
 
 	void
 	AP_WS_Server::SetWebSocketTelemetryReporting(uint64_t RPCID, uint64_t SerialNumber,
 												 uint64_t Interval, uint64_t Lifetime,
 												 const std::vector<std::string> &TelemetryTypes) {
-		auto hashIndex = Utils::CalculateMacAddressHash(SerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
-		if (Device == end(SerialNumbers_[hashIndex]) || Device->second.second == nullptr) {
-			return;
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			auto hashIndex = MACHash::Hash(SerialNumber);
+			std::lock_guard DeviceLock(SerialNumbersMutex_[hashIndex]);
+			auto DeviceHint = SerialNumbers_[hashIndex].find(SerialNumber);
+			if (DeviceHint == end(SerialNumbers_[hashIndex]) || DeviceHint->second == nullptr) {
+				return;
+			}
+			Connection = DeviceHint->second;
 		}
-		Device->second.second->SetWebSocketTelemetryReporting(RPCID, Interval, Lifetime, TelemetryTypes);
+		Connection->SetWebSocketTelemetryReporting(RPCID, Interval, Lifetime, TelemetryTypes);
 	}
 
 	void AP_WS_Server::SetKafkaTelemetryReporting(uint64_t RPCID, uint64_t SerialNumber,
 												  uint64_t Interval, uint64_t Lifetime,
 												  const std::vector<std::string> &TelemetryTypes) {
-		auto hashIndex = Utils::CalculateMacAddressHash(SerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
-		if (Device == end(SerialNumbers_[hashIndex]) || Device->second.second == nullptr) {
-			return;
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			auto hashIndex = MACHash::Hash(SerialNumber);
+			std::lock_guard DeviceLock(SerialNumbersMutex_[hashIndex]);
+			auto DeviceHint = SerialNumbers_[hashIndex].find(SerialNumber);
+			if (DeviceHint == end(SerialNumbers_[hashIndex]) || DeviceHint->second == nullptr) {
+				return;
+			}
+			Connection = DeviceHint->second;
 		}
-		Device->second.second->SetKafkaTelemetryReporting(RPCID, Interval, Lifetime, TelemetryTypes);
+		Connection->SetKafkaTelemetryReporting(RPCID, Interval, Lifetime, TelemetryTypes);
 	}
 
 	void AP_WS_Server::StopKafkaTelemetry(uint64_t RPCID, uint64_t SerialNumber) {
-		auto hashIndex = Utils::CalculateMacAddressHash(SerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
-		if (Device == end(SerialNumbers_[hashIndex]) || Device->second.second == nullptr) {
-			return;
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			auto hashIndex = MACHash::Hash(SerialNumber);
+			std::lock_guard DevicesLock(SerialNumbersMutex_[hashIndex]);
+			auto DeviceHint = SerialNumbers_[hashIndex].find(SerialNumber);
+			if (DeviceHint == end(SerialNumbers_[hashIndex]) || DeviceHint->second == nullptr) {
+				return;
+			}
+			Connection = DeviceHint->second;
 		}
-		Device->second.second->StopKafkaTelemetry(RPCID);
+		Connection->StopKafkaTelemetry(RPCID);
 	}
 
 	void AP_WS_Server::GetTelemetryParameters(
@@ -451,14 +659,18 @@ namespace OpenWifi {
 		uint64_t &TelemetryWebSocketCount, uint64_t &TelemetryKafkaCount,
 		uint64_t &TelemetryWebSocketPackets, uint64_t &TelemetryKafkaPackets) {
 
-		auto hashIndex = Utils::CalculateMacAddressHash(SerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(SerialNumber);
-		if (Device == end(SerialNumbers_[hashIndex]) || Device->second.second == nullptr) {
-			return;
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			auto hashIndex = MACHash::Hash(SerialNumber);
+			std::lock_guard DevicesLock(SerialNumbersMutex_[hashIndex]);
+			auto DeviceHint = SerialNumbers_[hashIndex].find(SerialNumber);
+			if (DeviceHint == end(SerialNumbers_[hashIndex]) || DeviceHint->second == nullptr) {
+				return;
+			}
+			Connection = DeviceHint->second;
 		}
 
-		Device->second.second->GetTelemetryParameters(TelemetryRunning, TelemetryInterval,
+		Connection->GetTelemetryParameters(TelemetryRunning, TelemetryInterval,
 										  TelemetryWebSocketTimer, TelemetryKafkaTimer,
 										  TelemetryWebSocketCount, TelemetryKafkaCount,
 										  TelemetryWebSocketPackets, TelemetryKafkaPackets);
@@ -467,16 +679,24 @@ namespace OpenWifi {
 	bool AP_WS_Server::SendRadiusAccountingData(const std::string &SerialNumber,
 												const unsigned char *buffer, std::size_t size) {
 
-		auto IntSerialNumber = Utils::SerialNumberToInt(SerialNumber);
-		auto hashIndex = Utils::CalculateMacAddressHash(IntSerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(IntSerialNumber);
-		if (Device == end(SerialNumbers_[hashIndex]) || Device->second.second == nullptr) {
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			auto IntSerialNumber = Utils::SerialNumberToInt(SerialNumber);
+			auto hashIndex = MACHash::Hash(IntSerialNumber);
+			std::lock_guard DevicesLock(SerialNumbersMutex_[hashIndex]);
+			auto DeviceHint = SerialNumbers_[hashIndex].find(IntSerialNumber);
+			if (DeviceHint == end(SerialNumbers_[hashIndex]) || DeviceHint->second == nullptr) {
+				return false;
+			}
+			Connection = DeviceHint->second;
+		}
+
+		if(Connection->Dead_) {
 			return false;
 		}
 
 		try {
-			return Device->second.second->SendRadiusAccountingData(buffer, size);
+			return Connection->SendRadiusAccountingData(buffer, size);
 		} catch (...) {
 			poco_debug(
 				Logger(),
@@ -488,16 +708,24 @@ namespace OpenWifi {
 
 	bool AP_WS_Server::SendRadiusAuthenticationData(const std::string &SerialNumber,
 													const unsigned char *buffer, std::size_t size) {
-		auto IntSerialNumber = Utils::SerialNumberToInt(SerialNumber);
-		auto hashIndex = Utils::CalculateMacAddressHash(IntSerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(IntSerialNumber);
-		if (Device == end(SerialNumbers_[hashIndex]) || Device->second.second == nullptr) {
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			auto IntSerialNumber = Utils::SerialNumberToInt(SerialNumber);
+			auto hashIndex = MACHash::Hash(IntSerialNumber);
+			std::lock_guard DevicesLock(SerialNumbersMutex_[hashIndex]);
+			auto DeviceHint = SerialNumbers_[hashIndex].find(IntSerialNumber);
+			if (DeviceHint == end(SerialNumbers_[hashIndex]) || DeviceHint->second == nullptr) {
+				return false;
+			}
+			Connection = DeviceHint->second;
+		}
+
+		if(Connection->Dead_) {
 			return false;
 		}
 
 		try {
-			return Device->second.second->SendRadiusAuthenticationData(buffer, size);
+			return Connection->SendRadiusAuthenticationData(buffer, size);
 		} catch (...) {
 			poco_debug(
 				Logger(),
@@ -509,16 +737,23 @@ namespace OpenWifi {
 
 	bool AP_WS_Server::SendRadiusCoAData(const std::string &SerialNumber,
 										 const unsigned char *buffer, std::size_t size) {
-		auto IntSerialNumber = Utils::SerialNumberToInt(SerialNumber);
-		auto hashIndex = Utils::CalculateMacAddressHash(IntSerialNumber);
-		std::lock_guard Lock(SerialNumbersMutex_[hashIndex]);
-		auto Device = SerialNumbers_[hashIndex].find(IntSerialNumber);
-		if (Device == end(SerialNumbers_[hashIndex]) || Device->second.second == nullptr) {
-			return false;
+		std::shared_ptr<AP_WS_Connection> Connection;
+		{
+			auto IntSerialNumber = Utils::SerialNumberToInt(SerialNumber);
+			auto hashIndex = MACHash::Hash(IntSerialNumber);
+			std::lock_guard DeviceLock(SerialNumbersMutex_[hashIndex]);
+			auto DeviceHint = SerialNumbers_[hashIndex].find(IntSerialNumber);
+			if (DeviceHint == end(SerialNumbers_[hashIndex]) || DeviceHint->second == nullptr) {
+				return false;
+			}
+			Connection = DeviceHint->second;
 		}
 
+		if(Connection->Dead_) {
+			return false;
+		}
 		try {
-			return Device->second.second->SendRadiusCoAData(buffer, size);
+			return Connection->SendRadiusCoAData(buffer, size);
 		} catch (...) {
 			poco_debug(Logger(),
 					   fmt::format(": SendRadiusCoAData: Could not send data to device '{}'",
diff --git a/src/AP_WS_Server.h b/src/AP_WS_Server.h
index 37dc5b10..af6a575c 100644
--- a/src/AP_WS_Server.h
+++ b/src/AP_WS_Server.h
@@ -24,46 +24,51 @@
 #include "Poco/Timer.h"
 
 #include "AP_WS_Connection.h"
-#include "AP_WS_ReactorPool.h"
+#include "AP_WS_Reactor_Pool.h"
 
 #include "framework/SubSystemServer.h"
 #include "framework/utils.h"
 
 namespace OpenWifi {
 
-	class AP_WS_RequestHandler : public Poco::Net::HTTPRequestHandler {
+	constexpr uint MACHashMax = 256;
+	constexpr uint MACHashMask = MACHashMax-1;
+	class MACHash {
 	  public:
-		explicit AP_WS_RequestHandler(Poco::Logger &L, uint64_t id) : Logger_(L), id_(id){};
+		[[nodiscard]] static inline uint16_t Hash(std::uint64_t value) {
+			uint8_t hash = 0, i=6;
+			while(i) {
+				hash ^= (value & MACHashMask) + 1;
+				value >>= 8;
+				--i;
+			}
+			return hash;
+		}
 
-		void handleRequest(Poco::Net::HTTPServerRequest &request,
-						   Poco::Net::HTTPServerResponse &response) override;
+		[[nodiscard]] static inline uint16_t Hash(const std::string & value) {
+			return Hash(Utils::MACToInt(value));
+		}
 
-	  private:
-		Poco::Logger &Logger_;
-		uint64_t id_ = 0;
+		[[nodiscard]] static inline uint16_t HashMax() {
+			return MACHashMax;
+		}
 	};
 
-	class AP_WS_RequestHandlerFactory : public Poco::Net::HTTPRequestHandlerFactory {
+	constexpr uint SessionHashMax = 256;
+	constexpr uint SessionHashMask = SessionHashMax-1;
+	class SessionHash {
 	  public:
-		inline explicit AP_WS_RequestHandlerFactory(Poco::Logger &L) : Logger_(L) {}
-
-		inline Poco::Net::HTTPRequestHandler *
-		createRequestHandler(const Poco::Net::HTTPServerRequest &request) override {
-			if (request.find("Upgrade") != request.end() &&
-				Poco::icompare(request["Upgrade"], "websocket") == 0) {
-				Utils::SetThreadName("ws:conn-init");
-				return new AP_WS_RequestHandler(Logger_, id_++);
-			} else {
-				return nullptr;
-			}
+		[[nodiscard]] static inline uint16_t Hash(std::uint64_t value) {
+			return (value & SessionHashMask);
 		}
 
-	  private:
-		Poco::Logger &Logger_;
-		inline static uint64_t id_ = 1;
+		[[nodiscard]] static inline uint16_t HashMax() {
+			return SessionHashMax;
+		}
 	};
 
-	class AP_WS_Server : public SubSystemServer {
+
+	class AP_WS_Server : public SubSystemServer, public Poco::Runnable {
 	  public:
 		static auto instance() {
 			static auto instance_ = new AP_WS_Server;
@@ -77,48 +82,50 @@ namespace OpenWifi {
 								 const Poco::Crypto::X509Certificate &Certificate);
 
 		inline bool IsSimSerialNumber(const std::string &SerialNumber) const {
-			return IsSim(Poco::toLower(SerialNumber)) &&
-				   Poco::toLower(SerialNumber) == Poco::toLower(SimulatorId_);
+			return IsSim(SerialNumber) &&
+				   SerialNumber == SimulatorId_;
 		}
 
 		inline static bool IsSim(const std::string &SerialNumber) {
 			return SerialNumber.substr(0, 6) == "53494d";
 		}
 
-		inline bool IsSimEnabled() const { return SimulatorEnabled_; }
-
-		inline bool AllowSerialNumberMismatch() const { return AllowSerialNumberMismatch_; }
-
-		inline uint64_t MismatchDepth() const { return MismatchDepth_; }
-
-		inline bool UseProvisioning() const { return LookAtProvisioning_; }
-		inline bool UseDefaults() const { return UseDefaultConfig_; }
-
-		[[nodiscard]] inline Poco::Net::SocketReactor &NextReactor() {
+		void run() override;		//	Garbage collector thread.
+		[[nodiscard]] inline bool IsSimEnabled() const { return SimulatorEnabled_; }
+		[[nodiscard]] inline bool AllowSerialNumberMismatch() const { return AllowSerialNumberMismatch_; }
+		[[nodiscard]] inline uint64_t MismatchDepth() const { return MismatchDepth_; }
+		[[nodiscard]] inline bool UseProvisioning() const { return LookAtProvisioning_; }
+		[[nodiscard]] inline bool UseDefaults() const { return UseDefaultConfig_; }
+		[[nodiscard]] inline bool Running() const { return Running_; }
+		[[nodiscard]] inline std::pair<std::shared_ptr<Poco::Net::SocketReactor>, std::shared_ptr<LockedDbSession>> NextReactor() {
 			return Reactor_pool_->NextReactor();
 		}
-		[[nodiscard]] inline bool Running() const { return Running_; }
 
-		inline void AddConnection(uint64_t session_id,
-								  std::shared_ptr<AP_WS_Connection> Connection) {
-			std::lock_guard Lock(SessionMutex_);
-			Sessions_[session_id] = std::move(Connection);
+		inline void AddConnection(std::shared_ptr<AP_WS_Connection> Connection) {
+			std::uint64_t sessionHash = SessionHash::Hash(Connection->State_.sessionId);
+			std::lock_guard SessionLock(SessionMutex_[sessionHash]);
+			if(Sessions_[sessionHash].find(Connection->State_.sessionId)==end(Sessions_[sessionHash])) {
+				Sessions_[sessionHash][Connection->State_.sessionId] = std::move(Connection);
+			}
 		}
 
-		inline bool DeviceRequiresSecureRtty(uint64_t serialNumber) const {
-			auto hashIndex = Utils::CalculateMacAddressHash(serialNumber);
-			std::lock_guard	G(SerialNumbersMutex_[hashIndex]);
-
-			auto Connection = SerialNumbers_[hashIndex].find(serialNumber);
-			if (Connection==end(SerialNumbers_[hashIndex]) || Connection->second.second==nullptr)
-				return false;
-			return Connection->second.second->RttyMustBeSecure_;
+		[[nodiscard]] inline bool DeviceRequiresSecureRTTY(uint64_t serialNumber) const {
+			std::shared_ptr<AP_WS_Connection> Connection;
+			{
+				auto hashIndex = MACHash::Hash(serialNumber);
+				std::lock_guard DeviceLock(SerialNumbersMutex_[hashIndex]);
+				auto DeviceHint = SerialNumbers_[hashIndex].find(serialNumber);
+				if (DeviceHint == end(SerialNumbers_[hashIndex]) || DeviceHint->second == nullptr)
+					return false;
+				Connection = DeviceHint->second;
+			}
+			return Connection->RTTYMustBeSecure_;
 		}
 
 		inline bool GetStatistics(const std::string &SerialNumber, std::string &Statistics) const {
 			return GetStatistics(Utils::SerialNumberToInt(SerialNumber), Statistics);
 		}
-		bool GetStatistics(uint64_t SerialNumber, std::string &Statistics) const;
+		[[nodiscard]] bool GetStatistics(uint64_t SerialNumber, std::string &Statistics) const;
 
 		inline bool GetState(const std::string &SerialNumber,
 							 GWObjects::ConnectionState &State) const {
@@ -134,13 +141,7 @@ namespace OpenWifi {
 
 		bool Connected(uint64_t SerialNumber, GWObjects::DeviceRestrictions &Restrictions) 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(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,
@@ -148,9 +149,8 @@ namespace OpenWifi {
 		bool SendRadiusCoAData(const std::string &SerialNumber, const unsigned char *buffer,
 							   std::size_t size);
 
-		void SetSessionDetails(uint64_t connection_id, uint64_t SerialNumber);
-		bool EndSession(uint64_t connection_id, uint64_t serial_number);
-		bool EndSessionUnSafe(uint64_t session_id, uint64_t serial_number);
+		void StartSession(uint64_t session_id, uint64_t SerialNumber);
+		bool EndSession(uint64_t session_id, uint64_t SerialNumber);
 		void SetWebSocketTelemetryReporting(uint64_t RPCID, uint64_t SerialNumber,
 											uint64_t Interval, uint64_t Lifetime,
 											const std::vector<std::string> &TelemetryTypes);
@@ -167,7 +167,9 @@ namespace OpenWifi {
 									uint64_t &TelemetryWebSocketPackets,
 									uint64_t &TelemetryKafkaPackets);
 
-		void onGarbageCollecting(Poco::Timer &timer);
+		bool GetHealthDevices(std::uint64_t lowLimit, std::uint64_t  highLimit, std::vector<std::string> & SerialNumbers);
+//		bool ExtendedAttributes(const std::string &serialNumber, bool & hasGPS, std::uint64_t &Sanity,
+//								std::double_t &MemoryUsed, std::double_t &Load, std::double_t &Temperature);
 
 		inline void AverageDeviceStatistics(uint64_t &Connections, uint64_t &AverageConnectionTime,
 											uint64_t &NumberOfConnectingDevices) const {
@@ -176,94 +178,80 @@ namespace OpenWifi {
 			NumberOfConnectingDevices = NumberOfConnectingDevices_;
 		}
 
+		inline bool SendFrame(const std::string &SerialNumber, const std::string &Payload) const {
+			return SendFrame(Utils::SerialNumberToInt(SerialNumber), Payload);
+		}
+
 		inline void AddRX(std::uint64_t bytes) {
-			std::lock_guard		G(StatsMutex_);
 			RX_ += bytes;
 		}
 
 		inline void AddTX(std::uint64_t bytes) {
-			std::lock_guard		G(StatsMutex_);
 			TX_ += bytes;
 		}
 
 		inline void GetTotalDataStatistics(std::uint64_t &TX, std::uint64_t &RX) const {
-			std::lock_guard		G(StatsMutex_);
 			TX = TX_;
 			RX = RX_;
 		}
 
-		//	TOD: move to hash based map.
-		inline bool GetHealthDevices(std::uint64_t lowLimit, std::uint64_t  highLimit, std::vector<std::string> & SerialNumbers) {
-			std::lock_guard Lock(SessionMutex_);
-			for(const auto &connection:Sessions_) {
-				if(	connection.second->RawLastHealthcheck_.Sanity>=lowLimit 	&&
-					connection.second->RawLastHealthcheck_.Sanity<=highLimit) {
-					SerialNumbers.push_back(connection.second->SerialNumber_);
-				}
-			}
-			return true;
+		bool KafkaDisableState() const { return KafkaDisableState_; }
+		bool KafkaDisableHealthChecks() const { return KafkaDisableHealthChecks_; }
+
+		inline void IncrementConnectionCount() {
+			++NumberOfConnectedDevices_;
 		}
 
-		inline bool ExtendedAttributes(const std::string &serialNumber,
-			bool & hasGPS,
-			std::uint64_t &Sanity,
-			std::double_t &MemoryUsed,
-			std::double_t &Load,
-			std::double_t &Temperature
-			) {
-
-			auto serialNumberInt = Utils::SerialNumberToInt(serialNumber);
-			auto hashIndex = Utils::CalculateMacAddressHash(serialNumberInt);
-			std::lock_guard	G(SerialNumbersMutex_[hashIndex]);
-			auto session_hint = SerialNumbers_[hashIndex].find(Utils::SerialNumberToInt(serialNumber));
-			if(session_hint==end(SerialNumbers_[hashIndex])) {
-				return false;
-			}
-			hasGPS = session_hint->second.second->hasGPS;
-			Sanity = session_hint->second.second->RawLastHealthcheck_.Sanity;
-			MemoryUsed = session_hint->second.second->memory_used_;
-			Load = session_hint->second.second->cpu_load_;
-			Temperature = session_hint->second.second->temperature_;
-			return true;
+		inline void DecrementConnectionCount() {
+			--NumberOfConnectedDevices_;
+		}
+
+		inline void AddCleanupSession(uint64_t session_id, uint64_t SerialNumber) {
+			std::lock_guard G(CleanupMutex_);
+			CleanupSessions_.emplace_back(session_id, SerialNumber);
 		}
 
+		void CleanupSessions();
+
 	  private:
-		mutable std::mutex 			SessionMutex_;
-		mutable std::mutex			StatsMutex_;
+		std::array<std::mutex,SessionHashMax> 			SessionMutex_;
+		std::array<std::map<std::uint64_t, std::shared_ptr<AP_WS_Connection>>,SessionHashMax> Sessions_;
+		using SerialNumberMap = std::map<uint64_t /* serial number */,
+										 std::shared_ptr<AP_WS_Connection>>;
+		std::array<SerialNumberMap,MACHashMax>			SerialNumbers_;
+		mutable std::array<std::mutex,MACHashMax>		SerialNumbersMutex_;
+
 		std::unique_ptr<Poco::Crypto::X509Certificate> IssuerCert_;
 		std::list<std::unique_ptr<Poco::Net::HTTPServer>> WebServers_;
+		Poco::ThreadPool DeviceConnectionPool_{"ws:dev-pool", 4, 256};
 		Poco::Net::SocketReactor Reactor_;
 		Poco::Thread ReactorThread_;
 		std::string SimulatorId_;
-		Poco::ThreadPool DeviceConnectionPool_{"ws:dev-pool", 2, 64};
 		bool LookAtProvisioning_ = false;
 		bool UseDefaultConfig_ = true;
 		bool SimulatorEnabled_ = false;
-		std::unique_ptr<AP_WS_ReactorThreadPool> Reactor_pool_;
-		std::atomic_bool Running_ = false;
-		std::map<std::uint64_t, std::shared_ptr<AP_WS_Connection>> Sessions_;
+		bool AllowSerialNumberMismatch_ = true;
 
-		using SerialNumberMap = std::map<uint64_t /* serial number */, std::pair<uint64_t /* session id*/,
-									 std::shared_ptr<AP_WS_Connection>>>;
+		Poco::Thread            CleanupThread_;
+		std::mutex              CleanupMutex_;
+		std::deque<std::pair<uint64_t, uint64_t>> CleanupSessions_;
 
-		std::array<SerialNumberMap,256>			SerialNumbers_;
-		mutable std::array<std::mutex,256>		SerialNumbersMutex_;
+		std::unique_ptr<AP_WS_ReactorThreadPool> Reactor_pool_;
+		std::atomic_bool Running_ = false;
 
-		std::atomic_bool AllowSerialNumberMismatch_ = true;
-		std::atomic_uint64_t MismatchDepth_ = 2;
+		std::uint64_t 			MismatchDepth_ = 2;
 
-		std::uint64_t 			NumberOfConnectedDevices_ = 0;
-		std::uint64_t 			AverageDeviceConnectionTime_ = 0;
+		std::atomic_uint64_t 	NumberOfConnectedDevices_ = 0;
+		std::atomic_uint64_t 	AverageDeviceConnectionTime_ = 0;
 		std::uint64_t 			NumberOfConnectingDevices_ = 0;
 		std::uint64_t 			SessionTimeOut_ = 10*60;
-
+		std::uint64_t 			LeftOverSessions_ = 0;
 		std::atomic_uint64_t 	TX_=0,RX_=0;
 
-		std::vector<std::shared_ptr<AP_WS_Connection>> Garbage_;
+		std::atomic_bool 		KafkaDisableState_=false,
+						 		KafkaDisableHealthChecks_=false;
 
-		std::unique_ptr<Poco::TimerCallback<AP_WS_Server>> GarbageCollectorCallback_;
-		Poco::Timer Timer_;
-		Poco::Thread GarbageCollector_;
+		Poco::Thread 			GarbageCollector_;
 
 		AP_WS_Server() noexcept
 			: SubSystemServer("WebSocketServer", "WS-SVR", "ucentral.websocket") {}
diff --git a/src/CapabilitiesCache.h b/src/CapabilitiesCache.h
index 866a8efb..6658a0f1 100644
--- a/src/CapabilitiesCache.h
+++ b/src/CapabilitiesCache.h
@@ -10,6 +10,7 @@
 #include <string>
 
 #include "framework/MicroServiceFuncs.h"
+#include "framework/ow_constants.h"
 
 #include "CentralConfig.h"
 #include "nlohmann/json.hpp"
@@ -34,7 +35,7 @@ namespace OpenWifi {
 			std::lock_guard G(Mutex_);
 			if (!PlatformsLoaded_)
 				LoadPlatforms();
-			auto P = Poco::toUpper(Caps.Platform());
+			auto P = Poco::toLower(Caps.Platform());
 			auto Hint = Platforms_.find(Caps.Compatible());
 			if (Hint == Platforms_.end()) {
 				Platforms_.insert(std::make_pair(Caps.Compatible(), P));
@@ -68,7 +69,7 @@ namespace OpenWifi {
 
 			auto Hint = Platforms_.find(DeviceType);
 			if (Hint == Platforms_.end())
-				return "AP";
+				return Platforms::AP;
 			return Hint->second;
 		}
 
@@ -110,7 +111,7 @@ namespace OpenWifi {
 				i >> cache;
 
 				for (const auto &[Type, Platform] : cache.items()) {
-					Platforms_[Type] = Platform;
+					Platforms_[Type] = Poco::toLower(to_string(Platform));
 				}
 			} catch (...) {
 			}
diff --git a/src/CentralConfig.cpp b/src/CentralConfig.cpp
index ffab6b51..ae881a14 100644
--- a/src/CentralConfig.cpp
+++ b/src/CentralConfig.cpp
@@ -204,6 +204,17 @@ namespace OpenWifi::Config {
 		return false;
 	}
 
+	std::uint64_t Config::UUID() {
+		try {
+			Poco::JSON::Parser Parser;
+			auto object = Parser.parse(Config_).extract<Poco::JSON::Object::Ptr>();
+			if (object->has("uuid"))
+				return object->get("uuid");
+		} catch (...) {
+		}
+		return 0;
+	}
+
 	bool Config::Valid() {
 		try {
 			Poco::JSON::Parser Parser;
diff --git a/src/CentralConfig.h b/src/CentralConfig.h
index 56ae2e4c..118592d9 100644
--- a/src/CentralConfig.h
+++ b/src/CentralConfig.h
@@ -23,6 +23,7 @@ namespace OpenWifi::Config {
 		[[nodiscard]] std::string get() { return Config_; };
 		[[nodiscard]] std::string Default();
 		[[nodiscard]] Poco::JSON::Object::Ptr to_json();
+		[[nodiscard]] std::uint64_t UUID();
 
 	  private:
 		void Init();
diff --git a/src/CommandManager.cpp b/src/CommandManager.cpp
index c9ee370a..82ccd332 100644
--- a/src/CommandManager.cpp
+++ b/src/CommandManager.cpp
@@ -45,11 +45,9 @@ namespace OpenWifi {
 							std::lock_guard Lock(LocalMutex_);
 							auto RPC = OutStandingRequests_.find(ID);
 							if (RPC == OutStandingRequests_.end()) {
-								//								std::cout << __LINE__ << std::endl;
 								poco_debug(Logger(), fmt::format("({}): RPC {} cannot be found.",
 																 SerialNumberStr, ID));
 							} else if (RPC->second.SerialNumber != Resp->SerialNumber_) {
-								//								std::cout << __LINE__ << std::endl;
 								poco_debug(
 									Logger(),
 									fmt::format("({}): RPC {} serial number mismatch {}!={}.",
@@ -60,7 +58,6 @@ namespace OpenWifi {
 								std::chrono::duration<double, std::milli> rpc_execution_time =
 									std::chrono::high_resolution_clock::now() -
 									RPC->second.submitted;
-								//								std::cout << __LINE__ << std::endl;
 								poco_debug(Logger(),
 										   fmt::format("({}): Received RPC answer {}. Command={}",
 													   SerialNumberStr, ID,
@@ -140,7 +137,6 @@ namespace OpenWifi {
 				}
 			}
 		} else {
-			//				std::cout << __LINE__ << std::endl;
 		}
 		Command.State = 0;
 
@@ -163,7 +159,6 @@ namespace OpenWifi {
 		if (Command.rpc_entry) {
 			TmpRpcEntry = Command.rpc_entry;
 		}
-		//		std::cout << __LINE__ << "  State=" << Command.State << std::endl;
 		if (Command.State == 2) {
 			//	 look at the payload to see if we should continue or not...
 			if (Payload->has("result")) {
@@ -173,12 +168,10 @@ namespace OpenWifi {
 
 					std::uint64_t Error = Status->get("error");
 					if (Error == 0) {
-						//						std::cout << __LINE__ << std::endl;
 						StorageService()->CommandCompleted(Command.UUID, Payload,
 														   rpc_execution_time, true);
 						Command.State = 1;
 					} else {
-						//						std::cout << __LINE__ << std::endl;
 						StorageService()->CommandCompleted(Command.UUID, Payload,
 														   rpc_execution_time, true);
 						std::string ErrorTxt = Status->get("result");
@@ -186,14 +179,11 @@ namespace OpenWifi {
 						Command.State = 0;
 					}
 				} else {
-					//					std::cout << __LINE__ << std::endl;
 				}
 			} else {
-				//				std::cout << __LINE__ << std::endl;
 				Command.State = 0;
 			}
 		} else if (Command.State == 1) {
-			//			std::cout << "Completing script 2 phase commit." << std::endl;
 			StorageService()->CommandCompleted(Command.UUID, Payload, rpc_execution_time, true);
 			if (Command.Deferred) {
 				Reply = false;
@@ -202,7 +192,6 @@ namespace OpenWifi {
 		}
 
 		if (Command.State == 0) {
-			//			std::cout << __LINE__ << "  State=" << Command.State << std::endl;
 			OutStandingRequests_.erase(Command.Id);
 		}
 		if (Reply && TmpRpcEntry != nullptr)
@@ -262,8 +251,6 @@ namespace OpenWifi {
 		for (auto request = OutStandingRequests_.begin(); request != OutStandingRequests_.end();) {
 			std::chrono::duration<double, std::milli> delta = now - request->second.submitted;
 			if (delta > 10min) {
-				//				std::cout << __LINE__ << "  -->> " << request->second.Id <<
-				// std::endl;
 				MyLogger.debug(fmt::format("{}: Command={} for {} Timed out.", request->second.UUID,
 										   APCommands::to_string(request->second.Command),
 										   Utils::IntToSerialNumber(request->second.SerialNumber)));
@@ -275,8 +262,6 @@ namespace OpenWifi {
 				StorageService()->SetCommandTimedOut(request->second.UUID);
 				request = OutStandingRequests_.erase(request);
 			} else {
-				//				std::cout << __LINE__ << "  -->> " << request->second.Id <<
-				// std::endl;
 				++request;
 			}
 		}
diff --git a/src/ConfigurationCache.h b/src/ConfigurationCache.h
index f9717487..d2507eb7 100644
--- a/src/ConfigurationCache.h
+++ b/src/ConfigurationCache.h
@@ -11,12 +11,12 @@
 namespace OpenWifi {
 	class ConfigurationCache {
 	  public:
-		static ConfigurationCache &instance() {
-			static ConfigurationCache instance;
+		static auto instance() {
+			static auto instance = new ConfigurationCache;
 			return instance;
 		}
 
-		inline uint64_t CurrentConfig(uint64_t SerialNumber) {
+		inline uint64_t GetCurrentConfig(std::uint64_t SerialNumber) {
 			std::lock_guard G(Mutex_);
 			const auto Hint = Cache_.find(SerialNumber);
 			if (Hint == end(Cache_))
@@ -24,25 +24,25 @@ namespace OpenWifi {
 			return Hint->second;
 		}
 
-		inline void Add(uint64_t SerialNumber, uint64_t Id) {
+		inline void SetCurrentConfig(std::uint64_t SerialNumber, uint64_t Id) {
 			std::lock_guard G(Mutex_);
 			Cache_[SerialNumber] = Id;
 		}
 
 	  private:
-		std::recursive_mutex Mutex_;
+		std::mutex Mutex_;
 		std::map<uint64_t, uint64_t> Cache_;
 	};
 
-	inline uint64_t GetCurrentConfigurationID(uint64_t SerialNumber) {
-		return ConfigurationCache::instance().CurrentConfig(SerialNumber);
+	inline auto GetCurrentConfigurationID(std::uint64_t SerialNumber) {
+		return ConfigurationCache::instance()->GetCurrentConfig(SerialNumber);
 	}
 
-	inline void SetCurrentConfigurationID(const std::string &SerialNumber, uint64_t ID) {
-		return ConfigurationCache::instance().Add(Utils::SerialNumberToInt(SerialNumber), ID);
+	inline void SetCurrentConfigurationID(const std::string &SerialNumber, std::uint64_t ID) {
+		return ConfigurationCache::instance()->SetCurrentConfig(Utils::SerialNumberToInt(SerialNumber), ID);
 	}
 
-	inline void SetCurrentConfigurationID(uint64_t SerialNumber, uint64_t ID) {
-		return ConfigurationCache::instance().Add(SerialNumber, ID);
+	inline void SetCurrentConfigurationID(uint64_t SerialNumber, std::uint64_t ID) {
+		return ConfigurationCache::instance()->SetCurrentConfig(SerialNumber, ID);
 	}
 } // namespace OpenWifi
diff --git a/src/Daemon.cpp b/src/Daemon.cpp
index df40a93e..73e391e3 100644
--- a/src/Daemon.cpp
+++ b/src/Daemon.cpp
@@ -49,7 +49,7 @@ namespace OpenWifi {
 				SignatureManager(), AP_WS_Server(),
 				RegulatoryInfo(),
 				RADIUSSessionTracker(),
-				AP_WS_ConfigAutoUpgrader(),
+			 	AP_WS_ConfigAutoUpgradeAgent(),
 				FirmwareRevisionCache()
 			});
 		return &instance;
@@ -78,7 +78,7 @@ namespace OpenWifi {
 			if (Id == DeviceType)
 				return Type;
 		}
-		return "AP";
+		return Platforms::AP;
 	}
 
 	void DaemonPostInitialization(Poco::Util::Application &self) {
diff --git a/src/Dashboard.cpp b/src/Dashboard.cpp
index 43cff93e..ff76b41f 100644
--- a/src/Dashboard.cpp
+++ b/src/Dashboard.cpp
@@ -21,7 +21,6 @@ namespace OpenWifi {
 
 	void DeviceDashboard::Generate(GWObjects::Dashboard &D, Poco::Logger &Logger) {
 		if (GeneratingDashboard_.load()) {
-			// std::cout << "Trying to generate dashboard but already being generated" << std::endl;
 			while (GeneratingDashboard_.load()) {
 				Poco::Thread::trySleep(100);
 			}
@@ -31,7 +30,6 @@ namespace OpenWifi {
 			GeneratingDashboard_ = true;
 			ValidDashboard_ = false;
 			try {
-				// std::cout << "Generating dashboard." << std::endl;
 				poco_information(Logger, "DASHBOARD: Generating a new dashboard.");
 				GWObjects::Dashboard NewData;
 				StorageService()->AnalyzeCommands(NewData.commands);
diff --git a/src/FileUploader.h b/src/FileUploader.h
index 8cb3566a..38d91cd0 100644
--- a/src/FileUploader.h
+++ b/src/FileUploader.h
@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include "Poco/Net/HTTPRequestHandler.h"
-#include "Poco/Net/HTTPRequestHandlerFactory.h"
-#include "Poco/Net/HTTPServer.h"
-#include "Poco/Net/HTTPServerRequest.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"
+#include <framework/SubSystemServer.h>
 
 namespace OpenWifi {
 
diff --git a/src/GWKafkaEvents.h b/src/GWKafkaEvents.h
index 02075d93..5b74d766 100644
--- a/src/GWKafkaEvents.h
+++ b/src/GWKafkaEvents.h
@@ -50,12 +50,22 @@ namespace OpenWifi {
 	class DeviceConfigurationChangeKafkaEvent : public GWKafkaEvents {
 	  public:
 		DeviceConfigurationChangeKafkaEvent(std::uint64_t serialNumber,
-											std::uint64_t timestamp, const Poco::JSON::Object::Ptr config)
+											std::uint64_t timestamp,
+											const Poco::JSON::Object::Ptr config)
 			: GWKafkaEvents(serialNumber, "unit.configuration_change", timestamp), config_(config) {
 		}
 
 		~DeviceConfigurationChangeKafkaEvent() {
-			payload_->set("configuration", *config_);
+			if(config_!= nullptr) {
+				std::ostringstream os;
+				config_->stringify(os);
+				if(os.str().size()> KafkaManager()->KafkaManagerMaximumPayloadSize()) {
+					payload_->set("configuration", "{}");
+					payload_->set("configurationTooBig", true);
+				} else {
+					payload_->set("configuration", *config_);
+				}
+			}
 			Send();
 		}
 
diff --git a/src/ParseWifiScan.h b/src/ParseWifiScan.h
index 67df6e78..f27a009e 100644
--- a/src/ParseWifiScan.h
+++ b/src/ParseWifiScan.h
@@ -1753,7 +1753,6 @@ namespace OpenWifi {
 		nlohmann::json new_ie;
 		nlohmann::json content;
 
-		// std::cout << BufferToHex(&data[0],data.size()) << std::endl;
 		uint offset = 0;
 		auto sub_ie = data[offset++];
 		switch (sub_ie) {
@@ -1788,7 +1787,6 @@ namespace OpenWifi {
 
 		try {
 			nlohmann::json D = nlohmann::json::parse(ofs.str());
-			// std::cout << "Start of parsing wifi" << std::endl;
 			if (D.contains("status")) {
 				auto Status = D["status"];
 				if (Status.contains("scan") && Status["scan"].is_array()) {
@@ -1803,8 +1801,6 @@ namespace OpenWifi {
 									if (ie.contains("type") && ie.contains("data")) {
 										uint64_t ie_type = ie["type"];
 										std::string ie_data = ie["data"];
-										// std::cout << "TYPE:" << ie_type << "  DATA:" << ie_data
-										// << std::endl;
 										auto data = Base64Decode2Vec(ie_data);
 										if (ie_type == ieee80211_eid::WLAN_EID_COUNTRY) {
 											new_ies.push_back(WFS_WLAN_EID_COUNTRY(data));
@@ -1858,18 +1854,12 @@ namespace OpenWifi {
 										} else if (ie_type == ieee80211_eid::WLAN_EID_EXTENSION) {
 											new_ies.push_back(WFS_WLAN_EID_EXTENSION(data));
 										} else {
-											// std::cout
-											//	<< "Skipping IE: no parsing available: " << ie_type
-											//	<< std::endl;
 											new_ies.push_back(ie);
 										}
 									} else {
-										// std::cout << "Skipping IE: no data and type" <<
-										// std::endl;
 										new_ies.push_back(ie);
 									}
 								} catch (...) {
-									// std::cout << "Skipping IE: exception" << std::endl;
 									Logger.information(fmt::format("Error parsing IEs"));
 									new_ies.push_back(ie);
 								}
@@ -1877,7 +1867,6 @@ namespace OpenWifi {
 							scan_entry["ies"] = new_ies;
 							ParsedScan.push_back(scan_entry);
 						} else {
-							// std::cout << "Skipping scan" << std::endl;
 							ParsedScan.push_back(scan_entry);
 						}
 					}
@@ -1886,7 +1875,6 @@ namespace OpenWifi {
 				}
 			}
 			Result << to_string(D);
-			// std::cout << "End of parsing wifi" << std::endl;
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger.log(E);
diff --git a/src/RADIUSSessionTracker.cpp b/src/RADIUSSessionTracker.cpp
index e7020874..7442126b 100644
--- a/src/RADIUSSessionTracker.cpp
+++ b/src/RADIUSSessionTracker.cpp
@@ -177,15 +177,6 @@ namespace OpenWifi {
 		} else {
 			session_hint->second->lastTransaction = Utils::Now();
 		}
-
-/*
-		if(ap_hint!=AccountingSessions_.end()) {
-			std::cout << "Auth table:" << std::endl;
-			for(const auto &session:ap_hint->second) {
-				std::cout << Notification.SerialNumber_ << ":  Index: " << session.first << ": ID: " << session.second->accountingSessionId << "  MID:" << session.second->accountingMultiSessionId << std::endl;
-			}
-		}
-*/
 	}
 
 	std::uint32_t GetUiInt32(const std::uint8_t *buf) {
@@ -423,15 +414,15 @@ namespace OpenWifi {
 	}
 
 	void RADIUSSessionTracker::DisconnectSession(const std::string &SerialNumber) {
-		poco_information(Logger(),fmt::format("{}: Disconnecting.", SerialNumber));
 
 		std::lock_guard		Guard(Mutex_);
-
 		auto hint = AccountingSessions_.find(SerialNumber);
 		if(hint==end(AccountingSessions_)) {
 			return;
 		}
 
+		poco_information(Logger(),fmt::format("{}: Disconnecting.", SerialNumber));
+
 		//	we need to go through all sessions and send an accounting stop
 		for(const auto &session:hint->second) {
 			poco_debug(Logger(), fmt::format("Stopping accounting for {}:{}", SerialNumber, session.first ));
diff --git a/src/RADIUS_Destination.h b/src/RADIUS_Destination.h
index f3a4c806..03884d23 100644
--- a/src/RADIUS_Destination.h
+++ b/src/RADIUS_Destination.h
@@ -75,8 +75,10 @@ namespace OpenWifi {
 				} else if ((Utils::Now() - LastKeepAlive) > Pool_.radsecKeepAlive) {
 					RADIUS::RadiusOutputPacket P(Pool_.authConfig.servers[ServerIndex_].radsecSecret);
 					P.MakeStatusMessage(Pool_.authConfig.servers[ServerIndex_].name);
-					poco_trace(Logger_, fmt::format("{}: Keep-Alive message.", Pool_.authConfig.servers[ServerIndex_].name));
-					Socket_->sendBytes(P.Data(), P.Len());
+					if(Type_!=GWObjects::RadiusEndpointType::generic) {
+						poco_trace(Logger_, fmt::format("{}: Keep-Alive message.", Pool_.authConfig.servers[ServerIndex_].name));
+						Socket_->sendBytes(P.Data(), P.Len());
+					}
 					LastKeepAlive = Utils::Now();
 				}
 				Poco::Thread::trySleep(2000);
@@ -163,17 +165,16 @@ namespace OpenWifi {
 									 fmt::format("Unknown packet: Type: {} (type={}) Length={}",
 												 P.PacketType(), P.PacketTypeInt(), P.BufferLen()));
 					}
+					return;
 				} else {
 					poco_warning(Logger_, "Invalid packet received. Resetting the connection.");
-					Disconnect();
 				}
 			} catch (const Poco::Exception &E) {
 				Logger_.log(E);
-				Disconnect();
 			} catch (...) {
-				Disconnect();
 				poco_warning(Logger_, "Exception occurred. Resetting the connection.");
 			}
+			Disconnect();
 		}
 
 		inline void
@@ -324,7 +325,7 @@ namespace OpenWifi {
 				ofs << OpenRoamingRootCert;
 				ofs.close();
 
-				Poco::Net::Context::Ptr SecureContext = Poco::AutoPtr<Poco::Net::Context>(
+				auto SecureContext = Poco::AutoPtr<Poco::Net::Context>(
 					new Poco::Net::Context(Poco::Net::Context::TLS_CLIENT_USE, ""));
 
 				if (Pool_.acctConfig.servers[ServerIndex_].allowSelfSigned) {
@@ -430,7 +431,7 @@ namespace OpenWifi {
 					DecodeFile(CaCertFiles_[CaCertFiles_.size() - 1]->path(), cert);
 				}
 
-				Poco::Net::Context::Ptr SecureContext =
+				auto SecureContext =
 					Poco::AutoPtr<Poco::Net::Context>(new Poco::Net::Context(
 						Poco::Net::Context::TLS_CLIENT_USE, KeyFile_.path(), CertFile_.path(), ""));
 				if (Pool_.acctConfig.servers[ServerIndex_].allowSelfSigned) {
@@ -498,7 +499,9 @@ namespace OpenWifi {
 		}
 
 		inline bool Connect_Generic() {
-			if (TryAgain_) {
+			poco_information(Logger_, fmt::format("Connecting {}", Pool_.name));
+			if (TryAgain_ && !Connected_) {
+
 				std::lock_guard G(LocalMutex_);
 
 				Poco::Net::SocketAddress AuthSockAddrV4(
@@ -520,18 +523,30 @@ namespace OpenWifi {
 					MicroServiceConfigGetInt("radius.proxy.coa.port", DEFAULT_RADIUS_CoA_PORT));
 				CoASocketV4_ = std::make_unique<Poco::Net::DatagramSocket>(CoASockAddrV4, true, true);
 
+				Reactor_.addEventHandler(
+					*AuthenticationSocketV4_,
+					Poco::NObserver<RADIUS_Destination, Poco::Net::ReadableNotification>(
+						*this, &RADIUS_Destination::OnAuthenticationSocketReadable));
+				Reactor_.addEventHandler(
+					*AccountingSocketV4_,
+					Poco::NObserver<RADIUS_Destination, Poco::Net::ReadableNotification>(
+						*this, &RADIUS_Destination::OnAccountingSocketReadable));
+				Reactor_.addEventHandler(
+					*CoASocketV4_, Poco::NObserver<RADIUS_Destination, Poco::Net::ReadableNotification>(
+									   *this, &RADIUS_Destination::OnCoASocketReadable));
+
 /*
-				AuthenticationSocketV6_ =
-					std::make_unique<Poco::Net::DatagramSocket>(AuthSockAddrV6, true, true);
- 				Poco::Net::SocketAddress AuthSockAddrV6(
+				Poco::Net::SocketAddress AuthSockAddrV6(
 					Poco::Net::AddressFamily::IPv6,
 					MicroServiceConfigGetInt("radius.proxy.authentication.port",
 											 DEFAULT_RADIUS_AUTHENTICATION_PORT));
+				AuthenticationSocketV6_ =
+					std::make_unique<Poco::Net::DatagramSocket>(AuthSockAddrV6, true, true);
 
 				Poco::Net::SocketAddress AcctSockAddrV6(
 					Poco::Net::AddressFamily::IPv6,
 					MicroServiceConfigGetInt("radius.proxy.accounting.port",
-											 DEFAULT_RADIUS_ACCOUNTING_PORT));
+											 DEFAULT_RADIUS_AUTHENTICATION_PORT));
 				AccountingSocketV6_ =
 					std::make_unique<Poco::Net::DatagramSocket>(AcctSockAddrV6, true, true);
 
@@ -539,19 +554,7 @@ namespace OpenWifi {
 					Poco::Net::AddressFamily::IPv6,
 					MicroServiceConfigGetInt("radius.proxy.coa.port", DEFAULT_RADIUS_CoA_PORT));
 				CoASocketV6_ = std::make_unique<Poco::Net::DatagramSocket>(CoASockAddrV6, true, true);
-*/
-				Reactor_.addEventHandler(
-					*AuthenticationSocketV4_,
-					Poco::NObserver<RADIUS_Destination, Poco::Net::ReadableNotification>(
-						*this, &RADIUS_Destination::OnAuthenticationSocketReadable));
-				Reactor_.addEventHandler(
-					*AccountingSocketV4_,
-					Poco::NObserver<RADIUS_Destination, Poco::Net::ReadableNotification>(
-						*this, &RADIUS_Destination::OnAccountingSocketReadable));
-				Reactor_.addEventHandler(
-					*CoASocketV4_, Poco::NObserver<RADIUS_Destination, Poco::Net::ReadableNotification>(
-									   *this, &RADIUS_Destination::OnCoASocketReadable));
-/*
+
 				Reactor_.addEventHandler(
 					*AuthenticationSocketV6_,
 					Poco::NObserver<RADIUS_Destination, Poco::Net::ReadableNotification>(
@@ -565,6 +568,7 @@ namespace OpenWifi {
 					*CoASocketV6_, Poco::NObserver<RADIUS_Destination, Poco::Net::ReadableNotification>(
 									   *this, &RADIUS_Destination::OnCoASocketReadable));
 */
+				Connected_ = true;
 			}
 			return true;
 		}
@@ -590,6 +594,8 @@ namespace OpenWifi {
 			if (Connected_) {
 				std::lock_guard G(LocalMutex_);
 				if(Type_==GWObjects::RadiusEndpointType::generic) {
+					poco_information(Logger_, fmt::format("Disconnecting {} generic server. Releasing all UDP resources.", Pool_.name));
+
 					if(AuthenticationSocketV4_) {
 						Reactor_.removeEventHandler(
 							*AuthenticationSocketV4_,
@@ -617,7 +623,8 @@ namespace OpenWifi {
 						CoASocketV4_.reset();
 					}
 
-/*					if(AuthenticationSocketV6_) {
+/*
+ 					if(AuthenticationSocketV6_) {
 						Reactor_.removeEventHandler(
 							*AuthenticationSocketV6_,
 							Poco::NObserver<RADIUS_Destination, Poco::Net::ReadableNotification>(
@@ -646,7 +653,6 @@ namespace OpenWifi {
 */
 				} else {
 					if(Socket_!=nullptr) {
-						std::lock_guard G(LocalMutex_);
 						Reactor_.removeEventHandler(
 							*Socket_, Poco::NObserver<RADIUS_Destination, Poco::Net::ReadableNotification>(
 										  *this, &RADIUS_Destination::onData));
@@ -660,9 +666,9 @@ namespace OpenWifi {
 						Socket_->close();
 					}
 				}
+				Connected_ = false;
 			}
-			Connected_ = false;
-			poco_information(Logger_, "Disconnecting.");
+			poco_information(Logger_, fmt::format("Disconnecting {}", Pool_.name));
 		}
 
 		static void DecodeFile(const std::string &filename, const std::string &s) {
@@ -724,7 +730,8 @@ namespace OpenWifi {
 		std::unique_ptr<Poco::Net::DatagramSocket> 		AuthenticationSocketV4_;
 		std::unique_ptr<Poco::Net::DatagramSocket> 		CoASocketV4_;
 
-/*		std::unique_ptr<Poco::Net::DatagramSocket> 		CoASocketV6_;
+/*
+ 		std::unique_ptr<Poco::Net::DatagramSocket> 		CoASocketV6_;
 		std::unique_ptr<Poco::Net::DatagramSocket> 		AccountingSocketV6_;
 		std::unique_ptr<Poco::Net::DatagramSocket> 		AuthenticationSocketV6_;
 */
diff --git a/src/RESTAPI/RESTAPI_blacklist.cpp b/src/RESTAPI/RESTAPI_blacklist.cpp
index 42259b88..b4c96c58 100644
--- a/src/RESTAPI/RESTAPI_blacklist.cpp
+++ b/src/RESTAPI/RESTAPI_blacklist.cpp
@@ -63,7 +63,7 @@ namespace OpenWifi {
 		poco_debug(Logger(), fmt::format("BLACKLIST-POST: {}", D.serialNumber));
 
 		Poco::toLowerInPlace(D.serialNumber);
-		if (StorageService()->IsBlackListed(D.serialNumber)) {
+		if (StorageService()->IsBlackListed(Utils::MACToInt(D.serialNumber))) {
 			return BadRequest(RESTAPI::Errors::SerialNumberExists);
 		}
 
diff --git a/src/RESTAPI/RESTAPI_default_configuration.cpp b/src/RESTAPI/RESTAPI_default_configuration.cpp
index 56944b9a..9ada772f 100644
--- a/src/RESTAPI/RESTAPI_default_configuration.cpp
+++ b/src/RESTAPI/RESTAPI_default_configuration.cpp
@@ -56,17 +56,27 @@ namespace OpenWifi {
 			return BadRequest(RESTAPI::Errors::InvalidJSONDocument);
 		}
 
-		if (DefConfig.Models.empty()) {
+		if (DefConfig.models.empty()) {
 			return BadRequest(RESTAPI::Errors::ModelIDListCannotBeEmpty);
 		}
 
-		std::vector<std::string> Error;
-		if (!ValidateUCentralConfiguration(DefConfig.Configuration, Error,
+		DefConfig.platform = DefConfig.platform.empty() ? Platforms::AP : DefConfig.platform;
+		if(DefConfig.platform != Platforms::AP && DefConfig.platform != Platforms::SWITCH) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
+
+		if(DefConfig.configuration.empty()) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
+
+		std::string Error;
+		if (!ValidateUCentralConfiguration(ConfigurationValidator::GetType(DefConfig.platform),
+										   DefConfig.configuration, Error,
 										   GetBoolParameter("strict", false))) {
-			return BadRequest(RESTAPI::Errors::ConfigBlockInvalid);
+			return BadRequest(RESTAPI::Errors::ConfigBlockInvalid, Error);
 		}
 
-		DefConfig.Created = DefConfig.LastModified = Utils::Now();
+		DefConfig.created = DefConfig.lastModified = Utils::Now();
 		if (StorageService()->CreateDefaultConfiguration(Name, DefConfig)) {
 			return OK();
 		}
@@ -88,19 +98,31 @@ namespace OpenWifi {
 			return NotFound();
 		}
 
-		if (!NewConfig.Configuration.empty()) {
-			std::vector<std::string> Error;
-			if (!ValidateUCentralConfiguration(NewConfig.Configuration, Error,
+		if(Existing.platform.empty()) {
+			Existing.platform = Platforms::AP;
+		}
+
+		if(ParsedBody_->has("platform")) {
+			if(NewConfig.platform.empty() || (NewConfig.platform != Platforms::AP && NewConfig.platform != Platforms::SWITCH)) {
+				return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+			}
+			Existing.platform = NewConfig.platform;
+		}
+
+		if (!NewConfig.configuration.empty()) {
+			std::string Error;
+			if (!ValidateUCentralConfiguration(ConfigurationValidator::GetType(Existing.platform),
+											   NewConfig.configuration, Error,
 											   GetBoolParameter("strict", false))) {
-				return BadRequest(RESTAPI::Errors::ConfigBlockInvalid);
+				return BadRequest(RESTAPI::Errors::ConfigBlockInvalid, Error);
 			}
-			Existing.Configuration = NewConfig.Configuration;
+			Existing.configuration = NewConfig.configuration;
 		}
 
-		Existing.LastModified = Utils::Now();
-		AssignIfPresent(Obj, "description", Existing.Description);
+		Existing.lastModified = Utils::Now();
+		AssignIfPresent(Obj, "description", Existing.description);
 		if (Obj->has("modelIds"))
-			Existing.Models = NewConfig.Models;
+			Existing.models = NewConfig.models;
 
 		if (StorageService()->UpdateDefaultConfiguration(Name, Existing)) {
 			GWObjects::DefaultConfiguration ModifiedConfig;
diff --git a/src/RESTAPI/RESTAPI_device_commandHandler.cpp b/src/RESTAPI/RESTAPI_device_commandHandler.cpp
index bc23d40c..e0a6f0d4 100644
--- a/src/RESTAPI/RESTAPI_device_commandHandler.cpp
+++ b/src/RESTAPI/RESTAPI_device_commandHandler.cpp
@@ -87,7 +87,7 @@ namespace OpenWifi {
 			poco_debug(
 				Logger_,
 				fmt::format(
-					"Command rtty TID={} can proceed. Identified as {} and RPCID as {}. thr_id={}",
+					"Command RTTY TID={} can proceed. Identified as {} and RPCID as {}. thr_id={}",
 					TransactionId_, UUID, RPC, Poco::Thread::current()->id()));
 			return Rtty(UUID, RPC, 60000ms, Restrictions);
 		};
@@ -166,7 +166,8 @@ namespace OpenWifi {
 		{APCommands::Commands::rrm, false, true, &RESTAPI_device_commandHandler::RRM, 60000ms},
 		{APCommands::Commands::certupdate, false, true, &RESTAPI_device_commandHandler::CertUpdate, 60000ms},
 		{APCommands::Commands::transfer, false, true, &RESTAPI_device_commandHandler::Transfer, 60000ms},
-		{APCommands::Commands::script, false, true, &RESTAPI_device_commandHandler::Script, 60000ms}
+		{APCommands::Commands::script, false, true, &RESTAPI_device_commandHandler::Script, 60000ms},
+		{APCommands::Commands::powercycle, false, true, &RESTAPI_device_commandHandler::PowerCycle, 60000ms}
 	};
 
 	void RESTAPI_device_commandHandler::DoPost() {
@@ -653,13 +654,18 @@ namespace OpenWifi {
 				return BadRequest(RESTAPI::Errors::SerialNumberMismatch);
 			}
 
+			GWObjects::Device DeviceInfo;
+			if (!StorageService()->GetDevice(SerialNumber_, DeviceInfo)) {
+				return NotFound();
+			}
 			auto Configuration =
 				GetS(RESTAPI::Protocol::CONFIGURATION, Obj, uCentralProtocol::EMPTY_JSON_DOC);
-			std::vector<std::string> Error;
-			if (!ValidateUCentralConfiguration(Configuration, Error,
+			std::string Error;
+			if (!ValidateUCentralConfiguration(ConfigurationValidator::GetType(DeviceInfo.DeviceType),
+											   Configuration, Error,
 											   GetBoolParameter("strict", false))) {
 				CallCanceled("CONFIGURE", CMD_UUID, CMD_RPC, RESTAPI::Errors::ConfigBlockInvalid);
-				return BadRequest(RESTAPI::Errors::ConfigBlockInvalid);
+				return BadRequest(RESTAPI::Errors::ConfigBlockInvalid, Error);
 			}
 
 			auto When = GetWhen(Obj);
@@ -1169,7 +1175,7 @@ namespace OpenWifi {
 
 				if (RTTYS_server()->UseInternal()) {
 					std::uint64_t SN = Utils::SerialNumberToInt(SerialNumber_);
-					bool mTLS = AP_WS_Server()->DeviceRequiresSecureRtty(SN);
+					bool mTLS = AP_WS_Server()->DeviceRequiresSecureRTTY(SN);
 					auto Hash =  Utils::ComputeHash(UserInfo_.webtoken.refresh_token_, Utils::Now());
 					Rtty.Token = Hash.substr(0, RTTY_DEVICE_TOKEN_LENGTH);
 					if (!RTTYS_server()->CreateEndPoint(Rtty.ConnectionId, Rtty.Token, Requester(),
@@ -1401,9 +1407,9 @@ namespace OpenWifi {
 		Cmd.WaitingForFile = 0;
 		Cmd.Status= "completed";
 		if(CommandManager()->FireAndForget(SerialNumber_, uCentralProtocol::RRM, Params)) {
+			Cmd.Status= "completed";
 			StorageService()->AddCommand(SerialNumber_, Cmd,
 										 Storage::CommandExecutionType::COMMAND_COMPLETED);
-			Cmd.Status= "completed";
 			return OK();
 		}
 		Cmd.Status= "failed";	//	should never happen
@@ -1501,4 +1507,45 @@ namespace OpenWifi {
 
 	}
 
+	void RESTAPI_device_commandHandler::PowerCycle(
+		const std::string &CMD_UUID, uint64_t CMD_RPC,
+		[[maybe_unused]] std::chrono::milliseconds timeout,
+		[[maybe_unused]] const GWObjects::DeviceRestrictions &Restrictions) {
+
+		if(UserInfo_.userinfo.userRole != SecurityObjects::ROOT &&
+			UserInfo_.userinfo.userRole != SecurityObjects::ADMIN) {
+			CallCanceled("RRM", CMD_UUID, CMD_RPC, RESTAPI::Errors::ACCESS_DENIED);
+			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
+		}
+
+		poco_debug(Logger_, fmt::format("POWERCYCLE({},{}): TID={} user={} serial={}", CMD_UUID,
+										CMD_RPC, TransactionId_, Requester(), SerialNumber_));
+
+		if(IsDeviceSimulated(SerialNumber_)) {
+			CallCanceled("RRM", CMD_UUID, CMD_RPC, RESTAPI::Errors::SimulatedDeviceNotSupported);
+			return BadRequest(RESTAPI::Errors::SimulatedDeviceNotSupported);
+		}
+
+		GWObjects::PowerCycleRequest	PR;
+		if(!PR.from_json(ParsedBody_)) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
+
+		GWObjects::CommandDetails Cmd;
+		Cmd.SerialNumber = SerialNumber_;
+		Cmd.SubmittedBy = Requester();
+		Cmd.UUID = CMD_UUID;
+		Cmd.Command = uCentralProtocol::POWERCYCLE;
+		std::ostringstream os;
+		ParsedBody_->stringify(os);
+		Cmd.Details = os.str();
+		Cmd.RunAt = PR.when;
+		Cmd.ErrorCode = 0;
+		Cmd.WaitingForFile = 0;
+
+		return RESTAPI_RPC::WaitForCommand(CMD_RPC, APCommands::Commands::powercycle, false, Cmd,
+										   *ParsedBody_, *Request, *Response, timeout, nullptr, this,
+										   Logger_);
+	}
+
 } // namespace OpenWifi
diff --git a/src/RESTAPI/RESTAPI_device_commandHandler.h b/src/RESTAPI/RESTAPI_device_commandHandler.h
index 57c84a06..e20800f3 100644
--- a/src/RESTAPI/RESTAPI_device_commandHandler.h
+++ b/src/RESTAPI/RESTAPI_device_commandHandler.h
@@ -68,6 +68,8 @@ namespace OpenWifi {
 					const GWObjects::DeviceRestrictions &R);
 		void Transfer(const std::string &UUID, uint64_t RPC, std::chrono::milliseconds timeout,
 					const GWObjects::DeviceRestrictions &R);
+		void PowerCycle(const std::string &UUID, uint64_t RPC, std::chrono::milliseconds timeout,
+					  const GWObjects::DeviceRestrictions &R);
 
 		static auto PathName() {
 			return std::list<std::string>{"/api/v1/device/{serialNumber}/{command}"};
diff --git a/src/RESTAPI/RESTAPI_device_handler.cpp b/src/RESTAPI/RESTAPI_device_handler.cpp
index 3c7b53ae..778a9027 100644
--- a/src/RESTAPI/RESTAPI_device_handler.cpp
+++ b/src/RESTAPI/RESTAPI_device_handler.cpp
@@ -101,9 +101,10 @@ namespace OpenWifi {
 			}
 			auto Config = Obj->get("configuration").toString();
 			Poco::JSON::Object Answer;
-			std::vector<std::string> Error;
+			std::string Error;
+			auto DeviceType = Poco::toLower(GetParameter("deviceType", Platforms::AP));
 			auto Res =
-				ValidateUCentralConfiguration(Config, Error, GetBoolParameter("strict", false));
+				ValidateUCentralConfiguration(ConfigurationValidator::GetType(DeviceType),Config, Error, GetBoolParameter("strict", false));
 			Answer.set("valid", Res);
 			if (!Error.empty())
 				Answer.set("error", Error);
@@ -123,12 +124,13 @@ namespace OpenWifi {
 			return BadRequest(RESTAPI::Errors::SerialNumberMismatch);
 		}
 
-		std::vector<std::string> Error;
+		std::string Error;
 		if (Device.Configuration.empty() ||
 			(!Device.Configuration.empty() &&
-			 !ValidateUCentralConfiguration(Device.Configuration, Error,
+			 !ValidateUCentralConfiguration(ConfigurationValidator::GetType(Device.DeviceType),
+											Device.Configuration, Error,
 											GetBoolParameter("strict", false)))) {
-			return BadRequest(RESTAPI::Errors::ConfigBlockInvalid);
+			return BadRequest(RESTAPI::Errors::ConfigBlockInvalid, Error);
 		}
 
 		for (auto &i : Device.Notes) {
@@ -169,10 +171,11 @@ namespace OpenWifi {
 		}
 
 		if (!NewDevice.Configuration.empty()) {
-			std::vector<std::string> Error;
-			if (!ValidateUCentralConfiguration(NewDevice.Configuration, Error,
+			std::string Error;
+			if (!ValidateUCentralConfiguration(ConfigurationValidator::GetType(Existing.DeviceType),
+											   NewDevice.Configuration, Error,
 											   GetBoolParameter("strict", false))) {
-				return BadRequest(RESTAPI::Errors::ConfigBlockInvalid);
+				return BadRequest(RESTAPI::Errors::ConfigBlockInvalid, Error);
 			}
 			Config::Config NewConfig(NewDevice.Configuration);
 			uint64_t NewConfigUUID = Utils::Now();
diff --git a/src/RESTAPI/RESTAPI_devices_handler.cpp b/src/RESTAPI/RESTAPI_devices_handler.cpp
index 7d67f990..2a78cf7b 100644
--- a/src/RESTAPI/RESTAPI_devices_handler.cpp
+++ b/src/RESTAPI/RESTAPI_devices_handler.cpp
@@ -82,15 +82,23 @@ namespace OpenWifi {
 			}
 		}
 
+		auto platform = Poco::toLower(GetParameter("platform", ""));
 		auto serialOnly = GetBoolParameter(RESTAPI::Protocol::SERIALONLY, false);
 		auto deviceWithStatus = GetBoolParameter(RESTAPI::Protocol::DEVICEWITHSTATUS, false);
 		auto completeInfo = GetBoolParameter("completeInfo", false);
 
+		if(!platform.empty() && (platform!=Platforms::AP && platform!=Platforms::SWITCH && platform!="all")) {
+			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
+		}
+
+		if(platform=="all")
+			platform="";
+
 		Poco::JSON::Object RetObj;
 		if (!QB_.Select.empty()) {
 			Poco::JSON::Array Objects;
 			for (auto &i : SelectedRecords()) {
-				auto SerialNumber = i;
+				auto &SerialNumber = i;
 				if (!Utils::ValidSerialNumber(i))
 					continue;
 				GWObjects::Device D;
@@ -116,14 +124,14 @@ namespace OpenWifi {
 			else
 				RetObj.set(RESTAPI::Protocol::DEVICES, Objects);
 
-		} else if (QB_.CountOnly == true) {
+		} else if (QB_.CountOnly) {
 			uint64_t Count = 0;
-			if (StorageService()->GetDeviceCount(Count)) {
+			if (StorageService()->GetDeviceCount(Count, platform)) {
 				return ReturnCountOnly(Count);
 			}
 		} else if (serialOnly) {
 			std::vector<std::string> SerialNumbers;
-			StorageService()->GetDeviceSerialNumbers(QB_.Offset, QB_.Limit, SerialNumbers, OrderBy);
+			StorageService()->GetDeviceSerialNumbers(QB_.Offset, QB_.Limit, SerialNumbers, OrderBy, platform);
 			Poco::JSON::Array Objects;
 			for (const auto &i : SerialNumbers) {
 				Objects.add(i);
@@ -141,7 +149,7 @@ namespace OpenWifi {
 			RetObj.set("serialNumbers", Objects);
 		} else {
 			std::vector<GWObjects::Device> Devices;
-			StorageService()->GetDevices(QB_.Offset, QB_.Limit, Devices, OrderBy);
+			StorageService()->GetDevices(QB_.Offset, QB_.Limit, Devices, OrderBy, platform);
 			Poco::JSON::Array Objects;
 			for (const auto &i : Devices) {
 				Poco::JSON::Object Obj;
@@ -175,10 +183,12 @@ namespace OpenWifi {
 		}
 
 		if(GetBoolParameter("simulatedDevices",false)) {
-			if(StorageService()->DeleteSimulatedDevice("")) {
-				return OK();
-			}
-			return NotFound();
+			auto F = []() ->void {
+				StorageService()->DeleteSimulatedDevice("");
+			};
+			std::thread T(F);
+			T.detach();
+			return OK();
 		}
 
 		if(!QB_.Select.empty() && !Utils::ValidSerialNumbers(QB_.Select)) {
diff --git a/src/RESTAPI/RESTAPI_file.h b/src/RESTAPI/RESTAPI_file.h
index c18174a7..9a9c446f 100644
--- a/src/RESTAPI/RESTAPI_file.h
+++ b/src/RESTAPI/RESTAPI_file.h
@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "framework/RESTAPI_Handler.h"
+#include <framework/RESTAPI_Handler.h>
 
 namespace OpenWifi {
 	class RESTAPI_file : public RESTAPIHandler {
diff --git a/src/RESTObjects/RESTAPI_AnalyticsObjects.h b/src/RESTObjects/RESTAPI_AnalyticsObjects.h
index dac46c78..27195182 100644
--- a/src/RESTObjects/RESTAPI_AnalyticsObjects.h
+++ b/src/RESTObjects/RESTAPI_AnalyticsObjects.h
@@ -7,6 +7,7 @@
 #include "RESTAPI_ProvObjects.h"
 #include "framework/utils.h"
 #include <vector>
+#include "framework/ow_constants.h"
 
 namespace OpenWifi {
 
diff --git a/src/RESTObjects/RESTAPI_GWobjects.cpp b/src/RESTObjects/RESTAPI_GWobjects.cpp
index 8d02d3a5..621b4f94 100644
--- a/src/RESTObjects/RESTAPI_GWobjects.cpp
+++ b/src/RESTObjects/RESTAPI_GWobjects.cpp
@@ -12,6 +12,7 @@
 #include "Daemon.h"
 #ifdef TIP_GATEWAY_SERVICE
 #include "AP_WS_Server.h"
+#include "StorageService.h"
 #include "CapabilitiesCache.h"
 #include "RADIUSSessionTracker.h"
 #endif
@@ -30,7 +31,7 @@ namespace OpenWifi::GWObjects {
 		field_to_json(Obj, "serialNumber", SerialNumber);
 #ifdef TIP_GATEWAY_SERVICE
 		field_to_json(Obj, "deviceType", CapabilitiesCache::instance()->GetPlatform(Compatible));
-		field_to_json(Obj, "hasRADIUSSessions", RADIUSSessionTracker()->HasSessions(SerialNumber));
+		field_to_json(Obj, "blackListed", StorageService()->IsBlackListed(Utils::MACToInt(SerialNumber)));
 #endif
 		field_to_json(Obj, "macAddress", MACAddress);
 		field_to_json(Obj, "manufacturer", Manufacturer);
@@ -68,9 +69,14 @@ namespace OpenWifi::GWObjects {
 
 #ifdef TIP_GATEWAY_SERVICE
 		ConnectionState ConState;
-
-		if (AP_WS_Server()->GetState(SerialNumber, ConState)) {
+#ifdef USE_MEDUSA_CLIENT
+        auto Res = GS()->GetState(SerialNumber);
+        if (Res.has_value()) {
+            Res.value().to_json(SerialNumber,Obj);
+#else
+        if (AP_WS_Server()->GetState(SerialNumber, ConState)) {
 			ConState.to_json(SerialNumber,Obj);
+#endif
 		} else {
 			field_to_json(Obj, "ipAddress", "");
 			field_to_json(Obj, "txBytes", (uint64_t)0);
@@ -166,14 +172,17 @@ namespace OpenWifi::GWObjects {
 		field_to_json(Obj, "recorded", Recorded);
 	}
 
-	void DefaultConfiguration::to_json(Poco::JSON::Object &Obj) const {
-		EmbedDocument("configuration", Obj, Configuration);
-		field_to_json(Obj, "name", Name);
-		field_to_json(Obj, "modelIds", Models);
-		field_to_json(Obj, "description", Description);
-		field_to_json(Obj, "created", Created);
-		field_to_json(Obj, "lastModified", LastModified);
-	}
+    bool HealthCheck::from_json(const Poco::JSON::Object::Ptr &Obj) {
+        try {
+            field_from_json(Obj, "UUID", UUID);
+            field_from_json(Obj, "sanity", Sanity);
+            field_from_json(Obj, "recorded", Recorded);
+            return true;
+        } catch(...) {
+
+        }
+        return false;
+    }
 
 	void DefaultFirmware::to_json(Poco::JSON::Object &Obj) const {
 		field_to_json(Obj, "deviceType", deviceType);
@@ -222,12 +231,25 @@ namespace OpenWifi::GWObjects {
 		field_to_json(Obj, "deferred", deferred);
 	}
 
+	void DefaultConfiguration::to_json(Poco::JSON::Object &Obj) const {
+		EmbedDocument("configuration", Obj, configuration);
+		field_to_json(Obj, "name", name);
+		field_to_json(Obj, "modelIds", models);
+		field_to_json(Obj, "description", description);
+		field_to_json(Obj, "created", created);
+		field_to_json(Obj, "lastModified", lastModified);
+		field_to_json(Obj, "platform", platform);
+	}
+
 	bool DefaultConfiguration::from_json(const Poco::JSON::Object::Ptr &Obj) {
 		try {
-			field_from_json(Obj, "name", Name);
-			field_from_json(Obj, "configuration", Configuration);
-			field_from_json(Obj, "modelIds", Models);
-			field_from_json(Obj, "description", Description);
+			field_from_json(Obj, "configuration", configuration);
+			field_from_json(Obj, "name", name);
+			field_from_json(Obj, "modelIds", models);
+			field_from_json(Obj, "description", description);
+			field_from_json(Obj, "created", created);
+			field_from_json(Obj, "lastModified", lastModified);
+			field_from_json(Obj, "platform", platform);
 			return true;
 		} catch (const Poco::Exception &E) {
 		}
@@ -276,13 +298,11 @@ namespace OpenWifi::GWObjects {
 		field_to_json(Obj, "totalConnectionTime", Utils::Now() - started);
 		field_to_json(Obj, "certificateExpiryDate", certificateExpiryDate);
 		field_to_json(Obj, "connectReason", connectReason);
+		field_to_json(Obj, "uptime", uptime);
+        field_to_json(Obj, "compatible", Compatible);
 
 #ifdef TIP_GATEWAY_SERVICE
 		hasRADIUSSessions = RADIUSSessionTracker()->HasSessions(SerialNumber);
-		AP_WS_Server()->ExtendedAttributes(SerialNumber, hasGPS, sanity,
-										   memoryUsed,
-										   load,
-										   temperature);
 #endif
 		field_to_json(Obj, "hasRADIUSSessions", hasRADIUSSessions );
 		field_to_json(Obj, "hasGPS", hasGPS);
@@ -314,6 +334,45 @@ namespace OpenWifi::GWObjects {
 		}
 	}
 
+    bool ConnectionState::from_json(const Poco::JSON::Object::Ptr &Obj) {
+        try {
+            field_from_json(Obj, "compatible", Compatible);
+            field_from_json(Obj, "ipAddress", Address);
+            field_from_json(Obj, "txBytes", TX);
+            field_from_json(Obj, "rxBytes", RX);
+            field_from_json(Obj, "messageCount", MessageCount);
+            field_from_json(Obj, "UUID", UUID);
+            field_from_json(Obj, "connected", Connected);
+            field_from_json(Obj, "firmware", Firmware);
+            field_from_json(Obj, "lastContact", LastContact);
+            field_from_json(Obj, "associations_2G", Associations_2G);
+            field_from_json(Obj, "associations_5G", Associations_5G);
+            field_from_json(Obj, "associations_6G", Associations_6G);
+            field_from_json(Obj, "webSocketClients", webSocketClients);
+            field_from_json(Obj, "websocketPackets", websocketPackets);
+            field_from_json(Obj, "kafkaClients", kafkaClients);
+            field_from_json(Obj, "kafkaPackets", kafkaPackets);
+            field_from_json(Obj, "locale", locale);
+            field_from_json(Obj, "started", started);
+            field_from_json(Obj, "sessionId", sessionId);
+            field_from_json(Obj, "connectionCompletionTime", connectionCompletionTime);
+            field_from_json(Obj, "totalConnectionTime", totalConnectionTime);
+            field_from_json(Obj, "certificateExpiryDate", certificateExpiryDate);
+            field_from_json(Obj, "connectReason", connectReason);
+            field_from_json(Obj, "uptime", uptime);
+            field_from_json(Obj, "hasRADIUSSessions", hasRADIUSSessions );
+            field_from_json(Obj, "hasGPS", hasGPS);
+            field_from_json(Obj, "sanity", sanity);
+            field_from_json(Obj, "memoryUsed", memoryUsed);
+            field_from_json(Obj, "sanity", sanity);
+            field_from_json(Obj, "load", load);
+            field_from_json(Obj, "temperature", temperature);
+            return true;
+        } catch(const Poco::Exception &E) {
+        }
+        return false;
+    }
+
 	void DeviceConnectionStatistics::to_json(Poco::JSON::Object &Obj) const {
 		field_to_json(Obj, "averageConnectionTime", averageConnectionTime);
 		field_to_json(Obj, "connectedDevices", connectedDevices);
@@ -711,7 +770,7 @@ namespace OpenWifi::GWObjects {
 
 	bool DeviceCertificateUpdateRequest::from_json(const Poco::JSON::Object::Ptr &Obj) {
 		try {
-			field_from_json(Obj, "serialNumber", serialNumber);
+			field_from_json(Obj, "serial", serialNumber);
 			field_from_json(Obj, "encodedCertificate", encodedCertificate);
 			return true;
 		} catch (const Poco::Exception &E) {
@@ -719,4 +778,25 @@ namespace OpenWifi::GWObjects {
 		return false;
 	}
 
+	bool PowerCyclePort::from_json(const Poco::JSON::Object::Ptr &Obj) {
+		try {
+			field_from_json(Obj, "name", name);
+			field_from_json(Obj, "cycle", cycle);
+			return true;
+		} catch (const Poco::Exception &E) {
+		}
+		return false;
+	}
+
+	bool PowerCycleRequest::from_json(const Poco::JSON::Object::Ptr &Obj) {
+		try {
+			field_from_json(Obj, "serial", serialNumber);
+			field_from_json(Obj, "when", when);
+			field_from_json(Obj, "ports", ports);
+			return true;
+		} catch (const Poco::Exception &E) {
+		}
+		return false;
+	}
+
 } // namespace OpenWifi::GWObjects
diff --git a/src/RESTObjects/RESTAPI_GWobjects.h b/src/RESTObjects/RESTAPI_GWobjects.h
index 168602c5..ed17aba7 100644
--- a/src/RESTObjects/RESTAPI_GWobjects.h
+++ b/src/RESTObjects/RESTAPI_GWobjects.h
@@ -49,8 +49,11 @@ namespace OpenWifi::GWObjects {
 		std::double_t load=0.0;
 		std::double_t temperature=0.0;
 		std::string 	connectReason;
+		std::uint64_t 	uptime=0;
+        std::uint64_t 	totalConnectionTime=0;
 
 		void to_json(const std::string &SerialNumber, Poco::JSON::Object &Obj) ;
+        bool from_json(const Poco::JSON::Object::Ptr &Obj);
 	};
 
 	struct DeviceRestrictionsKeyInfo {
@@ -112,6 +115,7 @@ namespace OpenWifi::GWObjects {
 		std::uint64_t 	lastRecordedContact=0;
 		std::uint64_t 	certificateExpiryDate = 0;
 		std::string 	connectReason;
+		bool			blackListed=false;
 
 		void to_json(Poco::JSON::Object &Obj) const;
 		void to_json_with_status(Poco::JSON::Object &Obj) const;
@@ -137,13 +141,15 @@ namespace OpenWifi::GWObjects {
 	};
 
 	struct HealthCheck {
-		std::string SerialNumber;
-		uint64_t UUID = 0;
-		std::string Data;
-		uint64_t Recorded = 0;
-		uint64_t Sanity = 0;
-		void to_json(Poco::JSON::Object &Obj) const;
-	};
+        std::string SerialNumber;
+        uint64_t UUID = 0;
+        std::string Data;
+        uint64_t Recorded = 0;
+        uint64_t Sanity = 0;
+
+        void to_json(Poco::JSON::Object &Obj) const;
+        bool from_json(const Poco::JSON::Object::Ptr &Obj);
+    };
 
 	struct Capabilities {
 		std::string Capabilities;
@@ -174,12 +180,13 @@ namespace OpenWifi::GWObjects {
 	};
 
 	struct DefaultConfiguration {
-		std::string Name;
-		std::string Configuration;
-		Types::StringVec Models;
-		std::string Description;
-		uint64_t Created;
-		uint64_t LastModified;
+		std::string name;
+		std::string configuration;
+		Types::StringVec models;
+		std::string description;
+		uint64_t created;
+		uint64_t lastModified;
+		std::string platform;
 		void to_json(Poco::JSON::Object &Obj) const;
 		bool from_json(const Poco::JSON::Object::Ptr &Obj);
 	};
@@ -513,4 +520,18 @@ namespace OpenWifi::GWObjects {
 		bool from_json(const Poco::JSON::Object::Ptr &Obj);
 	};
 
+	struct PowerCyclePort {
+		std::string 	name;
+		std::uint64_t 	cycle=10000;
+
+		bool from_json(const Poco::JSON::Object::Ptr &Obj);
+	};
+
+	struct PowerCycleRequest {
+		std::string 	serialNumber;
+		std::uint64_t 	when;
+		std::vector<PowerCyclePort> ports;
+
+		bool from_json(const Poco::JSON::Object::Ptr &Obj);
+	};
 } // namespace OpenWifi::GWObjects
diff --git a/src/RESTObjects/RESTAPI_ProvObjects.cpp b/src/RESTObjects/RESTAPI_ProvObjects.cpp
index 2a139f52..8cdb878b 100644
--- a/src/RESTObjects/RESTAPI_ProvObjects.cpp
+++ b/src/RESTObjects/RESTAPI_ProvObjects.cpp
@@ -587,6 +587,9 @@ namespace OpenWifi::ProvObjects {
 		field_to_json(Obj, "locale", locale);
 		field_to_json(Obj, "realMacAddress", realMacAddress);
 		field_to_json(Obj, "doNotAllowOverrides", doNotAllowOverrides);
+        field_to_json(Obj, "imported", imported);
+        field_to_json(Obj, "connected", connected);
+        field_to_json(Obj, "platform", platform);
 	}
 
 	bool InventoryTag::from_json(const Poco::JSON::Object::Ptr &Obj) {
@@ -609,6 +612,9 @@ namespace OpenWifi::ProvObjects {
 			field_from_json(Obj, "locale", locale);
 			field_from_json(Obj, "realMacAddress", realMacAddress);
 			field_from_json(Obj, "doNotAllowOverrides", doNotAllowOverrides);
+            field_from_json(Obj, "imported", imported);
+            field_from_json(Obj, "connected", connected);
+            field_from_json(Obj, "platform", platform);
 			return true;
 		} catch (...) {
 		}
diff --git a/src/RESTObjects/RESTAPI_ProvObjects.h b/src/RESTObjects/RESTAPI_ProvObjects.h
index 6014d617..e04c88a3 100644
--- a/src/RESTObjects/RESTAPI_ProvObjects.h
+++ b/src/RESTObjects/RESTAPI_ProvObjects.h
@@ -490,9 +490,11 @@ namespace OpenWifi::ProvObjects {
         std::string locale;
         std::string realMacAddress;
         bool doNotAllowOverrides = false;
+        std::uint64_t imported=0;
+        std::uint64_t connected=0;
+        std::string platform{Platforms::AP};
 
         void to_json(Poco::JSON::Object &Obj) const;
-
         bool from_json(const Poco::JSON::Object::Ptr &Obj);
     };
 
diff --git a/src/StateUtils.cpp b/src/StateUtils.cpp
index 5ab11170..7c0e3928 100644
--- a/src/StateUtils.cpp
+++ b/src/StateUtils.cpp
@@ -24,7 +24,7 @@ namespace OpenWifi::StateUtils {
 	}
 
 	bool ComputeAssociations(const Poco::JSON::Object::Ptr RawObject, uint64_t &Radios_2G,
-							 uint64_t &Radios_5G, uint64_t &Radios_6G) {
+							 uint64_t &Radios_5G, uint64_t &Radios_6G, uint64_t &UpTime	) {
 		Radios_2G = 0;
 		Radios_5G = 0;
 		Radios_6G = 0;
@@ -90,9 +90,15 @@ namespace OpenWifi::StateUtils {
 					}
 				}
 			}
-			//			std::cout << Radios_2G << " " << Radios_5G << " " << Radios_6G << std::endl;
 			return true;
 		}
+
+		if(RawObject->has("unit") && !RawObject->isNull("unit") && RawObject->isObject("unit")) {
+			auto unit = RawObject->getObject("unit");
+			if(unit->has("uptime")) {
+				UpTime = unit->get("uptime");
+			}
+		}
 		return false;
 	}
 } // namespace OpenWifi::StateUtils
\ No newline at end of file
diff --git a/src/StateUtils.h b/src/StateUtils.h
index ec2ec4ed..3ead447c 100644
--- a/src/StateUtils.h
+++ b/src/StateUtils.h
@@ -8,5 +8,5 @@
 
 namespace OpenWifi::StateUtils {
 	bool ComputeAssociations(const Poco::JSON::Object::Ptr RawObject, uint64_t &Radios_2G,
-							 uint64_t &Radios_5G, uint64_t &Radio_6G);
+							 uint64_t &Radios_5G, uint64_t &Radio_6G, uint64_t &UpTime);
 }
\ No newline at end of file
diff --git a/src/StorageService.cpp b/src/StorageService.cpp
index 1bc1bd2d..2adb993d 100644
--- a/src/StorageService.cpp
+++ b/src/StorageService.cpp
@@ -22,6 +22,8 @@ namespace OpenWifi {
 		ScriptDB_->Create();
 		ScriptDB_->Initialize();
 
+		FixDeviceTypeBug();
+
 		return 0;
 	}
 
diff --git a/src/StorageService.h b/src/StorageService.h
index a20a9f26..8be929cc 100644
--- a/src/StorageService.h
+++ b/src/StorageService.h
@@ -16,6 +16,22 @@
 
 namespace OpenWifi {
 
+	class LockedDbSession {
+	  public:
+		explicit LockedDbSession();
+		~LockedDbSession() = default;
+		inline std::mutex &Mutex() { return *Mutex_; };
+		inline Poco::Data::Session &Session() {
+			if(!Session_->isConnected()) {
+				Session_->reconnect();
+			}
+			return *Session_;
+		};
+	  private:
+		std::shared_ptr<Poco::Data::Session> 	Session_;
+		std::shared_ptr<std::mutex> 			Mutex_;
+	};
+
 	class Storage : public StorageClass {
 
 	  public:
@@ -90,7 +106,8 @@ namespace OpenWifi {
 
 		// typedef std::map<std::string,std::string>	DeviceCapabilitiesCache;
 
-		bool AddLog(const GWObjects::DeviceLog &Log);
+		bool AddLog(LockedDbSession &Session, const GWObjects::DeviceLog &Log);
+		bool AddStatisticsData(Poco::Data::Session &Session, const GWObjects::Statistics &Stats);
 		bool AddStatisticsData(const GWObjects::Statistics &Stats);
 		bool GetStatisticsData(std::string &SerialNumber, uint64_t FromDate, uint64_t ToDate,
 							   uint64_t Offset, uint64_t HowMany,
@@ -102,6 +119,7 @@ namespace OpenWifi {
 									 std::vector<GWObjects::Statistics> &Stats);
 
 		bool AddHealthCheckData(const GWObjects::HealthCheck &Check);
+		bool AddHealthCheckData(LockedDbSession &Session, const GWObjects::HealthCheck &Check);
 		bool GetHealthCheckData(std::string &SerialNumber, uint64_t FromDate, uint64_t ToDate,
 								uint64_t Offset, uint64_t HowMany,
 								std::vector<GWObjects::HealthCheck> &Checks);
@@ -115,16 +133,22 @@ namespace OpenWifi {
 									   uint64_t &NewUUID);
 
 		bool RollbackDeviceConfigurationChange(std::string & SerialNumber);
+		bool CompleteDeviceConfigurationChange(Poco::Data::Session &Session, std::string & SerialNumber);
 		bool CompleteDeviceConfigurationChange(std::string & SerialNumber);
-
+		bool CreateDevice(LockedDbSession &Session, GWObjects::Device &);
 		bool CreateDevice(GWObjects::Device &);
-		bool CreateDefaultDevice(std::string &SerialNumber, const Config::Capabilities &Caps,
+		bool CreateDefaultDevice(Poco::Data::Session &Session,std::string &SerialNumber,
+								 const Config::Capabilities &Caps,
 								 std::string &Firmware, const Poco::Net::IPAddress &IPAddress,
 								 bool simulated);
+		bool CreateDevice(Poco::Data::Session &Sess, GWObjects::Device &DeviceDetails);
 
-		bool GetDevice(std::string &SerialNumber, GWObjects::Device &);
+		bool GetDevice(LockedDbSession &Session, const std::string &SerialNumber, GWObjects::Device &);
+		bool GetDevice(Poco::Data::Session &Session, const std::string &SerialNumber, GWObjects::Device &DeviceDetails);
+		bool GetDevice(const std::string &SerialNumber, GWObjects::Device &);
 		bool GetDevices(uint64_t From, uint64_t HowMany, std::vector<GWObjects::Device> &Devices,
-						const std::string &orderBy = "");
+						const std::string &orderBy = "",
+						const std::string &platform = "");
 		//		bool GetDevices(uint64_t From, uint64_t HowMany, const std::string & Select,
 		// std::vector<GWObjects::Device> &Devices, const std::string & orderBy="");
 		bool DeleteDevice(std::string &SerialNumber);
@@ -132,14 +156,17 @@ namespace OpenWifi {
 		bool DeleteDevices(std::uint64_t OlderContact, bool SimulatedOnly);
 
 		bool UpdateDevice(GWObjects::Device &);
+		bool UpdateDevice(LockedDbSession &Session, GWObjects::Device &);
+		bool UpdateDevice(Poco::Data::Session &Sess, GWObjects::Device &NewDeviceDetails);
 		bool DeviceExists(std::string &SerialNumber);
 		bool SetConnectInfo(std::string &SerialNumber, std::string &Firmware);
-		bool GetDeviceCount(uint64_t &Count);
+		bool GetDeviceCount(uint64_t &Count, const std::string &platform = "");
 		bool GetDeviceSerialNumbers(uint64_t From, uint64_t HowMany,
 									std::vector<std::string> &SerialNumbers,
-									const std::string &orderBy = "");
+									const std::string &orderBy = "",
+									const std::string &platform = "");
 		bool GetDeviceFWUpdatePolicy(std::string &SerialNumber, std::string &Policy);
-		bool SetDevicePassword(std::string &SerialNumber, std::string &Password);
+		bool SetDevicePassword(LockedDbSession &Session, std::string &SerialNumber, std::string &Password);
 		bool UpdateSerialNumberCache();
 		static void GetDeviceDbFieldList(Types::StringVec &Fields);
 
@@ -148,9 +175,11 @@ namespace OpenWifi {
 
 		bool UpdateDeviceCapabilities(std::string &SerialNumber,
 									  const Config::Capabilities &Capabilities);
+		bool UpdateDeviceCapabilities(Poco::Data::Session &Session, std::string &SerialNumber,
+									  const Config::Capabilities &Capabilities);
 		bool GetDeviceCapabilities(std::string &SerialNumber, GWObjects::Capabilities &);
 		bool DeleteDeviceCapabilities(std::string &SerialNumber);
-		bool CreateDeviceCapabilities(std::string &SerialNumber,
+		bool CreateDeviceCapabilities(Poco::Data::Session &Session, std::string &SerialNumber,
 									  const Config::Capabilities &Capabilities);
 		bool InitCapabilitiesCache();
 
@@ -171,6 +200,7 @@ namespace OpenWifi {
 		bool GetDefaultConfigurations(uint64_t From, uint64_t HowMany,
 									  std::vector<GWObjects::DefaultConfiguration> &Devices);
 		bool FindDefaultConfigurationForModel(const std::string &Model,
+											  const std::string &Platform,
 											  GWObjects::DefaultConfiguration &DefConfig);
 		uint64_t GetDefaultConfigurationsCount();
 		bool DefaultConfigurationAlreadyExists(std::string &Name);
@@ -222,15 +252,15 @@ namespace OpenWifi {
 		void RemovedExpiredCommands();
 		void RemoveTimedOutCommands();
 
-		bool RemoveOldCommands(std::string &SerilNumber, std::string &Command);
+		bool RemoveOldCommands(std::string &SerialNumber, std::string &Command);
 
 		bool AddBlackListDevices(std::vector<GWObjects::BlackListedDevice> &Devices);
 		bool AddBlackListDevice(GWObjects::BlackListedDevice &Device);
 		bool GetBlackListDevice(std::string &SerialNumber, GWObjects::BlackListedDevice &Device);
 		bool DeleteBlackListDevice(std::string &SerialNumber);
-		bool IsBlackListed(const std::string &SerialNumber, std::string &reason,
+		bool IsBlackListed(std::uint64_t SerialNumber, std::string &reason,
 						   std::string &author, std::uint64_t &created);
-		bool IsBlackListed(const std::string &SerialNumber);
+		bool IsBlackListed(std::uint64_t SerialNumber);
 		bool InitializeBlackListCache();
 		bool GetBlackListDevices(uint64_t Offset, uint64_t HowMany,
 								 std::vector<GWObjects::BlackListedDevice> &Devices);
@@ -245,7 +275,9 @@ namespace OpenWifi {
 		bool RemoveCommandListRecordsOlderThan(uint64_t Date);
 		bool RemoveUploadedFilesRecordsOlderThan(uint64_t Date);
 
-		bool SetDeviceLastRecordedContact(std::string & SeialNumber, std::uint64_t lastRecordedContact);
+		bool SetDeviceLastRecordedContact(LockedDbSession &Session, std::string & SerialNumber, std::uint64_t lastRecordedContact);
+		bool SetDeviceLastRecordedContact(std::string & SerialNumber, std::uint64_t lastRecordedContact);
+		bool SetDeviceLastRecordedContact(Poco::Data::Session & Session, std::string & SerialNumber, std::uint64_t lastRecordedContact);
 
 		int Create_Tables();
 		int Create_Statistics();
@@ -262,13 +294,24 @@ namespace OpenWifi {
 		bool AnalyzeCommands(Types::CountedMap &R);
 		bool AnalyzeDevices(GWObjects::Dashboard &D);
 
+		void FixDeviceTypeBug();
+
 		int Start() override;
 		void Stop() override;
 
+		inline Poco::Data::Session	StartSession() {
+			return Pool_->get();
+		}
+
 	  private:
 		std::unique_ptr<OpenWifi::ScriptDB> ScriptDB_;
 	};
 
 	inline auto StorageService() { return Storage::instance(); }
 
+	inline LockedDbSession::LockedDbSession() {
+		Session_ = std::make_shared<Poco::Data::Session>(Poco::Data::Session(StorageService()->StartSession()));
+		Mutex_ = std::make_shared<std::mutex>();
+	}
+
 } // namespace OpenWifi
diff --git a/src/TelemetryStream.cpp b/src/TelemetryStream.cpp
index 9667c95d..b2d0271d 100644
--- a/src/TelemetryStream.cpp
+++ b/src/TelemetryStream.cpp
@@ -111,7 +111,6 @@ namespace OpenWifi {
 					}
 				} break;
 				case TelemetryNotification::NotificationType::unregister: {
-					std::lock_guard G(Mutex_);
 
 					auto client = Clients_.find(Notification->Data_);
 					if (client != Clients_.end()) {
diff --git a/src/TelemetryStream.h b/src/TelemetryStream.h
index e4fbbdcb..d9364e9f 100644
--- a/src/TelemetryStream.h
+++ b/src/TelemetryStream.h
@@ -23,7 +23,7 @@
 
 #include "framework/SubSystemServer.h"
 
-#include "AP_WS_ReactorPool.h"
+#include "AP_WS_Reactor_Pool.h"
 #include "TelemetryClient.h"
 
 namespace OpenWifi {
diff --git a/src/framework/ConfigurationValidator.cpp b/src/framework/ConfigurationValidator.cpp
index 28b6e0ca..f96b9243 100644
--- a/src/framework/ConfigurationValidator.cpp
+++ b/src/framework/ConfigurationValidator.cpp
@@ -3,7 +3,6 @@
 //
 
 #include <fstream>
-#include <iostream>
 #include <regex>
 
 #include "ConfigurationValidator.h"
@@ -23,28 +22,28 @@
 #include <valijson/utils/poco_json_utils.hpp>
 #include <valijson/validator.hpp>
 
-static const std::string GitUCentralJSONSchemaFile{
-	"https://raw.githubusercontent.com/Telecominfraproject/wlan-ucentral-schema/main/"
-	"ucentral.schema.json"};
+static const std::vector<std::string> GitJSONSchemaURLs = {
+	{"https://raw.githubusercontent.com/Telecominfraproject/wlan-ucentral-schema/main/ucentral.schema.json"},
+	{"https://raw.githubusercontent.com/Telecominfraproject/ols-ucentral-schema/main/ucentral.schema.json"}
+};
 
-static std::string DefaultUCentralSchema = R"foo(
+static std::string DefaultAPSchema = R"foo(
 
 {
     "$id": "https://openwrt.org/ucentral.schema.json",
     "$schema": "http://json-schema.org/draft-07/schema#",
+    "description": "OpenWrt uCentral schema",
     "type": "object",
     "properties": {
         "strict": {
+            "description": "The device will reject any configuration that causes warnings if strict mode is enabled.",
             "type": "boolean",
             "default": false
         },
         "uuid": {
+            "description": "The unique ID of the configuration. This is the unix timestamp of when the config was created.",
             "type": "integer"
         },
-        "public_ip_lookup": {
-            "type": "string",
-            "format": "uc-fqdn"
-        },
         "unit": {
             "$ref": "#/$defs/unit"
         },
@@ -91,19 +90,24 @@ static std::string DefaultUCentralSchema = R"foo(
     },
     "$defs": {
         "unit": {
+            "description": "A device has certain properties that describe its identity and location. These properties are described inside this object.",
             "type": "object",
             "properties": {
                 "name": {
+                    "description": "This is a free text field, stating the administrative name of the device. It may contain spaces and special characters.",
                     "type": "string"
                 },
                 "hostname": {
+                    "description": "The hostname that shall be set on the device. If this field is not set, then the devices serial number is used.",
                     "type": "string",
                     "format": "hostname"
                 },
                 "location": {
+                    "description": "This is a free text field, stating the location of the  device. It may contain spaces and special characters.",
                     "type": "string"
                 },
                 "timezone": {
+                    "description": "This allows you to change the TZ of the device.",
                     "type": "string",
                     "examples": [
                         "UTC",
@@ -112,23 +116,29 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "leds-active": {
+                    "description": "This allows forcing all LEDs off.",
                     "type": "boolean",
                     "default": true
                 },
                 "random-password": {
+                    "description": "The device shall create a random root password and tell the gateway about it.",
                     "type": "boolean",
                     "default": false
                 },
                 "beacon-advertisement": {
+                    "description": "The TIP vendor IEs that shall be added to beacons",
                     "type": "object",
                     "properties": {
                         "device-name": {
+                            "description": "Add an IE containing the device's name to beacons.",
                             "type": "boolean"
                         },
                         "device-serial": {
+                            "description": "Add an IE containing the device's serial to beacons.",
                             "type": "boolean"
                         },
                         "network-id": {
+                            "description": "A provider specific ID for the network/venue that the device is part of.",
                             "type": "integer"
                         }
                     }
@@ -168,6 +178,7 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "globals.wireless-multimedia.table": {
+            "description": "Define the default WMM behaviour of all SSIDs on the device. Each access category can be assigned a default class selector that gets used for packet matching.",
             "type": "object",
             "additionalProperties": false,
             "properties": {
@@ -202,6 +213,7 @@ static std::string DefaultUCentralSchema = R"foo(
             "additionalProperties": false,
             "properties": {
                 "profile": {
+                    "description": "Define a default profile that shall be used for the WMM behaviour of all SSIDs on the device.",
                     "type": "string",
                     "enum": [
                         "enterprise",
@@ -212,9 +224,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "globals": {
+            "description": "A device has certain global properties that are used to derive parts of the final configuration that gets applied.",
             "type": "object",
             "properties": {
                 "ipv4-network": {
+                    "description": "Define the IPv4 range that is delegatable to the downstream interfaces This is described as a CIDR block. (192.168.0.0/16, 172.16.128/17)",
                     "type": "string",
                     "format": "uc-cidr4",
                     "examples": [
@@ -222,6 +236,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "ipv6-network": {
+                    "description": "Define the IPv6 range that is delegatable to the downstream interfaces This is described as a CIDR block. (fdca:1234:4567::/48)",
                     "type": "string",
                     "format": "uc-cidr6",
                     "examples": [
@@ -241,9 +256,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.ssid.encryption": {
+            "description": "A device has certain properties that describe its identity and location. These properties are described inside this object.",
             "type": "object",
             "properties": {
                 "proto": {
+                    "description": "The wireless encryption protocol that shall be used for this BSS",
                     "type": "string",
                     "enum": [
                         "none",
@@ -267,11 +284,13 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "key": {
+                    "description": "The Pre Shared Key (PSK) that is used for encryption on the BSS when using any of the WPA-PSK modes.",
                     "type": "string",
                     "maxLength": 63,
                     "minLength": 8
                 },
                 "ieee80211w": {
+                    "description": "Enable 802.11w Management Frame Protection (MFP) for this BSS.",
                     "type": "string",
                     "enum": [
                         "disabled",
@@ -281,16 +300,19 @@ static std::string DefaultUCentralSchema = R"foo(
                     "default": "disabled"
                 },
                 "key-caching": {
+                    "description": "PMKSA created through EAP authentication and RSN preauthentication can be cached.",
                     "type": "boolean",
                     "default": true
                 }
             }
         },
         "definitions": {
+            "description": "This section is used to define templates that can be referenced by a configuration. This avoids duplication of data. A RADIUS server can be defined here for example and then referenced by several SSIDs.",
             "type": "object",
             "properties": {
                 "wireless-encryption": {
                     "type": "object",
+                    "description": "A dictionary of wireless encryption templates which can be referenced by the corresponding property name.",
                     "patternProperties": {
                         ".+": {
                             "$ref": "#/$defs/interface.ssid.encryption",
@@ -301,9 +323,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "ethernet": {
+            "description": "This section defines the linkk speed and duplex mode of the physical copper/fiber ports of the device.",
             "type": "object",
             "properties": {
                 "select-ports": {
+                    "description": "The list of physical network devices that shall be configured. The names are logical ones and wildcardable.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -319,6 +343,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "speed": {
+                    "description": "The link speed that shall be forced.",
                     "type": "integer",
                     "enum": [
                         10,
@@ -330,6 +355,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "duplex": {
+                    "description": "The duplex mode that shall be forced.",
                     "type": "string",
                     "enum": [
                         "half",
@@ -337,10 +363,12 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "enabled": {
+                    "description": "This allows forcing the port to down state by default.",
                     "type": "boolean",
                     "default": true
                 },
                 "services": {
+                    "description": "The services that shall be offered on this L2 interface.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -352,26 +380,32 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "switch": {
+            "description": "This section defines the switch fabric specific features of a physical switch.",
             "type": "object",
             "properties": {
                 "port-mirror": {
+                    "description": "Enable mirror of traffic from multiple minotor ports to a single analysis port.",
                     "type": "object",
                     "properties": {
                         "monitor-ports": {
+                            "description": "The list of ports that we want to mirror.",
                             "type": "array",
                             "items": {
                                 "type": "string"
                             }
                         },
                         "analysis-port": {
+                            "description": "The port that mirror'ed packets should be sent to.",
                             "type": "string"
                         }
                     }
                 },
                 "loop-detection": {
+                    "description": "Enable loop detection on the L2 switches/bridge.",
                     "type": "object",
                     "properties": {
                         "protocol": {
+                            "description": "Define which protocol shall be used for loop detection.",
                             "type": "string",
                             "enum": [
                                 "rstp"
@@ -379,6 +413,7 @@ static std::string DefaultUCentralSchema = R"foo(
                             "default": "rstp"
                         },
                         "roles": {
+                            "description": "Define on which logical switches/bridges we want to provide loop-detection.",
                             "type": "array",
                             "items": {
                                 "type": "string",
@@ -393,9 +428,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "radio.rates": {
+            "description": "The rate configuration of this BSS.",
             "type": "object",
             "properties": {
                 "beacon": {
+                    "description": "The beacon rate that shall be used by the BSS. Values are in Mbps.",
                     "type": "integer",
                     "default": 6000,
                     "enum": [
@@ -415,6 +452,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "multicast": {
+                    "description": "The multicast rate that shall be used by the BSS. Values are in Mbps.",
                     "type": "integer",
                     "default": 24000,
                     "enum": [
@@ -436,26 +474,32 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "radio.he": {
+            "description": "This section describes the HE specific configuration options of the BSS.",
             "type": "object",
             "properties": {
                 "multiple-bssid": {
+                    "description": "Enabling this option will make the PHY broadcast its BSSs using the multiple BSSID beacon IE.",
                     "type": "boolean",
                     "default": false
                 },
                 "ema": {
+                    "description": "Enableing this option will make the PHY broadcast its multiple BSSID beacons using EMA.",
                     "type": "boolean",
                     "default": false
                 },
                 "bss-color": {
+                    "description": "This enables BSS Coloring on the PHY. setting it to 0 disables the feature 1-63 sets the color and 64 will make hostapd pick a random color.",
                     "type": "integer",
                     "default": 64
                 }
             }
         },
         "radio": {
+            "description": "Describe a physical radio on the AP. A radio is be parent to several VAPs. They all share the same physical properties.",
             "type": "object",
             "properties": {
                 "band": {
+                    "description": "Specifies the wireless band to configure the radio for. Available radio device phys on the target system are matched by the wireless band given here. If multiple radio phys support the same band, the settings specified here will be applied to all of them.",
                     "type": "string",
                     "enum": [
                         "2G",
@@ -466,6 +510,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "bandwidth": {
+                    "description": "Specifies a narrow channel width in MHz, possible values are 5, 10, 20.",
                     "type": "integer",
                     "enum": [
                         5,
@@ -474,6 +519,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "channel": {
+                    "description": "Specifies the wireless channel to use. A value of 'auto' starts the ACS algorithm.",
                     "oneOf": [
                         {
                             "type": "integer",
@@ -487,6 +533,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "valid-channels": {
+                    "description": "Pass a list of valid-channels that can be used during ACS.",
                     "type": "array",
                     "items": {
                         "type": "integer",
@@ -495,6 +542,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "country": {
+                    "description": "Specifies the country code, affects the available channels and transmission powers.",
                     "type": "string",
                     "maxLength": 2,
                     "minLength": 2,
@@ -503,30 +551,36 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "allow-dfs": {
+                    "description": "This property defines whether a radio may use DFS channels.",
                     "type": "boolean",
                     "default": true
                 },
                 "channel-mode": {
+                    "description": "Define the ideal channel mode that the radio shall use. This can be 802.11n, 802.11ac or 802.11ax. This is just a hint for the AP. If the requested value is not supported then the AP will use the highest common denominator.",
                     "type": "string",
                     "enum": [
                         "HT",
                         "VHT",
-                        "HE"
+                        "HE",
+                        "EHT"
                     ],
                     "default": "HE"
                 },
                 "channel-width": {
+                    "description": "The channel width that the radio shall use. This is just a hint for the AP. If the requested value is not supported then the AP will use the highest common denominator.",
                     "type": "integer",
                     "enum": [
                         20,
                         40,
                         80,
                         160,
+                        320,
                         8080
                     ],
                     "default": 80
                 },
                 "require-mode": {
+                    "description": "Stations that do no fulfill these HT modes will be rejected.",
                     "type": "string",
                     "enum": [
                         "HT",
@@ -535,6 +589,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "mimo": {
+                    "description": "This option allows configuring the antenna pairs that shall be used. This is just a hint for the AP. If the requested value is not supported then the AP will use the highest common denominator.",
                     "type": "string",
                     "enum": [
                         "1x1",
@@ -548,25 +603,30 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "tx-power": {
+                    "description": "This option specifies the transmission power in dBm",
                     "type": "integer",
                     "maximum": 30,
                     "minimum": 0
                 },
                 "legacy-rates": {
+                    "description": "Allow legacy 802.11b data rates.",
                     "type": "boolean",
                     "default": false
                 },
                 "beacon-interval": {
+                    "description": "Beacon interval in kus (1.024 ms).",
                     "type": "integer",
                     "default": 100,
                     "maximum": 65535,
                     "minimum": 15
                 },
                 "maximum-clients": {
+                    "description": "Set the maximum number of clients that may connect to this radio. This value is accumulative for all attached VAP interfaces.",
                     "type": "integer",
                     "example": 64
                 },
                 "maximum-clients-ignore-probe": {
+                    "description": "Ignore probe requests if maximum-clients was reached.",
                     "type": "boolean"
                 },
                 "rates": {
@@ -576,6 +636,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     "$ref": "#/$defs/radio.he"
                 },
                 "hostapd-iface-raw": {
+                    "description": "This array allows passing raw hostapd.conf lines.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -594,9 +655,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.vlan": {
+            "description": "This section describes the vlan behaviour of a logical network interface.",
             "type": "object",
             "properties": {
                 "id": {
+                    "description": "This is the pvid of the vlan that shall be assigned to the interface. The individual physical network devices contained within the interface need to be told explicitly if egress traffic shall be tagged.",
                     "type": "integer",
                     "maximum": 4050
                 },
@@ -612,9 +675,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.bridge": {
+            "description": "This section describes the bridge behaviour of a logical network interface.",
             "type": "object",
             "properties": {
                 "mtu": {
+                    "description": "The MTU that shall be used by the network interface.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 256,
@@ -623,21 +688,25 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "tx-queue-len": {
+                    "description": "The Transmit Queue Length is a TCP/IP stack network interface value that sets the number of packets allowed per kernel transmit queue of a network interface device.",
                     "type": "integer",
                     "examples": [
                         5000
                     ]
                 },
                 "isolate-ports": {
+                    "description": "Isolates the bridge ports from each other.",
                     "type": "boolean",
                     "default": false
                 }
             }
         },
         "interface.ethernet": {
+            "description": "This section defines the physical copper/fiber ports that are members of the interface. Network devices are referenced by their logical names.",
             "type": "object",
             "properties": {
                 "select-ports": {
+                    "description": "The list of physical network devices that shall be added to the interface. The names are logical ones and wildcardable. \"WAN\" will use whatever the hardwares default upstream facing port is. \"LANx\" will use the \"x'th\" downstream facing ethernet port. LAN* will use all downstream ports.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -653,26 +722,32 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "multicast": {
+                    "description": "Enable multicast support.",
                     "type": "boolean",
                     "default": true
                 },
                 "learning": {
+                    "description": "Controls whether a given port will learn MAC addresses from received traffic or not. If learning if off, the bridge will end up flooding any traffic for which it has no FDB entry. By default this flag is on.",
                     "type": "boolean",
                     "default": true
                 },
                 "isolate": {
+                    "description": "Only allow communication with non-isolated bridge ports when enabled.",
                     "type": "boolean",
                     "default": false
                 },
                 "macaddr": {
+                    "description": "Enforce a specific MAC to these ports.",
                     "type": "string",
                     "format": "uc-mac"
                 },
                 "reverse-path-filter": {
+                    "description": "Reverse Path filtering is a method used by the Linux Kernel to help prevent attacks used by Spoofing IP Addresses.",
                     "type": "boolean",
                     "default": false
                 },
                 "vlan-tag": {
+                    "description": "Shall the port have a vlan tag.",
                     "type": "string",
                     "enum": [
                         "tagged",
@@ -684,31 +759,42 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.ipv4.dhcp": {
+            "description": "This section describes the DHCP server configuration",
             "type": "object",
             "properties": {
                 "lease-first": {
+                    "description": "The last octet of the first IPv4 address in this DHCP pool.",
                     "type": "integer",
                     "examples": [
                         10
                     ]
                 },
                 "lease-count": {
+                    "description": "The number of IPv4 addresses inside the DHCP pool.",
                     "type": "integer",
                     "examples": [
                         100
                     ]
                 },
                 "lease-time": {
+                    "description": "How long the lease is valid before a RENEW must be issued.",
                     "type": "string",
                     "format": "uc-timeout",
                     "default": "6h"
+                },
+                "use-dns": {
+                    "description": "The DNS server sent to clients as DHCP option 6.",
+                    "type": "string",
+                    "format": "uc-ip"
                 }
             }
         },
         "interface.ipv4.dhcp-lease": {
+            "description": "This section describes the static DHCP leases of this logical interface.",
             "type": "object",
             "properties": {
                 "macaddr": {
+                    "description": "The MAC address of the host that this lease shall be used for.",
                     "type": "string",
                     "format": "uc-mac",
                     "examples": [
@@ -716,26 +802,31 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "static-lease-offset": {
+                    "description": "The offset of the IP that shall be used in relation to the first IP in the available range.",
                     "type": "integer",
                     "examples": [
                         10
                     ]
                 },
                 "lease-time": {
+                    "description": "How long the lease is valid before a RENEW muss ne issued.",
                     "type": "string",
                     "format": "uc-timeout",
                     "default": "6h"
                 },
                 "publish-hostname": {
+                    "description": "Shall the hosts hostname be made available locally via DNS.",
                     "type": "boolean",
                     "default": true
                 }
             }
         },
         "interface.ipv4.port-forward": {
+            "description": "This section describes an IPv4 port forwarding.",
             "type": "object",
             "properties": {
                 "protocol": {
+                    "description": "The layer 3 protocol to match.",
                     "type": "string",
                     "enum": [
                         "tcp",
@@ -745,6 +836,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     "default": "any"
                 },
                 "external-port": {
+                    "description": "The external port(s) to forward.",
                     "type": [
                         "integer",
                         "string"
@@ -754,11 +846,13 @@ static std::string DefaultUCentralSchema = R"foo(
                     "format": "uc-portrange"
                 },
                 "internal-address": {
+                    "description": "The internal IP to forward to. The address will be masked and concatenated with the effective interface subnet.",
                     "type": "string",
                     "format": "ipv4",
                     "example": "0.0.0.120"
                 },
                 "internal-port": {
+                    "description": "The internal port to forward to. Defaults to the external port if omitted.",
                     "type": [
                         "integer",
                         "string"
@@ -774,9 +868,11 @@ static std::string DefaultUCentralSchema = R"foo(
             ]
         },
         "interface.ipv4": {
+            "description": "This section describes the IPv4 properties of a logical interface.",
             "type": "object",
             "properties": {
                 "addressing": {
+                    "description": "This option defines the method by which the IPv4 address of the interface is chosen.",
                     "type": "string",
                     "enum": [
                         "dynamic",
@@ -788,6 +884,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "subnet": {
+                    "description": "This option defines the static IPv4 of the logical interface in CIDR notation. auto/24 can be used, causing the configuration layer to automatically use and address range from globals.ipv4-network.",
                     "type": "string",
                     "format": "uc-cidr4",
                     "examples": [
@@ -795,6 +892,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "gateway": {
+                    "description": "This option defines the static IPv4 gateway of the logical interface.",
                     "type": "string",
                     "format": "ipv4",
                     "examples": [
@@ -802,6 +900,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "send-hostname": {
+                    "description": "include the devices hostname inside DHCP requests",
                     "type": "boolean",
                     "default": true,
                     "examples": [
@@ -809,6 +908,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "use-dns": {
+                    "description": "Define which DNS servers shall be used. This can either be a list of static IPv4 addresse or dhcp (use the server provided by the DHCP lease)",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -819,6 +919,18 @@ static std::string DefaultUCentralSchema = R"foo(
                         ]
                     }
                 },
+                "disallow-upstream-subnet": {
+                    "description": "This option only applies to \"downstream\" interfaces. The downstream interface will prevent traffic going out to the listed CIDR4s. This can be used to prevent a guest / captive interface being able to communicate with RFC1918 ranges.",
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "format": "uc-cidr4",
+                        "examples": [
+                            "192.168.0.0/16",
+                            "10.0.0.0/8"
+                        ]
+                    }
+                },
                 "dhcp": {
                     "$ref": "#/$defs/interface.ipv4.dhcp"
                 },
@@ -837,9 +949,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.ipv6.dhcpv6": {
+            "description": "This section describes the DHCPv6 server configuration",
             "type": "object",
             "properties": {
                 "mode": {
+                    "description": "Specifies the DHCPv6 server operation mode. When set to \"stateless\", the system will announce router advertisements only, without offering stateful DHCPv6 service. When set to \"stateful\", emitted router advertisements will instruct clients to obtain a DHCPv6 lease. When set to \"hybrid\", clients can freely chose whether to self-assign a random address through SLAAC, whether to request an address via DHCPv6, or both. For maximum compatibility with different clients, it is recommended to use the hybrid mode. The special mode \"relay\" will instruct the unit to act as DHCPv6 relay between this interface and any of the IPv6 interfaces in \"upstream\" mode.",
                     "type": "string",
                     "enum": [
                         "hybrid",
@@ -849,6 +963,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "announce-dns": {
+                    "description": "Overrides the DNS server to announce in DHCPv6 and RA messages. By default, the device will announce its own local interface address as DNS server, essentially acting as proxy for downstream clients. By specifying a non-empty list of IPv6 addresses here, this default behaviour can be overridden.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -856,6 +971,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "filter-prefix": {
+                    "description": "Selects a specific downstream prefix or a number of downstream prefix ranges to announce in DHCPv6 and RA messages. By default, all prefixes configured on a given downstream interface are advertised. By specifying an IPv6 prefix in CIDR notation here, only prefixes covered by this CIDR are selected.",
                     "type": "string",
                     "format": "uc-cidr6",
                     "default": "::/0"
@@ -863,9 +979,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.ipv6.port-forward": {
+            "description": "This section describes an IPv6 port forwarding.",
             "type": "object",
             "properties": {
                 "protocol": {
+                    "description": "The layer 3 protocol to match.",
                     "type": "string",
                     "enum": [
                         "tcp",
@@ -875,6 +993,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     "default": "any"
                 },
                 "external-port": {
+                    "description": "The external port(s) to forward.",
                     "type": [
                         "integer",
                         "string"
@@ -884,11 +1003,13 @@ static std::string DefaultUCentralSchema = R"foo(
                     "format": "uc-portrange"
                 },
                 "internal-address": {
+                    "description": "The internal IP to forward to. The address will be masked and concatenated with the effective interface subnet.",
                     "type": "string",
                     "format": "ipv6",
                     "example": "::1234:abcd"
                 },
                 "internal-port": {
+                    "description": "The internal port to forward to. Defaults to the external port if omitted.",
                     "type": [
                         "integer",
                         "string"
@@ -904,19 +1025,23 @@ static std::string DefaultUCentralSchema = R"foo(
             ]
         },
         "interface.ipv6.traffic-allow": {
+            "description": "This section describes an IPv6 traffic accept rule.",
             "type": "object",
             "properties": {
                 "protocol": {
+                    "description": "The layer 3 protocol to match.",
                     "type": "string",
                     "default": "any"
                 },
                 "source-address": {
+                    "description": "The source IP to allow traffic from.",
                     "type": "string",
                     "format": "uc-cidr6",
                     "example": "2001:db8:1234:abcd::/64",
                     "default": "::/0"
                 },
                 "source-ports": {
+                    "description": "The source port(s) to accept.",
                     "type": "array",
                     "minItems": 1,
                     "items": {
@@ -930,11 +1055,13 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "destination-address": {
+                    "description": "The destination IP to allow traffic to. The address will be masked and concatenated with the effective interface subnet.",
                     "type": "string",
                     "format": "ipv6",
                     "example": "::1000"
                 },
                 "destination-ports": {
+                    "description": "The destination ports to accept.",
                     "type": "array",
                     "minItems": 1,
                     "items": {
@@ -953,9 +1080,11 @@ static std::string DefaultUCentralSchema = R"foo(
             ]
         },
         "interface.ipv6": {
+            "description": "This section describes the IPv6 properties of a logical interface.",
             "type": "object",
             "properties": {
                 "addressing": {
+                    "description": "This option defines the method by which the IPv6 subnet of the interface is acquired. In static addressing mode, the specified subnet and gateway, if any, are configured on the interface in a fixed manner. Also - if a prefix size hint is specified - a prefix of the given size is allocated from each upstream received prefix delegation pool and assigned to the interface. In dynamic addressing mode, a DHCPv6 client will be launched to obtain IPv6 prefixes for the interface itself and for downstream delegation. Note that dynamic addressing usually only ever makes sense on upstream interfaces.",
                     "type": "string",
                     "enum": [
                         "dynamic",
@@ -963,6 +1092,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "subnet": {
+                    "description": "This option defines a static IPv6 prefix in CIDR notation to set on the logical interface. A special notation \"auto/64\" can be used, causing the configuration agent to automatically allocate a suitable prefix from the IPv6 address pool specified in globals.ipv6-network. This property only applies to static addressing mode. Note that this is usually not needed due to DHCPv6-PD assisted prefix assignment.",
                     "type": "string",
                     "format": "uc-cidr6",
                     "examples": [
@@ -970,6 +1100,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "gateway": {
+                    "description": "This option defines the static IPv6 gateway of the logical interface. It only applies to static addressing mode. Note that this is usually not needed due to DHCPv6-PD assisted prefix assignment.",
                     "type": "string",
                     "format": "ipv6",
                     "examples": [
@@ -977,6 +1108,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "prefix-size": {
+                    "description": "For dynamic addressing interfaces, this property specifies the prefix size to request from an upstream DHCPv6 server through prefix delegation. For static addressing interfaces, it specifies the size of the sub-prefix to allocate from the upstream-received delegation prefixes for assignment to the logical interface.",
                     "type": "integer",
                     "maximum": 64,
                     "minimum": 0
@@ -999,13 +1131,16 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.broad-band.wwan": {
+            "description": "This Object defines the properties of a broad-band uplink.",
             "type": "object",
             "properties": {
                 "protocol": {
+                    "description": "This uplink uses WWAN/LTE",
                     "type": "string",
                     "const": "wwan"
                 },
                 "modem-type": {
+                    "description": "The local protocol that the modem supports.",
                     "type": "string",
                     "enum": [
                         "qmi",
@@ -1014,9 +1149,11 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "access-point-name": {
+                    "description": "Commonly known as APN. The name of a gateway between a mobile network and the internet.",
                     "type": "string"
                 },
                 "authentication-type": {
+                    "description": "The authentication mode that shall be used.",
                     "type": "string",
                     "enum": [
                         "none",
@@ -1027,15 +1164,19 @@ static std::string DefaultUCentralSchema = R"foo(
                     "default": "none"
                 },
                 "pin-code": {
+                    "description": "The PIN that shall be used to unlock the SIM card.",
                     "type": "string"
                 },
                 "user-name": {
+                    "description": "This option is only required if an authentication-type is defined.",
                     "type": "string"
                 },
                 "password": {
+                    "description": "This option is only required if an authentication-type is defined.",
                     "type": "string"
                 },
                 "packet-data-protocol": {
+                    "description": "Define what kind of IP stack shall be used.",
                     "type": "string",
                     "enum": [
                         "ipv4",
@@ -1047,16 +1188,20 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.broad-band.pppoe": {
+            "description": "This Object defines the properties of a PPPoE uplink.",
             "type": "object",
             "properties": {
                 "protocol": {
+                    "description": "This uplink uses PPPoE",
                     "type": "string",
                     "const": "pppoe"
                 },
                 "user-name": {
+                    "description": "The username used to authenticate.",
                     "type": "string"
                 },
                 "password": {
+                    "description": "The password used to authenticate.",
                     "type": "string"
                 }
             }
@@ -1073,12 +1218,14 @@ static std::string DefaultUCentralSchema = R"foo(
         },
         "interface.ssid.multi-psk": {
             "type": "object",
+            "description": "A SSID can have multiple PSK/VID mappings. Each one of them can be bound to a specific MAC or be a wildcard.",
             "properties": {
                 "mac": {
                     "type": "string",
                     "format": "uc-mac"
                 },
                 "key": {
+                    "description": "The Pre Shared Key (PSK) that is used for encryption on the BSS when using any of the WPA-PSK modes.",
                     "type": "string",
                     "maxLength": 63,
                     "minLength": 8
@@ -1096,49 +1243,61 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.ssid.rrm": {
+            "description": "Enable 802.11k Radio Resource Management (RRM) for this BSS.",
             "type": "object",
             "properties": {
                 "neighbor-reporting": {
+                    "description": "Enable neighbor report via radio measurements (802.11k).",
                     "type": "boolean",
                     "default": false
                 },
                 "reduced-neighbor-reporting": {
+                    "description": "Enable reduced neighbor reports.",
                     "type": "boolean",
                     "default": false
                 },
                 "lci": {
+                    "description": "The content of a LCI measurement subelement",
                     "type": "string"
                 },
                 "civic-location": {
+                    "description": "The content of a location civic measurement subelement",
                     "type": "string"
                 },
                 "ftm-responder": {
+                    "description": "Publish fine timing measurement (FTM) responder functionality on this BSS.",
                     "type": "boolean",
                     "default": false
                 },
                 "stationary-ap": {
+                    "description": "Stationary AP config indicates that the AP doesn't move.",
                     "type": "boolean",
                     "default": false
                 }
             }
         },
         "interface.ssid.rate-limit": {
+            "description": "The UE rate-limiting configuration of this BSS.",
             "type": "object",
             "properties": {
                 "ingress-rate": {
+                    "description": "The ingress rate to which hosts will be shaped. Values are in Mbps",
                     "type": "integer",
                     "default": 0
                 },
                 "egress-rate": {
+                    "description": "The egress rate to which hosts will be shaped. Values are in Mbps",
                     "type": "integer",
                     "default": 0
                 }
             }
         },
         "interface.ssid.roaming": {
+            "description": "Enable 802.11r Fast Roaming for this BSS.",
             "type": "object",
             "properties": {
                 "message-exchange": {
+                    "description": "Shall the pre authenticated message exchange happen over the air or distribution system.",
                     "type": "string",
                     "enum": [
                         "air",
@@ -1147,10 +1306,12 @@ static std::string DefaultUCentralSchema = R"foo(
                     "default": "ds"
                 },
                 "generate-psk": {
+                    "description": "Whether to generate FT response locally for PSK networks. This avoids use of PMK-R1 push/pull from other APs with FT-PSK networks.",
                     "type": "boolean",
                     "default": false
                 },
                 "domain-identifier": {
+                    "description": "Mobility Domain identifier (dot11FTMobilityDomainID, MDID).",
                     "type": "string",
                     "maxLength": 4,
                     "minLength": 4,
@@ -1159,10 +1320,12 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "pmk-r0-key-holder": {
+                    "description": "The pairwise master key R0. This is unique to the mobility domain and is required for fast roaming over the air. If the field is left empty a deterministic key is generated.",
                     "type": "string",
                     "example": "14:DD:20:47:14:E4,14DD204714E4,00112233445566778899aabbccddeeff"
                 },
                 "pmk-r1-key-holder": {
+                    "description": "The pairwise master key R1. This is unique to the mobility domain and is required for fast roaming over the air. If the field is left empty a deterministic key is generated.",
                     "type": "string",
                     "example": "14:DD:20:47:14:E4,14DD204714E4,00112233445566778899aabbccddeeff"
                 }
@@ -1170,6 +1333,7 @@ static std::string DefaultUCentralSchema = R"foo(
         },
         "interface.ssid.radius.local-user": {
             "type": "object",
+            "description": "Describes a local EAP user/psk/vid triplet.",
             "properties": {
                 "mac": {
                     "type": "string",
@@ -1197,13 +1361,16 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.ssid.radius.local": {
+            "description": "Describe the properties of the local Radius server inside hostapd.",
             "type": "object",
             "properties": {
                 "server-identity": {
+                    "description": "EAP methods that provide mechanism for authenticated server identity delivery use this value.",
                     "type": "string",
                     "default": "uCentral"
                 },
                 "users": {
+                    "description": "Specifies a collection of local EAP user/psk/vid triplets.",
                     "type": "array",
                     "items": {
                         "$ref": "#/$defs/interface.ssid.radius.local-user"
@@ -1212,9 +1379,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.ssid.radius.server": {
+            "description": "Describe the properties of a Radius server.",
             "type": "object",
             "properties": {
                 "host": {
+                    "description": "The URI of our Radius server.",
                     "type": "string",
                     "format": "uc-host",
                     "examples": [
@@ -1222,6 +1391,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "port": {
+                    "description": "The network port of our Radius server.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 1024,
@@ -1230,15 +1400,18 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "secret": {
+                    "description": "The shared Radius authentication secret.",
                     "type": "string",
                     "examples": [
                         "secret"
                     ]
                 },
                 "secondary": {
+                    "description": "Definition of the secondary/failsafe radius server.",
                     "type": "object",
                     "properties": {
                         "host": {
+                            "description": "The URI of our Radius server.",
                             "type": "string",
                             "format": "uc-host",
                             "examples": [
@@ -1246,6 +1419,7 @@ static std::string DefaultUCentralSchema = R"foo(
                             ]
                         },
                         "port": {
+                            "description": "The network port of our Radius server.",
                             "type": "integer",
                             "maximum": 65535,
                             "minimum": 1024,
@@ -1254,6 +1428,7 @@ static std::string DefaultUCentralSchema = R"foo(
                             ]
                         },
                         "secret": {
+                            "description": "The shared Radius authentication secret.",
                             "type": "string",
                             "examples": [
                                 "secret"
@@ -1262,6 +1437,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "request-attribute": {
+                    "description": "The additional Access-Request attributes that gets sent to the server.",
                     "type": "array",
                     "items": {
                         "anyOf": [
@@ -1270,6 +1446,7 @@ static std::string DefaultUCentralSchema = R"foo(
                                 "properties": {
                                     "vendor-id": {
                                         "type": "integer",
+                                        "description": "The ID of the vendor specific RADIUS attribute",
                                         "maximum": 65535,
                                         "minimum": 1
                                     },
@@ -1277,14 +1454,17 @@ static std::string DefaultUCentralSchema = R"foo(
                                         "type": "array",
                                         "items": {
                                             "type": "object",
+                                            "description": "The numeric RADIUS attribute value",
                                             "properties": {
                                                 "id": {
                                                     "type": "integer",
+                                                    "description": "The ID of the vendor specific RADIUS attribute",
                                                     "maximum": 255,
                                                     "minimum": 1
                                                 },
                                                 "value": {
-                                                    "type": "string"
+                                                    "type": "string",
+                                                    "description": "The vendor specific RADIUS attribute value. This needs to be a hexadecimal string."
                                                 }
                                             }
                                         }
@@ -1296,11 +1476,13 @@ static std::string DefaultUCentralSchema = R"foo(
                                 "properties": {
                                     "id": {
                                         "type": "integer",
+                                        "description": "The ID of the RADIUS attribute",
                                         "maximum": 255,
                                         "minimum": 1
                                     },
                                     "value": {
                                         "type": "integer",
+                                        "description": "The numeric RADIUS attribute value",
                                         "maximum": 4294967295,
                                         "minimum": 0
                                     }
@@ -1321,11 +1503,13 @@ static std::string DefaultUCentralSchema = R"foo(
                                 "properties": {
                                     "id": {
                                         "type": "integer",
+                                        "description": "The ID of the RADIUS attribute",
                                         "maximum": 255,
                                         "minimum": 1
                                     },
                                     "value": {
-                                        "type": "string"
+                                        "type": "string",
+                                        "description": "The RADIUS attribute value string"
                                     }
                                 },
                                 "examples": [
@@ -1344,11 +1528,13 @@ static std::string DefaultUCentralSchema = R"foo(
                                 "properties": {
                                     "id": {
                                         "type": "integer",
+                                        "description": "The ID of the RADIUS attribute",
                                         "maximum": 255,
                                         "minimum": 1
                                     },
                                     "hex-value": {
-                                        "type": "string"
+                                        "type": "string",
+                                        "description": "The RADIUS attribute value string"
                                     }
                                 },
                                 "examples": [
@@ -1364,23 +1550,29 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.ssid.radius.health": {
+            "description": "The credentials used when health check probes this radius server.",
             "type": "object",
             "properties": {
                 "username": {
+                    "description": "The username that gets used when doing a healthcheck on this radius server.",
                     "type": "string"
                 },
                 "password": {
+                    "description": "The password that gets used when doing a healthcheck on this radius server.",
                     "type": "string"
                 }
             }
         },
         "interface.ssid.radius": {
+            "description": "When using EAP encryption we need to provide the required information allowing us to connect to the AAA servers.",
             "type": "object",
             "properties": {
                 "nas-identifier": {
+                    "description": "NAS-Identifier string for RADIUS messages. When used, this should be unique to the NAS within the scope of the RADIUS server.",
                     "type": "string"
                 },
                 "chargeable-user-id": {
+                    "description": "This will enable support for Chargeable-User-Identity (RFC 4372).",
                     "type": "boolean",
                     "default": false
                 },
@@ -1388,9 +1580,11 @@ static std::string DefaultUCentralSchema = R"foo(
                     "$ref": "#/$defs/interface.ssid.radius.local"
                 },
                 "dynamic-authorization": {
+                    "description": "Dynamic Authorization Extensions (DAE) is an extension to Radius.",
                     "type": "object",
                     "properties": {
                         "host": {
+                            "description": "The IP of the DAE client.",
                             "type": "string",
                             "format": "uc-ip",
                             "examples": [
@@ -1398,6 +1592,7 @@ static std::string DefaultUCentralSchema = R"foo(
                             ]
                         },
                         "port": {
+                            "description": "The network port that the DAE client can connet on.",
                             "type": "integer",
                             "maximum": 65535,
                             "minimum": 1024,
@@ -1406,6 +1601,7 @@ static std::string DefaultUCentralSchema = R"foo(
                             ]
                         },
                         "secret": {
+                            "description": "The shared DAE authentication secret.",
                             "type": "string",
                             "examples": [
                                 "secret"
@@ -1422,6 +1618,7 @@ static std::string DefaultUCentralSchema = R"foo(
                             "type": "object",
                             "properties": {
                                 "mac-filter": {
+                                    "description": "Should the radius server be used for MAC address ACL.",
                                     "type": "boolean",
                                     "default": false
                                 }
@@ -1438,6 +1635,7 @@ static std::string DefaultUCentralSchema = R"foo(
                             "type": "object",
                             "properties": {
                                 "interval": {
+                                    "description": "The interim accounting update interval. This value is defined in seconds.",
                                     "type": "integer",
                                     "maximum": 600,
                                     "minimum": 60,
@@ -1453,44 +1651,55 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.ssid.certificates": {
+            "description": "When running a local EAP server or using STA/MESH to connect to another BSS a set of certificates is required.",
             "type": "object",
             "properties": {
                 "use-local-certificates": {
+                    "description": "The device will use its local certificate bundle for the TLS setup and ignores all other certificate options in this section.",
                     "type": "boolean",
                     "default": false
                 },
                 "ca-certificate": {
+                    "description": "The local servers CA bundle.",
                     "type": "string"
                 },
                 "certificate": {
+                    "description": "The local servers certificate.",
                     "type": "string"
                 },
                 "private-key": {
+                    "description": "The local servers private key/",
                     "type": "string"
                 },
                 "private-key-password": {
+                    "description": "The password required to read the private key.",
                     "type": "string"
                 }
             }
         },
         "interface.ssid.pass-point": {
+            "description": "Enable Hotspot 2.0 support.",
             "type": "object",
             "properties": {
                 "venue-name": {
+                    "description": "This parameter can be used to configure one or more Venue Name Duples for Venue Name ANQP information.",
                     "type": "array",
                     "items": {
                         "type": "string"
                     }
                 },
                 "venue-group": {
+                    "description": "The available values are defined in 802.11u.",
                     "type": "integer",
                     "maximum": 32
                 },
                 "venue-type": {
+                    "description": "The available values are defined in IEEE Std 802.11u-2011, 7.3.1.34",
                     "type": "integer",
                     "maximum": 32
                 },
                 "venue-url": {
+                    "description": "This parameter can be used to configure one or more Venue URL Duples to provide additional information corresponding to Venue Name information.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -1498,9 +1707,11 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "auth-type": {
+                    "description": "This parameter indicates what type of network authentication is used in the network.",
                     "type": "object",
                     "properties": {
                         "type": {
+                            "description": "Specifies the specific network authentication type in use.",
                             "type": "string",
                             "enum": [
                                 "terms-and-conditions",
@@ -1510,6 +1721,7 @@ static std::string DefaultUCentralSchema = R"foo(
                             ]
                         },
                         "uri": {
+                            "description": "Specifies the redirect URL applicable to the indicated authentication type.",
                             "type": "string",
                             "format": "uri",
                             "examples": [
@@ -1522,6 +1734,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     "maxLength": 2
                 },
                 "domain-name": {
+                    "description": "The IEEE 802.11u Domain Name.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -1529,105 +1742,126 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "nai-realm": {
+                    "description": "NAI Realm information",
                     "type": "array",
                     "items": {
                         "type": "string"
                     }
                 },
                 "osen": {
+                    "description": "OSU Server-Only Authenticated L2 Encryption Network;",
                     "type": "boolean"
                 },
                 "anqp-domain": {
+                    "description": "ANQP Domain ID, An identifier for a set of APs in an ESS that share the same common ANQP information.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 0
                 },
                 "anqp-3gpp-cell-net": {
+                    "description": "The ANQP 3GPP Cellular Network information.",
                     "type": "array",
                     "items": {
                         "type": "string"
                     }
                 },
                 "friendly-name": {
+                    "description": "This parameter can be used to configure one or more Operator Friendly Name Duples.",
                     "type": "array",
                     "items": {
                         "type": "string"
                     }
                 },
                 "access-network-type": {
+                    "description": "Indicate the type of network. This is part of the interworking IE.",
                     "type": "integer",
                     "maximum": 15,
                     "default": 0
                 },
                 "internet": {
+                    "description": "Whether the network provides connectivity to the Internet",
                     "type": "boolean",
                     "default": true
                 },
                 "asra": {
+                    "description": "Additional Step Required for Access.",
                     "type": "boolean",
                     "default": false
                 },
                 "esr": {
+                    "description": "Emergency services reachable.",
                     "type": "boolean",
                     "default": false
                 },
                 "uesa": {
+                    "description": "Unauthenticated emergency service accessible.",
                     "type": "boolean",
                     "default": false
                 },
                 "hessid": {
+                    "description": "Homogeneous ESS identifier",
                     "type": "string",
                     "example": "00:11:22:33:44:55"
                 },
                 "roaming-consortium": {
+                    "description": "Roaming Consortium OIs can be configured here. Each OI is between 3 and 15 octets and is configured as a hexstring.",
                     "type": "array",
                     "items": {
                         "type": "string"
                     }
                 },
                 "disable-dgaf": {
+                    "description": "Disable Downstream Group-Addressed Forwarding. This can be used to configure a network where no group-addressed frames are allowed.",
                     "type": "boolean",
                     "default": false
                 },
                 "ipaddr-type-available": {
+                    "description": "IP Address Type Availability.",
                     "type": "integer",
                     "maximum": 255
                 },
                 "connection-capability": {
+                    "description": "This can be used to advertise what type of IP traffic can be sent through the hotspot.",
                     "type": "array",
                     "items": {
                         "type": "string"
                     }
                 },
                 "icons": {
+                    "description": "The operator icons.",
                     "type": "array",
                     "items": {
                         "type": "object",
                         "properties": {
                             "width": {
                                 "type": "integer",
+                                "description": "The width of the operator icon in pixel",
                                 "examples": [
                                     64
                                 ]
                             },
                             "height": {
                                 "type": "integer",
+                                "description": "The height of the operator icon in pixel",
                                 "examples": [
                                     64
                                 ]
                             },
                             "type": {
                                 "type": "string",
+                                "description": "The mimetype of the operator icon",
                                 "examples": [
                                     "image/png"
                                 ]
                             },
                             "icon": {
                                 "type": "string",
-                                "format": "uc-base64"
+                                "format": "uc-base64",
+                                "description": "The base64 encoded image"
                             },
                             "language": {
                                 "type": "string",
+                                "description": "ISO 639-2 language code of the icon",
                                 "pattern": "^[a-z][a-z][a-z]$",
                                 "examples": [
                                     "eng",
@@ -1649,9 +1883,11 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "wan-metrics": {
+                    "description": "A description of the wan metric offered by this device.",
                     "type": "object",
                     "properties": {
                         "info": {
+                            "description": "The state of the devices uplink",
                             "type": "string",
                             "enum": [
                                 "up",
@@ -1660,9 +1896,11 @@ static std::string DefaultUCentralSchema = R"foo(
                             ]
                         },
                         "downlink": {
+                            "description": "Estimate of WAN backhaul link current downlink speed in kbps.",
                             "type": "integer"
                         },
                         "uplink": {
+                            "description": "Estimate of WAN backhaul link current uplink speed in kbps.",
                             "type": "integer"
                         }
                     }
@@ -1670,27 +1908,34 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.ssid.quality-thresholds": {
+            "description": "The thresholds that need to be meet for a clien association to be allowed.",
             "type": "object",
             "properties": {
                 "probe-request-rssi": {
+                    "description": "Probe requests will be ignored if the rssi is below this threshold.",
                     "type": "integer"
                 },
                 "association-request-rssi": {
+                    "description": "Association requests will be denied if the rssi is below this threshold.",
                     "type": "integer"
                 },
                 "client-kick-rssi": {
+                    "description": "Clients will get kicked if their SNR drops below this value.",
                     "type": "integer"
                 },
                 "client-kick-ban-time": {
+                    "description": "The duration that a client is banned from re-joining after it was kicked.",
                     "type": "integer",
                     "default": 0
                 }
             }
         },
         "interface.ssid.acl": {
+            "description": "The MAC ACL that defines which clients are allowed or denied to associations.",
             "type": "object",
             "properties": {
                 "mode": {
+                    "description": "Defines if this is an allow or deny list.",
                     "type": "string",
                     "enum": [
                         "allow",
@@ -1698,6 +1943,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "mac-address": {
+                    "description": "Association requests will be denied if the rssi is below this threshold.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -1707,22 +1953,27 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "service.captive.click": {
+            "description": "This section can be used to setup a captive portal on the AP with a click-to-continue splash page.",
             "type": "object",
             "properties": {
                 "auth-mode": {
+                    "description": "This field must be set to 'click-to-continue'",
                     "type": "string",
                     "const": "click-to-continue"
                 }
             }
         },
         "service.captive.radius": {
+            "description": "This section can be used to setup a captive portal on the AP with a click-to-continue splash page.",
             "type": "object",
             "properties": {
                 "auth-mode": {
+                    "description": "This field must be set to 'radius'",
                     "type": "string",
                     "const": "radius"
                 },
                 "auth-server": {
+                    "description": "The URI of our Radius Authentication server.",
                     "type": "string",
                     "format": "uc-host",
                     "examples": [
@@ -1730,18 +1981,21 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "auth-port": {
+                    "description": "The network port of our Radius Authentication server.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 1024,
                     "default": 1812
                 },
                 "auth-secret": {
+                    "description": "The shared Radius authentication Authentication secret.",
                     "type": "string",
                     "examples": [
                         "secret"
                     ]
                 },
                 "acct-server": {
+                    "description": "The URI of our Radius Authentication server.",
                     "type": "string",
                     "format": "uc-host",
                     "examples": [
@@ -1749,31 +2003,37 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "acct-port": {
+                    "description": "The network port of our Radius Authentication server.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 1024,
                     "default": 1812
                 },
                 "acct-secret": {
+                    "description": "The shared Radius authentication Authentication secret.",
                     "type": "string",
                     "examples": [
                         "secret"
                     ]
                 },
                 "acct-interval": {
+                    "description": "The timeout used for interim messages.",
                     "type": "integer",
                     "default": 600
                 }
             }
         },
         "service.captive.credentials": {
+            "description": "This section can be used to setup a captive portal on the AP with a credentials splash page.",
             "type": "object",
             "properties": {
                 "auth-mode": {
+                    "description": "This field must be set to 'credentials'",
                     "type": "string",
                     "const": "credentials"
                 },
                 "credentials": {
+                    "description": "The list of local username/password pairs that can be used to login.",
                     "type": "array",
                     "items": {
                         "type": "object",
@@ -1790,31 +2050,39 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "service.captive.uam": {
+            "description": "This section can be used to setup a captive portal on the AP with a remote UAM server.",
             "type": "object",
             "properties": {
                 "auth-mode": {
+                    "description": "This field must be set to 'uam'",
                     "type": "string",
                     "const": "uam"
                 },
                 "uam-port": {
+                    "description": "The local UAM port.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 1024,
                     "default": 3990
                 },
                 "uam-secret": {
+                    "description": "The pre-shared UAM secret.",
                     "type": "string"
                 },
                 "uam-server": {
+                    "description": "The fqdn of the UAM server.",
                     "type": "string"
                 },
                 "nasid": {
+                    "description": "The NASID that gets sent to the UAM server.",
                     "type": "string"
                 },
                 "nasmac": {
+                    "description": "The NAS MAC that gets send to the UAM server. The devices serial is used if this value is not provided.",
                     "type": "string"
                 },
                 "auth-server": {
+                    "description": "The URI of our Radius Authentication server.",
                     "type": "string",
                     "format": "uc-host",
                     "examples": [
@@ -1822,18 +2090,21 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "auth-port": {
+                    "description": "The network port of our Radius Authentication server.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 1024,
                     "default": 1812
                 },
                 "auth-secret": {
+                    "description": "The shared Radius authentication Authentication secret.",
                     "type": "string",
                     "examples": [
                         "secret"
                     ]
                 },
                 "acct-server": {
+                    "description": "The URI of our Radius Authentication server.",
                     "type": "string",
                     "format": "uc-host",
                     "examples": [
@@ -1841,25 +2112,30 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "acct-port": {
+                    "description": "The network port of our Radius Authentication server.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 1024,
                     "default": 1812
                 },
                 "acct-secret": {
+                    "description": "The shared Radius authentication Authentication secret.",
                     "type": "string",
                     "examples": [
                         "secret"
                     ]
                 },
                 "acct-interval": {
+                    "description": "The timeout used for interim messages.",
                     "type": "integer",
                     "default": 600
                 },
                 "ssid": {
+                    "description": "The name of the SSID that shall be sent as part of the UAM redirect.",
                     "type": "string"
                 },
                 "mac-format": {
+                    "description": "Defines the format used to send the MAC address inside AAA frames.",
                     "type": "string",
                     "enum": [
                         "aabbccddeeff",
@@ -1871,6 +2147,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "final-redirect-url": {
+                    "description": "Define the behaviour off the final redirect. Default will honour \"userurl\" and fallback to \"local\". Alternatively it is possible to force a redirect to the \"UAM\" or \"local\" URL.",
                     "type": "string",
                     "enum": [
                         "default",
@@ -1878,10 +2155,12 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "mac-auth": {
+                    "description": "Try to authenticate new clients using macauth.",
                     "type": "boolean",
                     "default": "default"
                 },
                 "radius-gw-proxy": {
+                    "description": "Tunnel all radius traffic via the radius-gw-proxy.",
                     "type": "boolean",
                     "default": false
                 }
@@ -1909,12 +2188,14 @@ static std::string DefaultUCentralSchema = R"foo(
                     "type": "object",
                     "properties": {
                         "walled-garden-fqdn": {
+                            "description": "The list of FQDNs that a non-authenticated client is allowed to connect to.",
                             "type": "array",
                             "items": {
                                 "type": "string"
                             }
                         },
                         "walled-garden-ipaddr": {
+                            "description": "The list of IP addresses that a non-authenticated client is allowed to connect to.",
                             "type": "array",
                             "items": {
                                 "type": "string",
@@ -1922,14 +2203,17 @@ static std::string DefaultUCentralSchema = R"foo(
                             }
                         },
                         "web-root": {
+                            "description": "A base64 encoded TAR file with the custom web-root.",
                             "type": "string",
                             "format": "uc-base64"
                         },
                         "idle-timeout": {
+                            "description": "How long may a client be idle before getting removed.",
                             "type": "integer",
                             "default": 600
                         },
                         "session-timeout": {
+                            "description": "How long may a client be idle before getting removed.",
                             "type": "integer"
                         }
                     }
@@ -1937,9 +2221,11 @@ static std::string DefaultUCentralSchema = R"foo(
             ]
         },
         "interface.ssid": {
+            "description": "A device has certain properties that describe its identity and location. These properties are described inside this object.",
             "type": "object",
             "properties": {
                 "purpose": {
+                    "description": "An SSID can have a special purpose such as the hidden on-boarding BSS. All purposes other than \"user-defined\" are static pre-defined configurations.",
                     "type": "string",
                     "enum": [
                         "user-defined",
@@ -1949,11 +2235,13 @@ static std::string DefaultUCentralSchema = R"foo(
                     "default": "user-defined"
                 },
                 "name": {
+                    "description": "The broadcasted SSID of the wireless network and for for managed mode the SSID of the network you\u2019re connecting to",
                     "type": "string",
                     "maxLength": 32,
                     "minLength": 1
                 },
                 "wifi-bands": {
+                    "description": "The band that the SSID should be broadcasted on. The configuration layer will use the first matching band.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -1967,6 +2255,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "bss-mode": {
+                    "description": "Selects the operation mode of the wireless network interface controller.",
                     "type": "string",
                     "enum": [
                         "ap",
@@ -1979,35 +2268,44 @@ static std::string DefaultUCentralSchema = R"foo(
                     "default": "ap"
                 },
                 "bssid": {
+                    "description": "Override the BSSID of the network, only applicable in adhoc or sta mode.",
                     "type": "string",
                     "format": "uc-mac"
                 },
                 "hidden-ssid": {
+                    "description": "Disables the broadcasting of beacon frames if set to 1 and,in doing so, hides the ESSID.",
                     "type": "boolean"
                 },
                 "isolate-clients": {
+                    "description": "Isolates wireless clients from each other on this BSS.",
                     "type": "boolean"
                 },
                 "strict-forwarding": {
+                    "description": "Isolate the BSS from all other members on the bridge apart from the first wired port.",
                     "type": "boolean",
                     "default": false
                 },
                 "power-save": {
+                    "description": "Unscheduled Automatic Power Save Delivery.",
                     "type": "boolean"
                 },
                 "rts-threshold": {
+                    "description": "Set the RTS/CTS threshold of the BSS.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 1
                 },
                 "broadcast-time": {
+                    "description": "This option will make the unit braodcast the time inside its beacons.",
                     "type": "boolean"
                 },
                 "unicast-conversion": {
+                    "description": "Convert multicast traffic to unicast on this BSS.",
                     "type": "boolean",
                     "default": true
                 },
                 "services": {
+                    "description": "The services that shall be offered on this logical interface. These are just strings such as \"wifi-steering\"",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -2017,16 +2315,19 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "dtim-period": {
+                    "description": "Set the DTIM (delivery traffic information message) period. There will be one DTIM per this many beacon frames. This may be set between 1 and 255. This option only has an effect on ap wifi-ifaces.",
                     "type": "integer",
                     "default": 2,
                     "maximum": 255,
                     "minimum": 1
                 },
                 "maximum-clients": {
+                    "description": "Set the maximum number of clients that may connect to this VAP.",
                     "type": "integer",
                     "example": 64
                 },
                 "proxy-arp": {
+                    "description": "Proxy ARP is the technique in which the host router, answers ARP requests intended for another machine.",
                     "type": "boolean",
                     "default": true
                 },
@@ -2045,6 +2346,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     "default": true
                 },
                 "fils-discovery-interval": {
+                    "description": "The maximum interval for FILS discovery announcement frames. This is a condensed beacon used in 6GHz channels for passive BSS discovery.",
                     "type": "integer",
                     "default": 20,
                     "maximum": 20
@@ -2070,6 +2372,7 @@ static std::string DefaultUCentralSchema = R"foo(
                             "$ref": "#/$defs/interface.ssid.roaming"
                         },
                         {
+                            "description": "Enable 802.11r Fast Roaming for this BSS. This will enable \"auto\" mode which will work for most scenarios.",
                             "type": "boolean"
                         }
                     ]
@@ -2092,7 +2395,20 @@ static std::string DefaultUCentralSchema = R"foo(
                 "captive": {
                     "$ref": "#/$defs/service.captive"
                 },
+                "vlan-awareness": {
+                    "description": "Setup additional VLANs inside the bridge",
+                    "type": "object",
+                    "properties": {
+                        "first": {
+                            "type": "integer"
+                        },
+                        "last": {
+                            "type": "integer"
+                        }
+                    }
+                },
                 "hostapd-bss-raw": {
+                    "description": "This array allows passing raw hostapd.conf lines.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -2111,27 +2427,33 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.tunnel.mesh": {
+            "description": "This Object defines the properties of a mesh interface overlay.",
             "type": "object",
             "properties": {
                 "proto": {
+                    "description": "This field must be set to mesh.",
                     "type": "string",
                     "const": "mesh"
                 }
             }
         },
         "interface.tunnel.vxlan": {
+            "description": "This Object defines the properties of a vxlan tunnel.",
             "type": "object",
             "properties": {
                 "proto": {
+                    "description": "This field must be set to vxlan.",
                     "type": "string",
                     "const": "vxlan"
                 },
                 "peer-address": {
+                    "description": "This is the IP address of the remote host, that the VXLAN tunnel shall be established with.",
                     "type": "string",
                     "format": "ipv4",
                     "example": "192.168.100.1"
                 },
                 "peer-port": {
+                    "description": "The network port that shall be used to establish the VXLAN tunnel.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 1,
@@ -2142,60 +2464,74 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "interface.tunnel.l2tp": {
+            "description": "This Object defines the properties of a l2tp tunnel.",
             "type": "object",
             "properties": {
                 "proto": {
+                    "description": "This field must be set to vxlan.",
                     "type": "string",
                     "const": "l2tp"
                 },
                 "server": {
+                    "description": "This is the IP address of the remote host, that the L2TP tunnel shall be established with.",
                     "type": "string",
                     "format": "ipv4",
                     "example": "192.168.100.1"
                 },
                 "user-name": {
+                    "description": "The username used to authenticate.",
                     "type": "string"
                 },
                 "password": {
+                    "description": "The password used to authenticate.",
                     "type": "string"
                 }
             }
         },
         "interface.tunnel.gre": {
+            "description": "This Object defines the properties of a GRE tunnel.",
             "type": "object",
             "properties": {
                 "proto": {
+                    "description": "This field must be set to gre.",
                     "type": "string",
                     "const": "gre"
                 },
                 "peer-address": {
+                    "description": "This is the IP address of the remote host, that the GRE tunnel shall be established with.",
                     "type": "string",
                     "format": "ipv4",
                     "example": "192.168.100.1"
                 },
                 "dhcp-healthcheck": {
+                    "description": "Healthcheck will probe if the remote peer replies to DHCP discovery without sending an ACK.",
                     "type": "boolean",
                     "default": false
                 },
                 "dont-fragment": {
+                    "description": "Set \u201cDon't Fragment\u201d flag on encapsulated packets.",
                     "type": "boolean",
                     "default": false
                 }
             }
         },
         "interface.tunnel.gre6": {
+            "description": "This Object defines the properties of a GREv6 tunnel.",
             "type": "object",
             "properties": {
                 "proto": {
+                    "description": "This field must be set to gre6.",
                     "type": "string",
                     "const": "gre6"
                 },
                 "peer-address": {
+                    "description": "This is the IPv6 address of the remote host, that the GRE tunnel shall be established with.",
                     "type": "string",
                     "format": "ipv6",
                     "example": "2405:200:802:600:61::1"
                 },
                 "dhcp-healthcheck": {
+                    "description": "Healthcheck will probe if the remote peer replies to DHCP discovery without sending an ACK.",
                     "type": "boolean",
                     "default": false
                 }
@@ -2221,15 +2557,18 @@ static std::string DefaultUCentralSchema = R"foo(
             ]
         },
         "interface": {
+            "description": "This section describes the logical network interfaces of the device. Interfaces as their primary have a role that is upstream, downstream, guest, ....",
             "type": "object",
             "properties": {
                 "name": {
+                    "description": "This is a free text field, stating the administrative name of the interface. It may contain spaces and special characters.",
                     "type": "string",
                     "examples": [
                         "LAN"
                     ]
                 },
                 "role": {
+                    "description": "The role defines if the interface is upstream or downstream facing.",
                     "type": "string",
                     "enum": [
                         "upstream",
@@ -2237,19 +2576,23 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "isolate-hosts": {
+                    "description": "This option makes sure that any traffic leaving this interface is isolated and all local IP ranges are blocked. It essentially enforces \"guest network\" firewall settings.",
                     "type": "boolean"
                 },
                 "metric": {
+                    "description": "The routing metric of this logical interface. Lower values have higher priority.",
                     "type": "integer",
                     "maximum": 4294967295,
                     "minimum": 0
                 },
                 "mtu": {
+                    "description": "The MTU of this logical interface.",
                     "type": "integer",
                     "maximum": 1500,
                     "minimum": 1280
                 },
                 "services": {
+                    "description": "The services that shall be offered on this logical interface. These are just strings such as \"ssh\", \"lldp\", \"mdns\"",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -2260,6 +2603,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "vlan-awareness": {
+                    "description": "Setup additional VLANs inside the bridge",
                     "type": "object",
                     "properties": {
                         "first": {
@@ -2270,6 +2614,22 @@ static std::string DefaultUCentralSchema = R"foo(
                         }
                     }
                 },
+                "ieee8021x-ports": {
+                    "description": "The list of physical network devices that shall serve .1x for this interface.",
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "examples": [
+                            "LAN1",
+                            "LAN2",
+                            "LAN3",
+                            "LAN4",
+                            "LAN*",
+                            "WAN*",
+                            "*"
+                        ]
+                    }
+                },
                 "vlan": {
                     "$ref": "#/$defs/interface.vlan"
                 },
@@ -2306,24 +2666,29 @@ static std::string DefaultUCentralSchema = R"foo(
             "type": "object",
             "properties": {
                 "describe": {
+                    "description": "The LLDP description field. If set to \"auto\" it will be derived from unit.name.",
                     "type": "string",
                     "default": "uCentral Access Point"
                 },
                 "location": {
+                    "description": "The LLDP location field. If set to \"auto\" it will be derived from unit.location.",
                     "type": "string",
                     "default": "uCentral Network"
                 }
             }
         },
         "service.ssh": {
+            "description": "This section can be used to setup a SSH server on the AP.",
             "type": "object",
             "properties": {
                 "port": {
+                    "description": "This option defines which port the SSH server shall be available on.",
                     "type": "integer",
                     "maximum": 65535,
                     "default": 22
                 },
                 "authorized-keys": {
+                    "description": "This allows the upload of public ssh keys. Keys need to be seperated by a newline.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -2335,6 +2700,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "password-authentication": {
+                    "description": "This option defines if password authentication shall be enabled. If set to false, only ssh key based authentication is possible.",
                     "type": "boolean",
                     "default": true
                 }
@@ -2342,8 +2708,10 @@ static std::string DefaultUCentralSchema = R"foo(
         },
         "service.ntp": {
             "type": "object",
+            "description": "This section can be used to setup the upstream NTP servers.",
             "properties": {
                 "servers": {
+                    "description": "This is an array of URL/IP of the upstream NTP servers that the unit shall use to acquire its current time.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -2352,28 +2720,26 @@ static std::string DefaultUCentralSchema = R"foo(
                     "examples": [
                         "0.openwrt.pool.ntp.org"
                     ]
-                },
-                "local-server": {
-                    "type": "boolean",
-                    "examples": [
-                        true
-                    ]
                 }
             }
         },
         "service.mdns": {
+            "description": "This section can be used to configure the MDNS server.",
             "type": "object",
             "properties": {
                 "enable": {
+                    "description": "Enable this option if you would like to enable the MDNS server on the unit.",
                     "type": "boolean",
                     "default": false
                 }
             }
         },
         "service.rtty": {
+            "description": "This section can be used to setup a persistent connection to a rTTY server.",
             "type": "object",
             "properties": {
                 "host": {
+                    "description": "The server that the device shall connect to.",
                     "type": "string",
                     "format": "uc-host",
                     "examples": [
@@ -2381,11 +2747,13 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "port": {
+                    "description": "This option defines the port that device shall connect to.",
                     "type": "integer",
                     "maximum": 65535,
                     "default": 5912
                 },
                 "token": {
+                    "description": "The security token that shall be used to authenticate with the server.",
                     "type": "string",
                     "maxLength": 32,
                     "minLength": 32,
@@ -2394,15 +2762,18 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "mutual-tls": {
+                    "description": "Shall the connection enforce mTLS",
                     "type": "boolean",
                     "default": true
                 }
             }
         },
         "service.log": {
+            "description": "This section can be used to configure remote syslog support.",
             "type": "object",
             "properties": {
                 "host": {
+                    "description": "IP address of a syslog server to which the log messages should be sent in addition to the local destination.",
                     "type": "string",
                     "format": "uc-host",
                     "examples": [
@@ -2410,6 +2781,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "port": {
+                    "description": "Port number of the remote syslog server specified with log_ip.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 100,
@@ -2418,6 +2790,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "proto": {
+                    "description": "Sets the protocol to use for the connection, either tcp or udp.",
                     "type": "string",
                     "enum": [
                         "tcp",
@@ -2426,11 +2799,13 @@ static std::string DefaultUCentralSchema = R"foo(
                     "default": "udp"
                 },
                 "size": {
+                    "description": "Size of the file based log buffer in KiB. This value is used as the fallback value for log_buffer_size if the latter is not specified.",
                     "type": "integer",
                     "minimum": 32,
                     "default": 1000
                 },
                 "priority": {
+                    "description": "Filter messages by their log priority. the value maps directly to the 0-7 range used by syslog.",
                     "type": "integer",
                     "minimum": 0,
                     "default": 7
@@ -2438,9 +2813,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "service.http": {
+            "description": "Enable the webserver with the on-boarding webui",
             "type": "object",
             "properties": {
                 "http-port": {
+                    "description": "The port that the HTTP server should run on.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 1,
@@ -2449,32 +2826,30 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "service.igmp": {
+            "description": "This section allows enabling the IGMP/Multicast proxy",
             "type": "object",
             "properties": {
                 "enable": {
+                    "description": "This option defines if the IGMP/Multicast proxy shall be enabled on the device.",
                     "type": "boolean",
                     "default": false
                 }
             }
         },
         "service.ieee8021x": {
+            "description": "This section allows enabling wired ieee802.1X",
             "type": "object",
             "properties": {
-                "ca-certificate": {
-                    "type": "string"
-                },
-                "use-local-certificates": {
-                    "type": "boolean",
-                    "default": false
-                },
                 "mode": {
+                    "description": "This field must be set to 'radius or user'",
                     "type": "string",
                     "enum": [
                         "radius",
                         "user"
                     ]
                 },
-                "port-filter": {
+                "select-ports": {
+                    "description": "Specifies a list of ports that we want to filter.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -2485,25 +2860,23 @@ static std::string DefaultUCentralSchema = R"foo(
                         ]
                     }
                 },
-                "server-certificate": {
-                    "type": "string"
-                },
-                "private-key": {
-                    "type": "string"
-                },
                 "users": {
+                    "description": "Specifies a collection of local EAP user/psk/vid triplets.",
                     "type": "array",
                     "items": {
                         "$ref": "#/$defs/interface.ssid.radius.local-user"
                     }
                 },
                 "radius": {
+                    "description": "Specifies the information about radius account authentication and accounting",
                     "type": "object",
                     "properties": {
                         "nas-identifier": {
+                            "description": "NAS-Identifier string for RADIUS messages. When used, this should be unique to the NAS within the scope of the RADIUS server.",
                             "type": "string"
                         },
                         "auth-server-addr": {
+                            "description": "The URI of our Radius server.",
                             "type": "string",
                             "format": "uc-host",
                             "examples": [
@@ -2511,6 +2884,7 @@ static std::string DefaultUCentralSchema = R"foo(
                             ]
                         },
                         "auth-server-port": {
+                            "description": "The network port of our Radius server.",
                             "type": "integer",
                             "maximum": 65535,
                             "minimum": 1024,
@@ -2519,12 +2893,14 @@ static std::string DefaultUCentralSchema = R"foo(
                             ]
                         },
                         "auth-server-secret": {
+                            "description": "The shared Radius authentication secret.",
                             "type": "string",
                             "examples": [
                                 "secret"
                             ]
                         },
                         "acct-server-addr": {
+                            "description": "The URI of our Radius server.",
                             "type": "string",
                             "format": "uc-host",
                             "examples": [
@@ -2532,6 +2908,7 @@ static std::string DefaultUCentralSchema = R"foo(
                             ]
                         },
                         "acct-server-port": {
+                            "description": "The network port of our Radius server.",
                             "type": "integer",
                             "maximum": 65535,
                             "minimum": 1024,
@@ -2540,12 +2917,14 @@ static std::string DefaultUCentralSchema = R"foo(
                             ]
                         },
                         "acct-server-secret": {
+                            "description": "The shared Radius accounting secret.",
                             "type": "string",
                             "examples": [
                                 "secret"
                             ]
                         },
                         "coa-server-addr": {
+                            "description": "The URI of our Radius server.",
                             "type": "string",
                             "format": "uc-host",
                             "examples": [
@@ -2553,6 +2932,7 @@ static std::string DefaultUCentralSchema = R"foo(
                             ]
                         },
                         "coa-server-port": {
+                            "description": "The network port of our Radius server.",
                             "type": "integer",
                             "maximum": 65535,
                             "minimum": 1024,
@@ -2561,23 +2941,31 @@ static std::string DefaultUCentralSchema = R"foo(
                             ]
                         },
                         "coa-server-secret": {
+                            "description": "The shared Radius accounting secret.",
                             "type": "string",
                             "examples": [
                                 "secret"
                             ]
+                        },
+                        "mac-address-bypass": {
+                            "description": "Trigger mac-auth when a new ARP is learned.",
+                            "type": "boolean"
                         }
                     }
                 }
             }
         },
         "service.radius-proxy": {
+            "description": "This section can be used to setup a radius security proxy instance (radsecproxy).",
             "type": "object",
             "properties": {
                 "proxy-secret": {
+                    "description": "The radius secret used to communicate with the proxy.",
                     "type": "string",
                     "default": "secret"
                 },
                 "realms": {
+                    "description": "The various realms that we can proxy to.",
                     "type": "array",
                     "items": {
                         "anyOf": [
@@ -2585,6 +2973,7 @@ static std::string DefaultUCentralSchema = R"foo(
                                 "type": "object",
                                 "properties": {
                                     "protocol": {
+                                        "description": "Defines whether the real should use radsec or normal radius.",
                                         "type": "string",
                                         "enum": [
                                             "radsec"
@@ -2592,6 +2981,7 @@ static std::string DefaultUCentralSchema = R"foo(
                                         "default": "radsec"
                                     },
                                     "realm": {
+                                        "description": "The realm that that this server shall be used for.",
                                         "type": "array",
                                         "items": {
                                             "type": "string",
@@ -2599,10 +2989,12 @@ static std::string DefaultUCentralSchema = R"foo(
                                         }
                                     },
                                     "auto-discover": {
+                                        "description": "Auto discover radsec server address via realm DNS NAPTR record.",
                                         "type": "boolean",
                                         "default": false
                                     },
                                     "host": {
+                                        "description": "The remote proxy server that the device shall connect to.",
                                         "type": "string",
                                         "format": "uc-host",
                                         "examples": [
@@ -2610,27 +3002,34 @@ static std::string DefaultUCentralSchema = R"foo(
                                         ]
                                     },
                                     "port": {
+                                        "description": "The remote proxy port that the device shall connect to.",
                                         "type": "integer",
                                         "maximum": 65535,
                                         "default": 2083
                                     },
                                     "secret": {
+                                        "description": "The radius secret that will be used for the connection.",
                                         "type": "string"
                                     },
                                     "use-local-certificates": {
+                                        "description": "The device will use its local certificate bundle for the TLS setup and ignores all other certificate options in this section.",
                                         "type": "boolean",
                                         "default": false
                                     },
                                     "ca-certificate": {
+                                        "description": "The local servers CA bundle.",
                                         "type": "string"
                                     },
                                     "certificate": {
+                                        "description": "The local servers certificate.",
                                         "type": "string"
                                     },
                                     "private-key": {
+                                        "description": "The local servers private key/",
                                         "type": "string"
                                     },
                                     "private-key-password": {
+                                        "description": "The password required to read the private key.",
                                         "type": "string"
                                     }
                                 }
@@ -2639,12 +3038,14 @@ static std::string DefaultUCentralSchema = R"foo(
                                 "type": "object",
                                 "properties": {
                                     "protocol": {
+                                        "description": "Defines whether the real should use radsec or normal radius.",
                                         "type": "string",
                                         "enum": [
                                             "radius"
                                         ]
                                     },
                                     "realm": {
+                                        "description": "The realm that that this server shall be used for.",
                                         "type": "array",
                                         "items": {
                                             "type": "string",
@@ -2652,6 +3053,7 @@ static std::string DefaultUCentralSchema = R"foo(
                                         }
                                     },
                                     "auth-server": {
+                                        "description": "The URI of our Radius server.",
                                         "type": "string",
                                         "format": "uc-host",
                                         "examples": [
@@ -2659,6 +3061,7 @@ static std::string DefaultUCentralSchema = R"foo(
                                         ]
                                     },
                                     "auth-port": {
+                                        "description": "The network port of our Radius server.",
                                         "type": "integer",
                                         "maximum": 65535,
                                         "minimum": 1024,
@@ -2667,12 +3070,14 @@ static std::string DefaultUCentralSchema = R"foo(
                                         ]
                                     },
                                     "auth-secret": {
+                                        "description": "The shared Radius authentication secret.",
                                         "type": "string",
                                         "examples": [
                                             "secret"
                                         ]
                                     },
                                     "acct-server": {
+                                        "description": "The URI of our Radius server.",
                                         "type": "string",
                                         "format": "uc-host",
                                         "examples": [
@@ -2680,6 +3085,7 @@ static std::string DefaultUCentralSchema = R"foo(
                                         ]
                                     },
                                     "acct-port": {
+                                        "description": "The network port of our Radius server.",
                                         "type": "integer",
                                         "maximum": 65535,
                                         "minimum": 1024,
@@ -2688,6 +3094,7 @@ static std::string DefaultUCentralSchema = R"foo(
                                         ]
                                     },
                                     "acct-secret": {
+                                        "description": "The shared Radius authentication secret.",
                                         "type": "string",
                                         "examples": [
                                             "secret"
@@ -2699,12 +3106,14 @@ static std::string DefaultUCentralSchema = R"foo(
                                 "type": "object",
                                 "properties": {
                                     "protocol": {
+                                        "description": "Defines whether the real should use radsec or normal radius.",
                                         "type": "string",
                                         "enum": [
                                             "block"
                                         ]
                                     },
                                     "realm": {
+                                        "description": "The realm that that this server shall be used for.",
                                         "type": "array",
                                         "items": {
                                             "type": "string",
@@ -2712,6 +3121,7 @@ static std::string DefaultUCentralSchema = R"foo(
                                         }
                                     },
                                     "message": {
+                                        "description": "The message that is sent when a realm is blocked.",
                                         "type": "string",
                                         "items": {
                                             "type": "string",
@@ -2726,9 +3136,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "service.online-check": {
+            "description": "This section can be used to configure the online check service.",
             "type": "object",
             "properties": {
                 "ping-hosts": {
+                    "description": "Hosts that shall be pinged to find out if we are online.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -2739,6 +3151,7 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "download-hosts": {
+                    "description": "URLs to which a http/s connection shall be established to find out if we are online. The service will try to download http://$string/online.txt and expects the content of that file to be \"Ok\". HTTP 30x is support allowing https redirects.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -2748,14 +3161,17 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "check-interval": {
+                    "description": "The interval in seconds in between each online-check.",
                     "type": "number",
                     "default": 60
                 },
                 "check-threshold": {
+                    "description": "How often does the online check need to fail until the system assumes that it has lost online connectivity.",
                     "type": "number",
                     "default": 1
                 },
                 "action": {
+                    "description": "The action that the device shall execute when it has detected that it is not online.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -2768,17 +3184,21 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "service.data-plane": {
+            "description": "This section can be used to define eBPF and cBPF blobs that shall be loaded for virtual data-planes and SDN.",
             "type": "object",
             "properties": {
                 "ingress-filters": {
+                    "description": "A list of programs that can be loaded as ingress filters on interfaces.",
                     "type": "array",
                     "items": {
                         "type": "object",
                         "properties": {
                             "name": {
+                                "description": "The name of the ingress filter.",
                                 "type": "string"
                             },
                             "program": {
+                                "description": "The base64 encoded xBPF.",
                                 "type": "string",
                                 "format": "uc-base64"
                             }
@@ -2788,9 +3208,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "service.wifi-steering": {
+            "description": "This section describes the band steering behaviour of the unit.",
             "type": "object",
             "properties": {
                 "mode": {
+                    "description": "Wifi sterring can happen either locally or via the backend gateway.",
                     "type": "string",
                     "enum": [
                         "local",
@@ -2801,30 +3223,37 @@ static std::string DefaultUCentralSchema = R"foo(
                     ]
                 },
                 "assoc-steering": {
+                    "description": "Allow rejecting assoc requests for steering purposes.",
                     "type": "boolean",
                     "default": false
                 },
                 "required-snr": {
+                    "description": "Minimum required signal level (dBm) for connected clients. If the client will be kicked if the SNR drops below this value.",
                     "type": "integer",
                     "default": 0
                 },
                 "required-probe-snr": {
+                    "description": "Minimum required signal level (dBm) to allow connections. If the SNR is below this value, probe requests will not be replied to.",
                     "type": "integer",
                     "default": 0
                 },
                 "required-roam-snr": {
+                    "description": "Minimum required signal level (dBm) before an attempt is made to roam the client to a better AP.",
                     "type": "integer",
                     "default": 0
                 },
                 "load-kick-threshold": {
+                    "description": "Minimum channel load (%) before kicking clients",
                     "type": "integer",
                     "default": 0
                 },
                 "auto-channel": {
+                    "description": "Allow multiple instances of the steering daemon to coordinate the best channel usage amongst eachother.",
                     "type": "boolean",
                     "default": false
                 },
                 "ipv6": {
+                    "description": "Use IPv6 multicast to communicate with remote usteerd instances, rather than IPv4 broadcast.",
                     "type": "boolean",
                     "default": false
                 }
@@ -2860,9 +3289,11 @@ static std::string DefaultUCentralSchema = R"foo(
             ]
         },
         "service.quality-of-service": {
+            "description": "This section describes the QoS behaviour of the unit.",
             "type": "object",
             "properties": {
                 "select-ports": {
+                    "description": "The physical network devices that shall be considered the primary uplink interface. All classification and shaping will happen on this device.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -2870,47 +3301,57 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "bandwidth-up": {
+                    "description": "Defines the upload bandwidth of this device. If it is not known or the device is attached to a shared medium, this value needs to be 0.",
                     "type": "integer",
                     "default": 0
                 },
                 "bandwidth-down": {
+                    "description": "Defines the download bandwidth of this device. If it is not known or the device is attached to a shared medium, this value needs to be 0.",
                     "type": "integer",
                     "default": 0
                 },
                 "bulk-detection": {
+                    "description": "The QoS feature can automatically detect and classify bulk flows. This is based on average packet size and PPS.",
                     "type": "object",
                     "properties": {
                         "dscp": {
+                            "description": "The differentiated services code point that shall be assigned to packets that belong to a bulk flow.",
                             "$ref": "#/$defs/service.quality-of-service.class-selector",
                             "default": "CS0"
                         },
                         "packets-per-second": {
+                            "description": "The required PPS rate that will cause a flow to be classified as bulk.",
                             "type": "number",
                             "default": 0
                         }
                     }
                 },
                 "services": {
+                    "description": "A list of predefined named services that shall be classified according to the communities DB.",
                     "type": "array",
                     "items": {
                         "type": "string"
                     }
                 },
                 "classifier": {
+                    "description": "A list of classifiers. Each classifier will map certain traffic to specific ToS/DSCP values based upon the defined constraints.",
                     "type": "array",
                     "items": {
                         "type": "object",
                         "properties": {
                             "dscp": {
+                                "description": "The differentiated services code point that shall be assigned to packet that match the rules of this entry.",
                                 "$ref": "#/$defs/service.quality-of-service.class-selector",
                                 "default": "CS1"
                             },
                             "ports": {
+                                "description": "Each entry defines a layer3 protocol and a port(range) that will be used to match packets.",
                                 "type": "array",
                                 "items": {
                                     "type": "object",
                                     "properties": {
                                         "protocol": {
+                                            "description": "The port match can apply for TCP, UDP or any IP protocol.",
                                             "type": "string",
                                             "enum": [
                                                 "any",
@@ -2920,12 +3361,15 @@ static std::string DefaultUCentralSchema = R"foo(
                                             "default": "any"
                                         },
                                         "port": {
+                                            "description": "The port of this match rule.",
                                             "type": "integer"
                                         },
                                         "range-end": {
+                                            "description": "The last port of this match rule if it is a port range.",
                                             "type": "integer"
                                         },
                                         "reclassify": {
+                                            "description": "Ignore the ToS/DSCP of packets and reclassify them.",
                                             "type": "boolean",
                                             "default": true
                                         }
@@ -2933,6 +3377,7 @@ static std::string DefaultUCentralSchema = R"foo(
                                 }
                             },
                             "dns": {
+                                "description": "Each entry defines a wildcard FQDN. The IP that this resolves to will be used to match packets.",
                                 "type": "array",
                                 "items": {
                                     "type": "object",
@@ -2942,10 +3387,12 @@ static std::string DefaultUCentralSchema = R"foo(
                                             "format": "uc-fqdn"
                                         },
                                         "suffix-matching": {
+                                            "description": "Match for all suffixes of the FQDN.",
                                             "type": "boolean",
                                             "default": true
                                         },
                                         "reclassify": {
+                                            "description": "Ignore the ToS/DSCP of packets and reclassify them.",
                                             "type": "boolean",
                                             "default": true
                                         }
@@ -2958,85 +3405,106 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "service.facebook-wifi": {
+            "description": "This section describes the FaceBook Wifi behaviour of the unit.",
             "type": "object",
             "properties": {
                 "vendor-id": {
+                    "description": "The Vendors ID.",
                     "type": "string"
                 },
                 "gateway-id": {
+                    "description": "The Gateways ID.",
                     "type": "string"
                 },
                 "secret": {
+                    "description": "The Device specific secret",
                     "type": "string"
                 }
             }
         },
         "service.airtime-fairness": {
+            "description": "This section describes the vlan behaviour of a logical network interface.",
             "type": "object",
             "properties": {
                 "voice-weight": {
+                    "description": "Voice traffic does not get aggregated. As voice and video are both considered priotity voice is considered to have a heavier weight when calculation priority average.",
                     "type": "number",
                     "default": 4
                 },
                 "packet-threshold": {
+                    "description": "The amount of packets that need to be received for a specific type of traffic before new averageg is calculated.",
                     "type": "number",
                     "default": 100
                 },
                 "bulk-threshold": {
+                    "description": "This option is a percentual value. If more the X% of the traffic is bulk, we assign the bulk weight.",
                     "type": "number",
                     "default": 50
                 },
                 "priority-threshold": {
+                    "description": "This option is a percentual value. If more the X% of the traffic is priority, we assign the priority weight. Priority classification will take precedence over bulk.",
                     "type": "number",
                     "default": 30
                 },
                 "weight-normal": {
+                    "description": "The default ATF weight that UEs get assigned.",
                     "type": "number",
                     "default": 256
                 },
                 "weight-priority": {
+                    "description": "The default ATF weight that UEs get assigned when priority traffic above the configured percentage is detected.",
                     "type": "number",
                     "default": 394
                 },
                 "weight-bulk": {
+                    "description": "The default ATF weight that UEs get assigned when bulk traffic above the configured percentage is detected.",
                     "type": "number",
                     "default": 128
                 }
             }
         },
         "service.wireguard-overlay": {
+            "description": "This Object defines the properties of a wireguard-overlay.",
             "type": "object",
             "properties": {
                 "proto": {
+                    "description": "This field must be set to wireguard-overlay.",
                     "type": "string",
                     "const": "wireguard-overlay"
                 },
                 "private-key": {
+                    "description": "The private key of the device. This key is used to lookup the host entry inside the config.",
                     "type": "string"
                 },
                 "peer-port": {
+                    "description": "The network port that shall be used to establish the wireguard tunnel.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 1,
                     "default": 3456
                 },
                 "peer-exchange-port": {
+                    "description": "The network port that shall be used to exchange peer data inside the tunnel.",
                     "type": "integer",
                     "maximum": 65535,
                     "minimum": 1,
                     "default": 3458
                 },
                 "root-node": {
+                    "description": "The descritption of the root node of the overlay.",
                     "type": "object",
                     "properties": {
                         "key": {
+                            "description": "The public key of the host.",
                             "type": "string"
                         },
                         "endpoint": {
+                            "description": "The public IP of the host (optional).",
                             "type": "string",
                             "format": "uc-ip"
                         },
                         "ipaddr": {
+                            "description": "The list of private IPs that a host is reachable on inside the overlay.",
                             "type": "array",
                             "items": {
                                 "type": "string",
@@ -3046,21 +3514,26 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "hosts": {
+                    "description": "The list of all known hosts inside the overlay.",
                     "type": "array",
                     "items": {
                         "type": "object",
                         "properties": {
                             "name": {
+                                "description": "The unique name of the host.",
                                 "type": "string"
                             },
                             "key": {
+                                "description": "The public key of the host.",
                                 "type": "string"
                             },
                             "endpoint": {
+                                "description": "The public IP of the host (optional).",
                                 "type": "string",
                                 "format": "uc-ip"
                             },
                             "subnet": {
+                                "description": "The list of subnets that shall be routed to this host.",
                                 "type": "array",
                                 "items": {
                                     "type": "string",
@@ -3068,6 +3541,7 @@ static std::string DefaultUCentralSchema = R"foo(
                                 }
                             },
                             "ipaddr": {
+                                "description": "The list of private IPs that a host is reachable on inside the overlay.",
                                 "type": "array",
                                 "items": {
                                     "type": "string",
@@ -3078,21 +3552,25 @@ static std::string DefaultUCentralSchema = R"foo(
                     }
                 },
                 "vxlan": {
+                    "description": "The descritption of the root node of the overlay.",
                     "type": "object",
                     "properties": {
                         "port": {
+                            "description": "The network port that shall be used to establish the vxlan overlay.",
                             "type": "integer",
                             "maximum": 65535,
                             "minimum": 1,
                             "default": 4789
                         },
                         "mtu": {
+                            "description": "The MTU that shall be used by the vxlan tunnel.",
                             "type": "integer",
                             "maximum": 65535,
                             "minimum": 256,
                             "default": 1420
                         },
                         "isolate": {
+                            "description": "If set to true hosts will only be able to talk with the root node and not forward L@ traffic between each other.",
                             "type": "boolean",
                             "default": true
                         }
@@ -3101,13 +3579,16 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "service.gps": {
+            "description": "This section can be used to configure a GPS dongle",
             "type": "object",
             "properties": {
                 "adjust-time": {
+                    "description": "Adjust the systems clock upon a successful GPS lock.",
                     "type": "boolean",
                     "default": false
                 },
                 "baud-rate": {
+                    "description": "The baudrate used by the attached GPS dongle",
                     "type": "integer",
                     "enum": [
                         2400,
@@ -3119,27 +3600,33 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "service.dhcp-relay": {
+            "description": "Define the vlans on which the dhcp shall be relayed.",
             "type": "object",
             "properties": {
                 "select-ports": {
+                    "description": "The list of physical network devices that shall be used to fwd the DHCP frames.",
                     "type": "array",
                     "items": {
                         "type": "string"
                     }
                 },
                 "vlans": {
+                    "description": "The list of all vlans",
                     "type": "array",
                     "items": {
                         "type": "object",
                         "properties": {
                             "vlan": {
+                                "description": "The vlan id.",
                                 "type": "number"
                             },
                             "relay-server": {
+                                "description": "The unicast target DHCP pool server where frames get relayed to.",
                                 "type": "string",
                                 "format": "uc-ip"
                             },
                             "circuit-id-format": {
+                                "description": "This option selects what info shall be contained within a relayed frame's circuit ID.",
                                 "type": "string",
                                 "enum": [
                                     "vlan-id",
@@ -3149,6 +3636,7 @@ static std::string DefaultUCentralSchema = R"foo(
                                 "default": "vlan-id"
                             },
                             "remote-id-format": {
+                                "description": "This option selects what info shall be contained within a relayed frame's remote ID.",
                                 "type": "string",
                                 "enum": [
                                     "vlan-id",
@@ -3162,7 +3650,59 @@ static std::string DefaultUCentralSchema = R"foo(
                 }
             }
         },
+        "service.admin-ui": {
+            "type": "object",
+            "properties": {
+                "wifi-ssid": {
+                    "description": "The name of the admin ssid.",
+                    "type": "string",
+                    "default": "Maverick",
+                    "maxLength": 32,
+                    "minLength": 1
+                },
+                "wifi-key": {
+                    "description": "The Pre Shared Key (PSK) that is used for encryption on the BSS.",
+                    "type": "string",
+                    "maxLength": 63,
+                    "minLength": 8
+                },
+                "wifi-bands": {
+                    "description": "The band that the SSID should be broadcasted on. The configuration layer will use the first matching band.",
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "enum": [
+                            "2G",
+                            "5G",
+                            "5G-lower",
+                            "5G-upper",
+                            "6G"
+                        ]
+                    }
+                },
+                "offline-trigger": {
+                    "description": "The admin-ui will be spawned when this offline threshold was exceeded.",
+                    "type": "number"
+                }
+            }
+        },
+        "service.rrm": {
+            "description": "This section describes the band steering behaviour of the unit.",
+            "type": "object",
+            "properties": {
+                "beacon-request-assoc": {
+                    "description": "Tell stations to send a beacon request scan when they associate.",
+                    "type": "boolean",
+                    "default": true
+                },
+                "station-stats-interval": {
+                    "description": "Periodically send station statistics every N seconds.",
+                    "type": "number"
+                }
+            }
+        },
         "service": {
+            "description": "This section describes all of the services that may be present on the AP. Each service is then referenced via its name inside an interface, ssid, ...",
             "type": "object",
             "properties": {
                 "lldp": {
@@ -3224,17 +3764,26 @@ static std::string DefaultUCentralSchema = R"foo(
                 },
                 "dhcp-relay": {
                     "$ref": "#/$defs/service.dhcp-relay"
+                },
+                "admin-ui": {
+                    "$ref": "#/$defs/service.admin-ui"
+                },
+                "rrm": {
+                    "$ref": "#/$defs/service.rrm"
                 }
             }
         },
         "metrics.statistics": {
+            "description": "Statistics are traffic counters, neighbor tables, ...",
             "type": "object",
             "properties": {
                 "interval": {
+                    "description": "The reporting interval defined in seconds.",
                     "type": "integer",
                     "minimum": 60
                 },
                 "types": {
+                    "description": "A list of names of subsystems that shall be reported periodically.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -3249,34 +3798,42 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "metrics.health": {
+            "description": "Health check gets executed periodically and will report a health value between 0-100 indicating how healthy the device thinks it is",
             "type": "object",
             "properties": {
                 "interval": {
+                    "description": "The reporting interval defined in seconds.",
                     "type": "integer",
                     "minimum": 60
                 },
                 "dhcp-local": {
+                    "description": "This is makes the AP probe local downstream DHCP servers.",
                     "type": "boolean",
                     "default": true
                 },
                 "dhcp-remote": {
+                    "description": "This is makes the AP probe remote upstream DHCP servers.",
                     "type": "boolean",
                     "default": false
                 },
                 "dns-local": {
+                    "description": "This is makes the AP probe DNS servers.",
                     "type": "boolean",
                     "default": true
                 },
                 "dns-remote": {
+                    "description": "This is makes the AP probe DNS servers.",
                     "type": "boolean",
                     "default": true
                 }
             }
         },
         "metrics.wifi-frames": {
+            "description": "Define which types of ieee802.11 management frames shall be sent up to the controller.",
             "type": "object",
             "properties": {
                 "filters": {
+                    "description": "A list of the management frames types that shall be sent to the backend.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -3297,9 +3854,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "metrics.dhcp-snooping": {
+            "description": "DHCP snooping allows us to intercept DHCP packages on interface that are bridged, where DHCP is not offered as a service by the AP.",
             "type": "object",
             "properties": {
                 "filters": {
+                    "description": "A list of the message types that shall be sent to the backend.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -3317,26 +3876,33 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "metrics.wifi-scan": {
+            "description": "Define the behaviour of the periodic wifi scanning interface.",
             "type": "object",
             "properties": {
                 "interval": {
+                    "description": "The periodicity at which the scan shall be performed.",
                     "type": "integer"
                 },
                 "verbose": {
+                    "description": "Add capabilities, v/ht_oper, ... to the resulting scan info.",
                     "type": "boolean"
                 },
                 "information-elements": {
+                    "description": "Add all IEs to the resulting scan info.",
                     "type": "boolean"
                 }
             }
         },
         "metrics.telemetry": {
+            "description": "Configure the unsolicited telemetry stream.",
             "type": "object",
             "properties": {
                 "interval": {
+                    "description": "The reporting interval defined in seconds.",
                     "type": "integer"
                 },
                 "types": {
+                    "description": "The event types that get added to telemetry.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -3365,9 +3931,11 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "metrics.realtime": {
+            "description": "Configure the realtime events that get sent to the cloud.",
             "type": "object",
             "properties": {
                 "types": {
+                    "description": "The event types that get added to telemetry.",
                     "type": "array",
                     "items": {
                         "type": "string",
@@ -3396,6 +3964,7 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "metrics": {
+            "description": "There are several types of mertics that shall be reported in certain intervals. This section provides a granual configuration.",
             "type": "object",
             "properties": {
                 "statistics": {
@@ -3422,6 +3991,7 @@ static std::string DefaultUCentralSchema = R"foo(
             }
         },
         "config-raw": {
+            "description": "This object allows passing raw uci commands, that get applied after all the other configuration was ben generated.",
             "type": "array",
             "items": {
                 "type": "array",
@@ -3466,195 +4036,4166 @@ static std::string DefaultUCentralSchema = R"foo(
 
 )foo";
 
-static inline bool IsIPv4(const std::string &value) {
-	Poco::Net::IPAddress A;
-	return ((Poco::Net::IPAddress::tryParse(value, A) && A.family() == Poco::Net::IPAddress::IPv4));
-}
-
-static inline bool IsIPv6(const std::string &value) {
-	Poco::Net::IPAddress A;
-	return ((Poco::Net::IPAddress::tryParse(value, A) && A.family() == Poco::Net::IPAddress::IPv6));
-}
-
-static inline bool IsIP(const std::string &value) { return IsIPv4(value) || IsIPv6(value); }
-
-static inline bool IsCIDRv6(const std::string &value) {
-	auto Tokens = Poco::StringTokenizer(value, "/");
-	if (Tokens.count() == 2 && IsIPv6(Tokens[0])) {
-		auto Mask = std::atoi(Tokens[1].c_str());
-		if (Mask >= 48 && Mask <= 128)
-			return true;
-	}
-	return false;
-}
-
-static inline bool IsCIDRv4(const std::string &value) {
-	auto Tokens = Poco::StringTokenizer(value, "/");
-	if (Tokens.count() == 2 && IsIPv4(Tokens[0])) {
-		auto Mask = std::atoi(Tokens[1].c_str());
-		if (Mask >= 0 && Mask <= 32)
-			return true;
-	}
-	return false;
-}
-
-static inline bool IsCIDR(const std::string &value) { return IsCIDRv4(value) || IsCIDRv6(value); }
-
-static inline bool IsPortRangeIsValid(const std::string &r) {
-	const auto ports = Poco::StringTokenizer("-", r, Poco::StringTokenizer::TOK_TRIM);
-
-	for (const auto &port : ports) {
-		uint32_t port_num = std::stoul(port);
-		if (port_num == 0 || port_num > 65535)
-			return false;
-	}
-	return true;
-}
-
-bool ExternalValijsonFormatChecker(const std::string &format, const std::string &value,
-								   [[maybe_unused]] std::vector<std::string> &context,
-								   [[maybe_unused]] valijson::ValidationResults *const results) {
-	static const std::regex host_regex{
-		"^(?=.{1,254}$)((?=[a-z0-9-]{1,63}\\.)(xn--+)?[a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,63}$"};
-	static const std::regex mac_regex{"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"};
-	static const std::regex uc_timeout_regex{"^[0-9]+[dmshw]$"};
-	static const std::regex b64_regex("^[a-zA-Z0-9\\+/]*={0,3}$");
-
-	if (format == "uc-cidr4") {
-		if (IsCIDRv4(value))
-			return true;
-		if (results)
-			results->pushError(context, fmt::format("{} is not a valid CIDR IPv4 block", value));
-	} else if (format == "uc-cidr6") {
-		if (IsCIDRv6(value))
-			return true;
-		if (results)
-			results->pushError(context, fmt::format("{} is not a valid CIDR IPv6 block", value));
-	} else if (format == "uc-cidr") {
-		if (IsCIDR(value))
-			return true;
-		if (results)
-			results->pushError(context, fmt::format("{} is not a valid CIDR block", value));
-	} else if (format == "uc-mac") {
-		if (std::regex_match(value, mac_regex))
-			return true;
-		if (results)
-			results->pushError(context, fmt::format("{} is not a valid MAC address", value));
-	} else if (format == "uc-timeout") {
-		if (std::regex_match(value, uc_timeout_regex))
-			return true;
-		if (results)
-			results->pushError(context, fmt::format("{} is not a valid timeout value", value));
-	} else if (format == "uc-host") {
-		if (IsIP(value))
-			return true;
-		if (std::regex_match(value, host_regex))
-			return true;
-		if (results)
-			results->pushError(context, fmt::format("{} is not a valid hostname", value));
-	} else if (format == "fqdn" || format == "uc-fqdn") {
-		if (std::regex_match(value, host_regex))
-			return true;
-		if (results)
-			results->pushError(context, fmt::format("{} is not a valid FQDN", value));
-	} else if (format == "uc-base64") {
-		std::string s{value};
-		Poco::trimInPlace(s);
-		if ((s.size() % 4 == 0) && std::regex_match(s, b64_regex))
-			return true;
-		if (results)
-			results->pushError(context, fmt::format("{} is not a valid base 64 value", value));
-	} else if (format == "uri") {
-		try {
-			Poco::URI uri(value);
-			return true;
-		} catch (...) {
-		}
-		if (results)
-			results->pushError(context, fmt::format("{} is not a valid URL", value));
-	} else if (format == "uc-portrange") {
-		try {
-			if (IsPortRangeIsValid(value))
-				return true;
-		} catch (...) {
-		}
-		if (results)
-			results->pushError(context, fmt::format("{} is not a valid post range", value));
-	} else if (format == "ip") {
-		if (IsIP(value))
-			return true;
-		if (results)
-			results->pushError(context, fmt::format("{} is not a valid IP address", value));
-	}
-	return true;
-}
-
-namespace OpenWifi {
-
-	int ConfigurationValidator::Start() {
-		Init();
-		return 0;
-	}
-
-	void ConfigurationValidator::Stop() {}
-
-	bool ConfigurationValidator::SetSchema(const std::string &SchemaStr) {
-		try {
-			Poco::JSON::Parser P;
-			SchemaDocPtr_ = P.parse(SchemaStr).extract<Poco::JSON::Object::Ptr>();
-			RootSchema_ = std::make_unique<valijson::Schema>();
-			SchemaParser_ = std::make_unique<valijson::SchemaParser>();
-			PocoJsonAdapter_ = std::make_unique<valijson::adapters::PocoJsonAdapter>(SchemaDocPtr_);
-			SchemaParser_->populateSchema(*PocoJsonAdapter_, *RootSchema_);
-			Initialized_ = Working_ = true;
-			return true;
-		} catch (const Poco::Exception &E) {
-			Logger().log(E);
-		} catch (...) {
-			Logger().error("Validation schema is invalid, falling back.");
-		}
-		return false;
-	}
-
-	void ConfigurationValidator::Init() {
-		if (Initialized_)
-			return;
-
-		std::string GitSchema;
-		if (MicroServiceConfigGetBool("ucentral.datamodel.internal", true)) {
-			SetSchema(DefaultUCentralSchema);
-			poco_information(Logger(), "Using uCentral validation from built-in default.");
-			return;
-		}
+static std::string DefaultSWITCHSchema = R"foo(
 
-		try {
-			auto GitURI =
-				MicroServiceConfigGetString("ucentral.datamodel.uri", GitUCentralJSONSchemaFile);
-			if (Utils::wgets(GitURI, GitSchema) && SetSchema(GitSchema)) {
-				poco_information(Logger(), "Using uCentral data model validation schema from GIT.");
-				return;
-			} else {
-				std::string FileName{MicroServiceDataDirectory() + "/ucentral.schema.json"};
-				std::ifstream input(FileName);
-				std::stringstream schema_file;
-				schema_file << input.rdbuf();
-				input.close();
-				if (SetSchema(schema_file.str())) {
-					poco_information(
-						Logger(), "Using uCentral data model validation schema from local file.");
-					return;
-				}
-			}
-		} catch (const Poco::Exception &E) {
+{
+    "$id": "https://openwrt.org/ucentral.schema.json",
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "properties": {
+        "strict": {
+            "type": "boolean",
+            "default": false
+        },
+        "uuid": {
+            "type": "integer"
+        },
+        "unit": {
+            "$ref": "#/$defs/unit"
+        },
+        "globals": {
+            "$ref": "#/$defs/globals"
+        },
+        "definitions": {
+            "$ref": "#/$defs/definitions"
+        },
+        "ethernet": {
+            "type": "array",
+            "items": {
+                "$ref": "#/$defs/ethernet"
+            }
+        },
+        "switch": {
+            "$ref": "#/$defs/switch"
+        },
+        "radios": {
+            "type": "array",
+            "items": {
+                "$ref": "#/$defs/radio"
+            }
+        },
+        "interfaces": {
+            "type": "array",
+            "items": {
+                "$ref": "#/$defs/interface"
+            }
+        },
+        "services": {
+            "$ref": "#/$defs/service"
+        },
+        "metrics": {
+            "$ref": "#/$defs/metrics"
+        },
+        "config-raw": {
+            "$ref": "#/$defs/config-raw"
+        },
+        "third-party": {
+            "type": "object",
+            "additionalProperties": true
+        }
+    },
+    "$defs": {
+        "unit": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "hostname": {
+                    "type": "string",
+                    "format": "hostname"
+                },
+                "location": {
+                    "type": "string"
+                },
+                "timezone": {
+                    "type": "string",
+                    "examples": [
+                        "UTC",
+                        "EST5",
+                        "CET-1CEST,M3.5.0,M10.5.0/3"
+                    ]
+                },
+                "leds-active": {
+                    "type": "boolean",
+                    "default": true
+                },
+                "random-password": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "system-password": {
+                    "type": "string"
+                },
+                "beacon-advertisement": {
+                    "type": "object",
+                    "properties": {
+                        "device-name": {
+                            "type": "boolean"
+                        },
+                        "device-serial": {
+                            "type": "boolean"
+                        },
+                        "network-id": {
+                            "type": "integer"
+                        }
+                    }
+                },
+                "poe": {
+                    "type": "object",
+                    "properties": {
+                        "power-management": {
+                            "type": "string",
+                            "examples": [
+                                "class",
+                                "dynamic",
+                                "dynamic-priority",
+                                "static",
+                                "static-priority"
+                            ]
+                        },
+                        "usage-threshold": {
+                            "type": "number",
+                            "default": 90
+                        }
+                    }
+                },
+                "multicast": {
+                    "type": "object",
+                    "properties": {
+                        "igmp-snooping-enable": {
+                            "type": "boolean",
+                            "default": true
+                        },
+                        "mld-snooping-enable": {
+                            "type": "boolean",
+                            "default": true
+                        }
+                    }
+                }
+            }
+        },
+        "globals.wireless-multimedia.class-selector": {
+            "type": "array",
+            "items": {
+                "type": "string",
+                "enum": [
+                    "CS0",
+                    "CS1",
+                    "CS2",
+                    "CS3",
+                    "CS4",
+                    "CS5",
+                    "CS6",
+                    "CS7",
+                    "AF11",
+                    "AF12",
+                    "AF13",
+                    "AF21",
+                    "AF22",
+                    "AF23",
+                    "AF31",
+                    "AF32",
+                    "AF33",
+                    "AF41",
+                    "AF42",
+                    "AF43",
+                    "DF",
+                    "EF",
+                    "VA",
+                    "LE"
+                ]
+            }
+        },
+        "globals.wireless-multimedia.table": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "UP0": {
+                    "$ref": "#/$defs/globals.wireless-multimedia.class-selector"
+                },
+                "UP1": {
+                    "$ref": "#/$defs/globals.wireless-multimedia.class-selector"
+                },
+                "UP2": {
+                    "$ref": "#/$defs/globals.wireless-multimedia.class-selector"
+                },
+                "UP3": {
+                    "$ref": "#/$defs/globals.wireless-multimedia.class-selector"
+                },
+                "UP4": {
+                    "$ref": "#/$defs/globals.wireless-multimedia.class-selector"
+                },
+                "UP5": {
+                    "$ref": "#/$defs/globals.wireless-multimedia.class-selector"
+                },
+                "UP6": {
+                    "$ref": "#/$defs/globals.wireless-multimedia.class-selector"
+                },
+                "UP7": {
+                    "$ref": "#/$defs/globals.wireless-multimedia.class-selector"
+                }
+            }
+        },
+        "globals.wireless-multimedia.profile": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "profile": {
+                    "type": "string",
+                    "enum": [
+                        "enterprise",
+                        "rfc8325",
+                        "3gpp"
+                    ]
+                }
+            }
+        },
+        "globals": {
+            "type": "object",
+            "properties": {
+                "ipv4-network": {
+                    "type": "string",
+                    "format": "uc-cidr4",
+                    "examples": [
+                        "192.168.0.0/16"
+                    ]
+                },
+                "ipv6-network": {
+                    "type": "string",
+                    "format": "uc-cidr6",
+                    "examples": [
+                        "fdca:1234:4567::/48"
+                    ]
+                },
+                "wireless-multimedia": {
+                    "anyOf": [
+                        {
+                            "$ref": "#/$defs/globals.wireless-multimedia.table"
+                        },
+                        {
+                            "$ref": "#/$defs/globals.wireless-multimedia.profile"
+                        }
+                    ]
+                },
+                "ipv4-blackhole": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "prefix": {
+                                "type": "string",
+                                "format": "uc-cidr4",
+                                "examples": [
+                                    "192.168.1.0/24"
+                                ]
+                            },
+                            "vrf": {
+                                "type": "number"
+                            }
+                        }
+                    }
+                },
+                "ipv4-unreachable": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "prefix": {
+                                "type": "string",
+                                "format": "uc-cidr4",
+                                "examples": [
+                                    "192.168.1.0/24"
+                                ]
+                            },
+                            "vrf": {
+                                "type": "number"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "interface.ssid.encryption": {
+            "type": "object",
+            "properties": {
+                "proto": {
+                    "type": "string",
+                    "enum": [
+                        "none",
+                        "owe",
+                        "owe-transition",
+                        "psk",
+                        "psk2",
+                        "psk-mixed",
+                        "psk2-radius",
+                        "wpa",
+                        "wpa2",
+                        "wpa-mixed",
+                        "sae",
+                        "sae-mixed",
+                        "wpa3",
+                        "wpa3-192",
+                        "wpa3-mixed"
+                    ],
+                    "examples": [
+                        "psk2"
+                    ]
+                },
+                "key": {
+                    "type": "string",
+                    "maxLength": 63,
+                    "minLength": 8
+                },
+                "ieee80211w": {
+                    "type": "string",
+                    "enum": [
+                        "disabled",
+                        "optional",
+                        "required"
+                    ],
+                    "default": "disabled"
+                },
+                "key-caching": {
+                    "type": "boolean",
+                    "default": true
+                }
+            }
+        },
+        "definitions": {
+            "type": "object",
+            "properties": {
+                "wireless-encryption": {
+                    "type": "object",
+                    "patternProperties": {
+                        ".+": {
+                            "$ref": "#/$defs/interface.ssid.encryption",
+                            "additionalProperties": false
+                        }
+                    }
+                }
+            }
+        },
+        "ethernet": {
+            "type": "object",
+            "properties": {
+                "select-ports": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "examples": [
+                            "LAN1",
+                            "LAN2",
+                            "LAN3",
+                            "LAN4",
+                            "LAN*",
+                            "WAN*",
+                            "*"
+                        ]
+                    }
+                },
+                "speed": {
+                    "type": "integer",
+                    "enum": [
+                        10,
+                        100,
+                        1000,
+                        2500,
+                        5000,
+                        10000,
+                        25000,
+                        100000
+                    ],
+                    "default": 1000
+                },
+                "duplex": {
+                    "type": "string",
+                    "enum": [
+                        "half",
+                        "full"
+                    ],
+                    "default": "full"
+                },
+                "enabled": {
+                    "type": "boolean",
+                    "default": true
+                },
+                "services": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "examples": [
+                            "quality-of-service"
+                        ]
+                    }
+                },
+                "poe": {
+                    "type": "object",
+                    "properties": {
+                        "admin-mode": {
+                            "type": "boolean",
+                            "default": false
+                        },
+                        "do-reset": {
+                            "type": "boolean"
+                        },
+                        "detection": {
+                            "type": "string",
+                            "examples": [
+                                "2pt-dot3af",
+                                "2pt-dot3af+legacy",
+                                "4pt-dot3af",
+                                "4pt-dot3af+legacy",
+                                "dot3bt",
+                                "dot3bt+legacy",
+                                "legacy"
+                            ],
+                            "default": "dot3bt"
+                        },
+                        "power-limit": {
+                            "type": "integer",
+                            "default": 99900
+                        },
+                        "priority": {
+                            "type": "string",
+                            "default": "low",
+                            "examples": [
+                                "critical",
+                                "high",
+                                "medium",
+                                "low"
+                            ]
+                        }
+                    }
+                },
+                "ieee8021x": {
+                    "type": "object",
+                    "properties": {
+                        "is-authenticator": {
+                            "type": "boolean",
+                            "default": false
+                        },
+                        "authentication-mode": {
+                            "type": "string",
+                            "enum": [
+                                "force-authorized",
+                                "force-unauthorized",
+                                "auto"
+                            ],
+                            "default": "force-authorized"
+                        },
+                        "host-mode": {
+                            "type": "string",
+                            "enum": [
+                                "multi-auth",
+                                "multi-domain",
+                                "multi-host",
+                                "single-host"
+                            ],
+                            "default": "multi-auth"
+                        },
+                        "guest-vlan": {
+                            "type": "integer",
+                            "minimum": 1,
+                            "maximum": 4094
+                        },
+                        "unauthenticated-vlan": {
+                            "type": "integer",
+                            "minimum": 1,
+                            "maximum": 4094
+                        }
+                    }
+                },
+                "port-isolation": {
+                    "type": "object",
+                    "properties": {
+                        "sessions": {
+                            "type": "array",
+                            "items": {
+                                "type": "object",
+                                "properties": {
+                                    "id": {
+                                        "type": "integer"
+                                    },
+                                    "uplink": {
+                                        "type": "object",
+                                        "properties": {
+                                            "interface-list": {
+                                                "type": "array",
+                                                "items": {
+                                                    "type": "string"
+                                                }
+                                            }
+                                        }
+                                    },
+                                    "downlink": {
+                                        "type": "object",
+                                        "properties": {
+                                            "interface-list": {
+                                                "type": "array",
+                                                "items": {
+                                                    "type": "string"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "switch": {
+            "type": "object",
+            "properties": {
+                "port-mirror": {
+                    "type": "object",
+                    "properties": {
+                        "monitor-ports": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        },
+                        "analysis-port": {
+                            "type": "string"
+                        }
+                    }
+                },
+                "loop-detection": {
+                    "type": "object",
+                    "properties": {
+                        "protocol": {
+                            "type": "string",
+                            "enum": [
+                                "none",
+                                "stp",
+                                "rstp",
+                                "mstp",
+                                "pvstp",
+                                "rpvstp"
+                            ],
+                            "default": "rstp"
+                        },
+                        "roles": {
+                            "type": "array",
+                            "items": {
+                                "type": "string",
+                                "enum": [
+                                    "upstream",
+                                    "downstream"
+                                ]
+                            }
+                        }
+                    },
+                    "instances": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "integer"
+                                },
+                                "enabled": {
+                                    "type": "boolean",
+                                    "default": true
+                                },
+                                "priority": {
+                                    "type": "integer",
+                                    "default": 32768
+                                },
+                                "forward_delay": {
+                                    "type": "integer",
+                                    "default": 15
+                                },
+                                "hello_time": {
+                                    "type": "integer",
+                                    "default": 2
+                                },
+                                "max_age": {
+                                    "type": "integer",
+                                    "default": 20
+                                }
+                            }
+                        }
+                    }
+                },
+                "ieee8021x": {
+                    "type": "object",
+                    "properties": {
+                        "auth-control-enable": {
+                            "type": "boolean",
+                            "default": false
+                        },
+                        "radius": {
+                            "type": "array",
+                            "items": {
+                                "type": "object",
+                                "properties": {
+                                    "server-host": {
+                                        "type": "string",
+                                        "examples": [
+                                            "192.168.1.1",
+                                            "somehost.com"
+                                        ]
+                                    },
+                                    "server-authentication-port": {
+                                        "type": "integer",
+                                        "maximum": 65535,
+                                        "minimum": 1
+                                    },
+                                    "server-key": {
+                                        "type": "string",
+                                        "examples": [
+                                            "somepassword"
+                                        ]
+                                    },
+                                    "server-priority": {
+                                        "type": "integer",
+                                        "maximum": 64,
+                                        "minimum": 1
+                                    }
+                                }
+                            }
+                        },
+                        "dynamic-authorization": {
+                            "type": "object",
+                            "properties": {
+                                "auth-type": {
+                                    "type": "string",
+                                    "enum": [
+                                        "all",
+                                        "any",
+                                        "session-key"
+                                    ]
+                                },
+                                "bounce-port-ignore": {
+                                    "type": "boolean",
+                                    "default": false
+                                },
+                                "disable-port-ignore": {
+                                    "type": "boolean",
+                                    "default": false
+                                },
+                                "ignore-server-key": {
+                                    "type": "boolean",
+                                    "default": false
+                                },
+                                "ignore-session-key": {
+                                    "type": "boolean",
+                                    "default": false
+                                },
+                                "server-key": {
+                                    "type": "string"
+                                },
+                                "client": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "object",
+                                        "properties": {
+                                            "address": {
+                                                "type": "string"
+                                            },
+                                            "server-key": {
+                                                "type": "string"
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "radio.rates": {
+            "type": "object",
+            "properties": {
+                "beacon": {
+                    "type": "integer",
+                    "default": 6000,
+                    "enum": [
+                        0,
+                        1000,
+                        2000,
+                        5500,
+                        6000,
+                        9000,
+                        11000,
+                        12000,
+                        18000,
+                        24000,
+                        36000,
+                        48000,
+                        54000
+                    ]
+                },
+                "multicast": {
+                    "type": "integer",
+                    "default": 24000,
+                    "enum": [
+                        0,
+                        1000,
+                        2000,
+                        5500,
+                        6000,
+                        9000,
+                        11000,
+                        12000,
+                        18000,
+                        24000,
+                        36000,
+                        48000,
+                        54000
+                    ]
+                }
+            }
+        },
+        "radio.he": {
+            "type": "object",
+            "properties": {
+                "multiple-bssid": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "ema": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "bss-color": {
+                    "type": "integer",
+                    "default": 64
+                }
+            }
+        },
+        "radio": {
+            "type": "object",
+            "properties": {
+                "band": {
+                    "type": "string",
+                    "enum": [
+                        "2G",
+                        "5G",
+                        "5G-lower",
+                        "5G-upper",
+                        "6G"
+                    ]
+                },
+                "bandwidth": {
+                    "type": "integer",
+                    "enum": [
+                        5,
+                        10,
+                        20
+                    ]
+                },
+                "channel": {
+                    "oneOf": [
+                        {
+                            "type": "integer",
+                            "maximum": 196,
+                            "minimum": 1
+                        },
+                        {
+                            "type": "string",
+                            "const": "auto"
+                        }
+                    ]
+                },
+                "valid-channels": {
+                    "type": "array",
+                    "items": {
+                        "type": "integer",
+                        "maximum": 196,
+                        "minimum": 1
+                    }
+                },
+                "country": {
+                    "type": "string",
+                    "maxLength": 2,
+                    "minLength": 2,
+                    "examples": [
+                        "US"
+                    ]
+                },
+                "allow-dfs": {
+                    "type": "boolean",
+                    "default": true
+                },
+                "channel-mode": {
+                    "type": "string",
+                    "enum": [
+                        "HT",
+                        "VHT",
+                        "HE",
+                        "EHT"
+                    ],
+                    "default": "HE"
+                },
+                "channel-width": {
+                    "type": "integer",
+                    "enum": [
+                        20,
+                        40,
+                        80,
+                        160,
+                        320,
+                        8080
+                    ],
+                    "default": 80
+                },
+                "require-mode": {
+                    "type": "string",
+                    "enum": [
+                        "HT",
+                        "VHT",
+                        "HE"
+                    ]
+                },
+                "mimo": {
+                    "type": "string",
+                    "enum": [
+                        "1x1",
+                        "2x2",
+                        "3x3",
+                        "4x4",
+                        "5x5",
+                        "6x6",
+                        "7x7",
+                        "8x8"
+                    ]
+                },
+                "tx-power": {
+                    "type": "integer",
+                    "maximum": 30,
+                    "minimum": 0
+                },
+                "legacy-rates": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "beacon-interval": {
+                    "type": "integer",
+                    "default": 100,
+                    "maximum": 65535,
+                    "minimum": 15
+                },
+                "maximum-clients": {
+                    "type": "integer",
+                    "example": 64
+                },
+                "maximum-clients-ignore-probe": {
+                    "type": "boolean"
+                },
+                "rates": {
+                    "$ref": "#/$defs/radio.rates"
+                },
+                "he-settings": {
+                    "$ref": "#/$defs/radio.he"
+                },
+                "hostapd-iface-raw": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "examples": [
+                            "ap_table_expiration_time=3600",
+                            "device_type=6-0050F204-1",
+                            "ieee80211h=1",
+                            "rssi_ignore_probe_request=-75",
+                            "time_zone=EST5",
+                            "uuid=12345678-9abc-def0-1234-56789abcdef0",
+                            "venue_url=1:http://www.example.com/info-eng",
+                            "wpa_deny_ptk0_rekey=0"
+                        ]
+                    }
+                }
+            }
+        },
+        "interface.vlan": {
+            "type": "object",
+            "properties": {
+                "id": {
+                    "type": "integer",
+                    "maximum": 4050
+                },
+                "proto": {
+                    "decription": "The L2 vlan tag that shall be added (1q,1ad)",
+                    "type": "string",
+                    "enum": [
+                        "802.1ad",
+                        "802.1q"
+                    ],
+                    "default": "802.1q"
+                },
+                "stp-instance": {
+                    "decription": "MSTP instance identifier of the vlan. This field does nothing if MSTP is not enabled.",
+                    "type": "integer"
+                }
+            }
+        },
+        "interface.bridge": {
+            "type": "object",
+            "properties": {
+                "mtu": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 256,
+                    "examples": [
+                        1500
+                    ]
+                },
+                "tx-queue-len": {
+                    "type": "integer",
+                    "examples": [
+                        5000
+                    ]
+                },
+                "isolate-ports": {
+                    "type": "boolean",
+                    "default": false
+                }
+            }
+        },
+        "interface.ethernet": {
+            "type": "object",
+            "properties": {
+                "select-ports": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "examples": [
+                            "LAN1",
+                            "LAN2",
+                            "LAN3",
+                            "LAN4",
+                            "LAN*",
+                            "WAN*",
+                            "*"
+                        ]
+                    }
+                },
+                "multicast": {
+                    "type": "boolean",
+                    "default": true
+                },
+                "learning": {
+                    "type": "boolean",
+                    "default": true
+                },
+                "isolate": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "macaddr": {
+                    "type": "string",
+                    "format": "uc-mac"
+                },
+                "reverse-path-filter": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "vlan-tag": {
+                    "type": "string",
+                    "enum": [
+                        "tagged",
+                        "un-tagged",
+                        "auto"
+                    ],
+                    "default": "auto"
+                }
+            }
+        },
+        "interface.ipv4.dhcp": {
+            "type": "object",
+            "properties": {
+                "lease-first": {
+                    "type": "integer",
+                    "examples": [
+                        10
+                    ]
+                },
+                "lease-count": {
+                    "type": "integer",
+                    "examples": [
+                        100
+                    ]
+                },
+                "lease-time": {
+                    "type": "string",
+                    "format": "uc-timeout",
+                    "default": "6h"
+                },
+                "relay-server": {
+                    "type": "string",
+                    "format": "ipv4",
+                    "example": "192.168.2.1"
+                },
+                "circuit-id-format": {
+                    "type": "string",
+                    "example": [
+                        "\\{Interface\\}:\\{VLAN-ID\\}}"
+                    ]
+                }
+            }
+        },
+        "interface.ipv4.dhcp-lease": {
+            "type": "object",
+            "properties": {
+                "macaddr": {
+                    "type": "string",
+                    "format": "uc-mac",
+                    "examples": [
+                        "00:11:22:33:44:55"
+                    ]
+                },
+                "static-lease-offset": {
+                    "type": "integer",
+                    "examples": [
+                        10
+                    ]
+                },
+                "lease-time": {
+                    "type": "string",
+                    "format": "uc-timeout",
+                    "default": "6h"
+                },
+                "publish-hostname": {
+                    "type": "boolean",
+                    "default": true
+                }
+            }
+        },
+        "interface.ipv4.port-forward": {
+            "type": "object",
+            "properties": {
+                "protocol": {
+                    "type": "string",
+                    "enum": [
+                        "tcp",
+                        "udp",
+                        "any"
+                    ],
+                    "default": "any"
+                },
+                "external-port": {
+                    "type": [
+                        "integer",
+                        "string"
+                    ],
+                    "minimum": 0,
+                    "maximum": 65535,
+                    "format": "uc-portrange"
+                },
+                "internal-address": {
+                    "type": "string",
+                    "format": "ipv4",
+                    "example": "0.0.0.120"
+                },
+                "internal-port": {
+                    "type": [
+                        "integer",
+                        "string"
+                    ],
+                    "minimum": 0,
+                    "maximum": 65535,
+                    "format": "uc-portrange"
+                }
+            },
+            "required": [
+                "external-port",
+                "internal-address"
+            ]
+        },
+        "interface.ipv4": {
+            "type": "object",
+            "properties": {
+                "addressing": {
+                    "type": "string",
+                    "enum": [
+                        "dynamic",
+                        "static",
+                        "none"
+                    ],
+                    "examples": [
+                        "static"
+                    ]
+                },
+                "subnet": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "prefix": {
+                                "type": "string",
+                                "format": "uc-cidr4",
+                                "examples": [
+                                    "192.168.1.0/24"
+                                ]
+                            },
+                            "vrf": {
+                                "type": "number"
+                            }
+                        }
+                    }
+                },
+                "gateway": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "prefix": {
+                                "type": "string",
+                                "format": "uc-cidr4",
+                                "examples": [
+                                    "192.168.1.0/24"
+                                ]
+                            },
+                            "nexthop": {
+                                "type": "string",
+                                "format": "ipv4",
+                                "examples": [
+                                    "192.168.1.1"
+                                ]
+                            },
+                            "vrf": {
+                                "type": "number"
+                            },
+                            "metric": {
+                                "type": "number"
+                            }
+                        }
+                    }
+                },
+                "broadcast": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "prefix": {
+                                "type": "string",
+                                "format": "uc-cidr4",
+                                "examples": [
+                                    "192.168.1.0/24"
+                                ]
+                            },
+                            "vrf": {
+                                "type": "number"
+                            }
+                        }
+                    }
+                },
+                "multicast": {
+                    "type": "object",
+                    "properties": {
+                        "unknown-multicast-flood-control": {
+                            "type": "boolean",
+                            "default": true
+                        },
+                        "igmp": {
+                            "type": "object",
+                            "properties": {
+                                "snooping-enable": {
+                                    "type": "boolean",
+                                    "default": true
+                                },
+                                "version": {
+                                    "type": "integer",
+                                    "enum": [
+                                        1,
+                                        2,
+                                        3
+                                    ],
+                                    "examples": [
+                                        3
+                                    ],
+                                    "default": 3
+                                },
+                                "querier-enable": {
+                                    "type": "boolean",
+                                    "default": false
+                                },
+                                "fast-leave-enable": {
+                                    "type": "boolean",
+                                    "default": false
+                                },
+                                "query-interval": {
+                                    "type": "integer",
+                                    "default": 1000
+                                },
+                                "last-member-query-interval": {
+                                    "type": "integer",
+                                    "default": 1000
+                                },
+                                "max-response-time": {
+                                    "type": "integer",
+                                    "default": 10
+                                },
+                                "static-mcast-groups": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "object",
+                                        "properties": {
+                                            "egress-ports": {
+                                                "type": "array",
+                                                "items": {
+                                                    "type": "string"
+                                                }
+                                            },
+                                            "address": {
+                                                "type": "string",
+                                                "format": "ipv4",
+                                                "examples": [
+                                                    "225.0.0.1"
+                                                ]
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                "send-hostname": {
+                    "type": "boolean",
+                    "default": true,
+                    "examples": [
+                        true
+                    ]
+                },
+                "use-dns": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "format": "ipv4",
+                        "examples": [
+                            "8.8.8.8",
+                            "4.4.4.4"
+                        ]
+                    }
+                },
+                "dhcp": {
+                    "$ref": "#/$defs/interface.ipv4.dhcp"
+                },
+                "dhcp-leases": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/interface.ipv4.dhcp-lease"
+                    }
+                },
+                "port-forward": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/interface.ipv4.port-forward"
+                    }
+                }
+            }
+        },
+        "interface.ipv6.dhcpv6": {
+            "type": "object",
+            "properties": {
+                "mode": {
+                    "type": "string",
+                    "enum": [
+                        "hybrid",
+                        "stateless",
+                        "stateful",
+                        "relay"
+                    ]
+                },
+                "announce-dns": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "format": "ipv6"
+                    }
+                },
+                "filter-prefix": {
+                    "type": "string",
+                    "format": "uc-cidr6",
+                    "default": "::/0"
+                }
+            }
+        },
+        "interface.ipv6.port-forward": {
+            "type": "object",
+            "properties": {
+                "protocol": {
+                    "type": "string",
+                    "enum": [
+                        "tcp",
+                        "udp",
+                        "any"
+                    ],
+                    "default": "any"
+                },
+                "external-port": {
+                    "type": [
+                        "integer",
+                        "string"
+                    ],
+                    "minimum": 0,
+                    "maximum": 65535,
+                    "format": "uc-portrange"
+                },
+                "internal-address": {
+                    "type": "string",
+                    "format": "ipv6",
+                    "example": "::1234:abcd"
+                },
+                "internal-port": {
+                    "type": [
+                        "integer",
+                        "string"
+                    ],
+                    "minimum": 0,
+                    "maximum": 65535,
+                    "format": "uc-portrange"
+                }
+            },
+            "required": [
+                "external-port",
+                "internal-address"
+            ]
+        },
+        "interface.ipv6.traffic-allow": {
+            "type": "object",
+            "properties": {
+                "protocol": {
+                    "type": "string",
+                    "default": "any"
+                },
+                "source-address": {
+                    "type": "string",
+                    "format": "uc-cidr6",
+                    "example": "2001:db8:1234:abcd::/64",
+                    "default": "::/0"
+                },
+                "source-ports": {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": {
+                        "type": [
+                            "integer",
+                            "string"
+                        ],
+                        "minimum": 0,
+                        "maximum": 65535,
+                        "format": "uc-portrange"
+                    }
+                },
+                "destination-address": {
+                    "type": "string",
+                    "format": "ipv6",
+                    "example": "::1000"
+                },
+                "destination-ports": {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": {
+                        "type": [
+                            "integer",
+                            "string"
+                        ],
+                        "minimum": 0,
+                        "maximum": 65535,
+                        "format": "uc-portrange"
+                    }
+                }
+            },
+            "required": [
+                "destination-address"
+            ]
+        },
+        "interface.ipv6": {
+            "type": "object",
+            "properties": {
+                "addressing": {
+                    "type": "string",
+                    "enum": [
+                        "dynamic",
+                        "static"
+                    ]
+                },
+                "subnet": {
+                    "type": "string",
+                    "format": "uc-cidr6",
+                    "examples": [
+                        "auto/64"
+                    ]
+                },
+                "gateway": {
+                    "type": "string",
+                    "format": "ipv6",
+                    "examples": [
+                        "2001:db8:123:456::1"
+                    ]
+                },
+                "prefix-size": {
+                    "type": "integer",
+                    "maximum": 64,
+                    "minimum": 0
+                },
+                "dhcpv6": {
+                    "$ref": "#/$defs/interface.ipv6.dhcpv6"
+                },
+                "port-forward": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/interface.ipv6.port-forward"
+                    }
+                },
+                "traffic-allow": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/interface.ipv6.traffic-allow"
+                    }
+                }
+            }
+        },
+        "interface.broad-band.wwan": {
+            "type": "object",
+            "properties": {
+                "protocol": {
+                    "type": "string",
+                    "const": "wwan"
+                },
+                "modem-type": {
+                    "type": "string",
+                    "enum": [
+                        "qmi",
+                        "mbim",
+                        "wwan"
+                    ]
+                },
+                "access-point-name": {
+                    "type": "string"
+                },
+                "authentication-type": {
+                    "type": "string",
+                    "enum": [
+                        "none",
+                        "pap",
+                        "chap",
+                        "pap-chap"
+                    ],
+                    "default": "none"
+                },
+                "pin-code": {
+                    "type": "string"
+                },
+                "user-name": {
+                    "type": "string"
+                },
+                "password": {
+                    "type": "string"
+                },
+                "packet-data-protocol": {
+                    "type": "string",
+                    "enum": [
+                        "ipv4",
+                        "ipv6",
+                        "dual-stack"
+                    ],
+                    "default": "dual-stack"
+                }
+            }
+        },
+        "interface.broad-band.pppoe": {
+            "type": "object",
+            "properties": {
+                "protocol": {
+                    "type": "string",
+                    "const": "pppoe"
+                },
+                "user-name": {
+                    "type": "string"
+                },
+                "password": {
+                    "type": "string"
+                }
+            }
+        },
+        "interface.broad-band": {
+            "oneOf": [
+                {
+                    "$ref": "#/$defs/interface.broad-band.wwan"
+                },
+                {
+                    "$ref": "#/$defs/interface.broad-band.pppoe"
+                }
+            ]
+        },
+        "interface.ssid.multi-psk": {
+            "type": "object",
+            "properties": {
+                "mac": {
+                    "type": "string",
+                    "format": "uc-mac"
+                },
+                "key": {
+                    "type": "string",
+                    "maxLength": 63,
+                    "minLength": 8
+                },
+                "vlan-id": {
+                    "type": "integer",
+                    "maximum": 4096,
+                    "examples": [
+                        3,
+                        100,
+                        200,
+                        4094
+                    ]
+                }
+            }
+        },
+        "interface.ssid.rrm": {
+            "type": "object",
+            "properties": {
+                "neighbor-reporting": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "reduced-neighbor-reporting": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "lci": {
+                    "type": "string"
+                },
+                "civic-location": {
+                    "type": "string"
+                },
+                "ftm-responder": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "stationary-ap": {
+                    "type": "boolean",
+                    "default": false
+                }
+            }
+        },
+        "interface.ssid.rate-limit": {
+            "type": "object",
+            "properties": {
+                "ingress-rate": {
+                    "type": "integer",
+                    "default": 0
+                },
+                "egress-rate": {
+                    "type": "integer",
+                    "default": 0
+                }
+            }
+        },
+        "interface.ssid.roaming": {
+            "type": "object",
+            "properties": {
+                "message-exchange": {
+                    "type": "string",
+                    "enum": [
+                        "air",
+                        "ds"
+                    ],
+                    "default": "ds"
+                },
+                "generate-psk": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "domain-identifier": {
+                    "type": "string",
+                    "maxLength": 4,
+                    "minLength": 4,
+                    "examples": [
+                        "abcd"
+                    ]
+                },
+                "pmk-r0-key-holder": {
+                    "type": "string",
+                    "example": "14:DD:20:47:14:E4,14DD204714E4,00112233445566778899aabbccddeeff"
+                },
+                "pmk-r1-key-holder": {
+                    "type": "string",
+                    "example": "14:DD:20:47:14:E4,14DD204714E4,00112233445566778899aabbccddeeff"
+                }
+            }
+        },
+        "interface.ssid.radius.local-user": {
+            "type": "object",
+            "properties": {
+                "mac": {
+                    "type": "string",
+                    "format": "uc-mac"
+                },
+                "user-name": {
+                    "type": "string",
+                    "minLength": 1
+                },
+                "password": {
+                    "type": "string",
+                    "maxLength": 63,
+                    "minLength": 8
+                },
+                "vlan-id": {
+                    "type": "integer",
+                    "maximum": 4096,
+                    "examples": [
+                        3,
+                        100,
+                        200,
+                        4094
+                    ]
+                }
+            }
+        },
+        "interface.ssid.radius.local": {
+            "type": "object",
+            "properties": {
+                "server-identity": {
+                    "type": "string",
+                    "default": "uCentral"
+                },
+                "users": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/interface.ssid.radius.local-user"
+                    }
+                }
+            }
+        },
+        "interface.ssid.radius.server": {
+            "type": "object",
+            "properties": {
+                "host": {
+                    "type": "string",
+                    "format": "uc-host",
+                    "examples": [
+                        "192.168.1.10"
+                    ]
+                },
+                "port": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 1024,
+                    "examples": [
+                        1812
+                    ]
+                },
+                "secret": {
+                    "type": "string",
+                    "examples": [
+                        "secret"
+                    ]
+                },
+                "secondary": {
+                    "type": "object",
+                    "properties": {
+                        "host": {
+                            "type": "string",
+                            "format": "uc-host",
+                            "examples": [
+                                "192.168.1.10"
+                            ]
+                        },
+                        "port": {
+                            "type": "integer",
+                            "maximum": 65535,
+                            "minimum": 1024,
+                            "examples": [
+                                1812
+                            ]
+                        },
+                        "secret": {
+                            "type": "string",
+                            "examples": [
+                                "secret"
+                            ]
+                        }
+                    }
+                },
+                "request-attribute": {
+                    "type": "array",
+                    "items": {
+                        "anyOf": [
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "vendor-id": {
+                                        "type": "integer",
+                                        "maximum": 65535,
+                                        "minimum": 1
+                                    },
+                                    "vendor-attributes": {
+                                        "type": "array",
+                                        "items": {
+                                            "type": "object",
+                                            "properties": {
+                                                "id": {
+                                                    "type": "integer",
+                                                    "maximum": 255,
+                                                    "minimum": 1
+                                                },
+                                                "value": {
+                                                    "type": "string"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            },
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "id": {
+                                        "type": "integer",
+                                        "maximum": 255,
+                                        "minimum": 1
+                                    },
+                                    "value": {
+                                        "type": "integer",
+                                        "maximum": 4294967295,
+                                        "minimum": 0
+                                    }
+                                },
+                                "examples": [
+                                    {
+                                        "id": 27,
+                                        "value": 900
+                                    },
+                                    {
+                                        "id": 56,
+                                        "value": 1004
+                                    }
+                                ]
+                            },
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "id": {
+                                        "type": "integer",
+                                        "maximum": 255,
+                                        "minimum": 1
+                                    },
+                                    "value": {
+                                        "type": "string"
+                                    }
+                                },
+                                "examples": [
+                                    {
+                                        "id": 32,
+                                        "value": "My NAS ID"
+                                    },
+                                    {
+                                        "id": 126,
+                                        "value": "Example Operator"
+                                    }
+                                ]
+                            },
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "id": {
+                                        "type": "integer",
+                                        "maximum": 255,
+                                        "minimum": 1
+                                    },
+                                    "hex-value": {
+                                        "type": "string"
+                                    }
+                                },
+                                "examples": [
+                                    {
+                                        "id": 32,
+                                        "value": "0a0b0c0d"
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                }
+            }
+        },
+        "interface.ssid.radius.health": {
+            "type": "object",
+            "properties": {
+                "username": {
+                    "type": "string"
+                },
+                "password": {
+                    "type": "string"
+                }
+            }
+        },
+        "interface.ssid.radius": {
+            "type": "object",
+            "properties": {
+                "nas-identifier": {
+                    "type": "string"
+                },
+                "chargeable-user-id": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "local": {
+                    "$ref": "#/$defs/interface.ssid.radius.local"
+                },
+                "dynamic-authorization": {
+                    "type": "object",
+                    "properties": {
+                        "host": {
+                            "type": "string",
+                            "format": "uc-ip",
+                            "examples": [
+                                "192.168.1.10"
+                            ]
+                        },
+                        "port": {
+                            "type": "integer",
+                            "maximum": 65535,
+                            "minimum": 1024,
+                            "examples": [
+                                1812
+                            ]
+                        },
+                        "secret": {
+                            "type": "string",
+                            "examples": [
+                                "secret"
+                            ]
+                        }
+                    }
+                },
+                "authentication": {
+                    "allOf": [
+                        {
+                            "$ref": "#/$defs/interface.ssid.radius.server"
+                        },
+                        {
+                            "type": "object",
+                            "properties": {
+                                "mac-filter": {
+                                    "type": "boolean",
+                                    "default": false
+                                }
+                            }
+                        }
+                    ]
+                },
+                "accounting": {
+                    "allOf": [
+                        {
+                            "$ref": "#/$defs/interface.ssid.radius.server"
+                        },
+                        {
+                            "type": "object",
+                            "properties": {
+                                "interval": {
+                                    "type": "integer",
+                                    "maximum": 600,
+                                    "minimum": 60,
+                                    "default": 60
+                                }
+                            }
+                        }
+                    ]
+                },
+                "health": {
+                    "$ref": "#/$defs/interface.ssid.radius.health"
+                }
+            }
+        },
+        "interface.ssid.certificates": {
+            "type": "object",
+            "properties": {
+                "use-local-certificates": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "ca-certificate": {
+                    "type": "string"
+                },
+                "certificate": {
+                    "type": "string"
+                },
+                "private-key": {
+                    "type": "string"
+                },
+                "private-key-password": {
+                    "type": "string"
+                }
+            }
+        },
+        "interface.ssid.pass-point": {
+            "type": "object",
+            "properties": {
+                "venue-name": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "venue-group": {
+                    "type": "integer",
+                    "maximum": 32
+                },
+                "venue-type": {
+                    "type": "integer",
+                    "maximum": 32
+                },
+                "venue-url": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "format": "uri"
+                    }
+                },
+                "auth-type": {
+                    "type": "object",
+                    "properties": {
+                        "type": {
+                            "type": "string",
+                            "enum": [
+                                "terms-and-conditions",
+                                "online-enrollment",
+                                "http-redirection",
+                                "dns-redirection"
+                            ]
+                        },
+                        "uri": {
+                            "type": "string",
+                            "format": "uri",
+                            "examples": [
+                                "https://operator.example.org/wireless-access/terms-and-conditions.html",
+                                "http://www.example.com/redirect/me/here/"
+                            ]
+                        }
+                    },
+                    "minLength": 2,
+                    "maxLength": 2
+                },
+                "domain-name": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "format": "hostname"
+                    }
+                },
+                "nai-realm": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "osen": {
+                    "type": "boolean"
+                },
+                "anqp-domain": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 0
+                },
+                "anqp-3gpp-cell-net": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "friendly-name": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "access-network-type": {
+                    "type": "integer",
+                    "maximum": 15,
+                    "default": 0
+                },
+                "internet": {
+                    "type": "boolean",
+                    "default": true
+                },
+                "asra": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "esr": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "uesa": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "hessid": {
+                    "type": "string",
+                    "example": "00:11:22:33:44:55"
+                },
+                "roaming-consortium": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "disable-dgaf": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "ipaddr-type-available": {
+                    "type": "integer",
+                    "maximum": 255
+                },
+                "connection-capability": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "icons": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "width": {
+                                "type": "integer",
+                                "examples": [
+                                    64
+                                ]
+                            },
+                            "height": {
+                                "type": "integer",
+                                "examples": [
+                                    64
+                                ]
+                            },
+                            "type": {
+                                "type": "string",
+                                "examples": [
+                                    "image/png"
+                                ]
+                            },
+                            "icon": {
+                                "type": "string",
+                                "format": "uc-base64"
+                            },
+                            "language": {
+                                "type": "string",
+                                "pattern": "^[a-z][a-z][a-z]$",
+                                "examples": [
+                                    "eng",
+                                    "fre",
+                                    "ger",
+                                    "ita"
+                                ]
+                            }
+                        },
+                        "examples": [
+                            {
+                                "width": 32,
+                                "height": 32,
+                                "type": "image/png",
+                                "language": "eng",
+                                "icon": "R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
+                            }
+                        ]
+                    }
+                },
+                "wan-metrics": {
+                    "type": "object",
+                    "properties": {
+                        "info": {
+                            "type": "string",
+                            "enum": [
+                                "up",
+                                "down",
+                                "testing"
+                            ]
+                        },
+                        "downlink": {
+                            "type": "integer"
+                        },
+                        "uplink": {
+                            "type": "integer"
+                        }
+                    }
+                }
+            }
+        },
+        "interface.ssid.quality-thresholds": {
+            "type": "object",
+            "properties": {
+                "probe-request-rssi": {
+                    "type": "integer"
+                },
+                "association-request-rssi": {
+                    "type": "integer"
+                },
+                "client-kick-rssi": {
+                    "type": "integer"
+                },
+                "client-kick-ban-time": {
+                    "type": "integer",
+                    "default": 0
+                }
+            }
+        },
+        "interface.ssid.acl": {
+            "type": "object",
+            "properties": {
+                "mode": {
+                    "type": "string",
+                    "enum": [
+                        "allow",
+                        "deny"
+                    ]
+                },
+                "mac-address": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "format": "uc-mac"
+                    }
+                }
+            }
+        },
+        "service.captive.click": {
+            "type": "object",
+            "properties": {
+                "auth-mode": {
+                    "type": "string",
+                    "const": "click-to-continue"
+                }
+            }
+        },
+        "service.captive.radius": {
+            "type": "object",
+            "properties": {
+                "auth-mode": {
+                    "type": "string",
+                    "const": "radius"
+                },
+                "auth-server": {
+                    "type": "string",
+                    "format": "uc-host",
+                    "examples": [
+                        "192.168.1.10"
+                    ]
+                },
+                "auth-port": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 1024,
+                    "default": 1812
+                },
+                "auth-secret": {
+                    "type": "string",
+                    "examples": [
+                        "secret"
+                    ]
+                },
+                "acct-server": {
+                    "type": "string",
+                    "format": "uc-host",
+                    "examples": [
+                        "192.168.1.10"
+                    ]
+                },
+                "acct-port": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 1024,
+                    "default": 1812
+                },
+                "acct-secret": {
+                    "type": "string",
+                    "examples": [
+                        "secret"
+                    ]
+                },
+                "acct-interval": {
+                    "type": "integer",
+                    "default": 600
+                }
+            }
+        },
+        "service.captive.credentials": {
+            "type": "object",
+            "properties": {
+                "auth-mode": {
+                    "type": "string",
+                    "const": "credentials"
+                },
+                "credentials": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "username": {
+                                "type": "string"
+                            },
+                            "password": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "service.captive.uam": {
+            "type": "object",
+            "properties": {
+                "auth-mode": {
+                    "type": "string",
+                    "const": "uam"
+                },
+                "uam-port": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 1024,
+                    "default": 3990
+                },
+                "uam-secret": {
+                    "type": "string"
+                },
+                "uam-server": {
+                    "type": "string"
+                },
+                "nasid": {
+                    "type": "string"
+                },
+                "nasmac": {
+                    "type": "string"
+                },
+                "auth-server": {
+                    "type": "string",
+                    "format": "uc-host",
+                    "examples": [
+                        "192.168.1.10"
+                    ]
+                },
+                "auth-port": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 1024,
+                    "default": 1812
+                },
+                "auth-secret": {
+                    "type": "string",
+                    "examples": [
+                        "secret"
+                    ]
+                },
+                "acct-server": {
+                    "type": "string",
+                    "format": "uc-host",
+                    "examples": [
+                        "192.168.1.10"
+                    ]
+                },
+                "acct-port": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 1024,
+                    "default": 1812
+                },
+                "acct-secret": {
+                    "type": "string",
+                    "examples": [
+                        "secret"
+                    ]
+                },
+                "acct-interval": {
+                    "type": "integer",
+                    "default": 600
+                },
+                "ssid": {
+                    "type": "string"
+                },
+                "mac-format": {
+                    "type": "string",
+                    "enum": [
+                        "aabbccddeeff",
+                        "aa-bb-cc-dd-ee-ff",
+                        "aa:bb:cc:dd:ee:ff",
+                        "AABBCCDDEEFF",
+                        "AA:BB:CC:DD:EE:FF",
+                        "AA-BB-CC-DD-EE-FF"
+                    ]
+                },
+                "final-redirect-url": {
+                    "type": "string",
+                    "enum": [
+                        "default",
+                        "uam"
+                    ]
+                },
+                "mac-auth": {
+                    "type": "boolean",
+                    "default": "default"
+                },
+                "radius-gw-proxy": {
+                    "type": "boolean",
+                    "default": false
+                }
+            }
+        },
+        "service.captive": {
+            "allOf": [
+                {
+                    "oneOf": [
+                        {
+                            "$ref": "#/$defs/service.captive.click"
+                        },
+                        {
+                            "$ref": "#/$defs/service.captive.radius"
+                        },
+                        {
+                            "$ref": "#/$defs/service.captive.credentials"
+                        },
+                        {
+                            "$ref": "#/$defs/service.captive.uam"
+                        }
+                    ]
+                },
+                {
+                    "type": "object",
+                    "properties": {
+                        "walled-garden-fqdn": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        },
+                        "walled-garden-ipaddr": {
+                            "type": "array",
+                            "items": {
+                                "type": "string",
+                                "format": "uc-ip"
+                            }
+                        },
+                        "web-root": {
+                            "type": "string",
+                            "format": "uc-base64"
+                        },
+                        "idle-timeout": {
+                            "type": "integer",
+                            "default": 600
+                        },
+                        "session-timeout": {
+                            "type": "integer"
+                        }
+                    }
+                }
+            ]
+        },
+        "interface.ssid": {
+            "type": "object",
+            "properties": {
+                "purpose": {
+                    "type": "string",
+                    "enum": [
+                        "user-defined",
+                        "onboarding-ap",
+                        "onboarding-sta"
+                    ],
+                    "default": "user-defined"
+                },
+                "name": {
+                    "type": "string",
+                    "maxLength": 32,
+                    "minLength": 1
+                },
+                "wifi-bands": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "enum": [
+                            "2G",
+                            "5G",
+                            "5G-lower",
+                            "5G-upper",
+                            "6G"
+                        ]
+                    }
+                },
+                "bss-mode": {
+                    "type": "string",
+                    "enum": [
+                        "ap",
+                        "sta",
+                        "mesh",
+                        "wds-ap",
+                        "wds-sta",
+                        "wds-repeater"
+                    ],
+                    "default": "ap"
+                },
+                "bssid": {
+                    "type": "string",
+                    "format": "uc-mac"
+                },
+                "hidden-ssid": {
+                    "type": "boolean"
+                },
+                "isolate-clients": {
+                    "type": "boolean"
+                },
+                "strict-forwarding": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "power-save": {
+                    "type": "boolean"
+                },
+                "rts-threshold": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 1
+                },
+                "broadcast-time": {
+                    "type": "boolean"
+                },
+                "unicast-conversion": {
+                    "type": "boolean",
+                    "default": true
+                },
+                "services": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "examples": [
+                            "wifi-steering"
+                        ]
+                    }
+                },
+                "dtim-period": {
+                    "type": "integer",
+                    "default": 2,
+                    "maximum": 255,
+                    "minimum": 1
+                },
+                "maximum-clients": {
+                    "type": "integer",
+                    "example": 64
+                },
+                "proxy-arp": {
+                    "type": "boolean",
+                    "default": true
+                },
+                "disassoc-low-ack": {
+                    "decription": "Disassociate stations based on excessive transmission failures or other indications of connection loss.",
+                    "type": "boolean",
+                    "default": false
+                },
+                "vendor-elements": {
+                    "decription": "This option allows embedding custom vendor specific IEs inside the beacons of a BSS in AP mode.",
+                    "type": "string"
+                },
+                "tip-information-element": {
+                    "decription": "The device will broadcast the TIP vendor IE inside its beacons if this option is enabled.",
+                    "type": "boolean",
+                    "default": true
+                },
+                "fils-discovery-interval": {
+                    "type": "integer",
+                    "default": 20,
+                    "maximum": 20
+                },
+                "encryption": {
+                    "$ref": "#/$defs/interface.ssid.encryption"
+                },
+                "multi-psk": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/interface.ssid.multi-psk"
+                    }
+                },
+                "rrm": {
+                    "$ref": "#/$defs/interface.ssid.rrm"
+                },
+                "rate-limit": {
+                    "$ref": "#/$defs/interface.ssid.rate-limit"
+                },
+                "roaming": {
+                    "anyOf": [
+                        {
+                            "$ref": "#/$defs/interface.ssid.roaming"
+                        },
+                        {
+                            "type": "boolean"
+                        }
+                    ]
+                },
+                "radius": {
+                    "$ref": "#/$defs/interface.ssid.radius"
+                },
+                "certificates": {
+                    "$ref": "#/$defs/interface.ssid.certificates"
+                },
+                "pass-point": {
+                    "$ref": "#/$defs/interface.ssid.pass-point"
+                },
+                "quality-thresholds": {
+                    "$ref": "#/$defs/interface.ssid.quality-thresholds"
+                },
+                "access-control-list": {
+                    "$ref": "#/$defs/interface.ssid.acl"
+                },
+                "captive": {
+                    "$ref": "#/$defs/service.captive"
+                },
+                "hostapd-bss-raw": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "examples": [
+                            "ap_table_expiration_time=3600",
+                            "device_type=6-0050F204-1",
+                            "ieee80211h=1",
+                            "rssi_ignore_probe_request=-75",
+                            "time_zone=EST5",
+                            "uuid=12345678-9abc-def0-1234-56789abcdef0",
+                            "venue_url=1:http://www.example.com/info-eng",
+                            "wpa_deny_ptk0_rekey=0"
+                        ]
+                    }
+                }
+            }
+        },
+        "interface.tunnel.mesh": {
+            "type": "object",
+            "properties": {
+                "proto": {
+                    "type": "string",
+                    "const": "mesh"
+                }
+            }
+        },
+        "interface.tunnel.vxlan": {
+            "type": "object",
+            "properties": {
+                "proto": {
+                    "type": "string",
+                    "const": "vxlan"
+                },
+                "peer-address": {
+                    "type": "string",
+                    "format": "ipv4",
+                    "example": "192.168.100.1"
+                },
+                "peer-port": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 1,
+                    "examples": [
+                        4789
+                    ]
+                }
+            }
+        },
+        "interface.tunnel.l2tp": {
+            "type": "object",
+            "properties": {
+                "proto": {
+                    "type": "string",
+                    "const": "l2tp"
+                },
+                "server": {
+                    "type": "string",
+                    "format": "ipv4",
+                    "example": "192.168.100.1"
+                },
+                "user-name": {
+                    "type": "string"
+                },
+                "password": {
+                    "type": "string"
+                }
+            }
+        },
+        "interface.tunnel.gre": {
+            "type": "object",
+            "properties": {
+                "proto": {
+                    "type": "string",
+                    "const": "gre"
+                },
+                "peer-address": {
+                    "type": "string",
+                    "format": "ipv4",
+                    "example": "192.168.100.1"
+                },
+                "dhcp-healthcheck": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "dont-fragment": {
+                    "type": "boolean",
+                    "default": false
+                }
+            }
+        },
+        "interface.tunnel.gre6": {
+            "type": "object",
+            "properties": {
+                "proto": {
+                    "type": "string",
+                    "const": "gre6"
+                },
+                "peer-address": {
+                    "type": "string",
+                    "format": "ipv6",
+                    "example": "2405:200:802:600:61::1"
+                },
+                "dhcp-healthcheck": {
+                    "type": "boolean",
+                    "default": false
+                }
+            }
+        },
+        "interface.tunnel": {
+            "oneOf": [
+                {
+                    "$ref": "#/$defs/interface.tunnel.mesh"
+                },
+                {
+                    "$ref": "#/$defs/interface.tunnel.vxlan"
+                },
+                {
+                    "$ref": "#/$defs/interface.tunnel.l2tp"
+                },
+                {
+                    "$ref": "#/$defs/interface.tunnel.gre"
+                },
+                {
+                    "$ref": "#/$defs/interface.tunnel.gre6"
+                }
+            ]
+        },
+        "interface": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "examples": [
+                        "LAN"
+                    ]
+                },
+                "role": {
+                    "type": "string",
+                    "enum": [
+                        "upstream",
+                        "downstream"
+                    ]
+                },
+                "isolate-hosts": {
+                    "type": "boolean"
+                },
+                "metric": {
+                    "type": "integer",
+                    "maximum": 4294967295,
+                    "minimum": 0
+                },
+                "mtu": {
+                    "type": "integer",
+                    "maximum": 1500,
+                    "minimum": 1280
+                },
+                "services": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "examples": [
+                            "ssh",
+                            "lldp"
+                        ]
+                    }
+                },
+                "vlan-awareness": {
+                    "type": "object",
+                    "properties": {
+                        "first": {
+                            "type": "integer"
+                        },
+                        "last": {
+                            "type": "integer"
+                        }
+                    }
+                },
+                "vlan": {
+                    "$ref": "#/$defs/interface.vlan"
+                },
+                "bridge": {
+                    "$ref": "#/$defs/interface.bridge"
+                },
+                "ethernet": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/interface.ethernet"
+                    }
+                },
+                "ipv4": {
+                    "$ref": "#/$defs/interface.ipv4"
+                },
+                "ipv6": {
+                    "$ref": "#/$defs/interface.ipv6"
+                },
+                "broad-band": {
+                    "$ref": "#/$defs/interface.broad-band"
+                },
+                "ssids": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/interface.ssid"
+                    }
+                },
+                "tunnel": {
+                    "$ref": "#/$defs/interface.tunnel"
+                }
+            }
+        },
+        "service.lldp": {
+            "type": "object",
+            "properties": {
+                "describe": {
+                    "type": "string",
+                    "default": "uCentral Access Point"
+                },
+                "location": {
+                    "type": "string",
+                    "default": "uCentral Network"
+                }
+            }
+        },
+        "service.ssh": {
+            "type": "object",
+            "properties": {
+                "port": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "default": 22
+                },
+                "authorized-keys": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "examples": [
+                            "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQC0ghdSd2D2y08TFowZLMZn3x1/Djw3BkNsIeHt/Z+RaXwvfV1NQAnNdaOngMT/3uf5jZtYxhpl+dbZtRhoUPRvKflKBeFHYBqjZVzD3r4ns2Ofm2UpHlbdOpMuy9oeTSCeF0IKZZ6szpkvSirQogeP2fe9KRkzQpiza6YxxaJlWw== user@example",
+                            "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJ4FDjyCsg+1Mh2C5G7ibR3z0Kw1dU57kfXebLRwS6CL bob@work",
+                            "ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBP/JpJ/KHtKKImzISBDwLO0/EwytIr4pGZQXcP6GCSHchLMyfjf147KNlF9gC+3FibzqKH02EiQspVhRgfuK6y0= alice@home"
+                        ]
+                    }
+                },
+                "password-authentication": {
+                    "type": "boolean",
+                    "default": true
+                },
+                "enable": {
+                    "type": "boolean"
+                }
+            }
+        },
+        "service.ntp": {
+            "type": "object",
+            "properties": {
+                "servers": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "format": "uc-host"
+                    },
+                    "examples": [
+                        "0.openwrt.pool.ntp.org"
+                    ]
+                },
+                "local-server": {
+                    "type": "boolean",
+                    "examples": [
+                        true
+                    ]
+                }
+            }
+        },
+        "service.mdns": {
+            "type": "object",
+            "properties": {
+                "enable": {
+                    "type": "boolean",
+                    "default": false
+                }
+            }
+        },
+        "service.rtty": {
+            "type": "object",
+            "properties": {
+                "host": {
+                    "type": "string",
+                    "format": "uc-host",
+                    "examples": [
+                        "192.168.1.10"
+                    ]
+                },
+                "port": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "default": 5912
+                },
+                "token": {
+                    "type": "string",
+                    "maxLength": 32,
+                    "minLength": 32,
+                    "examples": [
+                        "01234567890123456789012345678901"
+                    ]
+                },
+                "mutual-tls": {
+                    "type": "boolean",
+                    "default": true
+                }
+            }
+        },
+        "service.log": {
+            "type": "object",
+            "properties": {
+                "host": {
+                    "type": "string",
+                    "format": "uc-host",
+                    "examples": [
+                        "192.168.1.10"
+                    ]
+                },
+                "port": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 100,
+                    "examples": [
+                        2000
+                    ]
+                },
+                "proto": {
+                    "type": "string",
+                    "enum": [
+                        "tcp",
+                        "udp"
+                    ],
+                    "default": "udp"
+                },
+                "size": {
+                    "type": "integer",
+                    "minimum": 32,
+                    "default": 1000
+                },
+                "priority": {
+                    "type": "integer",
+                    "minimum": 0,
+                    "default": 7
+                }
+            }
+        },
+        "service.http": {
+            "type": "object",
+            "properties": {
+                "http-port": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 1,
+                    "default": 80
+                },
+                "enable": {
+                    "type": "boolean"
+                }
+            }
+        },
+        "service.igmp": {
+            "type": "object",
+            "properties": {
+                "enable": {
+                    "type": "boolean",
+                    "default": false
+                }
+            }
+        },
+        "service.ieee8021x": {
+            "type": "object",
+            "properties": {
+                "mode": {
+                    "type": "string",
+                    "enum": [
+                        "radius",
+                        "user"
+                    ]
+                },
+                "port-filter": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "examples": [
+                            {
+                                "LAN1": null
+                            }
+                        ]
+                    }
+                },
+                "users": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/interface.ssid.radius.local-user"
+                    }
+                },
+                "radius": {
+                    "type": "object",
+                    "properties": {
+                        "nas-identifier": {
+                            "type": "string"
+                        },
+                        "auth-server-addr": {
+                            "type": "string",
+                            "format": "uc-host",
+                            "examples": [
+                                "192.168.1.10"
+                            ]
+                        },
+                        "auth-server-port": {
+                            "type": "integer",
+                            "maximum": 65535,
+                            "minimum": 1024,
+                            "examples": [
+                                1812
+                            ]
+                        },
+                        "auth-server-secret": {
+                            "type": "string",
+                            "examples": [
+                                "secret"
+                            ]
+                        },
+                        "acct-server-addr": {
+                            "type": "string",
+                            "format": "uc-host",
+                            "examples": [
+                                "192.168.1.10"
+                            ]
+                        },
+                        "acct-server-port": {
+                            "type": "integer",
+                            "maximum": 65535,
+                            "minimum": 1024,
+                            "examples": [
+                                1813
+                            ]
+                        },
+                        "acct-server-secret": {
+                            "type": "string",
+                            "examples": [
+                                "secret"
+                            ]
+                        },
+                        "coa-server-addr": {
+                            "type": "string",
+                            "format": "uc-host",
+                            "examples": [
+                                "192.168.1.10"
+                            ]
+                        },
+                        "coa-server-port": {
+                            "type": "integer",
+                            "maximum": 65535,
+                            "minimum": 1024,
+                            "examples": [
+                                1814
+                            ]
+                        },
+                        "coa-server-secret": {
+                            "type": "string",
+                            "examples": [
+                                "secret"
+                            ]
+                        }
+                    }
+                }
+            }
+        },
+        "service.radius-proxy": {
+            "type": "object",
+            "properties": {
+                "proxy-secret": {
+                    "type": "string",
+                    "default": "secret"
+                },
+                "realms": {
+                    "type": "array",
+                    "items": {
+                        "anyOf": [
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "protocol": {
+                                        "type": "string",
+                                        "enum": [
+                                            "radsec"
+                                        ],
+                                        "default": "radsec"
+                                    },
+                                    "realm": {
+                                        "type": "array",
+                                        "items": {
+                                            "type": "string",
+                                            "default": "*"
+                                        }
+                                    },
+                                    "auto-discover": {
+                                        "type": "boolean",
+                                        "default": false
+                                    },
+                                    "host": {
+                                        "type": "string",
+                                        "format": "uc-host",
+                                        "examples": [
+                                            "192.168.1.10"
+                                        ]
+                                    },
+                                    "port": {
+                                        "type": "integer",
+                                        "maximum": 65535,
+                                        "default": 2083
+                                    },
+                                    "secret": {
+                                        "type": "string"
+                                    },
+                                    "use-local-certificates": {
+                                        "type": "boolean",
+                                        "default": false
+                                    },
+                                    "ca-certificate": {
+                                        "type": "string"
+                                    },
+                                    "certificate": {
+                                        "type": "string"
+                                    },
+                                    "private-key": {
+                                        "type": "string"
+                                    },
+                                    "private-key-password": {
+                                        "type": "string"
+                                    }
+                                }
+                            },
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "protocol": {
+                                        "type": "string",
+                                        "enum": [
+                                            "radius"
+                                        ]
+                                    },
+                                    "realm": {
+                                        "type": "array",
+                                        "items": {
+                                            "type": "string",
+                                            "default": "*"
+                                        }
+                                    },
+                                    "auth-server": {
+                                        "type": "string",
+                                        "format": "uc-host",
+                                        "examples": [
+                                            "192.168.1.10"
+                                        ]
+                                    },
+                                    "auth-port": {
+                                        "type": "integer",
+                                        "maximum": 65535,
+                                        "minimum": 1024,
+                                        "examples": [
+                                            1812
+                                        ]
+                                    },
+                                    "auth-secret": {
+                                        "type": "string",
+                                        "examples": [
+                                            "secret"
+                                        ]
+                                    },
+                                    "acct-server": {
+                                        "type": "string",
+                                        "format": "uc-host",
+                                        "examples": [
+                                            "192.168.1.10"
+                                        ]
+                                    },
+                                    "acct-port": {
+                                        "type": "integer",
+                                        "maximum": 65535,
+                                        "minimum": 1024,
+                                        "examples": [
+                                            1812
+                                        ]
+                                    },
+                                    "acct-secret": {
+                                        "type": "string",
+                                        "examples": [
+                                            "secret"
+                                        ]
+                                    }
+                                }
+                            },
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "protocol": {
+                                        "type": "string",
+                                        "enum": [
+                                            "block"
+                                        ]
+                                    },
+                                    "realm": {
+                                        "type": "array",
+                                        "items": {
+                                            "type": "string",
+                                            "default": "*"
+                                        }
+                                    },
+                                    "message": {
+                                        "type": "string",
+                                        "items": {
+                                            "type": "string",
+                                            "default": "blocked"
+                                        }
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                }
+            }
+        },
+        "service.online-check": {
+            "type": "object",
+            "properties": {
+                "ping-hosts": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "format": "uc-host",
+                        "examples": [
+                            "192.168.1.10"
+                        ]
+                    }
+                },
+                "download-hosts": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "examples": [
+                            "www.example.org"
+                        ]
+                    }
+                },
+                "check-interval": {
+                    "type": "number",
+                    "default": 60
+                },
+                "check-threshold": {
+                    "type": "number",
+                    "default": 1
+                },
+                "action": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "enum": [
+                            "wifi",
+                            "leds"
+                        ]
+                    }
+                }
+            }
+        },
+        "service.data-plane": {
+            "type": "object",
+            "properties": {
+                "ingress-filters": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "name": {
+                                "type": "string"
+                            },
+                            "program": {
+                                "type": "string",
+                                "format": "uc-base64"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "service.wifi-steering": {
+            "type": "object",
+            "properties": {
+                "mode": {
+                    "type": "string",
+                    "enum": [
+                        "local",
+                        "none"
+                    ],
+                    "examples": [
+                        "local"
+                    ]
+                },
+                "assoc-steering": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "required-snr": {
+                    "type": "integer",
+                    "default": 0
+                },
+                "required-probe-snr": {
+                    "type": "integer",
+                    "default": 0
+                },
+                "required-roam-snr": {
+                    "type": "integer",
+                    "default": 0
+                },
+                "load-kick-threshold": {
+                    "type": "integer",
+                    "default": 0
+                },
+                "auto-channel": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "ipv6": {
+                    "type": "boolean",
+                    "default": false
+                }
+            }
+        },
+        "service.quality-of-service.class-selector": {
+            "type": "string",
+            "enum": [
+                "CS0",
+                "CS1",
+                "CS2",
+                "CS3",
+                "CS4",
+                "CS5",
+                "CS6",
+                "CS7",
+                "AF11",
+                "AF12",
+                "AF13",
+                "AF21",
+                "AF22",
+                "AF23",
+                "AF31",
+                "AF32",
+                "AF33",
+                "AF41",
+                "AF42",
+                "AF43",
+                "DF",
+                "EF",
+                "VA",
+                "LE"
+            ]
+        },
+        "service.quality-of-service": {
+            "type": "object",
+            "properties": {
+                "select-ports": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "default": "WAN"
+                    }
+                },
+                "bandwidth-up": {
+                    "type": "integer",
+                    "default": 0
+                },
+                "bandwidth-down": {
+                    "type": "integer",
+                    "default": 0
+                },
+                "bulk-detection": {
+                    "type": "object",
+                    "properties": {
+                        "dscp": {
+                            "$ref": "#/$defs/service.quality-of-service.class-selector",
+                            "default": "CS0"
+                        },
+                        "packets-per-second": {
+                            "type": "number",
+                            "default": 0
+                        }
+                    }
+                },
+                "services": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "classifier": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "dscp": {
+                                "$ref": "#/$defs/service.quality-of-service.class-selector",
+                                "default": "CS1"
+                            },
+                            "ports": {
+                                "type": "array",
+                                "items": {
+                                    "type": "object",
+                                    "properties": {
+                                        "protocol": {
+                                            "type": "string",
+                                            "enum": [
+                                                "any",
+                                                "tcp",
+                                                "udp"
+                                            ],
+                                            "default": "any"
+                                        },
+                                        "port": {
+                                            "type": "integer"
+                                        },
+                                        "range-end": {
+                                            "type": "integer"
+                                        },
+                                        "reclassify": {
+                                            "type": "boolean",
+                                            "default": true
+                                        }
+                                    }
+                                }
+                            },
+                            "dns": {
+                                "type": "array",
+                                "items": {
+                                    "type": "object",
+                                    "properties": {
+                                        "fqdn": {
+                                            "type": "string",
+                                            "format": "uc-fqdn"
+                                        },
+                                        "suffix-matching": {
+                                            "type": "boolean",
+                                            "default": true
+                                        },
+                                        "reclassify": {
+                                            "type": "boolean",
+                                            "default": true
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "service.facebook-wifi": {
+            "type": "object",
+            "properties": {
+                "vendor-id": {
+                    "type": "string"
+                },
+                "gateway-id": {
+                    "type": "string"
+                },
+                "secret": {
+                    "type": "string"
+                }
+            }
+        },
+        "service.airtime-fairness": {
+            "type": "object",
+            "properties": {
+                "voice-weight": {
+                    "type": "number",
+                    "default": 4
+                },
+                "packet-threshold": {
+                    "type": "number",
+                    "default": 100
+                },
+                "bulk-threshold": {
+                    "type": "number",
+                    "default": 50
+                },
+                "priority-threshold": {
+                    "type": "number",
+                    "default": 30
+                },
+                "weight-normal": {
+                    "type": "number",
+                    "default": 256
+                },
+                "weight-priority": {
+                    "type": "number",
+                    "default": 394
+                },
+                "weight-bulk": {
+                    "type": "number",
+                    "default": 128
+                }
+            }
+        },
+        "service.wireguard-overlay": {
+            "type": "object",
+            "properties": {
+                "proto": {
+                    "type": "string",
+                    "const": "wireguard-overlay"
+                },
+                "private-key": {
+                    "type": "string"
+                },
+                "peer-port": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 1,
+                    "default": 3456
+                },
+                "peer-exchange-port": {
+                    "type": "integer",
+                    "maximum": 65535,
+                    "minimum": 1,
+                    "default": 3458
+                },
+                "root-node": {
+                    "type": "object",
+                    "properties": {
+                        "key": {
+                            "type": "string"
+                        },
+                        "endpoint": {
+                            "type": "string",
+                            "format": "uc-ip"
+                        },
+                        "ipaddr": {
+                            "type": "array",
+                            "items": {
+                                "type": "string",
+                                "format": "uc-ip"
+                            }
+                        }
+                    }
+                },
+                "hosts": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "name": {
+                                "type": "string"
+                            },
+                            "key": {
+                                "type": "string"
+                            },
+                            "endpoint": {
+                                "type": "string",
+                                "format": "uc-ip"
+                            },
+                            "subnet": {
+                                "type": "array",
+                                "items": {
+                                    "type": "string",
+                                    "format": "uc-cidr"
+                                }
+                            },
+                            "ipaddr": {
+                                "type": "array",
+                                "items": {
+                                    "type": "string",
+                                    "format": "uc-ip"
+                                }
+                            }
+                        }
+                    }
+                },
+                "vxlan": {
+                    "type": "object",
+                    "properties": {
+                        "port": {
+                            "type": "integer",
+                            "maximum": 65535,
+                            "minimum": 1,
+                            "default": 4789
+                        },
+                        "mtu": {
+                            "type": "integer",
+                            "maximum": 65535,
+                            "minimum": 256,
+                            "default": 1420
+                        },
+                        "isolate": {
+                            "type": "boolean",
+                            "default": true
+                        }
+                    }
+                }
+            }
+        },
+        "service.gps": {
+            "type": "object",
+            "properties": {
+                "adjust-time": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "baud-rate": {
+                    "type": "integer",
+                    "enum": [
+                        2400,
+                        4800,
+                        9600,
+                        19200
+                    ]
+                }
+            }
+        },
+        "service.dhcp-relay": {
+            "type": "object",
+            "properties": {
+                "select-ports": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "vlans": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "vlan": {
+                                "type": "number"
+                            },
+                            "relay-server": {
+                                "type": "string",
+                                "format": "uc-ip"
+                            },
+                            "circuit-id-format": {
+                                "type": "string",
+                                "enum": [
+                                    "vlan-id",
+                                    "ap-mac",
+                                    "ssid"
+                                ],
+                                "default": "vlan-id"
+                            },
+                            "remote-id-format": {
+                                "type": "string",
+                                "enum": [
+                                    "vlan-id",
+                                    "ap-mac",
+                                    "ssid"
+                                ],
+                                "default": "ap-mac"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "service.admin-ui": {
+            "type": "object",
+            "properties": {
+                "wifi-ssid": {
+                    "type": "string",
+                    "default": "Maverick",
+                    "maxLength": 32,
+                    "minLength": 1
+                },
+                "wifi-key": {
+                    "type": "string",
+                    "maxLength": 63,
+                    "minLength": 8
+                },
+                "wifi-bands": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "enum": [
+                            "2G",
+                            "5G",
+                            "5G-lower",
+                            "5G-upper",
+                            "6G"
+                        ]
+                    }
+                },
+                "offline-trigger": {
+                    "type": "number"
+                }
+            }
+        },
+        "service.rrm": {
+            "type": "object",
+            "properties": {
+                "beacon-request-assoc": {
+                    "type": "boolean",
+                    "default": true
+                },
+                "station-stats-interval": {
+                    "type": "number"
+                }
+            }
+        },
+        "service.telnet": {
+            "type": "object",
+            "properties": {
+                "enable": {
+                    "type": "boolean"
+                }
+            }
+        },
+        "service": {
+            "type": "object",
+            "properties": {
+                "lldp": {
+                    "$ref": "#/$defs/service.lldp"
+                },
+                "ssh": {
+                    "$ref": "#/$defs/service.ssh"
+                },
+                "ntp": {
+                    "$ref": "#/$defs/service.ntp"
+                },
+                "mdns": {
+                    "$ref": "#/$defs/service.mdns"
+                },
+                "rtty": {
+                    "$ref": "#/$defs/service.rtty"
+                },
+                "log": {
+                    "$ref": "#/$defs/service.log"
+                },
+                "http": {
+                    "$ref": "#/$defs/service.http"
+                },
+                "igmp": {
+                    "$ref": "#/$defs/service.igmp"
+                },
+                "ieee8021x": {
+                    "$ref": "#/$defs/service.ieee8021x"
+                },
+                "radius-proxy": {
+                    "$ref": "#/$defs/service.radius-proxy"
+                },
+                "online-check": {
+                    "$ref": "#/$defs/service.online-check"
+                },
+                "data-plane": {
+                    "$ref": "#/$defs/service.data-plane"
+                },
+                "wifi-steering": {
+                    "$ref": "#/$defs/service.wifi-steering"
+                },
+                "quality-of-service": {
+                    "$ref": "#/$defs/service.quality-of-service"
+                },
+                "facebook-wifi": {
+                    "$ref": "#/$defs/service.facebook-wifi"
+                },
+                "airtime-fairness": {
+                    "$ref": "#/$defs/service.airtime-fairness"
+                },
+                "wireguard-overlay": {
+                    "$ref": "#/$defs/service.wireguard-overlay"
+                },
+                "captive": {
+                    "$ref": "#/$defs/service.captive"
+                },
+                "gps": {
+                    "$ref": "#/$defs/service.gps"
+                },
+                "dhcp-relay": {
+                    "$ref": "#/$defs/service.dhcp-relay"
+                },
+                "admin-ui": {
+                    "$ref": "#/$defs/service.admin-ui"
+                },
+                "rrm": {
+                    "$ref": "#/$defs/service.rrm"
+                },
+                "telnet": {
+                    "$ref": "#/$defs/service.telnet"
+                }
+            }
+        },
+        "metrics.statistics": {
+            "type": "object",
+            "properties": {
+                "interval": {
+                    "type": "integer",
+                    "minimum": 60
+                },
+                "types": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "enum": [
+                            "ssids",
+                            "lldp",
+                            "clients",
+                            "tid-stats"
+                        ]
+                    }
+                },
+                "wired-clients-max-num": {
+                    "type": "integer"
+                }
+            }
+        },
+        "metrics.health": {
+            "type": "object",
+            "properties": {
+                "interval": {
+                    "type": "integer",
+                    "minimum": 60
+                },
+                "dhcp-local": {
+                    "type": "boolean",
+                    "default": true
+                },
+                "dhcp-remote": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "dns-local": {
+                    "type": "boolean",
+                    "default": true
+                },
+                "dns-remote": {
+                    "type": "boolean",
+                    "default": true
+                }
+            }
+        },
+        "metrics.wifi-frames": {
+            "type": "object",
+            "properties": {
+                "filters": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "enum": [
+                            "probe",
+                            "auth",
+                            "assoc",
+                            "disassoc",
+                            "deauth",
+                            "local-deauth",
+                            "inactive-deauth",
+                            "key-mismatch",
+                            "beacon-report",
+                            "radar-detected"
+                        ]
+                    }
+                }
+            }
+        },
+        "metrics.dhcp-snooping": {
+            "type": "object",
+            "properties": {
+                "filters": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "enum": [
+                            "ack",
+                            "discover",
+                            "offer",
+                            "request",
+                            "solicit",
+                            "reply",
+                            "renew"
+                        ]
+                    }
+                }
+            }
+        },
+        "metrics.wifi-scan": {
+            "type": "object",
+            "properties": {
+                "interval": {
+                    "type": "integer"
+                },
+                "verbose": {
+                    "type": "boolean"
+                },
+                "information-elements": {
+                    "type": "boolean"
+                }
+            }
+        },
+        "metrics.telemetry": {
+            "type": "object",
+            "properties": {
+                "interval": {
+                    "type": "integer"
+                },
+                "types": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "enum": [
+                            "ssh",
+                            "health",
+                            "health.dns",
+                            "health.dhcp",
+                            "health.radius",
+                            "health.memory",
+                            "client",
+                            "client.join",
+                            "client.leave",
+                            "client.key-mismatch",
+                            "wifi",
+                            "wifi.start",
+                            "wifi.stop",
+                            "wired",
+                            "wired.carrier-up",
+                            "wired.carrier-down",
+                            "unit",
+                            "unit.boot-up"
+                        ]
+                    }
+                }
+            }
+        },
+        "metrics.realtime": {
+            "type": "object",
+            "properties": {
+                "types": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "enum": [
+                            "ssh",
+                            "health",
+                            "health.dns",
+                            "health.dhcp",
+                            "health.radius",
+                            "health.memory",
+                            "client",
+                            "client.join",
+                            "client.leave",
+                            "client.key-mismatch",
+                            "wifi",
+                            "wifi.start",
+                            "wifi.stop",
+                            "wired",
+                            "wired.carrier-up",
+                            "wired.carrier-down",
+                            "unit",
+                            "unit.boot-up"
+                        ]
+                    }
+                }
+            }
+        },
+        "metrics": {
+            "type": "object",
+            "properties": {
+                "statistics": {
+                    "$ref": "#/$defs/metrics.statistics"
+                },
+                "health": {
+                    "$ref": "#/$defs/metrics.health"
+                },
+                "wifi-frames": {
+                    "$ref": "#/$defs/metrics.wifi-frames"
+                },
+                "dhcp-snooping": {
+                    "$ref": "#/$defs/metrics.dhcp-snooping"
+                },
+                "wifi-scan": {
+                    "$ref": "#/$defs/metrics.wifi-scan"
+                },
+                "telemetry": {
+                    "$ref": "#/$defs/metrics.telemetry"
+                },
+                "realtime": {
+                    "$ref": "#/$defs/metrics.realtime"
+                }
+            }
+        },
+        "config-raw": {
+            "type": "array",
+            "items": {
+                "type": "array",
+                "minItems": 2,
+                "items": {
+                    "type": "string"
+                },
+                "examples": [
+                    [
+                        "set",
+                        "system.@system[0].timezone",
+                        "GMT0"
+                    ],
+                    [
+                        "delete",
+                        "firewall.@zone[0]"
+                    ],
+                    [
+                        "delete",
+                        "dhcp.wan"
+                    ],
+                    [
+                        "add",
+                        "dhcp",
+                        "dhcp"
+                    ],
+                    [
+                        "add-list",
+                        "system.ntp.server",
+                        "0.pool.example.org"
+                    ],
+                    [
+                        "del-list",
+                        "system.ntp.server",
+                        "1.openwrt.pool.ntp.org"
+                    ]
+                ]
+            }
+        }
+    }
+}
+
+)foo";
+
+static inline bool IsIPv4(const std::string &value) {
+	Poco::Net::IPAddress A;
+	return ((Poco::Net::IPAddress::tryParse(value, A) && A.family() == Poco::Net::IPAddress::IPv4));
+}
+
+static inline bool IsIPv6(const std::string &value) {
+	Poco::Net::IPAddress A;
+	return ((Poco::Net::IPAddress::tryParse(value, A) && A.family() == Poco::Net::IPAddress::IPv6));
+}
+
+static inline bool IsIP(const std::string &value) { return IsIPv4(value) || IsIPv6(value); }
+
+static inline bool IsCIDRv6(const std::string &value) {
+	auto Tokens = Poco::StringTokenizer(value, "/");
+	if (Tokens.count() == 2 && IsIPv6(Tokens[0])) {
+		auto Mask = std::atoi(Tokens[1].c_str());
+		if (Mask >= 48 && Mask <= 128)
+			return true;
+	}
+	return false;
+}
+
+static inline bool IsCIDRv4(const std::string &value) {
+	auto Tokens = Poco::StringTokenizer(value, "/");
+	if (Tokens.count() == 2 && IsIPv4(Tokens[0])) {
+		auto Mask = std::atoi(Tokens[1].c_str());
+		if (Mask >= 0 && Mask <= 32)
+			return true;
+	}
+	return false;
+}
+
+static inline bool IsCIDR(const std::string &value) { return IsCIDRv4(value) || IsCIDRv6(value); }
+
+static inline bool IsPortRangeIsValid(const std::string &r) {
+	const auto ports = Poco::StringTokenizer("-", r, Poco::StringTokenizer::TOK_TRIM);
+
+	for (const auto &port : ports) {
+		uint32_t port_num = std::stoul(port);
+		if (port_num == 0 || port_num > 65535)
+			return false;
+	}
+	return true;
+}
+
+bool ExternalValijsonFormatChecker(const std::string &format, const std::string &value,
+								   [[maybe_unused]] std::vector<std::string> &context,
+								   [[maybe_unused]] valijson::ValidationResults *const results) {
+	static const std::regex host_regex{
+		"^(?=.{1,254}$)((?=[a-z0-9-]{1,63}\\.)(xn--+)?[a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,63}$"};
+	static const std::regex mac_regex{"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"};
+	static const std::regex uc_timeout_regex{"^[0-9]+[dmshw]$"};
+	static const std::regex b64_regex("^[a-zA-Z0-9\\+/]*={0,3}$");
+
+	if (format == "uc-cidr4") {
+		if (IsCIDRv4(value))
+			return true;
+		if (results)
+			results->pushError(context, fmt::format("{} is not a valid CIDR IPv4 block", value));
+        return false;
+	} else if (format == "uc-cidr6") {
+		if (IsCIDRv6(value))
+			return true;
+		if (results)
+			results->pushError(context, fmt::format("{} is not a valid CIDR IPv6 block", value));
+        return false;
+	} else if (format == "uc-cidr") {
+		if (IsCIDR(value))
+			return true;
+		if (results)
+			results->pushError(context, fmt::format("{} is not a valid CIDR block", value));
+        return false;
+	} else if (format == "uc-mac") {
+		if (std::regex_match(value, mac_regex))
+			return true;
+		if (results)
+			results->pushError(context, fmt::format("{} is not a valid MAC address", value));
+        return false;
+	} else if (format == "uc-timeout") {
+		if (std::regex_match(value, uc_timeout_regex))
+			return true;
+		if (results)
+			results->pushError(context, fmt::format("{} is not a valid timeout value", value));
+        return false;
+	} else if (format == "uc-host") {
+		if (IsIP(value))
+			return true;
+		if (std::regex_match(value, host_regex))
+			return true;
+		if (results)
+			results->pushError(context, fmt::format("{} is not a valid hostname", value));
+        return false;
+	} else if (format == "fqdn" || format == "uc-fqdn") {
+		if (std::regex_match(value, host_regex))
+			return true;
+		if (results)
+			results->pushError(context, fmt::format("{} is not a valid FQDN", value));
+        return false;
+	} else if (format == "uc-base64") {
+        bool valid =  value.size() % 4 == 0 && std::all_of(value.begin(), value.end(), [](char c) {
+            return std::isalnum(c) || c == '+' || c == '/' || c == '=';
+        });
+        if (valid)
+            return true;
+		if (results)
+			results->pushError(context, fmt::format("{} is not a valid base 64 value", "..."));
+        return false;
+	} else if (format == "uri") {
+		try {
+			Poco::URI uri(value);
+			return true;
+		} catch (...) {
+		}
+		if (results)
+			results->pushError(context, fmt::format("{} is not a valid URL", value));
+        return false;
+	} else if (format == "uc-portrange") {
+		try {
+			if (IsPortRangeIsValid(value))
+				return true;
+		} catch (...) {
+		}
+		if (results)
+			results->pushError(context, fmt::format("{} is not a valid post range", value));
+        return false;
+	} else if (format == "ip") {
+		if (IsIP(value))
+			return true;
+		if (results)
+			results->pushError(context, fmt::format("{} is not a valid IP address", value));
+        return false;
+	}
+	return true;
+}
+
+namespace OpenWifi {
+
+	int ConfigurationValidator::Start() {
+		Init();
+		return 0;
+	}
+
+	void ConfigurationValidator::Stop() {}
+
+	bool ConfigurationValidator::SetSchema(ConfigurationType Type, const std::string &SchemaStr) {
+		try {
+			Poco::JSON::Parser P;
+			auto SchemaDocPtr = P.parse(SchemaStr).extract<Poco::JSON::Object::Ptr>();
+            valijson::SchemaParser    SchemaParser;
+			valijson::adapters::PocoJsonAdapter     Adaptor(SchemaDocPtr);
+			SchemaParser.populateSchema(Adaptor, RootSchema_[static_cast<int>(Type)]);
+			Initialized_ = Working_ = true;
+			return true;
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		} catch (...) {
+			Logger().error("Validation schema is invalid, falling back.");
+		}
+		return false;
+	}
+
+	std::vector<std::string>	DefaultConfigureKeys {
+		"ucentral.datamodel.uri" ,
+		"ucentral.datamodelols.uri"
+	};
+
+	std::vector<std::string>	DefaultJSONSchemaFileNames {
+		"/ucentral.schema.json" ,
+		"/ucentralols.schema.json"
+	};
+
+	void ConfigurationValidator::Init() {
+
+        if (Initialized_)
+			return;
+
+		std::string GitSchema;
+		if (MicroServiceConfigGetBool("ucentral.datamodel.internal", true)) {
+			SetSchema(ConfigurationType::AP, DefaultAPSchema);
+			SetSchema(ConfigurationType::SWITCH, DefaultSWITCHSchema);
+			poco_information(Logger(), "Using uCentral validation from built-in default.");
+			return;
+		}
 
+		try {
+			for(auto Type : {ConfigurationType::AP, ConfigurationType::SWITCH}) {
+				auto GitURI =
+					MicroServiceConfigGetString(DefaultConfigureKeys[static_cast<int>(Type)],
+												GitJSONSchemaURLs[static_cast<int>(Type)]);
+				if (Utils::wgets(GitURI, GitSchema) && SetSchema(Type, GitSchema)) {
+					poco_information(Logger(),
+									 "Using uCentral data model validation schema from GIT.");
+					return;
+				} else {
+					std::string FileName{MicroServiceDataDirectory() + DefaultJSONSchemaFileNames[static_cast<int>(Type)]};
+					std::ifstream input(FileName);
+					std::stringstream schema_file;
+					schema_file << input.rdbuf();
+					input.close();
+					if (SetSchema(Type,schema_file.str())) {
+						poco_information(
+							Logger(),
+							"Using uCentral data model validation schema from local file.");
+						return;
+					}
+				}
+			}
+		} catch (const Poco::Exception &E) {
+            Logger().log(E);
 		} catch (...) {
 		}
-		SetSchema(DefaultUCentralSchema);
+		SetSchema(ConfigurationType::AP, DefaultAPSchema);
+		SetSchema(ConfigurationType::SWITCH, DefaultSWITCHSchema);
 		poco_information(Logger(),
 						 "Using uCentral data model validation schema from built-in default.");
 	}
 
-	bool ConfigurationValidator::Validate(const std::string &C, std::vector<std::string> &Errors,
+	bool ConfigurationValidator::Validate(ConfigurationType Type, const std::string &C, std::string &Errors,
 										  bool Strict) {
 		if (Working_) {
 			try {
@@ -3663,12 +8204,24 @@ namespace OpenWifi {
 				valijson::adapters::PocoJsonAdapter Tester(Doc);
 				valijson::Validator Validator;
 				valijson::ValidationResults Results;
-				if (Validator.validate(*RootSchema_, Tester, &Results)) {
+				if (Validator.validate(RootSchema_[static_cast<int>(Type)], Tester, &Results)) {
 					return true;
 				}
+
+                Poco::JSON::Array ErrorArray;
 				for (const auto &error : Results) {
-					Errors.push_back(error.description);
+                    Poco::JSON::Array   ContextArray;
+                    for(const auto &context : error.context) {
+                        ContextArray.add(context);
+                    }
+                    Poco::JSON::Object  ErrorObject;
+                    ErrorObject.set("context", ContextArray);
+                    ErrorObject.set("description", error.description);
+                    ErrorArray.add(ErrorObject);
 				}
+                std::stringstream os;
+                ErrorArray.stringify(os);
+                Errors = os.str();
 				return false;
 			} catch (const Poco::Exception &E) {
 				Logger().log(E);
diff --git a/src/framework/ConfigurationValidator.h b/src/framework/ConfigurationValidator.h
index 58ef1803..5986802c 100644
--- a/src/framework/ConfigurationValidator.h
+++ b/src/framework/ConfigurationValidator.h
@@ -5,7 +5,7 @@
 #pragma once
 
 #include "framework/SubSystemServer.h"
-
+#include "framework/ow_constants.h"
 #include <valijson/adapters/poco_json_adapter.hpp>
 #include <valijson/constraints/constraint.hpp>
 #include <valijson/constraints/constraint_visitor.hpp>
@@ -17,33 +17,42 @@
 namespace OpenWifi {
 	class ConfigurationValidator : public SubSystemServer {
 	  public:
+
+		enum class ConfigurationType { AP = 0 , SWITCH = 1};
+
 		static auto instance() {
 			static auto instance_ = new ConfigurationValidator;
 			return instance_;
 		}
 
-		bool Validate(const std::string &C, std::vector<std::string> &Errors, bool Strict);
+		bool Validate(ConfigurationType Type, const std::string &C, std::string &Errors, bool Strict);
 		int Start() override;
 		void Stop() override;
 		void reinitialize(Poco::Util::Application &self) override;
 
+		inline static ConfigurationType GetType(const std::string &type) {
+			std::string Type = Poco::toUpper(type);
+			if (Type == Platforms::AP)
+				return ConfigurationType::AP;
+			if (Type == Platforms::SWITCH)
+				return ConfigurationType::SWITCH;
+			return ConfigurationType::AP;
+		}
+
 	  private:
 		bool Initialized_ = false;
 		bool Working_ = false;
 		void Init();
-		std::unique_ptr<valijson::Schema> RootSchema_;
-		std::unique_ptr<valijson::SchemaParser> SchemaParser_;
-		std::unique_ptr<valijson::adapters::PocoJsonAdapter> PocoJsonAdapter_;
-		Poco::JSON::Object::Ptr SchemaDocPtr_;
-		bool SetSchema(const std::string &SchemaStr);
+		std::array<valijson::Schema,2> 			RootSchema_;
+		bool SetSchema(ConfigurationType Type, const std::string &SchemaStr);
 
 		ConfigurationValidator()
 			: SubSystemServer("ConfigValidator", "CFG-VALIDATOR", "config.validator") {}
 	};
 
 	inline auto ConfigurationValidator() { return ConfigurationValidator::instance(); }
-	inline bool ValidateUCentralConfiguration(const std::string &C, std::vector<std::string> &Error,
+	inline bool ValidateUCentralConfiguration(ConfigurationValidator::ConfigurationType Type, const std::string &C, std::string &Errors,
 											  bool strict) {
-		return ConfigurationValidator::instance()->Validate(C, Error, strict);
+		return ConfigurationValidator::instance()->Validate(Type, C, Errors, strict);
 	}
 } // namespace OpenWifi
diff --git a/src/framework/EventBusManager.cpp b/src/framework/EventBusManager.cpp
index ca28ad94..4f4e8c76 100644
--- a/src/framework/EventBusManager.cpp
+++ b/src/framework/EventBusManager.cpp
@@ -9,8 +9,6 @@
 
 namespace OpenWifi {
 
-	EventBusManager::EventBusManager(Poco::Logger &L) : Logger_(L) {}
-
 	void EventBusManager::run() {
 		Running_ = true;
 		Utils::SetThreadName("fmwk:EventMgr");
@@ -18,9 +16,9 @@ namespace OpenWifi {
 		KafkaManager()->PostMessage(KafkaTopics::SERVICE_EVENTS, MicroServicePrivateEndPoint(), Msg,
 									false);
 		while (Running_) {
-			Poco::Thread::trySleep((unsigned long)MicroServiceDaemonBusTimer());
-			if (!Running_)
-				break;
+			if(!Poco::Thread::trySleep((unsigned long)MicroServiceDaemonBusTimer())) {
+                break;
+            }
 			Msg = (MicroServiceMakeSystemEventMessage(KafkaTopics::ServiceEvents::EVENT_KEEP_ALIVE));
 			KafkaManager()->PostMessage(KafkaTopics::SERVICE_EVENTS, MicroServicePrivateEndPoint(),
 										Msg, false);
@@ -31,7 +29,7 @@ namespace OpenWifi {
 	};
 
 	void EventBusManager::Start() {
-		poco_information(Logger(), "Starting...");
+		poco_information(Logger_, "Starting...");
 		if (KafkaManager()->Enabled()) {
 			Thread_.start(*this);
 		}
@@ -39,11 +37,11 @@ namespace OpenWifi {
 
 	void EventBusManager::Stop() {
 		if (KafkaManager()->Enabled()) {
-			poco_information(Logger(), "Stopping...");
+			poco_information(Logger_, "Stopping...");
 			Running_ = false;
 			Thread_.wakeUp();
 			Thread_.join();
-			poco_information(Logger(), "Stopped...");
+			poco_information(Logger_, "Stopped...");
 		}
 	}
 
diff --git a/src/framework/EventBusManager.h b/src/framework/EventBusManager.h
index 9a7316e9..4982fb44 100644
--- a/src/framework/EventBusManager.h
+++ b/src/framework/EventBusManager.h
@@ -12,7 +12,16 @@ namespace OpenWifi {
 
 	class EventBusManager : public Poco::Runnable {
 	  public:
-		explicit EventBusManager(Poco::Logger &L);
+		EventBusManager() :
+			Logger_(Poco::Logger::create(
+				"EventBusManager", Poco::Logger::root().getChannel(), Poco::Logger::root().getLevel())) {
+		}
+
+		static auto instance() {
+			static auto instance_ = new EventBusManager;
+			return instance_;
+		}
+
 		void run() final;
 		void Start();
 		void Stop();
@@ -24,4 +33,6 @@ namespace OpenWifi {
 		Poco::Logger &Logger_;
 	};
 
+	inline auto EventBusManager() { return EventBusManager::instance(); }
+
 } // namespace OpenWifi
diff --git a/src/framework/KafkaManager.cpp b/src/framework/KafkaManager.cpp
index f2936e7d..96057369 100644
--- a/src/framework/KafkaManager.cpp
+++ b/src/framework/KafkaManager.cpp
@@ -79,8 +79,10 @@ namespace OpenWifi {
 		Utils::SetThreadName("Kafka:Prod");
 		cppkafka::Configuration Config(
 			{{"client.id", MicroServiceConfigGetString("openwifi.kafka.client.id", "")},
-			 {"metadata.broker.list",
-			  MicroServiceConfigGetString("openwifi.kafka.brokerlist", "")}});
+			 {"metadata.broker.list",MicroServiceConfigGetString("openwifi.kafka.brokerlist", "")} // ,
+			 // {"send.buffer.bytes", KafkaManager()->KafkaManagerMaximumPayloadSize() }
+			}
+ 		);
 
 		AddKafkaSecurity(Config);
 
@@ -275,6 +277,7 @@ namespace OpenWifi {
 	int KafkaManager::Start() {
 		if (!KafkaEnabled_)
 			return 0;
+		MaxPayloadSize_ = MicroServiceConfigGetInt("openwifi.kafka.max.payload", 250000);
 		ConsumerThr_.Start();
 		ProducerThr_.Start();
 		return 0;
diff --git a/src/framework/KafkaManager.h b/src/framework/KafkaManager.h
index e6272d33..75b9aa69 100644
--- a/src/framework/KafkaManager.h
+++ b/src/framework/KafkaManager.h
@@ -94,11 +94,14 @@ namespace OpenWifi {
 			return ConsumerThr_.UnregisterTopicWatcher(Topic,Id);
 		}
 
+		std::uint64_t KafkaManagerMaximumPayloadSize() const { return MaxPayloadSize_; }
+
 	  private:
 		bool KafkaEnabled_ = false;
 		std::string SystemInfoWrapper_;
 		KafkaProducer ProducerThr_;
 		KafkaConsumer ConsumerThr_;
+		std::uint64_t MaxPayloadSize_ = 250000;
 
 		void PartitionAssignment(const cppkafka::TopicPartitionList &partitions);
 		void PartitionRevocation(const cppkafka::TopicPartitionList &partitions);
diff --git a/src/framework/MicroService.cpp b/src/framework/MicroService.cpp
index 5d517d9f..71a187ec 100644
--- a/src/framework/MicroService.cpp
+++ b/src/framework/MicroService.cpp
@@ -1,4 +1,5 @@
 //
+//
 // Created by stephane bourque on 2022-10-26.
 //
 
@@ -29,13 +30,29 @@
 #include "framework/WebSocketLogger.h"
 #include "framework/utils.h"
 
+#ifdef  USE_MEDUSA_CLIENT
+#include <medusa/MedusaClient.h>
+#endif
+
 namespace OpenWifi {
 
-	void MicroService::Exit(int Reason) { std::exit(Reason); }
+	static std::string MakeServiceListString(const Types::MicroServiceMetaMap &Services) {
+        std::string SvcList;
+        for (const auto &Svc : Services) {
+            if (SvcList.empty())
+                SvcList = Svc.second.Type;
+            else
+                SvcList += ", " + Svc.second.Type;
+        }
+        return SvcList;
+    }
 
 	void MicroService::BusMessageReceived([[maybe_unused]] const std::string &Key,
 										  const std::string &Payload) {
 		std::lock_guard G(InfraMutex_);
+
+		Poco::Logger &BusLogger = EventBusManager()->Logger();
+
 		try {
 			Poco::JSON::Parser P;
 			auto Object = P.parse(Payload).extract<Poco::JSON::Object::Ptr>();
@@ -55,13 +72,10 @@ namespace OpenWifi {
 							Object->has(KafkaTopics::ServiceEvents::Fields::KEY)) {
 							auto PrivateEndPoint =
 								Object->get(KafkaTopics::ServiceEvents::Fields::PRIVATE).toString();
-							if (Event == KafkaTopics::ServiceEvents::EVENT_KEEP_ALIVE &&
-								Services_.find(PrivateEndPoint) != Services_.end()) {
-								Services_[PrivateEndPoint].LastUpdate = Utils::Now();
-							} else if (Event == KafkaTopics::ServiceEvents::EVENT_LEAVE) {
+							if (Event == KafkaTopics::ServiceEvents::EVENT_LEAVE) {
 								Services_.erase(PrivateEndPoint);
-								poco_debug(
-									logger(),
+								poco_information(
+									BusLogger,
 									fmt::format(
 										"Service {} ID={} leaving system.",
 										Object->get(KafkaTopics::ServiceEvents::Fields::PRIVATE)
@@ -69,14 +83,7 @@ namespace OpenWifi {
 										ID));
 							} else if (Event == KafkaTopics::ServiceEvents::EVENT_JOIN ||
 									   Event == KafkaTopics::ServiceEvents::EVENT_KEEP_ALIVE) {
-								poco_debug(
-									logger(),
-									fmt::format(
-										"Service {} ID={} joining system.",
-										Object->get(KafkaTopics::ServiceEvents::Fields::PRIVATE)
-											.toString(),
-										ID));
-								Services_[PrivateEndPoint] = Types::MicroServiceMeta{
+								auto ServiceInfo = Types::MicroServiceMeta{
 									.Id = ID,
 									.Type = Poco::toLower(
 										Object->get(KafkaTopics::ServiceEvents::Fields::TYPE)
@@ -94,20 +101,46 @@ namespace OpenWifi {
 												   .toString(),
 									.LastUpdate = Utils::Now()};
 
-								std::string SvcList;
-								for (const auto &Svc : Services_) {
-									if (SvcList.empty())
-										SvcList = Svc.second.Type;
-									else
-										SvcList += ", " + Svc.second.Type;
+                                auto s1 = MakeServiceListString(Services_);
+								auto PreviousSize = Services_.size();
+								Services_[PrivateEndPoint] = ServiceInfo;
+								auto CurrentSize = Services_.size();
+								if(Event == KafkaTopics::ServiceEvents::EVENT_JOIN) {
+									if(!s1.empty()) {
+										poco_information(
+											BusLogger,
+											fmt::format(
+												"Service {} ID={} is joining the system.",
+												Object
+													->get(
+														KafkaTopics::ServiceEvents::Fields::PRIVATE)
+													.toString(),
+												ID));
+									}
+									std::string SvcList;
+									for (const auto &Svc : Services_) {
+										if (SvcList.empty())
+											SvcList = Svc.second.Type;
+										else
+											SvcList += ", " + Svc.second.Type;
+									}
+									poco_information(
+										BusLogger,
+										fmt::format("Current list of microservices: {}", SvcList));
+								} else if(CurrentSize!=PreviousSize) {
+									poco_information(
+										BusLogger,
+										fmt::format(
+											"Service {} ID={} is being added back in.",
+											Object
+												->get(KafkaTopics::ServiceEvents::Fields::PRIVATE)
+												.toString(),
+											ID));
 								}
-								poco_information(
-									logger(),
-									fmt::format("Current list of microservices: {}", SvcList));
 							}
 						} else {
-							poco_error(
-								logger(),
+							poco_information(
+								BusLogger,
 								fmt::format("KAFKA-MSG: invalid event '{}', missing a field.",
 											Event));
 						}
@@ -118,32 +151,39 @@ namespace OpenWifi {
 								Object->get(KafkaTopics::ServiceEvents::Fields::TOKEN).toString());
 #endif
 						} else {
-							poco_error(
-								logger(),
+							poco_information(
+								BusLogger,
 								fmt::format("KAFKA-MSG: invalid event '{}', missing token", Event));
 						}
 					} else {
-						poco_error(logger(),
+						poco_information(BusLogger,
 								   fmt::format("Unknown Event: {} Source: {}", Event, ID));
 					}
 				}
 			} else {
-				poco_error(logger(), "Bad bus message.");
-                std::ostringstream os;
-                Object->stringify(std::cout);
+				std::ostringstream os;
+				Object->stringify(std::cout);
+				poco_error(BusLogger, fmt::format("Bad bus message: {}", os.str()));
 			}
 
-			auto i = Services_.begin();
+			auto ServiceHint = Services_.begin();
 			auto now = Utils::Now();
-			for (; i != Services_.end();) {
-				if ((now - i->second.LastUpdate) > 60) {
-					i = Services_.erase(i);
+            auto si1 = Services_.size();
+            auto ss1 = MakeServiceListString(Services_);
+			while(ServiceHint!=Services_.end()) {
+				if ((now - ServiceHint->second.LastUpdate) > 120) {
+					poco_information(BusLogger, fmt::format("ZombieService: Removing service {}, ", ServiceHint->second.PublicEndPoint));
+					ServiceHint = Services_.erase(ServiceHint);
 				} else
-					++i;
+					++ServiceHint;
 			}
+            if(Services_.size() != si1) {
+                auto ss2 = MakeServiceListString(Services_);
+                poco_information(BusLogger, fmt::format("Current list of microservices: {} -> {}", ss1, ss2));
+            }
 
 		} catch (const Poco::Exception &E) {
-			logger().log(E);
+			BusLogger.log(E);
 		}
 	}
 
@@ -167,25 +207,29 @@ namespace OpenWifi {
 			Res.push_back(ServiceRec);
 		}
 		return Res;
+
 	}
 
 	void MicroService::LoadConfigurationFile() {
-		std::string Location = Poco::Environment::get(DAEMON_CONFIG_ENV_VAR, ".");
-		ConfigFileName_ =
-			ConfigFileName_.empty() ? Location + "/" + DAEMON_PROPERTIES_FILENAME : ConfigFileName_;
-		Poco::Path ConfigFile(ConfigFileName_);
-
-		if (!ConfigFile.isFile()) {
-			std::cerr << DAEMON_APP_NAME << ": Configuration " << ConfigFile.toString()
-					  << " does not seem to exist. Please set " + DAEMON_CONFIG_ENV_VAR +
-							 " env variable the path of the " + DAEMON_PROPERTIES_FILENAME +
-							 " file."
-					  << std::endl;
-			std::exit(Poco::Util::Application::EXIT_CONFIG);
-		}
-
-		// 	    loadConfiguration(ConfigFile.toString());
-		PropConfigurationFile_ = new Poco::Util::PropertyFileConfiguration(ConfigFile.toString());
+        if(ConfigContent_.empty()) {
+            std::string Location = Poco::Environment::get(DAEMON_CONFIG_ENV_VAR, ".");
+            ConfigFileName_ =
+                ConfigFileName_.empty() ? Location + "/" + DAEMON_PROPERTIES_FILENAME : ConfigFileName_;
+            Poco::Path ConfigFile(ConfigFileName_);
+
+            if (!ConfigFile.isFile()) {
+                std::cerr << DAEMON_APP_NAME << ": Configuration " << ConfigFile.toString()
+                          << " does not seem to exist. Please set " + DAEMON_CONFIG_ENV_VAR +
+                                 " env variable the path of the " + DAEMON_PROPERTIES_FILENAME +
+                                 " file."
+                          << std::endl;
+                std::exit(Poco::Util::Application::EXIT_CONFIG);
+            }
+            PropConfigurationFile_ = new Poco::Util::PropertyFileConfiguration(ConfigFile.toString());
+        } else {
+            std::istringstream is(ConfigContent_);
+            PropConfigurationFile_ = new Poco::Util::PropertyFileConfiguration(is);
+        }
 		configPtr()->addWriteable(PropConfigurationFile_, PRIO_DEFAULT);
 	}
 
@@ -388,49 +432,69 @@ namespace OpenWifi {
 
 	void DaemonPostInitialization(Poco::Util::Application &self);
 
-	void MicroService::initialize(Poco::Util::Application &self) {
-		// add the default services
-		LoadConfigurationFile();
-		InitializeLoggingSystem();
-
-		SubSystems_.push_back(KafkaManager());
-		SubSystems_.push_back(ALBHealthCheckServer());
-		SubSystems_.push_back(RESTAPI_ExtServer());
-		SubSystems_.push_back(RESTAPI_IntServer());
+    void MicroService::StartEverything(Poco::Util::Application &self) {
+        LoadConfigurationFile();
+        InitializeLoggingSystem();
+
+        static bool InitializedBaseService=false;
+        if(!InitializedBaseService) {
+            InitializedBaseService = true;
+            SubSystems_.push_back(KafkaManager());
+            SubSystems_.push_back(ALBHealthCheckServer());
+            SubSystems_.push_back(RESTAPI_ExtServer());
+            SubSystems_.push_back(RESTAPI_IntServer());
 #ifndef TIP_SECURITY_SERVICE
-		SubSystems_.push_back(AuthClient());
+            SubSystems_.push_back(AuthClient());
 #endif
-		Poco::Net::initializeSSL();
-		Poco::Net::HTTPStreamFactory::registerFactory();
-		Poco::Net::HTTPSStreamFactory::registerFactory();
-		Poco::Net::FTPStreamFactory::registerFactory();
-		Poco::Net::FTPSStreamFactory::registerFactory();
-
-		Poco::File DataDir(ConfigPath("openwifi.system.data"));
-		DataDir_ = DataDir.path();
-		if (!DataDir.exists()) {
-			try {
-				DataDir.createDirectory();
-			} catch (const Poco::Exception &E) {
-				logger().log(E);
-			}
-		}
-		WWWAssetsDir_ = ConfigPath("openwifi.restapi.wwwassets", "");
-		if (WWWAssetsDir_.empty())
-			WWWAssetsDir_ = DataDir_;
-
-		LoadMyConfig();
 
-		AllowExternalMicroServices_ = ConfigGetBool("allowexternalmicroservices", true);
-
-		InitializeSubSystemServers();
-		ServerApplication::initialize(self);
-		DaemonPostInitialization(self);
-
-		Types::TopicNotifyFunction F = [this](const std::string &Key, const std::string &Payload) {
-			this->BusMessageReceived(Key, Payload);
-		};
-		KafkaManager()->RegisterTopicWatcher(KafkaTopics::SERVICE_EVENTS, F);
+            Poco::Net::initializeSSL();
+            Poco::Net::HTTPStreamFactory::registerFactory();
+            Poco::Net::HTTPSStreamFactory::registerFactory();
+            Poco::Net::FTPStreamFactory::registerFactory();
+            Poco::Net::FTPSStreamFactory::registerFactory();
+        }
+
+        Poco::File DataDir(ConfigPath("openwifi.system.data"));
+        DataDir_ = DataDir.path();
+        if (!DataDir.exists()) {
+            try {
+                DataDir.createDirectory();
+            } catch (const Poco::Exception &E) {
+                Logger_.log(E);
+            }
+        }
+        WWWAssetsDir_ = ConfigPath("openwifi.restapi.wwwassets", "");
+        if (WWWAssetsDir_.empty())
+            WWWAssetsDir_ = DataDir_;
+
+        LoadMyConfig();
+
+        AllowExternalMicroServices_ = ConfigGetBool("allowexternalmicroservices", true);
+
+        InitializeSubSystemServers();
+        ServerApplication::initialize(self);
+        DaemonPostInitialization(self);
+
+        Types::TopicNotifyFunction F = [this](const std::string &Key, const std::string &Payload) {
+            this->BusMessageReceived(Key, Payload);
+        };
+        KafkaManager()->RegisterTopicWatcher(KafkaTopics::SERVICE_EVENTS, F);
+    }
+
+    void MicroService::StopEverything([[maybe_unused]] Poco::Util::Application &self) {
+        LoadConfigurationFile();
+        InitializeLoggingSystem();
+
+        Types::TopicNotifyFunction F = [this](const std::string &Key, const std::string &Payload) {
+            this->BusMessageReceived(Key, Payload);
+        };
+        KafkaManager()->RegisterTopicWatcher(KafkaTopics::SERVICE_EVENTS, F);
+    }
+
+    void MicroService::initialize([[maybe_unused]] Poco::Util::Application &self) {
+#ifndef USE_MEDUSA_CLIENT
+        StartEverything(self);
+#endif
 	}
 
 	void MicroService::uninitialize() {
@@ -530,14 +594,12 @@ namespace OpenWifi {
 		for (auto i : SubSystems_) {
 			i->Start();
 		}
-		EventBusManager_ = std::make_unique<EventBusManager>(Poco::Logger::create(
-			"EventBusManager", Poco::Logger::root().getChannel(), Poco::Logger::root().getLevel()));
-		EventBusManager_->Start();
+		EventBusManager()->Start();
 	}
 
 	void MicroService::StopSubSystemServers() {
 		AddActivity("Stopping");
-		EventBusManager_->Stop();
+		EventBusManager()->Stop();
 		for (auto i = SubSystems_.rbegin(); i != SubSystems_.rend(); ++i) {
 			(*i)->Stop();
 		}
@@ -697,7 +759,7 @@ namespace OpenWifi {
 			auto APIKEY = Request.get("X-API-KEY");
 			return APIKEY == MyHash_;
 		} catch (const Poco::Exception &E) {
-			logger().log(E);
+			Logger_.log(E);
 		}
 		return false;
 	}
@@ -718,6 +780,8 @@ namespace OpenWifi {
 		MicroServiceErrorHandler ErrorHandler(*this);
 		Poco::ErrorHandler::set(&ErrorHandler);
 
+        Args_ = args;
+
 		if (!HelpRequested_) {
 			SavePID();
 
@@ -733,11 +797,18 @@ namespace OpenWifi {
 				poco_information(logger, "Starting as a daemon.");
 			}
 
+#ifdef USE_MEDUSA_CLIENT
+            MedusaClient::instance()->SetSubSystems(SubSystems_);
+            MedusaClient::instance()->Start();
+			waitForTerminationRequest();
+            MedusaClient::instance()->Stop();
+#else
 			poco_information(logger, fmt::format("System ID set to {}", ID_));
 			StartSubSystemServers();
 			waitForTerminationRequest();
 			StopSubSystemServers();
 			logger.notice(fmt::format("Stopped {}...", DAEMON_APP_NAME));
+#endif
 		}
 
 		return Application::EXIT_OK;
diff --git a/src/framework/MicroService.h b/src/framework/MicroService.h
index 00532b47..a991316f 100644
--- a/src/framework/MicroService.h
+++ b/src/framework/MicroService.h
@@ -55,9 +55,6 @@ namespace OpenWifi {
 #include "nlohmann/json.hpp"
 #include "ow_version.h"
 
-#define _OWDEBUG_ std::cout << __FILE__ << ":" << __LINE__ << std::endl;
-// #define _OWDEBUG_ Logger().debug(Poco::format("%s: %lu",__FILE__,__LINE__));
-
 namespace OpenWifi {
 
 	class MicroService : public Poco::Util::ServerApplication {
@@ -70,7 +67,6 @@ namespace OpenWifi {
 			  SubSystems_(std::move(Subsystems)), Logger_(Poco::Logger::get("FRAMEWORK")) {
 			instance_ = this;
 			RandomEngine_.seed(std::chrono::steady_clock::now().time_since_epoch().count());
-			// Logger_ = Poco::Logger::root().get("BASE-SVC");
 		}
 
 		inline static const char *ExtraConfigurationFilename = "/configuration_override.json";
@@ -92,7 +88,7 @@ namespace OpenWifi {
 		inline uint64_t DaemonBusTimer() const { return DAEMON_BUS_TIMER; };
 		[[nodiscard]] const std::string &AppName() { return DAEMON_APP_NAME; }
 		static inline uint64_t GetPID() { return Poco::Process::id(); };
-		[[nodiscard]] inline const std::string GetPublicAPIEndPoint() {
+		[[nodiscard]] inline std::string GetPublicAPIEndPoint() const {
 			return MyPublicEndPoint_ + "/api/v1";
 		};
 		[[nodiscard]] inline const std::string &GetUIURI() const { return UIURI_; };
@@ -107,7 +103,8 @@ namespace OpenWifi {
 		}
 		static MicroService &instance() { return *instance_; }
 
-		inline void Exit(int Reason);
+		inline void Exit(int Reason) { std::exit(Reason); }
+
 		void BusMessageReceived(const std::string &Key, const std::string &Payload);
 		Types::MicroServiceMetaVec GetServices(const std::string &Type);
 		Types::MicroServiceMetaVec GetServices();
@@ -115,7 +112,9 @@ namespace OpenWifi {
 		void Reload();
 		void LoadMyConfig();
 		void initialize(Poco::Util::Application &self) override;
-		void uninitialize() override;
+        void StartEverything(Poco::Util::Application &self);
+        void StopEverything(Poco::Util::Application &self);
+        void uninitialize() override;
 		void reinitialize(Poco::Util::Application &self) override;
 		void defineOptions(Poco::Util::OptionSet &options) override;
 		void handleHelp(const std::string &name, const std::string &value);
@@ -132,7 +131,7 @@ namespace OpenWifi {
 		void Reload(const std::string &Sub);
 		Types::StringVec GetSubSystems() const;
 		Types::StringPairVec GetLogLevels();
-		const Types::StringVec &GetLogLevelNames();
+		static const Types::StringVec &GetLogLevelNames();
 		uint64_t ConfigGetInt(const std::string &Key, uint64_t Default);
 		uint64_t ConfigGetInt(const std::string &Key);
 		uint64_t ConfigGetBool(const std::string &Key, bool Default);
@@ -166,12 +165,25 @@ namespace OpenWifi {
 								const std::string &FormatterPattern,
 								const std::string &root_env_var);
 		inline bool AllowExternalMicroServices() const { return AllowExternalMicroServices_; }
+        const ArgVec &Args() const { return Args_; }
+
+        inline void SetConfigContent(const std::string &Content) { ConfigContent_ = Content; }
+
+        inline std::optional<OpenWifi::Types::MicroServiceMeta> GetPrivateEndPointServiceKey( const std::string & ServicePrivateEndPoint ) {
+            std::lock_guard   G(InfraMutex_);
+            auto K = Services_.find(ServicePrivateEndPoint);
+            if(K==end(Services_)) {
+                return std::nullopt;
+            }
+            return K->second;
+        }
 
 	  private:
 		static MicroService *instance_;
 		bool HelpRequested_ = false;
 		std::string LogDir_;
 		std::string ConfigFileName_;
+        std::string ConfigContent_;
 		uint64_t ID_ = 1;
 		Poco::SharedPtr<Poco::Crypto::RSAKey> AppKey_;
 		bool DebugMode_ = false;
@@ -201,7 +213,7 @@ namespace OpenWifi {
 		Poco::JWT::Signer Signer_;
 		Poco::Logger &Logger_;
 		Poco::ThreadPool TimerPool_{"timer:pool", 2, 32};
-		std::unique_ptr<EventBusManager> EventBusManager_;
+        ArgVec Args_;
 	};
 
 	inline MicroService *MicroService::instance_ = nullptr;
diff --git a/src/framework/MicroServiceFuncs.cpp b/src/framework/MicroServiceFuncs.cpp
index 6ebf457d..3bebe185 100644
--- a/src/framework/MicroServiceFuncs.cpp
+++ b/src/framework/MicroServiceFuncs.cpp
@@ -133,4 +133,8 @@ namespace OpenWifi {
 		return MicroService::instance().Hash();
 	}
 
+    std::optional<OpenWifi::Types::MicroServiceMeta> MicroServicePrivateAccessKey(const std::string &servicePrivateEndPoint) {
+        return MicroService::instance().GetPrivateEndPointServiceKey(servicePrivateEndPoint);
+    }
+
 } // namespace OpenWifi
diff --git a/src/framework/MicroServiceFuncs.h b/src/framework/MicroServiceFuncs.h
index 5ceebb6c..2d22392e 100644
--- a/src/framework/MicroServiceFuncs.h
+++ b/src/framework/MicroServiceFuncs.h
@@ -23,7 +23,9 @@ namespace OpenWifi {
 	std::string MicroServiceConfigGetString(const std::string &Key,
 											const std::string &DefaultValue);
 	std::string MicroServiceAccessKey();
-	bool MicroServiceConfigGetBool(const std::string &Key, bool DefaultValue);
+    std::optional<OpenWifi::Types::MicroServiceMeta> MicroServicePrivateAccessKey(const std::string &servicePrivateEndPoint);
+
+    bool MicroServiceConfigGetBool(const std::string &Key, bool DefaultValue);
 	std::uint64_t MicroServiceConfigGetInt(const std::string &Key, std::uint64_t DefaultValue);
 	std::string MicroServicePrivateEndPoint();
 	std::uint64_t MicroServiceID();
diff --git a/src/framework/StorageClass.h b/src/framework/StorageClass.h
index cfb55304..36751bc6 100644
--- a/src/framework/StorageClass.h
+++ b/src/framework/StorageClass.h
@@ -47,6 +47,8 @@ namespace OpenWifi {
 
         }
 
+		Poco::Data::SessionPool &Pool() { return *Pool_; }
+
 	  private:
 		inline int Setup_SQLite();
 		inline int Setup_MySQL();
diff --git a/src/framework/UI_WebSocketClientServer.cpp b/src/framework/UI_WebSocketClientServer.cpp
index 37c426fd..eb5b0b7d 100644
--- a/src/framework/UI_WebSocketClientServer.cpp
+++ b/src/framework/UI_WebSocketClientServer.cpp
@@ -58,11 +58,9 @@ namespace OpenWifi {
 	void UI_WebSocketClientServer::run() {
 		Running_ = true;
 		while (Running_) {
-			Poco::Thread::trySleep(2000);
-
-			if (!Running_)
-				break;
-
+			if(!Poco::Thread::trySleep(2000)) {
+                break;
+            }
 			std::lock_guard G(LocalMutex_);
 			for (const auto i : ToBeRemoved_) {
 				// std::cout << "Erasing old WS UI connection..." << std::endl;
diff --git a/src/framework/default_device_types.h b/src/framework/default_device_types.h
index 02941db4..c19cd3fb 100644
--- a/src/framework/default_device_types.h
+++ b/src/framework/default_device_types.h
@@ -7,57 +7,59 @@
 #include <vector>
 #include <string>
 
+#include "ow_constants.h"
+
 namespace OpenWifi {
 	inline  const std::vector<std::pair<std::string, std::string>> DefaultDeviceTypeList{
-		{"actiontec_web7200", "AP"},
-		{"cig_wf186w", "AP"},
-		{"cig_wf188n", "AP"},
-		{"cig_wf194c4", "AP"},
-		{"cig_wf196", "AP"},
-		{"cig_wf196-ca", "AP"},
-		{"cig_wf196-ca-ath12", "AP"},
-		{"cig_wf196-us", "AP"},
-		{"cig_wf610d", "AP"},
-		{"cig_wf660a", "AP"},
-		{"cig_wf808", "AP"},
-		{"cybertan_eww622-a1", "AP"},
-		{"edgecore_eap101", "AP"},
-		{"edgecore_eap101-ath12", "AP"},
-		{"edgecore_eap102", "AP"},
-		{"edgecore_eap104", "AP"},
-		{"edgecore_eap104-ath12", "AP"},
-		{"edgecore_ecs4100-12ph", "AP"},
-		{"edgecore_ecw5211", "AP"},
-		{"edgecore_ecw5410", "AP"},
-		{"edgecore_oap100", "AP"},
-		{"edgecore_spw2ac1200", "SWITCH"},
-		{"edgecore_spw2ac1200-lan-poe", "SWITCH"},
-		{"edgecore_ssw2ac2600", "SWITCH"},
-		{"hfcl_ion4", "AP"},
-		{"hfcl_ion4x", "AP"},
-		{"hfcl_ion4x_2", "AP"},
-		{"hfcl_ion4xe", "AP"},
-		{"hfcl_ion4xi", "AP"},
-		{"indio_um-305ac", "AP"},
-		{"indio_um-305ax", "AP"},
-		{"indio_um-310ax-v1", "AP"},
-		{"indio_um-325ac", "AP"},
-		{"indio_um-510ac-v3", "AP"},
-		{"indio_um-510axm-v1", "AP"},
-		{"indio_um-510axp-v1", "AP"},
-		{"indio_um-550ac", "AP"},
-		{"linksys_e8450-ubi", "AP"},
-		{"linksys_ea6350-v4", "AP"},
-		{"linksys_ea8300", "AP"},
-		{"liteon_wpx8324", "AP"},
-		{"meshpp_s618_cp01", "AP"},
-		{"meshpp_s618_cp03", "AP"},
-		{"udaya_a5-id2", "AP"},
-		{"wallys_dr40x9", "AP"},
-		{"wallys_dr6018", "AP"},
-		{"wallys_dr6018_v4", "AP"},
-		{"x64_vm", "AP"},
-		{"yuncore_ax840", "AP"},
-		{"yuncore_fap640", "AP"},
-		{"yuncore_fap650", "AP"}};
+		{"actiontec_web7200", Platforms::AP},
+		{"cig_wf186w", Platforms::AP},
+		{"cig_wf188n", Platforms::AP},
+		{"cig_wf194c4", Platforms::AP},
+		{"cig_wf196", Platforms::AP},
+		{"cig_wf196-ca", Platforms::AP},
+		{"cig_wf196-ca-ath12", Platforms::AP},
+		{"cig_wf196-us", Platforms::AP},
+		{"cig_wf610d", Platforms::AP},
+		{"cig_wf660a", Platforms::AP},
+		{"cig_wf808", Platforms::AP},
+		{"cybertan_eww622-a1", Platforms::AP},
+		{"edgecore_eap101", Platforms::AP},
+		{"edgecore_eap101-ath12", Platforms::AP},
+		{"edgecore_eap102", Platforms::AP},
+		{"edgecore_eap104", Platforms::AP},
+		{"edgecore_eap104-ath12", Platforms::AP},
+		{"edgecore_ecs4100-12ph", Platforms::AP},
+		{"edgecore_ecw5211", Platforms::AP},
+		{"edgecore_ecw5410", Platforms::AP},
+		{"edgecore_oap100", Platforms::AP},
+		{"edgecore_spw2ac1200", Platforms::SWITCH},
+		{"edgecore_spw2ac1200-lan-poe", Platforms::SWITCH},
+		{"edgecore_ssw2ac2600", Platforms::SWITCH},
+		{"hfcl_ion4", Platforms::AP},
+		{"hfcl_ion4x", Platforms::AP},
+		{"hfcl_ion4x_2", Platforms::AP},
+		{"hfcl_ion4xe", Platforms::AP},
+		{"hfcl_ion4xi", Platforms::AP},
+		{"indio_um-305ac", Platforms::AP},
+		{"indio_um-305ax", Platforms::AP},
+		{"indio_um-310ax-v1", Platforms::AP},
+		{"indio_um-325ac", Platforms::AP},
+		{"indio_um-510ac-v3", Platforms::AP},
+		{"indio_um-510axm-v1", Platforms::AP},
+		{"indio_um-510axp-v1", Platforms::AP},
+		{"indio_um-550ac", Platforms::AP},
+		{"linksys_e8450-ubi", Platforms::AP},
+		{"linksys_ea6350-v4", Platforms::AP},
+		{"linksys_ea8300", Platforms::AP},
+		{"liteon_wpx8324", Platforms::AP},
+		{"meshpp_s618_cp01", Platforms::AP},
+		{"meshpp_s618_cp03", Platforms::AP},
+		{"udaya_a5-id2", Platforms::AP},
+		{"wallys_dr40x9", Platforms::AP},
+		{"wallys_dr6018", Platforms::AP},
+		{"wallys_dr6018_v4", Platforms::AP},
+		{"x64_vm", Platforms::AP},
+		{"yuncore_ax840", Platforms::AP},
+		{"yuncore_fap640", Platforms::AP},
+		{"yuncore_fap650", Platforms::AP}};
 }
diff --git a/src/framework/orm.h b/src/framework/orm.h
index 9e83540f..c0be1373 100644
--- a/src/framework/orm.h
+++ b/src/framework/orm.h
@@ -576,8 +576,8 @@ namespace ORM {
 		bool UpdateRecord(field_name_t FieldName, const T &Value, const RecordType &R) {
 			try {
 				assert(ValidFieldName(FieldName));
-
 				Poco::Data::Session Session = Pool_.get();
+                Session.begin();
 				Poco::Data::Statement Update(Session);
 
 				RecordTuple RT;
@@ -593,6 +593,7 @@ namespace ORM {
 				Update.execute();
 				if (Cache_)
 					Cache_->UpdateCache(R);
+                Session.commit();
 				return true;
 			} catch (const Poco::Exception &E) {
 				Logger_.log(E);
@@ -662,6 +663,7 @@ namespace ORM {
 				assert(ValidFieldName(FieldName));
 
 				Poco::Data::Session Session = Pool_.get();
+                Session.begin();
 				Poco::Data::Statement Delete(Session);
 
 				std::string St = "delete from " + TableName_ + " where " + FieldName + "=?";
@@ -671,6 +673,7 @@ namespace ORM {
 				Delete.execute();
 				if (Cache_)
 					Cache_->Delete(FieldName, Value);
+                Session.commit();
 				return true;
 			} catch (const Poco::Exception &E) {
 				Logger_.log(E);
@@ -682,11 +685,13 @@ namespace ORM {
 			try {
 				assert(!WhereClause.empty());
 				Poco::Data::Session Session = Pool_.get();
+                Session.begin();
 				Poco::Data::Statement Delete(Session);
 
 				std::string St = "delete from " + TableName_ + " where " + WhereClause;
 				Delete << St;
 				Delete.execute();
+                Session.commit();
 				return true;
 			} catch (const Poco::Exception &E) {
 				Logger_.log(E);
diff --git a/src/framework/ow_constants.h b/src/framework/ow_constants.h
index ed4e246b..2e838ff2 100644
--- a/src/framework/ow_constants.h
+++ b/src/framework/ow_constants.h
@@ -565,6 +565,7 @@ namespace OpenWifi::RESTAPI::Protocol {
 
 	static const char *TRANSFER = "transfer";
 	static const char *CERTUPDATE = "certupdate";
+	static const char *POWERCYCLE = "powercycle";
 	static const char *RRM = "rrm";
 
 	static const char *REQUIREMENTS = "requirements";
@@ -687,6 +688,7 @@ namespace OpenWifi::uCentralProtocol {
 
 	static const char *TRANSFER = "transfer";
 	static const char *CERTUPDATE = "certupdate";
+	static const char *POWERCYCLE = "powercycle";
 	static const char *RRM = "rrm";
 	static const char *ACTIONS = "actions";
 
@@ -785,6 +787,7 @@ namespace OpenWifi::APCommands {
 		rrm,
 		certupdate,
 		transfer,
+		powercycle,
 		unknown
 	};
 
@@ -799,7 +802,7 @@ namespace OpenWifi::APCommands {
 		RESTAPI::Protocol::EVENTQUEUE,	 RESTAPI::Protocol::TELEMETRY,
 		RESTAPI::Protocol::PING,		 RESTAPI::Protocol::SCRIPT,
 		RESTAPI::Protocol::RRM,		 	 RESTAPI::Protocol::CERTUPDATE,
-		RESTAPI::Protocol::TRANSFER
+		RESTAPI::Protocol::TRANSFER,	 RESTAPI::Protocol::POWERCYCLE
 	};
 
 	inline const char *to_string(Commands Cmd) { return uCentralAPCommands[(uint8_t)Cmd]; }
@@ -828,6 +831,11 @@ namespace OpenWifi::Provisioning::DeviceClass {
 
 } // namespace OpenWifi::Provisioning::DeviceClass
 
+namespace OpenWifi::Platforms {
+	static const std::string AP = "ap";
+	static const std::string SWITCH = "switch";
+}
+
 #if defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
diff --git a/src/framework/utils.h b/src/framework/utils.h
index d5357de7..b20d32af 100644
--- a/src/framework/utils.h
+++ b/src/framework/utils.h
@@ -126,20 +126,6 @@ namespace OpenWifi::Utils {
 
 	[[nodiscard]] std::uint64_t ConvertDate(const std::string &d);
 
-	[[nodiscard]] inline uint8_t CalculateMacAddressHash(std::uint64_t value) {
-		uint8_t hash = 0, i=6;
-		while(i) {
-			hash ^= (value & 0xFF) + 1;
-			value >>= 8;
-			--i;
-		}
-		return hash;
-	}
-
-	[[nodiscard]] inline uint8_t CalculateMacAddressHash(const std::string & value) {
-		return CalculateMacAddressHash(MACToInt(value));
-	}
-
 	template <typename T> std::string int_to_hex(T i) {
 		std::stringstream stream;
 		stream << std::setfill('0') << std::setw(12) << std::hex << i;
@@ -330,5 +316,90 @@ namespace OpenWifi::Utils {
         uint32_t        Port;
     };
 
+	class CompressedString {
+	  public:
+		CompressedString() {
+			DecompressedSize_ = 0;
+		};
+
+		explicit CompressedString(const std::string &Data) : DecompressedSize_(Data.size()) {
+			CompressIt(Data);
+		}
+
+		CompressedString(const CompressedString &Data) {
+			this->DecompressedSize_ = Data.DecompressedSize_;
+			this->CompressedData_ = Data.CompressedData_;
+		}
+
+		CompressedString& operator=(const CompressedString& rhs) {
+			if (this != &rhs) {
+				this->DecompressedSize_ = rhs.DecompressedSize_;
+				this->CompressedData_ = rhs.CompressedData_;
+			}
+			return *this;
+		}
+
+		CompressedString& operator=(CompressedString&& rhs) {
+			if (this != &rhs) {
+				this->DecompressedSize_ = rhs.DecompressedSize_;
+				this->CompressedData_ = rhs.CompressedData_;
+			}
+			return *this;
+		}
+
+		~CompressedString() = default;
+
+		operator std::string() const {
+			return DecompressIt();
+		}
+
+		CompressedString &operator=(const std::string &Data) {
+			DecompressedSize_ = Data.size();
+			CompressIt(Data);
+			return *this;
+		}
+
+		auto CompressedSize() const { return CompressedData_.size(); }
+		auto DecompressedSize() const { return DecompressedSize_; }
+
+	  private:
+		std::string     CompressedData_;
+		std::size_t     DecompressedSize_;
+
+		inline void CompressIt(const std::string &Data) {
+			z_stream strm; // = {0};
+			CompressedData_.resize(Data.size());
+			strm.next_in = (Bytef *)Data.data();
+			strm.avail_in = Data.size();
+			strm.next_out = (Bytef *)CompressedData_.data();
+			strm.avail_out = Data.size();
+			strm.zalloc = Z_NULL;
+			strm.zfree = Z_NULL;
+			strm.opaque = Z_NULL;
+			deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 + 16, 8, Z_DEFAULT_STRATEGY);
+			deflate(&strm, Z_FINISH);
+			deflateEnd(&strm);
+			CompressedData_.resize(strm.total_out);
+		}
+
+		[[nodiscard]] std::string DecompressIt() const {
+			std::string Result;
+			if(DecompressedSize_!=0) {
+				Result.resize(DecompressedSize_);
+				z_stream strm ; //= {0};
+				strm.next_in = (Bytef *)CompressedData_.data();
+				strm.avail_in = CompressedData_.size();
+				strm.next_out = (Bytef *)Result.data();
+				strm.avail_out = Result.size();
+				strm.zalloc = Z_NULL;
+				strm.zfree = Z_NULL;
+				strm.opaque = Z_NULL;
+				inflateInit2(&strm, 15 + 32);
+				inflate(&strm, Z_FINISH);
+				inflateEnd(&strm);
+			}
+			return Result;
+		}
+	};
 
 } // namespace OpenWifi::Utils
diff --git a/src/rttys/RTTYS_server.cpp b/src/rttys/RTTYS_server.cpp
index a84d05a6..e71d34b0 100644
--- a/src/rttys/RTTYS_server.cpp
+++ b/src/rttys/RTTYS_server.cpp
@@ -146,7 +146,7 @@ namespace OpenWifi {
 
 				auto WebClientSecureContext =
 					new Poco::Net::Context(Poco::Net::Context::SERVER_USE, KeyFileName,
-										   CertFileName, "", Poco::Net::Context::VERIFY_RELAXED);
+										   CertFileName, "", Poco::Net::Context::VERIFY_NONE);
 				Poco::Crypto::X509Certificate WebRoot(RootCaFileName);
 				WebClientSecureContext->addCertificateAuthority(WebRoot);
 				WebClientSecureContext->disableStatelessSessionResumption();
diff --git a/src/storage/storage_blacklist.cpp b/src/storage/storage_blacklist.cpp
index e7b2242d..00662415 100644
--- a/src/storage/storage_blacklist.cpp
+++ b/src/storage/storage_blacklist.cpp
@@ -56,10 +56,10 @@ namespace OpenWifi {
 	struct DeviceDetails {
 		std::string reason;
 		std::string author;
-		std::uint64_t created;
+		std::uint64_t created=Utils::Now();
 	};
 
-	static std::map<std::string, DeviceDetails> BlackListDevices;
+	static std::map<std::uint64_t , DeviceDetails> BlackListDevices;
 	static std::recursive_mutex BlackListMutex;
 
 	bool Storage::InitializeBlackListCache() {
@@ -78,7 +78,7 @@ namespace OpenWifi {
 				auto Reason = RSet[1].convert<std::string>();
 				auto Author = RSet[2].convert<std::string>();
 				auto Created = RSet[3].convert<std::uint64_t>();
-				BlackListDevices[SerialNumber] =
+				BlackListDevices[Utils::MACToInt(SerialNumber)] =
 					DeviceDetails{.reason = Reason, .author = Author, .created = Created};
 				More = RSet.moveNext();
 			}
@@ -93,6 +93,7 @@ namespace OpenWifi {
 	bool Storage::AddBlackListDevice(GWObjects::BlackListedDevice &Device) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Insert(Sess);
 
 			std::string St{"INSERT INTO BlackList (" + DB_BlackListDeviceSelectFields + ") " +
@@ -102,9 +103,9 @@ namespace OpenWifi {
 			ConvertBlackListDeviceRecord(Device, T);
 			Insert << ConvertParams(St), Poco::Data::Keywords::use(T);
 			Insert.execute();
-
+			Sess.commit();
 			std::lock_guard G(BlackListMutex);
-			BlackListDevices[Device.serialNumber] = DeviceDetails{
+			BlackListDevices[Utils::MACToInt(Device.serialNumber)] = DeviceDetails{
 				.reason = Device.reason, .author = Device.author, .created = Device.created};
 			return true;
 		} catch (const Poco::Exception &E) {
@@ -130,6 +131,7 @@ namespace OpenWifi {
 	bool Storage::DeleteBlackListDevice(std::string &SerialNumber) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Delete(Sess);
 
 			std::string St{"DELETE FROM BlackList WHERE SerialNumber=?"};
@@ -137,9 +139,9 @@ namespace OpenWifi {
 			Poco::toLowerInPlace(SerialNumber);
 			Delete << ConvertParams(St), Poco::Data::Keywords::use(SerialNumber);
 			Delete.execute();
-
+			Sess.commit();
 			std::lock_guard G(BlackListMutex);
-			BlackListDevices.erase(SerialNumber);
+			BlackListDevices.erase(Utils::MACToInt(SerialNumber));
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
@@ -177,6 +179,7 @@ namespace OpenWifi {
 										GWObjects::BlackListedDevice &Device) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
 
 			std::string St{"UPDATE BlackList SET " + DB_BlackListDeviceUpdateFields +
@@ -187,9 +190,9 @@ namespace OpenWifi {
 			Update << ConvertParams(St), Poco::Data::Keywords::use(T),
 				Poco::Data::Keywords::use(SerialNumber);
 			Update.execute();
-
+			Sess.commit();
 			std::lock_guard G(BlackListMutex);
-			BlackListDevices[Device.serialNumber] = DeviceDetails{
+			BlackListDevices[Utils::MACToInt(Device.serialNumber)] = DeviceDetails{
 				.reason = Device.reason, .author = Device.author, .created = Device.created};
 
 			return true;
@@ -233,10 +236,10 @@ namespace OpenWifi {
 		return BlackListDevices.size();
 	}
 
-	bool Storage::IsBlackListed(const std::string &SerialNumber, std::string &reason,
+	bool Storage::IsBlackListed(std::uint64_t SerialNumber, std::string &reason,
 								std::string &author, std::uint64_t &created) {
 		std::lock_guard G(BlackListMutex);
-		auto DeviceHint = BlackListDevices.find(Poco::toLower(SerialNumber));
+		auto DeviceHint = BlackListDevices.find(SerialNumber);
 		if (DeviceHint == end(BlackListDevices))
 			return false;
 		reason = DeviceHint->second.reason;
@@ -245,9 +248,9 @@ namespace OpenWifi {
 		return true;
 	}
 
-	bool Storage::IsBlackListed(const std::string &SerialNumber) {
+	bool Storage::IsBlackListed(std::uint64_t SerialNumber) {
 		std::lock_guard G(BlackListMutex);
-		auto DeviceHint = BlackListDevices.find(Poco::toLower(SerialNumber));
+		auto DeviceHint = BlackListDevices.find(SerialNumber);
 		return DeviceHint != end(BlackListDevices);
 	}
 } // namespace OpenWifi
\ No newline at end of file
diff --git a/src/storage/storage_capabilities.cpp b/src/storage/storage_capabilities.cpp
index 72d054e4..6ae96330 100644
--- a/src/storage/storage_capabilities.cpp
+++ b/src/storage/storage_capabilities.cpp
@@ -17,11 +17,11 @@
 
 namespace OpenWifi {
 
-	bool Storage::CreateDeviceCapabilities(std::string &SerialNumber,
+	bool Storage::CreateDeviceCapabilities(Poco::Data::Session &Session, std::string &SerialNumber,
 										   const Config::Capabilities &Capabilities) {
 		try {
-			Poco::Data::Session Sess = Pool_->get();
-			Poco::Data::Statement UpSert(Sess);
+			Session.begin();
+			Poco::Data::Statement UpSert(Session);
 
 			std::string TCaps{Capabilities.AsString()};
 			uint64_t Now = Utils::Now();
@@ -33,6 +33,7 @@ namespace OpenWifi {
 				Poco::Data::Keywords::use(Now), Poco::Data::Keywords::use(TCaps),
 				Poco::Data::Keywords::use(Now);
 			UpSert.execute();
+			Session.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
@@ -41,11 +42,11 @@ namespace OpenWifi {
 		return false;
 	}
 
-	bool Storage::UpdateDeviceCapabilities(std::string &SerialNumber,
+	bool Storage::UpdateDeviceCapabilities(Poco::Data::Session &Session, std::string &SerialNumber,
 										   const Config::Capabilities &Caps) {
 		try {
-			Poco::Data::Session Sess = Pool_->get();
-			Poco::Data::Statement UpSert(Sess);
+			Session.begin();
+			Poco::Data::Statement UpSert(Session);
 
 			uint64_t Now = Utils::Now();
 			if (!Caps.Compatible().empty() && !Caps.Platform().empty())
@@ -61,6 +62,7 @@ namespace OpenWifi {
 				Poco::Data::Keywords::use(Now), Poco::Data::Keywords::use(TCaps),
 				Poco::Data::Keywords::use(Now);
 			UpSert.execute();
+			Session.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
@@ -99,13 +101,14 @@ namespace OpenWifi {
 	bool Storage::DeleteDeviceCapabilities(std::string &SerialNumber) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Delete(Sess);
 
 			std::string St{"DELETE FROM Capabilities WHERE SerialNumber=?"};
 
 			Delete << ConvertParams(St), Poco::Data::Keywords::use(SerialNumber);
 			Delete.execute();
-
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
diff --git a/src/storage/storage_command.cpp b/src/storage/storage_command.cpp
index b4664a59..d021f16d 100644
--- a/src/storage/storage_command.cpp
+++ b/src/storage/storage_command.cpp
@@ -105,6 +105,7 @@ namespace OpenWifi {
 	bool Storage::RemoveOldCommands(std::string &SerialNumber, std::string &Command) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Delete(Sess);
 
 			std::string St{
@@ -112,8 +113,7 @@ namespace OpenWifi {
 			Delete << ConvertParams(St), Poco::Data::Keywords::use(SerialNumber),
 				Poco::Data::Keywords::use(Command);
 			Delete.execute();
-			Delete.reset(Sess);
-
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -146,6 +146,7 @@ namespace OpenWifi {
 			RemoveOldCommands(SerialNumber, Command.Command);
 
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Insert(Sess);
 
 			std::string St{"INSERT INTO CommandList ( " + DB_Command_SelectFields + " ) VALUES( " +
@@ -156,7 +157,7 @@ namespace OpenWifi {
 
 			Insert << ConvertParams(St), Poco::Data::Keywords::use(R);
 			Insert.execute();
-
+			Sess.commit();
 			return true;
 
 		} catch (const Poco::Exception &E) {
@@ -215,6 +216,7 @@ namespace OpenWifi {
 	bool Storage::DeleteCommands(std::string &SerialNumber, uint64_t FromDate, uint64_t ToDate) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Delete(Sess);
 
 			bool DatesIncluded = (FromDate != 0 || ToDate != 0);
@@ -237,8 +239,7 @@ namespace OpenWifi {
 
 			Delete << IntroStatement + DateSelector;
 			Delete.execute();
-			Delete.reset(Sess);
-
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -274,7 +275,6 @@ namespace OpenWifi {
 				if (Records.size() < HowMany)
 					Done = true;
 			}
-			Select.reset(Sess);
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -286,6 +286,7 @@ namespace OpenWifi {
 
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
 
 			std::string St{"UPDATE CommandList SET Status=?,  Executed=?,  Completed=?,  "
@@ -299,7 +300,7 @@ namespace OpenWifi {
 				Poco::Data::Keywords::use(Command.ErrorCode), Poco::Data::Keywords::use(UUID);
 
 			Update.execute();
-
+			Sess.commit();
 			return true;
 
 		} catch (const Poco::Exception &E) {
@@ -311,6 +312,7 @@ namespace OpenWifi {
 	bool Storage::SetCommandExecuted(std::string &CommandUUID) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
 
 			auto Now = Utils::Now();
@@ -321,6 +323,7 @@ namespace OpenWifi {
 			Update << ConvertParams(St), Poco::Data::Keywords::use(Now),
 				Poco::Data::Keywords::use(Status), Poco::Data::Keywords::use(CommandUUID);
 			Update.execute();
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -331,6 +334,7 @@ namespace OpenWifi {
 	void Storage::RemovedExpiredCommands() {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
 
 			auto Now = Utils::Now(), Window = Now - CommandManager()->CommandTimeout();
@@ -341,8 +345,7 @@ namespace OpenWifi {
 			Update << ConvertParams(St), Poco::Data::Keywords::use(Now),
 				Poco::Data::Keywords::use(Status), Poco::Data::Keywords::use(Window);
 			Update.execute();
-			Update.reset(Sess);
-
+			Sess.commit();
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
 		}
@@ -351,6 +354,7 @@ namespace OpenWifi {
 	bool Storage::SetCommandLastTry(std::string &CommandUUID) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
 
 			auto Now = Utils::Now();
@@ -359,6 +363,7 @@ namespace OpenWifi {
 			Update << ConvertParams(St), Poco::Data::Keywords::use(Now),
 				Poco::Data::Keywords::use(CommandUUID);
 			Update.execute();
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -369,6 +374,7 @@ namespace OpenWifi {
 	void Storage::RemoveTimedOutCommands() {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
 
 			auto Now = Utils::Now(), Window = Now - CommandManager()->CommandTimeout();
@@ -377,7 +383,7 @@ namespace OpenWifi {
 			Update << ConvertParams(St), Poco::Data::Keywords::use(Now),
 				Poco::Data::Keywords::use(Window);
 			Update.execute();
-			Update.reset(Sess);
+			Sess.commit();
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
 		}
@@ -386,6 +392,7 @@ namespace OpenWifi {
 	bool Storage::SetCommandTimedOut(std::string &CommandUUID) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
 
 			auto Now = Utils::Now();
@@ -395,6 +402,7 @@ namespace OpenWifi {
 			Update << ConvertParams(St), Poco::Data::Keywords::use(Now),
 				Poco::Data::Keywords::use(Status), Poco::Data::Keywords::use(CommandUUID);
 			Update.execute();
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -425,6 +433,7 @@ namespace OpenWifi {
 	bool Storage::DeleteCommand(std::string &UUID) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Delete(Sess);
 
 			std::string St{"DELETE FROM CommandList WHERE UUID=?"};
@@ -435,8 +444,7 @@ namespace OpenWifi {
 			St = "DELETE FROM FileUploads WHERE UUID=?";
 			Delete << ConvertParams(St), Poco::Data::Keywords::use(UUID);
 			Delete.execute();
-			Delete.reset(Sess);
-
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -510,6 +518,7 @@ namespace OpenWifi {
 			auto Now = Utils::Now();
 
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
 
 			std::string St{"UPDATE CommandList SET Executed=? WHERE UUID=?"};
@@ -518,7 +527,7 @@ namespace OpenWifi {
 				Poco::Data::Keywords::use(UUID);
 
 			Update.execute();
-
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -555,6 +564,7 @@ namespace OpenWifi {
 			}
 
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
 
 			auto Status = to_string(Storage::CommandExecutionType::COMMAND_COMPLETED);
@@ -566,6 +576,7 @@ namespace OpenWifi {
 				Poco::Data::Keywords::use(ResultStr), Poco::Data::Keywords::use(Status),
 				Poco::Data::Keywords::use(tET), Poco::Data::Keywords::use(UUID);
 			Update.execute();
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -603,6 +614,7 @@ namespace OpenWifi {
 	bool Storage::CancelWaitFile(std::string &UUID, std::string &ErrorText) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			auto Now = Utils::Now();
 			uint64_t Size = 0, WaitForFile = 0;
 
@@ -616,6 +628,7 @@ namespace OpenWifi {
 				Poco::Data::Keywords::use(ErrorText), Poco::Data::Keywords::use(Now),
 				Poco::Data::Keywords::use(UUID);
 			Update.execute();
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -631,6 +644,7 @@ namespace OpenWifi {
 			uint64_t Size = FileContent.str().size();
 
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Statement(Sess);
 
 			std::string StatementStr;
@@ -644,14 +658,14 @@ namespace OpenWifi {
 				Poco::Data::Keywords::use(Now), Poco::Data::Keywords::use(Size),
 				Poco::Data::Keywords::use(UUID);
 			Statement.execute();
-
+			Sess.commit();
 			if (Size < FileUploader()->MaxSize()) {
 
 				Poco::Data::BLOB TheBlob;
 
 				TheBlob.appendRaw((const unsigned char *)FileContent.str().c_str(),
 								  FileContent.str().size());
-
+				Sess.begin();
 				Poco::Data::Statement Insert(Sess);
 				std::string FileType{Type};
 
@@ -662,10 +676,12 @@ namespace OpenWifi {
 					Poco::Data::Keywords::use(FileType), Poco::Data::Keywords::use(Now),
 					Poco::Data::Keywords::use(TheBlob);
 				Insert.execute();
-				return true;
+				Sess.commit();
 			} else {
 				poco_warning(Logger(), fmt::format("File {} is too large.", UUID));
 			}
+			Sess.commit();
+			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
 		}
@@ -712,6 +728,7 @@ namespace OpenWifi {
 	bool Storage::SetCommandResult(std::string &UUID, std::string &Result) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
 
 			auto Now = Utils::Now();
@@ -722,6 +739,7 @@ namespace OpenWifi {
 				Poco::Data::Keywords::use(Result), Poco::Data::Keywords::use(Status),
 				Poco::Data::Keywords::use(UUID);
 			Update.execute();
+			Sess.commit();
 			return true;
 
 		} catch (const Poco::Exception &E) {
@@ -733,13 +751,14 @@ namespace OpenWifi {
 	bool Storage::RemoveAttachedFile(std::string &UUID) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Delete(Sess);
 
 			std::string St{"DELETE FROM FileUploads WHERE UUID=?"};
 
 			Delete << ConvertParams(St), Poco::Data::Keywords::use(UUID);
 			Delete.execute();
-
+			Sess.commit();
 			return true;
 
 		} catch (const Poco::Exception &E) {
@@ -751,11 +770,13 @@ namespace OpenWifi {
 	bool Storage::RemoveUploadedFilesRecordsOlderThan(uint64_t Date) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Delete(Sess);
 
 			std::string St1{"delete from FileUploads where Created<?"};
 			Delete << ConvertParams(St1), Poco::Data::Keywords::use(Date);
 			Delete.execute();
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -766,11 +787,13 @@ namespace OpenWifi {
 	bool Storage::RemoveCommandListRecordsOlderThan(uint64_t Date) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Delete(Sess);
 
 			std::string St1{"delete from CommandList where Submitted<?"};
 			Delete << ConvertParams(St1), Poco::Data::Keywords::use(Date);
 			Delete.execute();
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
diff --git a/src/storage/storage_def_firmware.cpp b/src/storage/storage_def_firmware.cpp
index 9bb8a77e..b1e41828 100644
--- a/src/storage/storage_def_firmware.cpp
+++ b/src/storage/storage_def_firmware.cpp
@@ -82,6 +82,7 @@ namespace OpenWifi {
 			if (!TmpName.empty())
 				return false;
 
+			Sess.begin();
 			Poco::Data::Statement Insert(Sess);
 
 			std::string St2{"INSERT INTO DefaultFirmwares ( " + DB_DefFirmware_SelectFields +
@@ -94,6 +95,7 @@ namespace OpenWifi {
 			Insert << ConvertParams(St2),
 				Poco::Data::Keywords::use(R);
 			Insert.execute();
+			Sess.commit();
 			return true;
 
 		} catch (const Poco::Exception &E) {
@@ -107,6 +109,7 @@ namespace OpenWifi {
 		try {
 
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Delete(Sess);
 			Poco::toLowerInPlace(deviceType);
 
@@ -114,7 +117,7 @@ namespace OpenWifi {
 
 			Delete << ConvertParams(St), Poco::Data::Keywords::use(deviceType);
 			Delete.execute();
-
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
@@ -125,9 +128,9 @@ namespace OpenWifi {
 
 	bool Storage::UpdateDefaultFirmware(GWObjects::DefaultFirmware &DefFirmware) {
 		try {
+			uint64_t Now = Utils::Now();
 			Poco::Data::Session Sess = Pool_->get();
-
-			uint64_t Now = time(nullptr);
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
 			DefFirmware.LastModified = Now;
 			Poco::toLowerInPlace(DefFirmware.deviceType);
@@ -143,7 +146,7 @@ namespace OpenWifi {
 				Poco::Data::Keywords::use(R),
 				Poco::Data::Keywords::use(DefFirmware.deviceType);
 			Update.execute();
-
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
diff --git a/src/storage/storage_defconfig.cpp b/src/storage/storage_defconfig.cpp
index 7b0f2d39..e38e4ae8 100644
--- a/src/storage/storage_defconfig.cpp
+++ b/src/storage/storage_defconfig.cpp
@@ -19,37 +19,39 @@ namespace OpenWifi {
 																   "Models TEXT, "
 																   "Description TEXT, "
 																   "Created BIGINT , "
-																   "LastModified BIGINT)"};
+																   "LastModified BIGINT, Platform TEXT )"};
 
 	const static std::string DB_DefConfig_SelectFields{"Name, "
 													   "Configuration, "
 													   "Models, "
 													   "Description, "
 													   "Created, "
-													   "LastModified "};
+													   "LastModified, Platform "};
 
-	const static std::string DB_DefConfig_InsertValues{"?,?,?,?,?,?"};
+	const static std::string DB_DefConfig_InsertValues{"?,?,?,?,?,?,?"};
 
-	typedef Poco::Tuple<std::string, std::string, std::string, std::string, uint64_t, uint64_t>
+	typedef Poco::Tuple<std::string, std::string, std::string, std::string, uint64_t, uint64_t, std::string>
 		DefConfigRecordTuple;
 	typedef std::vector<DefConfigRecordTuple> DefConfigRecordList;
 
 	void Convert(const DefConfigRecordTuple &R, GWObjects::DefaultConfiguration &T) {
-		T.Name = R.get<0>();
-		T.Configuration = R.get<1>();
-		T.Models = RESTAPI_utils::to_object_array(R.get<2>());
-		T.Description = R.get<3>();
-		T.Created = R.get<4>();
-		T.LastModified = R.get<5>();
+		T.name = R.get<0>();
+		T.configuration = R.get<1>();
+		T.models = RESTAPI_utils::to_object_array(R.get<2>());
+		T.description = R.get<3>();
+		T.created = R.get<4>();
+		T.lastModified = R.get<5>();
+		T.platform = R.get<6>();
 	}
 
 	void Convert(const GWObjects::DefaultConfiguration &R, DefConfigRecordTuple &T) {
-		T.set<0>(R.Name);
-		T.set<1>(R.Configuration);
-		T.set<2>(RESTAPI_utils::to_string(R.Models));
-		T.set<3>(R.Description);
-		T.set<4>(R.Created);
-		T.set<5>(R.LastModified);
+		T.set<0>(R.name);
+		T.set<1>(R.configuration);
+		T.set<2>(RESTAPI_utils::to_string(R.models));
+		T.set<3>(R.description);
+		T.set<4>(R.created);
+		T.set<5>(R.lastModified);
+		T.set<6>(R.platform);
 	}
 
 	bool Storage::CreateDefaultConfiguration(std::string &Name,
@@ -69,9 +71,10 @@ namespace OpenWifi {
 			if (!TmpName.empty())
 				return false;
 
-			Config::Config Cfg(DefConfig.Configuration);
+			Config::Config Cfg(DefConfig.configuration);
 
 			if (Cfg.Valid()) {
+				Sess.begin();
 				Poco::Data::Statement Insert(Sess);
 
 				std::string St{"INSERT INTO DefaultConfigs ( " + DB_DefConfig_SelectFields +
@@ -83,6 +86,7 @@ namespace OpenWifi {
 				Convert(DefConfig, R);
 				Insert << ConvertParams(St), Poco::Data::Keywords::use(R);
 				Insert.execute();
+				Sess.commit();
 				return true;
 			} else {
 				poco_warning(Logger(), "Cannot create device: invalid configuration.");
@@ -99,13 +103,14 @@ namespace OpenWifi {
 		try {
 
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Delete(Sess);
 
 			std::string St{"DELETE FROM DefaultConfigs WHERE Name=?"};
 
 			Delete << ConvertParams(St), Poco::Data::Keywords::use(Name);
 			Delete.execute();
-
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
@@ -117,14 +122,14 @@ namespace OpenWifi {
 	bool Storage::UpdateDefaultConfiguration(std::string &Name,
 											 GWObjects::DefaultConfiguration &DefConfig) {
 		try {
+			uint64_t Now = Utils::Now();
 			Poco::Data::Session Sess = Pool_->get();
-
-			uint64_t Now = time(nullptr);
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
-			DefConfig.LastModified = Now;
+			DefConfig.lastModified = Now;
 
 			std::string St{"UPDATE DefaultConfigs SET Name=?, Configuration=?,  Models=?,  "
-						   "Description=?,  Created=? , LastModified=?  WHERE Name=?"};
+						   "Description=?,  Created=? , LastModified=? , Platform=?  WHERE Name=?"};
 
 			DefConfigRecordTuple R;
 			Convert(DefConfig, R);
@@ -132,6 +137,7 @@ namespace OpenWifi {
 			Update << ConvertParams(St), Poco::Data::Keywords::use(R),
 				Poco::Data::Keywords::use(Name);
 			Update.execute();
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
@@ -215,31 +221,30 @@ namespace OpenWifi {
 		return false;
 	}
 
-	bool Storage::FindDefaultConfigurationForModel(const std::string &Model,
-												   GWObjects::DefaultConfiguration &DefConfig) {
+	bool Storage::FindDefaultConfigurationForModel(const std::string &DeviceModel, const std::string &Platform,
+												   GWObjects::DefaultConfiguration &Config) {
 		try {
-			DefConfigRecordList Records;
+			DefConfigRecordList DefConfigs;
 
 			Poco::Data::Session Sess = Pool_->get();
 			Poco::Data::Statement Select(Sess);
 
 			Select << "SELECT " + DB_DefConfig_SelectFields + " FROM DefaultConfigs",
-				Poco::Data::Keywords::into(Records);
+				Poco::Data::Keywords::into(DefConfigs);
 			Select.execute();
 
-			for (const auto &i : Records) {
-				GWObjects::DefaultConfiguration Config;
-				Convert(i, Config);
-				for (const auto &j : Config.Models) {
-					if (j == "*" || j == Model) {
-						DefConfig = Config;
+			for (const auto &DefConfig : DefConfigs) {
+				GWObjects::DefaultConfiguration C;
+				Convert(DefConfig, C);
+				for (const auto &Model : C.models) {
+					if ((Model == "*" || Model == DeviceModel) && (Config.platform == Platform)){
+						Config = C;
 						return true;
 					}
 				}
 			}
 			Logger().information(
-				fmt::format("AUTO-PROVISIONING: no default configuration for model:{}", Model));
-			return false;
+				fmt::format("AUTO-PROVISIONING: no default configuration for model:{}", DeviceModel));
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
 											   E.displayText()));
diff --git a/src/storage/storage_device.cpp b/src/storage/storage_device.cpp
index 4e1a0d8a..5f39aa8b 100644
--- a/src/storage/storage_device.cpp
+++ b/src/storage/storage_device.cpp
@@ -172,14 +172,18 @@ namespace OpenWifi {
 		R.set<30>(D.connectReason);
 	}
 
-	bool Storage::GetDeviceCount(uint64_t &Count) {
+	bool Storage::GetDeviceCount(uint64_t &Count, const std::string &platform) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
 			Poco::Data::Statement Select(Sess);
 
-			std::string st{"SELECT COUNT(*) FROM Devices"};
-
-			Select << st, Poco::Data::Keywords::into(Count);
+			if(!platform.empty()) {
+				std::string st{"SELECT COUNT(*) FROM Devices WHERE DeviceType='" + platform + "'"};
+				Select << st, Poco::Data::Keywords::into(Count);
+			} else {
+				std::string st{"SELECT COUNT(*) FROM Devices"};
+				Select << st, Poco::Data::Keywords::into(Count);
+			}
 			Select.execute();
 			return true;
 		} catch (const Poco::Exception &E) {
@@ -190,16 +194,22 @@ namespace OpenWifi {
 
 	bool Storage::GetDeviceSerialNumbers(uint64_t From, uint64_t HowMany,
 										 std::vector<std::string> &SerialNumbers,
-										 const std::string &orderBy) {
+										 const std::string &orderBy,
+										 const std::string &platform) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
 			Poco::Data::Statement Select(Sess);
 
 			std::string st;
+			if(!platform.empty()) {
+				st = "SELECT SerialNumber From Devices WHERE DeviceType='" + platform + "' ";
+			} else {
+				st = "SELECT SerialNumber From Devices ";
+			}
 			if (orderBy.empty())
-				st = "SELECT SerialNumber From Devices ORDER BY SerialNumber ASC ";
+				st += " ORDER BY SerialNumber ASC ";
 			else
-				st = "SELECT SerialNumber From Devices " + orderBy;
+				st += orderBy;
 
 			Select << st + ComputeRange(From, HowMany), Poco::Data::Keywords::into(SerialNumbers);
 			Select.execute();
@@ -210,7 +220,7 @@ namespace OpenWifi {
 		return false;
 	}
 
-	bool Storage::UpdateDeviceConfiguration(std::string &SerialNumber, std::string &Configuration,
+/*	bool Storage::UpdateDeviceConfiguration(std::string &SerialNumber, std::string &Configuration,
 											uint64_t &NewUUID) {
 		try {
 
@@ -255,7 +265,7 @@ namespace OpenWifi {
 		}
 		return false;
 	}
-
+*/
 	bool Storage::RollbackDeviceConfigurationChange(std::string & SerialNumber) {
 		try {
 			GWObjects::Device D;
@@ -265,9 +275,10 @@ namespace OpenWifi {
 			D.pendingUUID = 0;
 			D.LastConfigurationChange = Utils::Now();
 
-			ConfigurationCache().Add(Utils::SerialNumberToInt(SerialNumber), D.UUID);
+			SetCurrentConfigurationID(Utils::SerialNumberToInt(SerialNumber), D.UUID);
 
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
 
 			DeviceRecordTuple R;
@@ -277,6 +288,7 @@ namespace OpenWifi {
 			Update << ConvertParams(St2), Poco::Data::Keywords::use(R),
 				Poco::Data::Keywords::use(SerialNumber);
 			Update.execute();
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -286,22 +298,43 @@ namespace OpenWifi {
 
 	bool Storage::CompleteDeviceConfigurationChange(std::string & SerialNumber) {
 		try {
+			auto Session = Pool_->get();
+			return CompleteDeviceConfigurationChange(Session, SerialNumber);
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		}
+		return false;
+	}
+
+	bool Storage::CompleteDeviceConfigurationChange(Poco::Data::Session & Session, std::string & SerialNumber) {
+		try {
+
 			GWObjects::Device D;
 			if (!GetDevice(SerialNumber, D))
 				return false;
 
-			if(D.pendingConfiguration.empty())
-				return true;
-			D.Configuration = D.pendingConfiguration;
-			D.pendingConfiguration.clear();
-			D.UUID = D.pendingUUID;
-			D.pendingUUID = 0;
-			D.LastConfigurationChange = Utils::Now();
+			if(!D.pendingConfiguration.empty()) {
+				D.Configuration = D.pendingConfiguration;
+				D.pendingConfiguration.clear();
+			}
+			if(D.pendingUUID!=0) {
+				D.UUID = D.pendingUUID;
+				D.pendingUUID = 0;
+			}
 
-			ConfigurationCache().Add(Utils::SerialNumberToInt(SerialNumber), D.UUID);
+			//	if this is a broken device, fix it...
+			if(D.UUID==0) {
+				Config::Config Cfg(D.Configuration);
+				if(Cfg.Valid()) {
+					D.UUID = Cfg.UUID();
+				}
+			}
 
-			Poco::Data::Session Sess = Pool_->get();
-			Poco::Data::Statement Update(Sess);
+			D.LastConfigurationChange = Utils::Now();
+			SetCurrentConfigurationID(Utils::SerialNumberToInt(SerialNumber), D.UUID);
+
+			Session.begin();
+			Poco::Data::Statement Update(Session);
 
 			DeviceRecordTuple R;
 			ConvertDeviceRecord(D, R);
@@ -310,6 +343,7 @@ namespace OpenWifi {
 			Update << ConvertParams(St2), Poco::Data::Keywords::use(R),
 				Poco::Data::Keywords::use(SerialNumber);
 			Update.execute();
+			Session.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -328,13 +362,12 @@ namespace OpenWifi {
 				return false;
 			}
 
-			Poco::Data::Session Sess = Pool_->get();
-			Poco::Data::Statement Select(Sess);
 
 			GWObjects::Device D;
 			if (!GetDevice(SerialNumber, D))
 				return false;
 
+
 			uint64_t Now = time(nullptr);
 			if(NewUUID==0) {
 				D.pendingUUID = NewUUID = (D.LastConfigurationChange == Now ? Now + 1 : Now);
@@ -343,6 +376,8 @@ namespace OpenWifi {
 			}
 
 			if (Cfg.SetUUID(NewUUID)) {
+				Poco::Data::Session Sess = Pool_->get();
+				Sess.begin();
 				Poco::Data::Statement Update(Sess);
 				D.pendingConfiguration = Cfg.get();
 
@@ -353,6 +388,7 @@ namespace OpenWifi {
 				Update << ConvertParams(St2), Poco::Data::Keywords::use(R),
 					Poco::Data::Keywords::use(SerialNumber);
 				Update.execute();
+				Sess.commit();
 				poco_information(Logger(),
 								 fmt::format("DEVICE-PENDING-CONFIGURATION-UPDATED({}): New UUID is {}",
 											 SerialNumber, NewUUID));
@@ -366,69 +402,95 @@ namespace OpenWifi {
 		return false;
 	}
 
-	bool Storage::SetDeviceLastRecordedContact(std::string &SerialNumber, std::uint64_t lastRecordedContact) {
+	bool Storage::SetDeviceLastRecordedContact(LockedDbSession &Session, std::string &SerialNumber, std::uint64_t lastRecordedContact) {
+		try {
+			std::lock_guard		Lock(Session.Mutex());
+			return SetDeviceLastRecordedContact(Session.Session(), SerialNumber, lastRecordedContact);
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		}
+		return false;
+	}
+
+	bool Storage::SetDeviceLastRecordedContact(Poco::Data::Session &Session, std::string &SerialNumber, std::uint64_t lastRecordedContact) {
 		try {
-			Poco::Data::Session 	Sess = Pool_->get();
-			Poco::Data::Statement 	Update(Sess);
+			Session.begin();
+			Poco::Data::Statement 	Update(Session);
 			std::string St{"UPDATE Devices SET lastRecordedContact=?  WHERE SerialNumber=?"};
 
 			Update << ConvertParams(St), Poco::Data::Keywords::use(lastRecordedContact),
 				Poco::Data::Keywords::use(SerialNumber);
 			Update.execute();
+			Session.commit();
 			return true;
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		}
+		return false;
+	}
 
+	bool Storage::SetDeviceLastRecordedContact(std::string &SerialNumber, std::uint64_t lastRecordedContact) {
+		try {
+			auto Session = Pool_->get();
+			return SetDeviceLastRecordedContact(Session, SerialNumber, lastRecordedContact);
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
 		}
 		return false;
 	}
 
-	bool Storage::CreateDevice(GWObjects::Device &DeviceDetails) {
+	bool Storage::CreateDevice(Poco::Data::Session &Sess, GWObjects::Device &DeviceDetails) {
 		std::string SerialNumber;
 		try {
+			Config::Config Cfg(DeviceDetails.Configuration);
+			uint64_t Now = Utils::Now();
 
-			Poco::Data::Session Sess = Pool_->get();
-			Poco::Data::Statement Select(Sess);
+			DeviceDetails.modified = Utils::Now();
+			DeviceDetails.CreationTimestamp = DeviceDetails.LastConfigurationDownload =
+				DeviceDetails.UUID = DeviceDetails.LastConfigurationChange = Now;
 
-			std::string St{"SELECT SerialNumber FROM Devices WHERE SerialNumber=?"};
-
-//			Select << ConvertParams(St), Poco::Data::Keywords::into(SerialNumber),
-//				Poco::Data::Keywords::use(DeviceDetails.SerialNumber);
-//			Select.execute();
-
-//			if (Select.rowsExtracted() == 0) {
-				Config::Config Cfg(DeviceDetails.Configuration);
-				uint64_t Now = Utils::Now();
+			if (Cfg.Valid() && Cfg.SetUUID(DeviceDetails.UUID)) {
 
-				DeviceDetails.modified = Utils::Now();
-				DeviceDetails.CreationTimestamp = DeviceDetails.LastConfigurationDownload =
-					DeviceDetails.UUID = DeviceDetails.LastConfigurationChange = Now;
+				DeviceDetails.Configuration = Cfg.get();
+				Sess.begin();
+				Poco::Data::Statement Insert(Sess);
 
-				if (Cfg.Valid() && Cfg.SetUUID(DeviceDetails.UUID)) {
+				std::string St2{"INSERT INTO Devices ( " + DB_DeviceSelectFields + " ) " +
+								DB_DeviceInsertValues + " ON CONFLICT (SerialNumber) DO NOTHING"};
 
-					DeviceDetails.Configuration = Cfg.get();
-					Poco::Data::Statement Insert(Sess);
+				SetCurrentConfigurationID(DeviceDetails.SerialNumber, DeviceDetails.UUID);
+				DeviceRecordTuple R;
+				ConvertDeviceRecord(DeviceDetails, R);
+				Insert << ConvertParams(St2), Poco::Data::Keywords::use(R);
+				Insert.execute();
+				Sess.commit();
+				SetCurrentConfigurationID(DeviceDetails.SerialNumber, DeviceDetails.UUID);
+				SerialNumberCache()->AddSerialNumber(DeviceDetails.SerialNumber);
+			} else {
+				poco_warning(Logger(), "Cannot create device: invalid configuration.");
+				return false;
+			}
+			return true;
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		}
+		return false;
+	}
 
-					std::string St2{"INSERT INTO Devices ( " + DB_DeviceSelectFields + " ) " +
-									DB_DeviceInsertValues + " ON CONFLICT (SerialNumber) DO NOTHING"};
+	bool Storage::CreateDevice(LockedDbSession &Session, GWObjects::Device &DeviceDetails) {
+		try {
+			std::lock_guard	Lock(Session.Mutex());
+			return CreateDevice(Session.Session(), DeviceDetails);
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		}
+		return false;
+	}
 
-					SetCurrentConfigurationID(DeviceDetails.SerialNumber, DeviceDetails.UUID);
-					DeviceRecordTuple R;
-					ConvertDeviceRecord(DeviceDetails, R);
-					Insert << ConvertParams(St2), Poco::Data::Keywords::use(R);
-					Insert.execute();
-					SetCurrentConfigurationID(DeviceDetails.SerialNumber, DeviceDetails.UUID);
-					SerialNumberCache()->AddSerialNumber(DeviceDetails.SerialNumber);
-					return true;
-				} else {
-					poco_warning(Logger(), "Cannot create device: invalid configuration.");
-					return false;
-				}
-//			} else {
-//				poco_warning(Logger(), fmt::format("Device {} already exists.", SerialNumber));
-//				return false;
-//			}
-			return true;
+		bool Storage::CreateDevice(GWObjects::Device &DeviceDetails) {
+		try {
+			auto Session = Pool_->get();
+			return CreateDevice(Session, DeviceDetails);
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
 		}
@@ -484,19 +546,18 @@ namespace OpenWifi {
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
 		}
-		return true;
+		return false;
 	}
 
-#define __DBGLOG__ std::cout << __LINE__ << std::endl;
-
-	bool Storage::CreateDefaultDevice(std::string &SerialNumber, const Config::Capabilities &Caps,
+	bool Storage::CreateDefaultDevice(Poco::Data::Session &Session, std::string &SerialNumber, const Config::Capabilities &Caps,
 									  std::string &Firmware,
 									  const Poco::Net::IPAddress &IPAddress,
 									  bool simulated) {
 
 		GWObjects::Device D;
-		poco_information(Logger(), fmt::format("AUTO-CREATION({})", SerialNumber));
-		uint64_t Now = time(nullptr);
+
+		// poco_information(Logger(), fmt::format("AUTO-CREATION({}): Start.", SerialNumber));
+		uint64_t Now = Utils::Now();
 		GWObjects::DefaultConfiguration DefConfig;
 
 		if (!Caps.Platform().empty() && !Caps.Compatible().empty()) {
@@ -517,21 +578,29 @@ namespace OpenWifi {
 		}
 
 		if (!Found && AP_WS_Server()->UseDefaults() &&
-			FindDefaultConfigurationForModel(Caps.Compatible(), DefConfig)) {
-			Config::Config NewConfig(DefConfig.Configuration);
+			FindDefaultConfigurationForModel(Caps.Compatible(), Caps.Platform(), DefConfig)) {
+			Config::Config NewConfig(DefConfig.configuration);
 			NewConfig.SetUUID(Now);
 			D.Configuration = NewConfig.get();
 		} else if (!Found) {
-			Config::Config NewConfig;
-			NewConfig.SetUUID(Now);
-			D.Configuration = NewConfig.get();
+			if(Caps.Platform()==Platforms::AP) {
+				Config::Config NewConfig;
+				NewConfig.SetUUID(Now);
+				D.Configuration = NewConfig.get();
+			} else {
+				Poco::JSON::Object Obj;
+				Obj.set("uuid", Now);
+				std::ostringstream os;
+				Obj.stringify(os);
+				D.Configuration = os.str();
+			}
 		}
 
 		//	We need to insert the country code according to the IP in the radios section...
 		D.locale = InsertRadiosCountyRegulation(D.Configuration, IPAddress);
 		D.SerialNumber = Poco::toLower(SerialNumber);
 		D.Compatible = Caps.Compatible();
-		D.DeviceType = Daemon()->IdentifyDevice(D.Compatible);
+		D.DeviceType = Caps.Platform();
 		D.MACAddress = Utils::SerialToMAC(SerialNumber);
 		D.Manufacturer = Caps.Model();
 		D.Firmware = Firmware;
@@ -539,12 +608,13 @@ namespace OpenWifi {
 		D.Notes = SecurityObjects::NoteInfoVec{
 			SecurityObjects::NoteInfo{(uint64_t)Utils::Now(), "", "Auto-provisioned."}};
 
-		CreateDeviceCapabilities(SerialNumber, Caps);
-
-		return CreateDevice(D);
+		CreateDeviceCapabilities(Session, SerialNumber, Caps);
+		auto Result = CreateDevice(Session, D);
+		poco_information(Logger(), fmt::format("AUTO-CREATION({}): Done, Result={}", SerialNumber, Result));
+		return Result;
 	}
 
-	bool Storage::GetDeviceFWUpdatePolicy(std::string &SerialNumber, std::string &Policy) {
+/*	bool Storage::GetDeviceFWUpdatePolicy(std::string &SerialNumber, std::string &Policy) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
 			Poco::Data::Statement Select(Sess);
@@ -559,46 +629,19 @@ namespace OpenWifi {
 		}
 		return false;
 	}
-
-	bool Storage::SetDevicePassword(std::string &SerialNumber, std::string &Password) {
+*/
+	bool Storage::SetDevicePassword(LockedDbSession &Sess, std::string &SerialNumber, std::string &Password) {
 		try {
-			Poco::Data::Session Sess = Pool_->get();
-			Poco::Data::Statement Update(Sess);
+			std::lock_guard		Lock(Sess.Mutex());
+			Sess.Session().begin();
+
+			Poco::Data::Statement Update(Sess.Session());
 			std::string St{"UPDATE Devices SET DevicePassword=?  WHERE SerialNumber=?"};
 
 			Update << ConvertParams(St), Poco::Data::Keywords::use(Password),
 				Poco::Data::Keywords::use(SerialNumber);
 			Update.execute();
-			return true;
-		} catch (const Poco::Exception &E) {
-			Logger().log(E);
-		}
-		return false;
-	}
-
-	bool Storage::SetConnectInfo(std::string &SerialNumber, std::string &Firmware) {
-		try {
-			Poco::Data::Session Sess = Pool_->get();
-			Poco::Data::Statement Select(Sess);
-
-			//	Get the old version and if they do not match, set the last date
-			std::string St{"SELECT Firmware FROM Devices  WHERE SerialNumber=?"};
-			std::string TmpFirmware;
-			Select << ConvertParams(St), Poco::Data::Keywords::into(TmpFirmware),
-				Poco::Data::Keywords::use(SerialNumber);
-			Select.execute();
-
-			if (TmpFirmware != Firmware) {
-				Poco::Data::Statement Update(Sess);
-				std::string St2{
-					"UPDATE Devices SET Firmware=?, LastFWUpdate=? WHERE SerialNumber=?"};
-				uint64_t Now = Utils::Now();
-
-				Update << ConvertParams(St2), Poco::Data::Keywords::use(Firmware),
-					Poco::Data::Keywords::use(Now), Poco::Data::Keywords::use(SerialNumber);
-				Update.execute();
-				return true;
-			}
+			Sess.Session().commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);
@@ -614,12 +657,14 @@ namespace OpenWifi {
 			for (const auto &tableName : TableNames) {
 
 				Poco::Data::Session Sess = Pool_->get();
+				Sess.begin();
 				Poco::Data::Statement Delete(Sess);
 
 				std::string St = fmt::format("DELETE FROM {} WHERE SerialNumber='{}'", tableName, SerialNumber);
 				try {
 					Delete << St;
 					Delete.execute();
+					Sess.commit();
 				} catch (...) {
 				}
 			}
@@ -692,19 +737,14 @@ namespace OpenWifi {
 		return false;
 	}
 
-	bool Storage::GetDevice(std::string &SerialNumber, GWObjects::Device &DeviceDetails) {
+	bool Storage::GetDevice(Poco::Data::Session &Session, const std::string &SerialNumber, GWObjects::Device &DeviceDetails) {
 		try {
-			Poco::Data::Session Sess = Pool_->get();
-			Poco::Data::Statement Select(Sess);
-
-			std::string St{"SELECT " + DB_DeviceSelectFields +
-						   " FROM Devices WHERE SerialNumber=?"};
+			Poco::Data::Statement Select(Session);
+			std::string St = fmt::format("SELECT {} FROM Devices WHERE SerialNumber='{}'", DB_DeviceSelectFields, SerialNumber);
 
 			DeviceRecordTuple R;
-			Select << ConvertParams(St), Poco::Data::Keywords::into(R),
-				Poco::Data::Keywords::use(SerialNumber);
+			Select << St, Poco::Data::Keywords::into(R);
 			Select.execute();
-
 			if (Select.rowsExtracted() == 0)
 				return false;
 			ConvertDeviceRecord(R, DeviceDetails);
@@ -715,6 +755,26 @@ namespace OpenWifi {
 		return false;
 	}
 
+	bool Storage::GetDevice(const std::string &SerialNumber, GWObjects::Device &DeviceDetails) {
+		try {
+			auto Sess = Pool_->get();
+			return GetDevice(Sess, SerialNumber, DeviceDetails);
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		}
+		return false;
+	}
+
+	bool Storage::GetDevice(LockedDbSession &Session, const std::string &SerialNumber, GWObjects::Device &DeviceDetails) {
+		try {
+			std::lock_guard		Lock(Session.Mutex());
+			return GetDevice(Session.Session(), SerialNumber, DeviceDetails);
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		}
+		return false;
+	}
+
 	bool Storage::DeviceExists(std::string &SerialNumber) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
@@ -741,6 +801,26 @@ namespace OpenWifi {
 	bool Storage::UpdateDevice(GWObjects::Device &NewDeviceDetails) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			return UpdateDevice(Sess, NewDeviceDetails);
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		}
+		return false;
+	}
+
+	bool Storage::UpdateDevice(LockedDbSession &Session, GWObjects::Device &NewDeviceDetails) {
+		try {
+			std::lock_guard Lock(Session.Mutex());
+			return UpdateDevice(Session.Session(), NewDeviceDetails);
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		}
+		return false;
+	}
+
+	bool Storage::UpdateDevice(Poco::Data::Session &Sess, GWObjects::Device &NewDeviceDetails) {
+		try {
+			Sess.begin();
 			Poco::Data::Statement Update(Sess);
 
 			DeviceRecordTuple R;
@@ -753,6 +833,7 @@ namespace OpenWifi {
 			Update << ConvertParams(St2), Poco::Data::Keywords::use(R),
 				Poco::Data::Keywords::use(NewDeviceDetails.SerialNumber);
 			Update.execute();
+			Sess.commit();
 			// GetDevice(NewDeviceDetails.SerialNumber,NewDeviceDetails);
 			return true;
 		} catch (const Poco::Exception &E) {
@@ -762,17 +843,24 @@ namespace OpenWifi {
 	}
 
 	bool Storage::GetDevices(uint64_t From, uint64_t HowMany,
-							 std::vector<GWObjects::Device> &Devices, const std::string &orderBy) {
+							 std::vector<GWObjects::Device> &Devices, const std::string &orderBy, const std::string &platform) {
 		DeviceRecordList Records;
 		try {
 			Poco::Data::Session Sess = Pool_->get();
 			Poco::Data::Statement Select(Sess);
 
-			// std::string st{"SELECT " + DB_DeviceSelectFields + " FROM Devices " + orderBy.empty()
-			// ? " ORDER BY SerialNumber ASC " + ComputeRange(From, HowMany)};
-			std::string st = fmt::format("SELECT {} FROM Devices {} {}", DB_DeviceSelectFields,
-										 orderBy.empty() ? " ORDER BY SerialNumber ASC " : orderBy,
-										 ComputeRange(From, HowMany));
+			std::string st;
+			if(platform.empty()) {
+				st =
+					fmt::format("SELECT {} FROM Devices {} {}", DB_DeviceSelectFields,
+								orderBy.empty() ? " ORDER BY SerialNumber ASC " : orderBy,
+								ComputeRange(From, HowMany));
+			} else {
+				st =
+					fmt::format("SELECT {} FROM Devices WHERE DeviceType='{}' {} {}", DB_DeviceSelectFields, platform,
+								orderBy.empty() ? " ORDER BY SerialNumber ASC " : orderBy,
+								ComputeRange(From, HowMany));
+			}
 
 			Select << ConvertParams(st), Poco::Data::Keywords::into(Records);
 			Select.execute();
@@ -1001,9 +1089,9 @@ namespace OpenWifi {
 							}
 						}
 
-						uint64_t Associations_2G, Associations_5G, Associations_6G;
+						uint64_t Associations_2G, Associations_5G, Associations_6G, uptime;
 						StateUtils::ComputeAssociations(RawObject, Associations_2G, Associations_5G,
-														Associations_6G);
+														Associations_6G, uptime);
 						UpdateCountedMap(Dashboard.associations, "2G", Associations_2G);
 						UpdateCountedMap(Dashboard.associations, "5G", Associations_5G);
 						UpdateCountedMap(Dashboard.associations, "6G", Associations_6G);
@@ -1027,4 +1115,25 @@ namespace OpenWifi {
 			FieldList.push_back(field);
 	}
 
+	void Storage::FixDeviceTypeBug() {
+		try {
+			std::vector<std::string> ScriptLines{
+				"update devices set devicetype='ap' where devicetype='AP';",
+				"update devices set devicetype='switch' where devicetype='SWITCH';",
+				"update devices set devicetype='ap' where devicetype!='ap' and devicetype!='switch';"
+			};
+
+			for (const auto &ScriptLine : ScriptLines) {
+				try {
+					Poco::Data::Session Sess = Pool_->get();
+					Poco::Data::Statement SqlStatement(Sess);
+					SqlStatement << ScriptLine, Poco::Data::Keywords::now;
+				} catch (...) {
+				}
+			}
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		}
+	}
+
 } // namespace OpenWifi
diff --git a/src/storage/storage_healthcheck.cpp b/src/storage/storage_healthcheck.cpp
index 971bbe7e..2d77f844 100644
--- a/src/storage/storage_healthcheck.cpp
+++ b/src/storage/storage_healthcheck.cpp
@@ -35,10 +35,11 @@ namespace OpenWifi {
 		R.set<4>(H.Recorded);
 	}
 
-	bool Storage::AddHealthCheckData(const GWObjects::HealthCheck &Check) {
+	bool Storage::AddHealthCheckData(LockedDbSession &Session, const GWObjects::HealthCheck &Check) {
 		try {
-			Poco::Data::Session Sess = Pool_->get();
-			Poco::Data::Statement Insert(Sess);
+			std::lock_guard Guard(Session.Mutex());
+			Session.Session().begin();
+			Poco::Data::Statement Insert(Session.Session());
 
 			std::string St{"INSERT INTO HealthChecks ( " + DB_HealthCheckSelectFields +
 						   " ) VALUES( " + DB_HealthCheckInsertValues + " )"};
@@ -47,6 +48,7 @@ namespace OpenWifi {
 			ConvertHealthCheckRecord(Check, R);
 			Insert << ConvertParams(St), Poco::Data::Keywords::use(R);
 			Insert.execute();
+			Session.Session().commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
@@ -134,7 +136,7 @@ namespace OpenWifi {
 										uint64_t ToDate) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
-
+			Sess.begin();
 			bool DatesIncluded = (FromDate != 0 || ToDate != 0);
 
 			std::string Prefix{"DELETE FROM HealthChecks "};
@@ -158,7 +160,7 @@ namespace OpenWifi {
 			Delete << Statement + DateSelector;
 
 			Delete.execute();
-
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
@@ -170,11 +172,13 @@ namespace OpenWifi {
 	bool Storage::RemoveHealthChecksRecordsOlderThan(uint64_t Date) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Delete(Sess);
 
 			std::string St1{"delete from HealthChecks where recorded<?"};
 			Delete << ConvertParams(St1), Poco::Data::Keywords::use(Date);
 			Delete.execute();
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
diff --git a/src/storage/storage_logs.cpp b/src/storage/storage_logs.cpp
index df8f54ae..ae998b2a 100644
--- a/src/storage/storage_logs.cpp
+++ b/src/storage/storage_logs.cpp
@@ -39,11 +39,11 @@ namespace OpenWifi {
 		R.set<6>(Log.UUID);
 	}
 
-	bool Storage::AddLog(const GWObjects::DeviceLog &Log) {
+	bool Storage::AddLog(LockedDbSession &Session, const GWObjects::DeviceLog &Log) {
 		try {
-
-			Poco::Data::Session Sess = Pool_->get();
-			Poco::Data::Statement Insert(Sess);
+			std::lock_guard Guard(Session.Mutex());
+			Session.Session().begin();
+			Poco::Data::Statement Insert(Session.Session());
 
 			std::string St{"INSERT INTO DeviceLogs (" + DB_LogsSelectFields + ") values( " +
 						   DB_LogsInsertValues + " )"};
@@ -53,6 +53,7 @@ namespace OpenWifi {
 
 			Insert << ConvertParams(St), Poco::Data::Keywords::use(R);
 			Insert.execute();
+			Session.Session().commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
@@ -114,7 +115,7 @@ namespace OpenWifi {
 								uint64_t Type) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
-
+			Sess.begin();
 			bool DatesIncluded = (FromDate != 0 || ToDate != 0);
 			bool HasWhere = DatesIncluded || !SerialNumber.empty();
 
@@ -141,7 +142,7 @@ namespace OpenWifi {
 			Delete << StatementStr + DateSelector + TypeSelector;
 
 			Delete.execute();
-			Delete.reset(Sess);
+			Sess.commit();
 
 			return true;
 		} catch (const Poco::Exception &E) {
@@ -183,11 +184,13 @@ namespace OpenWifi {
 	bool Storage::RemoveDeviceLogsRecordsOlderThan(uint64_t Date) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
+			Sess.begin();
 			Poco::Data::Statement Delete(Sess);
 
 			std::string St1{"delete from DeviceLogs where recorded<?"};
 			Delete << ConvertParams(St1), Poco::Data::Keywords::use(Date);
 			Delete.execute();
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
diff --git a/src/storage/storage_statistics.cpp b/src/storage/storage_statistics.cpp
index 7b3592c9..13580862 100644
--- a/src/storage/storage_statistics.cpp
+++ b/src/storage/storage_statistics.cpp
@@ -8,7 +8,6 @@
 
 #include "AP_WS_Server.h"
 #include "StorageService.h"
-
 #include "fmt/format.h"
 
 namespace OpenWifi {
@@ -33,10 +32,10 @@ namespace OpenWifi {
 		R.set<3>(Stats.Recorded);
 	}
 
-	bool Storage::AddStatisticsData(const GWObjects::Statistics &Stats) {
+	bool Storage::AddStatisticsData(Poco::Data::Session &Session, const GWObjects::Statistics &Stats) {
 		try {
-			Poco::Data::Session Sess(Pool_->get());
-			Poco::Data::Statement Insert(Sess);
+			Session.begin();
+			Poco::Data::Statement Insert(Session);
 
 			poco_trace(Logger(), fmt::format("{}: Adding stats. Size={}", Stats.SerialNumber,
 											 std::to_string(Stats.Data.size())));
@@ -46,6 +45,7 @@ namespace OpenWifi {
 			ConvertStatsRecord(Stats, R);
 			Insert << ConvertParams(St), Poco::Data::Keywords::use(R);
 			Insert.execute();
+			Session.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), fmt::format("{}: Failed with: {}", std::string(__func__),
@@ -167,7 +167,7 @@ namespace OpenWifi {
 									   uint64_t ToDate) {
 		try {
 			Poco::Data::Session Sess = Pool_->get();
-
+			Sess.begin();
 			bool DatesIncluded = (FromDate != 0 || ToDate != 0);
 
 			std::string Prefix{"DELETE FROM Statistics "};
@@ -189,7 +189,7 @@ namespace OpenWifi {
 			Poco::Data::Statement Select(Sess);
 			Select << Statement + DateSelector;
 			Select.execute();
-
+			Sess.commit();
 			return true;
 		} catch (const Poco::Exception &E) {
 			poco_warning(Logger(), (fmt::format("{}: Failed with: {}", std::string(__func__),
diff --git a/src/storage/storage_tables.cpp b/src/storage/storage_tables.cpp
index a54eaa92..08d1cbb2 100644
--- a/src/storage/storage_tables.cpp
+++ b/src/storage/storage_tables.cpp
@@ -275,9 +275,21 @@ namespace OpenWifi {
 						"Models TEXT, "
 						"Description TEXT, "
 						"Created BIGINT , "
-						"LastModified BIGINT)",
+						"LastModified BIGINT, Platform TEXT)",
 					Poco::Data::Keywords::now;
 			}
+
+			std::vector<std::string> Script{
+				"alter table DefaultConfigs add column Platform text"
+			};
+
+			for (const auto &i : Script) {
+				try {
+					Sess << i, Poco::Data::Keywords::now;
+				} catch (...) {
+				}
+			}
+
 			return 0;
 		} catch (const Poco::Exception &E) {
 			Logger().log(E);