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

Chg: update image tag in helm values to v2.7.1-RC2
Merge pull request #266 from Telecominfraproject/master
2025-11-02 03:37:57 +00:00 · 2022-10-19 23:07:27 +00:00 · 2022-10-14 19:14:55 +00:00 · 2022-10-14 11:53:10 -07:00 · 2022-10-14 11:50:32 -07:00 · 2022-10-14 10:43:04 -07:00
56 changed files with 962 additions and 2055 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.13)
-project(owgw VERSION 2.7.0)
+project(owgw VERSION 2.7.1)

 set(CMAKE_CXX_STANDARD 17)

@@ -79,8 +79,10 @@ add_executable( owgw
        src/framework/KafkaTopics.h
        src/framework/MicroService.h
        src/framework/OpenWifiTypes.h
+        src/framework/MicroServiceErrorHandler.h
        src/framework/orm.h
        src/framework/StorageClass.h
+        src/framework/MicroServiceErrorHandler.h
        src/RESTObjects/RESTAPI_SecurityObjects.h src/RESTObjects/RESTAPI_SecurityObjects.cpp
        src/RESTObjects/RESTAPI_ProvObjects.cpp src/RESTObjects/RESTAPI_ProvObjects.h
        src/RESTObjects/RESTAPI_GWobjects.h src/RESTObjects/RESTAPI_GWobjects.cpp
@@ -108,7 +110,7 @@ add_executable( owgw
        src/Daemon.cpp src/Daemon.h
        src/AP_WS_Server.cpp src/AP_WS_Server.h
        src/StorageService.cpp src/StorageService.h
-        src/DeviceRegistry.cpp src/DeviceRegistry.h
+#        src/DeviceRegistry.cpp src/DeviceRegistry.h
        src/CommandManager.cpp src/CommandManager.h
        src/CentralConfig.cpp src/CentralConfig.h
        src/FileUploader.cpp src/FileUploader.h
--- a/26
+++ b/26
@@ -1,16 +1,16 @@
-ARG ALPINE_VERSION=3.16.2
+ARG DEBIAN_VERSION=11.5-slim
 ARG POCO_VERSION=poco-tip-v1
 ARG FMTLIB_VERSION=9.0.0
 ARG CPPKAFKA_VERSION=tip-v1
 ARG JSON_VALIDATOR_VERSION=2.1.0

-FROM alpine:$ALPINE_VERSION AS build-base
+FROM debian:$DEBIAN_VERSION AS build-base

-RUN apk add --update --no-cache \
+RUN apt-get update && apt-get install --no-install-recommends -y \
    make cmake g++ git \
-    unixodbc-dev postgresql-dev mariadb-dev \
-    librdkafka-dev boost-dev openssl-dev \
-    zlib-dev nlohmann-json ca-certificates
+    libpq-dev libmariadb-dev libmariadbclient-dev-compat \
+    librdkafka-dev libboost-all-dev libssl-dev \
+    zlib1g-dev nlohmann-json3-dev ca-certificates

 FROM build-base AS poco-build

@@ -90,21 +90,21 @@ WORKDIR /owgw/cmake-build
 RUN cmake ..
 RUN cmake --build . --config Release -j8

-FROM alpine:$ALPINE_VERSION
+FROM debian:$DEBIAN_VERSION

 ENV OWGW_USER=owgw \
    OWGW_ROOT=/owgw-data \
    OWGW_CONFIG=/owgw-data

-RUN addgroup -S "$OWGW_USER" && \
-    adduser -S -G "$OWGW_USER" "$OWGW_USER"
+RUN useradd "$OWGW_USER"

 RUN mkdir /openwifi
 RUN mkdir -p "$OWGW_ROOT" "$OWGW_CONFIG" && \
    chown "$OWGW_USER": "$OWGW_ROOT" "$OWGW_CONFIG"

-RUN apk add --update --no-cache librdkafka su-exec gettext ca-certificates bash jq curl \
-    mariadb-connector-c libpq unixodbc postgresql-client
+RUN apt-get update && apt-get install --no-install-recommends -y \
+    librdkafka++1 gosu gettext ca-certificates bash jq curl wget \
+    libmariadb-dev-compat libpq5 unixodbc postgresql-client

 COPY readiness_check /readiness_check
 COPY test_scripts/curl/cli /cli
@@ -114,12 +114,14 @@ COPY docker-entrypoint.sh /
 COPY wait-for-postgres.sh /
 COPY rtty_ui /dist/rtty_ui
 RUN wget https://raw.githubusercontent.com/Telecominfraproject/wlan-cloud-ucentral-deploy/main/docker-compose/certs/restapi-ca.pem \
-    -O /usr/local/share/ca-certificates/restapi-ca-selfsigned.pem
+    -O /usr/local/share/ca-certificates/restapi-ca-selfsigned.crt

 COPY --from=owgw-build /owgw/cmake-build/owgw /openwifi/owgw
 COPY --from=cppkafka-build /cppkafka/cmake-build/src/lib /usr/local/lib/
 COPY --from=poco-build /poco/cmake-build/lib /usr/local/lib

+RUN ldconfig
+
 EXPOSE 15002 16002 16003 17002 16102

 ENTRYPOINT ["/docker-entrypoint.sh"]
--- a/README.md
+++ b/README.md
@@ -119,54 +119,61 @@ cmake ..
 make

 ```
- 
-### OSX Build
-The following instructions have proven to work on OSX Big Sur. You need to install [Homebrew](https://brew.sh/). You must also have installed [XCode for OS X](https://www.freecodecamp.org/news/how-to-download-and-install-xcode/).
+
+### macOS Build
+The following instructions have proven to work on macOS Big Sur. You need to install [Homebrew](https://brew.sh/). You must also have installed [XCode for OS X](https://www.freecodecamp.org/news/how-to-download-and-install-xcode/).
 ```
-brew install openssl
-brew install cmake
-brew install libpq
-brew install mysql-client
-brew install apr
-brew install apr-util
-brew install boost
-brew install yaml-cpp
-brew install postgresql
-brew install librdkafka
-brew install nlohmann-json
+brew install openssl \
+	cmake \
+	libpq \
+	mysql-client \
+	apr \
+	apr-util \
+	boost \
+	yaml-cpp \
+	postgresql \
+	librdkafka \
+	nlohmann-json \
+	fmt

 git clone https://github.com/AriliaWireless/poco --branch poco-tip-v1
-cd poco
+pushd poco
 mkdir cmake-build
-cd cmake-build
-cmake ..
+push cmake-build
+cmake -DOPENSSL_ROOT_DIR=</path/to/openssl> -DENABLE_NETSSL=1 -DENABLE_JWT=1 -DENABLE_CRYPTO=1 ..
 cmake --build . --config Release
 sudo cmake --build . --target install
+popd
+popd

 git clone https://github.com/AriliaWireless/cppkafka --branch tip-v1
-cd cppkafka
+pushd cppkafka
 mkdir cmake-build
-cd cmake-build
+pushd cmake-build
 cmake ..
 cmake --build . --config Release
 sudo cmake --build . --target install
+popd
+popd

-cd ~
 git clone https://github.com/pboettch/json-schema-validator.git --branch 2.1.0
-cd json-schema-validator
+pushd json-schema-validator
 mkdir cmake-build
-cd cmake-build
+pushd cmake-build
 cmake ..
 make -j
 sudo make install
+popd
+popd

-cd ~
 git clone https://github.com/Telecominfraproject/wlan-cloud-ucentralgw
-cd wlan-cloud-ucentralgw
+pushd wlan-cloud-ucentralgw
 mkdir cmake-build
-cd cmake-build
+pushd cmake-build
 cmake ..
 make -j
+popd
+popd
 ```

 ### Raspberry
--- a/2
+++ b/2
@@ -1 +1 @@
-125
+6
--- a/cmake-build-debug/.cmake/api/v1/reply/cmakeFiles-v1-226c9bda5ef53b58a803.json
+++ b/cmake-build-debug/.cmake/api/v1/reply/cmakeFiles-v1-226c9bda5ef53b58a803.json
--- a/cmake-build-debug/rdkafka_version_test.cpp
+++ b/cmake-build-debug/rdkafka_version_test.cpp
@@ -1,4 +0,0 @@
-#include <librdkafka/rdkafka.h>
- #if RD_KAFKA_VERSION >= 0x00090400
- int main() { }
- #endif
--- a/config.yaml
+++ b/config.yaml
@@ -1,26 +0,0 @@
-tip:
-  port: 6051
-  server: ssc.wlan.local
-  username: support@example.com
-  password: support
-
-certificates:
-  keyfile: keyfile.pem
-  certfile: certfile.pem
-  password: mypassword
-
-ucentral:
-  port: 1991
-  listeners: 100
-
-logger:
-  size: 10
-  days: 31
-
-ui:
-  port: 9771
-  username: support@example.com
-  password: support
-
-
-
--- a/docker-entrypoint.sh
+++ b/docker-entrypoint.sh
@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 set -e

 if [ "$SELFSIGNED_CERTS" = 'true' ]; then
@@ -95,7 +95,7 @@ if [ "$1" = '/openwifi/owgw' -a "$(id -u)" = '0' ]; then
    if [ "$RUN_CHOWN" = 'true' ]; then
        chown -R "$OWGW_USER": "$OWGW_ROOT" "$OWGW_CONFIG"
    fi
-    exec su-exec "$OWGW_USER" "$@"
+    exec gosu "$OWGW_USER" "$@"
 fi

 exec "$@"
--- a/docker_build.sh
+++ b/docker_build.sh
@@ -1,14 +0,0 @@
-USERNAME=arilia
-HUBNAME=tip-tip-wlan-cloud-ucentral.jfrog.io
-IMAGE_NAME=ucentralgw
-
-echo "Removing docker images before build..."
-docker rmi -f $(docker images -a -q)
-echo "Building $IMAGE_NAME image..."
-docker build --no-cache --tag $IMAGE_NAME .
-IMAGE_ID=`docker images -q $IMAGE_NAME`
-docker login --username=$USERNAME $HUBNAME
-docker tag $IMAGE_ID $HUBNAME/$IMAGE_NAME:latest
-echo "Updating $HUBNAME with the latest $IMAGE_NAME image..."
-docker push $HUBNAME/$IMAGE_NAME
-docker logout $HUBNAME
--- a/docker_clean.sh
+++ b/docker_clean.sh
@@ -1,5 +0,0 @@
-#!/bin/sh
-
-# Removes all local images. This is dangerous but good when debugging
-docker rmi -f $(docker images -a -q)
-
--- a/docker_run.sh
+++ b/docker_run.sh
@@ -1,43 +0,0 @@
-#!/bin/sh
-
-HUBNAME=tip-tip-wlan-cloud-ucentral.jfrog.io
-IMAGE_NAME=ucentralgw
-DOCKER_NAME=$HUBNAME/$IMAGE_NAME:master
-
-CONTAINER_NAME=ucentralgw
-
-#stop previously running images
-docker container stop $CONTAINER_NAME
-docker container rm $CONTAINER_NAME --force
-
-if [[ ! -d logs ]]
-then
-    mkdir logs
-fi
-
-if [[ ! -d uploads ]]
-then
-    mkdir uploads
-fi
-
-if [[ ! -d certs ]]
-then
-  echo "certs directory does not exist. Please create and add the proper certificates."
-  exit 1
-fi
-
-if [[ ! -f owgw.properties ]]
-then
-  echo "Configuration file ucentral.properties is missing in the current directory"
-  exit 2
-fi
-
-docker run -d -p 15002:15002 \
-              -p 16001:16001 \
-              -p 16003:16003 \
-              --init \
-              --volume="$PWD:/ucentral-data" \
-              -e UCENTRALGW_ROOT="/ucentral-data" \
-              -e UCENTRALGW_CONFIG="/ucentral-data" \
-              --name="ucentralgw" $DOCKER_NAME
-
--- a/helm/values.yaml
+++ b/helm/values.yaml
@@ -9,7 +9,7 @@ fullnameOverride: ""
 images:
  owgw:
    repository: tip-tip-wlan-cloud-ucentral.jfrog.io/owgw
-    tag: v2.7.0-RC2
+    tag: v2.7.1
    pullPolicy: Always
 #    regcred:
 #      registry: tip-tip-wlan-cloud-ucentral.jfrog.io
@@ -138,7 +138,7 @@ resources: {}
  #  memory: 128Mi

 securityContext:
-  fsGroup: 101
+  fsGroup: 1000
  # Usage of unsafe sysctls requires multiple things:
  # - allow these unsafe sysctls on kubelet level (by adding --allowed-unsafe-sysctls flag)
  # - enabling addition of PodSecurityContext setting podSecurityPolicy.enabled to "true" below
--- a/owgw.properties
+++ b/owgw.properties
@@ -178,4 +178,4 @@ archiver.db.3.keep = 7
 ########################################################################
 logging.type = file
 logging.path = $OWGW_ROOT/logs
-logging.level = debug
+logging.level = information
--- a/owgw.properties.tmpl
+++ b/owgw.properties.tmpl
@@ -174,4 +174,4 @@ archiver.db.3.keep = 7
 ########################################################################
 logging.type = console
 logging.path = $OWGW_ROOT/logs
-logging.level = debug
+logging.level = information
--- a/pcap/radius
+++ b/pcap/radius
@@ -1,41 +0,0 @@
-/* Frame (255 bytes) */
-static const unsigned char pkt41[255] = {
-0x14, 0x98, 0x77, 0x71, 0xc6, 0xe7, 0x34, 0xef, /* ..wq..4. */
-0xb6, 0xaf, 0x4a, 0x5c, 0x08, 0x00, 0x45, 0x00, /* ..J\..E. */
-0x00, 0xf1, 0x87, 0x50, 0x00, 0x00, 0x40, 0x11, /* ...P..@. */
-0x0c, 0xdf, 0xc0, 0xa8, 0xb2, 0x1b, 0xc0, 0xa8, /* ........ */
-0xb2, 0x60, 0xc3, 0xfe, 0x07, 0x14, 0x00, 0xdd, /* .`...... */
-0x26, 0x63, 0x01, 0x04, 0x00, 0xd5, 0xcc, 0x29, /* &c.....) */
-0x82, 0x36, 0xd6, 0x57, 0x3d, 0xa7, 0xd5, 0x62, /* .6.W=..b */
-0x70, 0x12, 0x00, 0xc0, 0xf2, 0x19, 0x01, 0x03, /* p....... */
-0x61, 0x1e, 0x1c, 0x33, 0x34, 0x2d, 0x45, 0x46, /* a..34-EF */
-0x2d, 0x42, 0x36, 0x2d, 0x41, 0x46, 0x2d, 0x34, /* -B6-AF-4 */
-0x41, 0x2d, 0x36, 0x30, 0x3a, 0x4f, 0x70, 0x65, /* A-60:Ope */
-0x6e, 0x57, 0x69, 0x66, 0x69, 0x3d, 0x06, 0x00, /* nWifi=.. */
-0x00, 0x00, 0x13, 0x06, 0x06, 0x00, 0x00, 0x00, /* ........ */
-0x02, 0x05, 0x06, 0x00, 0x00, 0x00, 0x01, 0x1f, /* ........ */
-0x13, 0x42, 0x36, 0x2d, 0x43, 0x34, 0x2d, 0x30, /* .B6-C4-0 */
-0x36, 0x2d, 0x30, 0x39, 0x2d, 0x31, 0x35, 0x2d, /* 6-09-15- */
-0x42, 0x37, 0x4d, 0x18, 0x43, 0x4f, 0x4e, 0x4e, /* B7M.CONN */
-0x45, 0x43, 0x54, 0x20, 0x35, 0x34, 0x4d, 0x62, /* ECT 54Mb */
-0x70, 0x73, 0x20, 0x38, 0x30, 0x32, 0x2e, 0x31, /* ps 802.1 */
-0x31, 0x61, 0x2c, 0x12, 0x33, 0x42, 0x45, 0x44, /* 1a,.3BED */
-0x37, 0x32, 0x39, 0x30, 0x44, 0x30, 0x43, 0x38, /* 7290D0C8 */
-0x35, 0x36, 0x44, 0x33, 0xba, 0x06, 0x00, 0x0f, /* 56D3.... */
-0xac, 0x04, 0xbb, 0x06, 0x00, 0x0f, 0xac, 0x04, /* ........ */
-0xbc, 0x06, 0x00, 0x0f, 0xac, 0x05, 0xbd, 0x06, /* ........ */
-0x00, 0x0f, 0xac, 0x06, 0x1a, 0x1b, 0x00, 0x00, /* ........ */
-0xe6, 0x08, 0x47, 0x15, 0x01, 0x13, 0x33, 0x34, /* ..G...34 */
-0x2d, 0x65, 0x66, 0x2d, 0x62, 0x36, 0x2d, 0x61, /* -ef-b6-a */
-0x66, 0x2d, 0x34, 0x61, 0x2d, 0x35, 0x63, 0x0c, /* f-4a-5c. */
-0x06, 0x00, 0x00, 0x05, 0x78, 0x4f, 0x08, 0x02, /* ....xO.. */
-0x01, 0x00, 0x06, 0x01, 0x61, 0x50, 0x12, 0x20, /* ....aP.  */
-0x9c, 0xae, 0xe5, 0xe3, 0x77, 0xaf, 0x0b, 0x1b, /* ....w... */
-0xaf, 0x0e, 0xb5, 0x08, 0x82, 0x9e, 0xeb        /* ....... */
-};
-
-/* Reassembled EAP (6 bytes) */
-static const unsigned char pkt41_1[6] = {
-0x02, 0x01, 0x00, 0x06, 0x01, 0x61              /* .....a */
-};
-
--- a/pcap/radius.blob.bin
+++ b/pcap/radius.blob.bin
@@ -1 +0,0 @@
-192.168.178.1
--- a/pcap/radius.pcapng
+++ b/pcap/radius.pcapng
--- a/run.sh
+++ b/run.sh
@@ -1,24 +0,0 @@
-#!/bin/bash
-
-daemon=ucentralgw
-
-if [[ "$1" == "aws" ]]
-then
-	cp ${daemon}.properties.aws ${daemon}.properties
-	. ./set_env.sh
-	cd cmake-build
-	./${daemon} --daemon
-	echo "Running AWS version as daemon..."
-fi
-
-if [[ "$1" == "priv" ]]
-then
-  cp ${daemon}.properties.priv ${daemon}.properties
-  . ./set_env.sh
-  cd cmake-build
-  ./${daemon} --daemon
-  echo "Running private version as daemon..."
-fi
-
-
-
--- a/src/AP_WS_Connection.cpp
+++ b/src/AP_WS_Connection.cpp
@@ -62,6 +62,7 @@ namespace OpenWifi {
 			*WS_, Poco::NObserver<AP_WS_Connection, Poco::Net::ErrorNotification>(
 					  *this, &AP_WS_Connection::OnSocketError));
 		Registered_ = true;
+		Valid_ = true;
 	}

 	class ThreadedCounter {
@@ -89,6 +90,9 @@ namespace OpenWifi {
 		if(DeviceValidated_)
 			return true;

+		if(!Valid_)
+			return false;
+
 		try {
 			auto SockImpl = dynamic_cast<Poco::Net::WebSocketImpl *>(WS_->impl());
 			auto SS = dynamic_cast<Poco::Net::SecureStreamSocketImpl*>(SockImpl->streamSocketImpl());
@@ -189,125 +193,6 @@ namespace OpenWifi {
 		return false;
 	}

-	void AP_WS_Connection::CompleteStartup() {
-
-		std::lock_guard Guard(Mutex_);
-		auto TC = ThreadedCounter(Threaded_,ConcurrentStartingDevices_);
-
-		try {
-			auto SockImpl = dynamic_cast<Poco::Net::WebSocketImpl *>(WS_->impl());
-			auto SS = dynamic_cast<Poco::Net::SecureStreamSocketImpl*>(SockImpl->streamSocketImpl());
-
-/*			while (true) {
-				auto V = SS->completeHandshake();
-				if (V == 1)
-					break;
-			}
-*/
-			PeerAddress_ = SS->peerAddress().host();
-			CId_ = Utils::FormatIPv6(SS->peerAddress().toString());
-
-			State_.started = OpenWifi::Now();
-
-			if (!SS->secure()) {
-				poco_warning(Logger_,fmt::format("CONNECTION({}): Session={} Connection is NOT secure. Device is not allowed.", CId_, State_.sessionId ));
-				return EndConnection();
-			}
-
-			poco_debug(Logger_,fmt::format("CONNECTION({}): Session={} Connection is secure.", CId_, State_.sessionId ));
-
-			if (!SS->havePeerCertificate()) {
-				State_.VerifiedCertificate = GWObjects::NO_CERTIFICATE;
-				poco_warning(Logger_,fmt::format("CONNECTION({}): Session={} No certificates available..", CId_, State_.sessionId ));
-				return EndConnection();
-			}
-
-			Poco::Crypto::X509Certificate PeerCert(SS->peerCertificate());
-			if (!AP_WS_Server()->ValidateCertificate(CId_, PeerCert)) {
-				State_.VerifiedCertificate = GWObjects::NO_CERTIFICATE;
-				poco_warning(Logger_, fmt::format("CONNECTION({}): Session={} Device certificate is not valid. Device is not allowed.",
-												CId_, State_.sessionId ));
-				return EndConnection();
-			}
-			CN_ = Poco::trim(Poco::toLower(PeerCert.commonName()));
-			State_.VerifiedCertificate = GWObjects::VALID_CERTIFICATE;
-			poco_debug(Logger_,
-					   fmt::format("CONNECTION({}): Session={} Valid certificate: CN={}", CId_, State_.sessionId , CN_));
-
-			if (AP_WS_Server::IsSim(CN_) && !AP_WS_Server()->IsSimEnabled()) {
-				poco_warning(
-					Logger_,
-					fmt::format("CONNECTION({}): Session={} Sim Device {} is not allowed. Disconnecting.",
-								CId_, State_.sessionId , CN_));
-				return EndConnection();
-			}
-
-			if (!CN_.empty() && StorageService()->IsBlackListed(SerialNumber_)) {
-				poco_warning(
-					Logger_,
-					fmt::format("CONNECTION({}): Session={} Device {} is black listed. Disconnecting.",
-								CId_, State_.sessionId , CN_));
-				return EndConnection();
-			}
-
-			SerialNumber_ = CN_;
-			SerialNumberInt_ = Utils::SerialNumberToInt(SerialNumber_);
-
-			WS_->setMaxPayloadSize(BufSize);
-			auto TS = Poco::Timespan(360, 0);
-			WS_->setReceiveTimeout(TS);
-			WS_->setNoDelay(true);
-			WS_->setKeepAlive(true);
-			WS_->setBlocking(false);
-
-			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));
-			Registered_ = true;
-			poco_debug(Logger_, fmt::format("CONNECTION({}): Session={} CN={} Completed. (t={})", CId_, State_.sessionId , CN_, ConcurrentStartingDevices_));
-			return;
-		} catch (const Poco::Net::CertificateValidationException &E) {
-			poco_error(Logger_,fmt::format("CONNECTION({}): Session:{} Poco::CertificateValidationException Certificate Validation failed during connection. Device will have to retry.",
-										CId_, State_.sessionId ));
-			Logger_.log(E);
-		} catch (const Poco::Net::WebSocketException &E) {
-			poco_error(Logger_,fmt::format("CONNECTION({}): Session:{} Poco::WebSocketException WebSocket error during connection. Device will have to retry.",
-										CId_, State_.sessionId ));
-			Logger_.log(E);
-		} catch (const Poco::Net::ConnectionAbortedException &E) {
-			poco_error(Logger_,fmt::format("CONNECTION({}):Session:{}  Poco::ConnectionAbortedException Connection was aborted during connection. Device will have to retry.",
-										CId_, State_.sessionId ));
-			Logger_.log(E);
-		} catch (const Poco::Net::ConnectionResetException &E) {
-			poco_error(Logger_,fmt::format("CONNECTION({}): Session:{} Poco::ConnectionResetException Connection was reset during connection. Device will have to retry.",
-										CId_, State_.sessionId ));
-			Logger_.log(E);
-		} catch (const Poco::Net::InvalidCertificateException &E) {
-			poco_error(Logger_,fmt::format(
-				"CONNECTION({}): Session:{} Poco::InvalidCertificateException Invalid certificate. Device will have to retry.",
-				CId_, State_.sessionId ));
-			Logger_.log(E);
-		} catch (const Poco::Net::SSLException &E) {
-			poco_error(Logger_,fmt::format("CONNECTION({}): Session:{} Poco::SSLException SSL Exception during connection. Device will have to retry.",
-										CId_, State_.sessionId ));
-			Logger_.log(E);
-		} catch (const Poco::Exception &E) {
-			poco_error(Logger_,fmt::format("CONNECTION({}): Session:{} Poco::Exception caught during device connection. Device will have to retry.",
-										CId_, State_.sessionId ));
-			Logger_.log(E);
-		} catch (...) {
-			poco_error(Logger_,fmt::format("CONNECTION({}): Session:{} Exception caught during device connection. Device will have to retry. Unsecure connect denied.",
-										CId_, State_.sessionId ));
-		}
-		return EndConnection();
-	}
-
 	static void NotifyKafkaDisconnect(const std::string & SerialNumber) {
 		try {
 			Poco::JSON::Object Disconnect;
@@ -324,36 +209,38 @@ namespace OpenWifi {
 	}

 	AP_WS_Connection::~AP_WS_Connection() {
-		if(!Dead_)
-			EndConnection();
+		Valid_=false;
+		EndConnection();
 	}

 	void AP_WS_Connection::EndConnection() {
-		Dead_=true;
-		poco_information(Logger_,fmt::format("CONNECTION-CLOSING({}): Session={} Serial={}.", CId_, State_.sessionId, SerialNumber_));
-		auto SessionDeleted = DeviceRegistry()->EndSession(State_.sessionId, SerialNumberInt_);
+		Valid_=false;
+		if(!Dead_.test_and_set()) {

-		if (Registered_) {
-			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 (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 (KafkaManager()->Enabled() && !SerialNumber_.empty()) {
-			std::string s(SerialNumber_);
-			std::thread t([s]() { NotifyKafkaDisconnect(s); });
-			t.detach();
+			if (KafkaManager()->Enabled() && !SerialNumber_.empty()) {
+				std::string s(SerialNumber_);
+				std::thread t([s]() { NotifyKafkaDisconnect(s); });
+				t.detach();
+			}
+
+			auto SessionDeleted = AP_WS_Server()->EndSession(State_.sessionId, SerialNumberInt_);
+			if (SessionDeleted)
+				WebSocketClientNotificationDeviceDisconnected(SerialNumber_);
 		}
-		if(SessionDeleted)
-			WebSocketClientNotificationDeviceDisconnected(SerialNumber_);
-		AP_WS_Server()->DeleteConnection(State_.sessionId);
 	}

 	bool AP_WS_Connection::LookForUpgrade(const uint64_t UUID, uint64_t & UpgradedUUID) {
@@ -647,19 +534,19 @@ namespace OpenWifi {
 	}

 	void AP_WS_Connection::OnSocketShutdown([[maybe_unused]] const Poco::AutoPtr<Poco::Net::ShutdownNotification> &pNf) {
-		std::lock_guard Guard(Mutex_);
 		poco_trace(Logger_, fmt::format("SOCKET-SHUTDOWN({}): Closing.", CId_));
 		return EndConnection();
 	}

 	void AP_WS_Connection::OnSocketError([[maybe_unused]] const Poco::AutoPtr<Poco::Net::ErrorNotification> &pNf) {
-		std::lock_guard Guard(Mutex_);
 		poco_trace(Logger_, fmt::format("SOCKET-ERROR({}): Closing.", CId_));
 		return EndConnection();
 	}

 	void AP_WS_Connection::OnSocketReadable([[maybe_unused]] const Poco::AutoPtr<Poco::Net::ReadableNotification> &pNf) {
-		std::lock_guard Guard(Mutex_);
+
+		if(!Valid_)
+			return;

 		if(!AP_WS_Server()->Running())
 			return EndConnection();
--- a/src/AP_WS_Connection.h
+++ b/src/AP_WS_Connection.h
@@ -5,6 +5,8 @@
 #pragma once

 #include <string>
+#include <shared_mutex>
+
 #include "Poco/Net/SocketReactor.h"
 #include "Poco/Net/StreamSocket.h"
 #include "Poco/JSON/Object.h"
@@ -12,7 +14,6 @@
 #include "Poco/Logger.h"
 #include "Poco/Net/WebSocket.h"

-#include "DeviceRegistry.h"
 #include "RESTObjects/RESTAPI_GWobjects.h"


@@ -83,9 +84,10 @@ namespace OpenWifi {
 		}

 		friend class DeviceRegistry;
+		friend class AP_WS_Server;

 	  private:
-		std::recursive_mutex                Mutex_;
+		// std::recursive_mutex 				LocalMutex_;
 		std::shared_mutex					TelemetryMutex_;
 		Poco::Logger                    	&Logger_;
 		Poco::Net::SocketReactor			&Reactor_;
@@ -112,12 +114,12 @@ namespace OpenWifi {
 		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};
 		bool 								Threaded_=false;
-		std::atomic_bool 					Dead_=false;
+		std::atomic_flag 					Dead_=false;
 		std::atomic_bool 					DeviceValidated_=false;
+		std::atomic_bool 					Valid_=false;

 		static inline std::atomic_uint64_t 	ConcurrentStartingDevices_=0;

-		void CompleteStartup();
 		bool StartTelemetry(std::uint64_t RPCID);
 		bool StopTelemetry(std::uint64_t RPCID);
 		void UpdateCounts();
--- a/src/AP_WS_Process_cfgpending.cpp
+++ b/src/AP_WS_Process_cfgpending.cpp
@@ -3,6 +3,8 @@
 //

 #include "AP_WS_Connection.h"
+#include "fmt/format.h"
+#include "framework/ow_constants.h"

 namespace OpenWifi {
 	void AP_WS_Connection::Process_cfgpending(Poco::JSON::Object::Ptr ParamsObj) {
--- a/src/AP_WS_Process_connect.cpp
+++ b/src/AP_WS_Process_connect.cpp
@@ -8,6 +8,7 @@
 #include "FindCountry.h"
 #include "framework/WebSocketClientNotifications.h"
 #include "Daemon.h"
+#include "CentralConfig.h"

 #include "CommandManager.h"

@@ -19,15 +20,17 @@ void AP_WS_Connection::Process_connect(Poco::JSON::Object::Ptr ParamsObj, const
 		ParamsObj->has(uCentralProtocol::CAPABILITIES)) {
 		uint64_t UUID = ParamsObj->get(uCentralProtocol::UUID);
 		auto Firmware = ParamsObj->get(uCentralProtocol::FIRMWARE).toString();
-		auto Capabilities = ParamsObj->get(uCentralProtocol::CAPABILITIES).toString();
+		auto CapabilitiesString = ParamsObj->get(uCentralProtocol::CAPABILITIES).toString();
+
+		Config::Capabilities Caps(CapabilitiesString);
+		Compatible_ = Caps.Compatible();

-		//// change this
 		SerialNumber_ = Serial;
 		SerialNumberInt_ = Utils::SerialNumberToInt(SerialNumber_);

 		CommandManager()->ClearQueue(SerialNumberInt_);

-		DeviceRegistry()->SetSessionDetails(State_.sessionId,SerialNumberInt_);
+		AP_WS_Server()->SetSessionDetails(State_.sessionId,SerialNumberInt_);
 		State_.UUID = UUID;
 		State_.Firmware = Firmware;
 		State_.PendingUUID = 0;
@@ -43,16 +46,22 @@ void AP_WS_Connection::Process_connect(Poco::JSON::Object::Ptr ParamsObj, const
 		GWObjects::Device	DeviceInfo;
 		auto DeviceExists = StorageService()->GetDevice(SerialNumber_,DeviceInfo);
 		if (Daemon()->AutoProvisioning() && !DeviceExists) {
-			StorageService()->CreateDefaultDevice(SerialNumber_, Capabilities, Firmware,
+			StorageService()->CreateDefaultDevice(SerialNumber_, CapabilitiesString, Firmware,
 												  Compatible_, PeerAddress_);
 		} else if (DeviceExists) {
-			StorageService()->UpdateDeviceCapabilities(SerialNumber_, Capabilities,
+			StorageService()->UpdateDeviceCapabilities(SerialNumber_, CapabilitiesString,
 													   Compatible_);
 			bool Updated = false;
-			if(!Firmware.empty() && Firmware!=DeviceInfo.Firmware) {
-				DeviceInfo.Firmware = Firmware;
-				Updated = true;
-				WebSocketClientNotificationDeviceFirmwareUpdated(SerialNumber_, Firmware);
+			if(!Firmware.empty()) {
+				if(Firmware!=DeviceInfo.Firmware) {
+					DeviceInfo.Firmware = Firmware;
+					DeviceInfo.LastFWUpdate = OpenWifi::Now();
+					Updated = true;
+					WebSocketClientNotificationDeviceFirmwareUpdated(SerialNumber_, Firmware);
+				} else if(DeviceInfo.LastFWUpdate==0) {
+					DeviceInfo.LastFWUpdate = OpenWifi::Now();
+					Updated = true;
+				}
 			}

 			if(DeviceInfo.locale != State_.locale) {
@@ -105,6 +114,8 @@ void AP_WS_Connection::Process_connect(Poco::JSON::Object::Ptr ParamsObj, const

 		WebSocketClientNotificationDeviceConnected(SerialNumber_);

+		// std::cout << "Serial: " << SerialNumber_ << "Session: " << State_.sessionId << std::endl;
+
 		if (KafkaManager()->Enabled()) {
 			Poco::JSON::Stringifier Stringify;
 			ParamsObj->set(uCentralProtocol::CONNECTIONIP, CId_);
--- a/src/AP_WS_Process_ping.cpp
+++ b/src/AP_WS_Process_ping.cpp
@@ -3,6 +3,8 @@
 //

 #include "AP_WS_Connection.h"
+#include "fmt/format.h"
+#include "framework/ow_constants.h"

 namespace OpenWifi {
 	void AP_WS_Connection::Process_ping(Poco::JSON::Object::Ptr ParamsObj) {
--- a/src/AP_WS_Server.cpp
+++ b/src/AP_WS_Server.cpp
@@ -11,8 +11,10 @@
 #include "Poco/Net/Context.h"

 #include "AP_WS_Server.h"
+#include "AP_WS_Connection.h"
 #include "ConfigurationCache.h"
 #include "TelemetryStream.h"
+#include "framework/WebSocketClientNotifications.h"

 namespace OpenWifi {

@@ -143,14 +145,65 @@ namespace OpenWifi {
 		SimulatorEnabled_ = !SimulatorId_.empty();
 		Utils::SetThreadName(ReactorThread_,"dev:react:head");

+		GarbageCollectorCallback_ = std::make_unique<Poco::TimerCallback<AP_WS_Server>>(*this,&AP_WS_Server::onGarbageCollecting);
+		Timer_.setStartInterval(10 * 1000);
+		Timer_.setPeriodicInterval(5 * 1000); // every minute
+		Timer_.start(*GarbageCollectorCallback_, MicroService::instance().TimerPool());
+
 		Running_ = true;
 		return 0;
 	}

+	void AP_WS_Server::onGarbageCollecting([[maybe_unused]] Poco::Timer &timer) {
+		std::lock_guard			Lock(LocalMutex_);
+		if(Garbage_.size()>0) {
+			std::cout << "Removing " << Garbage_.size() << " old connections." << std::endl;
+			Garbage_.clear();
+		}
+
+		static std::uint64_t last_log = OpenWifi::Now();
+
+		NumberOfConnectedDevices_ = 0;
+		NumberOfConnectingDevices_ = 0;
+		AverageDeviceConnectionTime_ = 0;
+		std::uint64_t	total_connected_time=0;
+
+		auto now = OpenWifi::Now();
+		for (auto connection=SerialNumbers_.begin(); connection!=SerialNumbers_.end();) {
+
+			if(connection->second.second== nullptr) {
+				connection++;
+				continue;
+			}
+
+			if (connection->second.second->State_.Connected) {
+				NumberOfConnectedDevices_++;
+				total_connected_time += (now - connection->second.second->State_.started);
+				connection++;
+			} else {
+				NumberOfConnectingDevices_++;
+				connection++;
+			}
+		}
+
+		AverageDeviceConnectionTime_ = (NumberOfConnectedDevices_!=0) ? total_connected_time/NumberOfConnectedDevices_ : 0;
+		if((now-last_log)>120) {
+			last_log = now;
+			poco_information(Logger(),
+							 fmt::format("Active AP connections: {} Connecting: {} Average connection time: {} seconds",
+										 NumberOfConnectedDevices_, NumberOfConnectingDevices_, AverageDeviceConnectionTime_));
+		}
+		WebSocketClientNotificationNumberOfConnections(NumberOfConnectedDevices_,
+													   AverageDeviceConnectionTime_,
+													   NumberOfConnectingDevices_);
+	}
+
 	void AP_WS_Server::Stop() {
 		poco_information(Logger(),"Stopping...");
 		Running_ = false;

+		Timer_.stop();
+
 		for(auto &server:WebServers_) {
 			server->stopAll();
 		}
@@ -160,4 +213,198 @@ namespace OpenWifi {
 		poco_information(Logger(),"Stopped...");
 	}

+	bool AP_WS_Server::GetStatistics(std::uint64_t SerialNumber, std::string &Statistics) const {
+		std::lock_guard			Lock(LocalMutex_);
+		auto Device = SerialNumbers_.find(SerialNumber);
+		if(Device == SerialNumbers_.end() || Device->second.second==nullptr)
+			return false;
+		Statistics = Device->second.second->LastStats_;
+		return true;
+	}
+
+	bool AP_WS_Server::GetState(uint64_t SerialNumber, GWObjects::ConnectionState & State) const {
+		std::lock_guard			Lock(LocalMutex_);
+		auto Device = SerialNumbers_.find(SerialNumber);
+		if(Device == SerialNumbers_.end() || Device->second.second==nullptr)
+			return false;
+		State = Device->second.second->State_;
+		return true;
+	}
+
+	bool AP_WS_Server::GetHealthcheck(uint64_t SerialNumber, GWObjects::HealthCheck & CheckData) const {
+		std::lock_guard			Lock(LocalMutex_);
+
+		auto Device = SerialNumbers_.find(SerialNumber);
+		if(Device == SerialNumbers_.end() || Device->second.second==nullptr)
+			return false;
+
+		CheckData = Device->second.second->LastHealthcheck_;
+		return true;
+	}
+
+	void AP_WS_Server::SetSessionDetails(std::uint64_t connection_id, uint64_t SerialNumber) {
+		std::lock_guard			Lock(LocalMutex_);
+
+		auto Conn = Sessions_.find(connection_id);
+		if(Conn == end(Sessions_))
+			return;
+
+		auto CurrentSerialNumber = SerialNumbers_.find(SerialNumber);
+		if(	(CurrentSerialNumber==SerialNumbers_.end())	||
+			(CurrentSerialNumber->second.first<connection_id)) {
+			SerialNumbers_[SerialNumber] = std::make_pair(connection_id, Conn->second.first);
+			return;
+		}
+	}
+
+	bool AP_WS_Server::EndSession(std::uint64_t session_id, std::uint64_t serial_number) {
+		std::unique_lock G(LocalMutex_);
+
+		auto Session = Sessions_.find(session_id);
+		if(Session==end(Sessions_))
+			return false;
+
+		Garbage_.push_back(Session->second.first);
+
+		auto Device = SerialNumbers_.find(serial_number);
+		if (Device == end(SerialNumbers_)) {
+			Sessions_.erase(Session);
+			return false;
+		}
+
+		if(Device->second.first==session_id) {
+			Sessions_.erase(Session);
+			SerialNumbers_.erase(Device);
+			return true;
+		}
+
+		Sessions_.erase(Session);
+		return false;
+	}
+
+	bool AP_WS_Server::Connected(uint64_t SerialNumber) const {
+		std::lock_guard			Lock(LocalMutex_);
+		auto Device = SerialNumbers_.find(SerialNumber);
+		if(Device==end(SerialNumbers_) || Device->second.second== nullptr)
+			return false;
+
+		return  Device->second.second->State_.Connected;
+	}
+
+	bool AP_WS_Server::SendFrame(uint64_t SerialNumber, const std::string & Payload) const {
+		std::lock_guard			Lock(LocalMutex_);
+		auto Device = SerialNumbers_.find(SerialNumber);
+		if(Device==SerialNumbers_.end() || Device->second.second== nullptr)
+			return false;
+
+		try {
+			// std::cout << "Device connection pointer: " << (std::uint64_t) Device->second.second << std::endl;
+			return Device->second.second->Send(Payload);
+		} catch (...) {
+			poco_debug(Logger(),fmt::format(": SendFrame: Could not send data to device '{}'", Utils::IntToSerialNumber(SerialNumber)));
+		}
+		return false;
+	}
+
+	void AP_WS_Server::StopWebSocketTelemetry(std::uint64_t RPCID, uint64_t SerialNumber) {
+		std::lock_guard			Lock(LocalMutex_);
+
+		auto Device = SerialNumbers_.find(SerialNumber);
+		if(Device==end(SerialNumbers_) || Device->second.second==nullptr)
+			return;
+		Device->second.second->StopWebSocketTelemetry(RPCID);
+	}
+
+	void AP_WS_Server::SetWebSocketTelemetryReporting(std::uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime) {
+		std::lock_guard			Lock(LocalMutex_);
+
+		auto Device = SerialNumbers_.find(SerialNumber);
+		if(Device==end(SerialNumbers_) || Device->second.second==nullptr)
+			return;
+		Device->second.second->SetWebSocketTelemetryReporting(RPCID, Interval, Lifetime);
+	}
+
+	void AP_WS_Server::SetKafkaTelemetryReporting(std::uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime) {
+		std::lock_guard			Lock(LocalMutex_);
+
+		auto Device = SerialNumbers_.find(SerialNumber);
+		if(Device==end(SerialNumbers_) || Device->second.second== nullptr)
+			return;
+		Device->second.second->SetKafkaTelemetryReporting(RPCID, Interval, Lifetime);
+	}
+
+	void AP_WS_Server::StopKafkaTelemetry(std::uint64_t RPCID, uint64_t SerialNumber) {
+		std::lock_guard			Lock(LocalMutex_);
+
+		auto Device = SerialNumbers_.find(SerialNumber);
+		if(Device==end(SerialNumbers_) || Device->second.second== nullptr)
+			return;
+		Device->second.second->StopKafkaTelemetry(RPCID);
+	}
+
+	void AP_WS_Server::GetTelemetryParameters(uint64_t SerialNumber , bool & TelemetryRunning,
+												uint64_t & TelemetryInterval,
+												uint64_t & TelemetryWebSocketTimer,
+												uint64_t & TelemetryKafkaTimer,
+												uint64_t & TelemetryWebSocketCount,
+												uint64_t & TelemetryKafkaCount,
+												uint64_t & TelemetryWebSocketPackets,
+												uint64_t & TelemetryKafkaPackets) {
+		std::lock_guard			Lock(LocalMutex_);
+
+		auto Device = SerialNumbers_.find(SerialNumber);
+		if(Device==end(SerialNumbers_)|| Device->second.second== nullptr)
+			return;
+		Device->second.second->GetTelemetryParameters(TelemetryRunning,
+													  TelemetryInterval,
+													  TelemetryWebSocketTimer,
+													  TelemetryKafkaTimer,
+													  TelemetryWebSocketCount,
+													  TelemetryKafkaCount,
+													  TelemetryWebSocketPackets,
+													  TelemetryKafkaPackets);
+	}
+
+	bool AP_WS_Server::SendRadiusAccountingData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size) {
+		std::lock_guard			Lock(LocalMutex_);
+		auto Device = 		SerialNumbers_.find(Utils::SerialNumberToInt(SerialNumber));
+		if(Device==SerialNumbers_.end() || Device->second.second== nullptr)
+			return false;
+
+		try {
+			return Device->second.second->SendRadiusAccountingData(buffer,size);
+		} catch (...) {
+			poco_debug(Logger(),fmt::format(": SendRadiusAuthenticationData: Could not send data to device '{}'", SerialNumber));
+		}
+		return false;
+	}
+
+	bool AP_WS_Server::SendRadiusAuthenticationData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size) {
+		std::lock_guard			Lock(LocalMutex_);
+		auto Device = 		SerialNumbers_.find(Utils::SerialNumberToInt(SerialNumber));
+		if(Device==SerialNumbers_.end() || Device->second.second== nullptr)
+			return false;
+
+		try {
+			return Device->second.second->SendRadiusAuthenticationData(buffer,size);
+		} catch (...) {
+			poco_debug(Logger(),fmt::format(": SendRadiusAuthenticationData: Could not send data to device '{}'", SerialNumber));
+		}
+		return false;
+	}
+
+	bool AP_WS_Server::SendRadiusCoAData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size) {
+		std::lock_guard			Lock(LocalMutex_);
+		auto Device = 		SerialNumbers_.find(Utils::SerialNumberToInt(SerialNumber));
+		if(Device==SerialNumbers_.end() || Device->second.second== nullptr)
+			return false;
+
+		try {
+			return Device->second.second->SendRadiusCoAData(buffer,size);
+		} catch (...) {
+			poco_debug(Logger(),fmt::format(": SendRadiusCoAData: Could not send data to device '{}'", SerialNumber));
+		}
+		return false;
+	}
+
 }      //namespace
--- a/src/AP_WS_Server.h
+++ b/src/AP_WS_Server.h
@@ -19,6 +19,7 @@
 #include "Poco/Net/SocketReactor.h"
 #include "Poco/Net/ParallelSocketAcceptor.h"
 #include "Poco/Net/SocketAcceptor.h"
+#include "Poco/Timer.h"

 #include "AP_WS_Connection.h"
 #include "AP_WS_ReactorPool.h"
@@ -100,41 +101,98 @@ namespace OpenWifi {
 		[[nodiscard]] inline bool Running() const { return Running_; }

 		inline void AddConnection(std::uint64_t session_id, std::shared_ptr<AP_WS_Connection> Connection ) {
-			std::unique_lock			Lock(LocalMutex_);
-			Connections_[session_id] = Connection;
-		}
-
-		inline void DeleteConnection(std::uint64_t session_id) {
-			std::unique_lock			Lock(LocalMutex_);
-			Connections_.erase(session_id);
+			std::lock_guard			Lock(LocalMutex_);
+			Sessions_[session_id] = std::make_pair(std::move(Connection),false);
 		}

 		inline std::shared_ptr<AP_WS_Connection> FindConnection(std::uint64_t session_id) const {
-			std::shared_lock	Lock(LocalMutex_);
+			std::lock_guard			Lock(LocalMutex_);

-			auto Connection = Connections_.find(session_id);
-			if(Connection!=end(Connections_))
-				return Connection->second;
+			auto Connection = Sessions_.find(session_id);
+			if(Connection!=end(Sessions_))
+				return Connection->second.first;
 			return nullptr;
 		}

+		inline bool GetStatistics(const std::string &SerialNumber, std::string & Statistics) const {
+			return GetStatistics(Utils::SerialNumberToInt(SerialNumber),Statistics);
+		}
+		bool GetStatistics(std::uint64_t SerialNumber, std::string & Statistics) const ;
+
+		inline bool GetState(const std::string & SerialNumber, GWObjects::ConnectionState & State) const {
+			return GetState(Utils::SerialNumberToInt(SerialNumber), State);
+		}
+		bool GetState(std::uint64_t SerialNumber, GWObjects::ConnectionState & State) const;
+
+		inline bool GetHealthcheck(const std::string &SerialNumber, GWObjects::HealthCheck & CheckData) const {
+			return GetHealthcheck(Utils::SerialNumberToInt(SerialNumber), CheckData);
+		}
+		bool GetHealthcheck(std::uint64_t SerialNumber, GWObjects::HealthCheck & CheckData) const ;
+
+		bool Connected(uint64_t SerialNumber) const ;
+
+		inline bool SendFrame(const std::string & SerialNumber, const std::string & Payload) const {
+			return SendFrame(Utils::SerialNumberToInt(SerialNumber), Payload);
+		}
+
+		bool SendFrame(std::uint64_t SerialNumber, const std::string & Payload) const ;
+
+		bool SendRadiusAuthenticationData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size);
+		bool SendRadiusAccountingData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size);
+		bool SendRadiusCoAData(const std::string & SerialNumber, const unsigned char * buffer, std::size_t size);
+
+		void SetSessionDetails(std::uint64_t connection_id, uint64_t SerialNumber);
+		bool EndSession(std::uint64_t connection_id, std::uint64_t serial_number);
+
+		void SetWebSocketTelemetryReporting(std::uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime);
+		void StopWebSocketTelemetry(std::uint64_t RPCID, uint64_t SerialNumber);
+		void SetKafkaTelemetryReporting(std::uint64_t RPCID, uint64_t SerialNumber, uint64_t Interval, uint64_t Lifetime);
+		void StopKafkaTelemetry(std::uint64_t RPCID, uint64_t SerialNumber);
+		void GetTelemetryParameters(uint64_t SerialNumber , bool & TelemetryRunning,
+									uint64_t & TelemetryInterval,
+									uint64_t & TelemetryWebSocketTimer,
+									uint64_t & TelemetryKafkaTimer,
+									uint64_t & TelemetryWebSocketCount,
+									uint64_t & TelemetryKafkaCount,
+									uint64_t & TelemetryWebSocketPackets,
+									uint64_t & TelemetryKafkaPackets);
+
+		void onGarbageCollecting(Poco::Timer & timer);
+
+		inline void AverageDeviceStatistics( std::uint64_t & Connections, std::uint64_t & AverageConnectionTime, std::uint64_t & NumberOfConnectingDevices) const {
+			Connections = NumberOfConnectedDevices_;
+			AverageConnectionTime = AverageDeviceConnectionTime_;
+			NumberOfConnectingDevices = NumberOfConnectingDevices_;
+		}
+
 	private:
-		mutable std::shared_mutex									LocalMutex_;
+		mutable std::recursive_mutex								LocalMutex_;
 		std::unique_ptr<Poco::Crypto::X509Certificate>				IssuerCert_;
 		std::list<std::unique_ptr<Poco::Net::HTTPServer>>			WebServers_;
 		Poco::Net::SocketReactor									Reactor_;
 		Poco::Thread												ReactorThread_;
 		std::string 												SimulatorId_;
-		Poco::ThreadPool											DeviceConnectionPool_{"ws:dev-pool", 2, 32};
+		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>>	Connections_;
+		std::map<std::uint64_t,	std::pair<std::shared_ptr<AP_WS_Connection>,bool>>	Sessions_;
+		std::map<std::uint64_t, std::pair<std::uint64_t,std::shared_ptr<AP_WS_Connection>>>	SerialNumbers_;
 		std::atomic_bool 											AllowSerialNumberMismatch_=true;
 		std::atomic_uint64_t 										MismatchDepth_=2;

+		std::atomic_uint64_t 										NumberOfConnectedDevices_=0;
+		std::atomic_uint64_t 										AverageDeviceConnectionTime_=0;
+		std::atomic_uint64_t 										NumberOfConnectingDevices_=0;
+
+		std::vector<std::shared_ptr<AP_WS_Connection>>				Garbage_;
+
+		std::unique_ptr<Poco::TimerCallback<AP_WS_Server>>   		GarbageCollectorCallback_;
+		Poco::Timer                     							Timer_;
+		Poco::Thread												GarbageCollector_;
+
 		AP_WS_Server() noexcept:
 			SubSystemServer("WebSocketServer", "WS-SVR", "ucentral.websocket") {
 		}
--- a/src/CommandManager.cpp
+++ b/src/CommandManager.cpp
@@ -13,7 +13,7 @@
 #include "Poco/JSON/Parser.h"

 #include "CommandManager.h"
-#include "DeviceRegistry.h"
+#include "AP_WS_Server.h"
 #include "StorageService.h"
 #include "framework/ow_constants.h"

@@ -41,7 +41,7 @@ namespace OpenWifi {
 						uint64_t ID = Payload.get(uCentralProtocol::ID);
 						poco_debug(Logger(),fmt::format("({}): Processing {} response.", SerialNumber, ID));
 						if (ID > 1) {
-							std::unique_lock Lock(LocalMutex_);
+							std::lock_guard	Lock(LocalMutex_);
 							auto RPC = OutStandingRequests_.find(ID);
 							if (RPC == OutStandingRequests_.end() ||
 								RPC->second.SerialNumber !=
@@ -110,7 +110,7 @@ namespace OpenWifi {
    }

 	void CommandManager::onJanitorTimer([[maybe_unused]] Poco::Timer & timer) {
-		std::unique_lock Lock(LocalMutex_);
+		std::lock_guard	Lock(LocalMutex_);
 		Utils::SetThreadName("cmd:janitor");
 		Poco::Logger	& MyLogger = Poco::Logger::get("CMD-MGR-JANITOR");
 		auto now = std::chrono::high_resolution_clock::now();
@@ -131,7 +131,7 @@ namespace OpenWifi {
 	}

 	bool CommandManager::IsCommandRunning(const std::string &C) {
-		std::shared_lock Lock(LocalMutex_);
+		std::lock_guard	Lock(LocalMutex_);
 		for (const auto &request : OutStandingRequests_) {
 			if (request.second.UUID == C) {
 				return true;
@@ -178,7 +178,7 @@ namespace OpenWifi {
 							continue;
 						}

-						if (!DeviceRegistry()->Connected(
+						if (!AP_WS_Server()->Connected(
 								Utils::SerialNumberToInt(Cmd.SerialNumber))) {
 							poco_trace(
 								MyLogger,
@@ -268,7 +268,7 @@ namespace OpenWifi {
 		Idx.rpc_entry = disk_only ? nullptr : std::make_shared<CommandManager::promise_type_t>();

 		poco_debug(Logger(), fmt::format("{}: Sending command. ID: {}", UUID, RPCID));
-		if(DeviceRegistry()->SendFrame(SerialNumber, ToSend.str())) {
+		if(AP_WS_Server()->SendFrame(SerialNumber, ToSend.str())) {
 			if(!oneway_rpc) {
 				std::lock_guard M(Mutex_);
 				OutStandingRequests_[RPCID] = Idx;
--- a/src/CommandManager.h
+++ b/src/CommandManager.h
@@ -153,7 +153,7 @@ namespace OpenWifi {
 			}

 			inline bool CommandRunningForDevice(std::uint64_t SerialNumber, std::string & uuid, std::string &command) {
-				std::shared_lock	Lock(LocalMutex_);
+				std::lock_guard	Lock(LocalMutex_);

 				for(const auto &[Request,Command]:OutStandingRequests_) {
 					if(Command.SerialNumber==SerialNumber) {
@@ -166,7 +166,7 @@ namespace OpenWifi {
 			}

 			inline void ClearQueue(std::uint64_t SerialNumber) {
-				std::unique_lock	Lock(LocalMutex_);
+				std::lock_guard	Lock(LocalMutex_);
 				for(auto Request = OutStandingRequests_.begin(); Request != OutStandingRequests_.end() ; ) {
 					if(Request->second.SerialNumber==SerialNumber)
 						Request = OutStandingRequests_.erase(Request);
@@ -176,7 +176,7 @@ namespace OpenWifi {
 			}

 	    private:
-		  	mutable std::shared_mutex				LocalMutex_;
+		  	mutable std::recursive_mutex			LocalMutex_;
 			std::atomic_bool 						Running_ = false;
 			Poco::Thread    						ManagerThread;
 			std::atomic_uint64_t 					Id_=3;	//	do not start @1. We ignore ID=1 & 0 is illegal..
--- a/src/Daemon.cpp
+++ b/src/Daemon.cpp
@@ -17,7 +17,6 @@
 #include "AP_WS_Server.h"
 #include "CommandManager.h"
 #include "Daemon.h"
-#include "DeviceRegistry.h"
 #include "FileUploader.h"
 #include "FindCountry.h"
 #include "OUIServer.h"
@@ -44,7 +43,7 @@ namespace OpenWifi {
 								   		WebSocketClientServer(),
 										OUIServer(),
 										FindCountryFromIP(),
-										DeviceRegistry(),
+//										DeviceRegistry(),
 										CommandManager(),
 										FileUploader(),
 										StorageArchiver(),
--- a/src/Dashboard.cpp
+++ b/src/Dashboard.cpp
@@ -3,7 +3,6 @@
 //

 #include "Dashboard.h"
-#include "DeviceRegistry.h"
 #include "StorageService.h"

 namespace OpenWifi {
--- a/src/DeviceRegistry.cpp
+++ b/src/DeviceRegistry.cpp
@@ -105,18 +105,19 @@ namespace OpenWifi {
 	}

 	bool DeviceRegistry::EndSession(std::uint64_t connection_id, std::uint64_t serial_number) {
-		std::unique_lock	G(LocalMutex_);

+		std::unique_lock G(LocalMutex_);
 		auto Connection = SerialNumbers_.find(serial_number);
-		if(Connection==end(SerialNumbers_)) {
+		if (Connection == end(SerialNumbers_)) {
 			return false;
 		}

-		if(Connection->second.first!=connection_id) {
+		if (Connection->second.first != connection_id) {
 			return false;
 		}

 		SerialNumbers_.erase(Connection);
+
 		return true;
 	}

--- a/src/OUIServer.cpp
+++ b/src/OUIServer.cpp
@@ -21,8 +21,26 @@ namespace OpenWifi {
 		LatestOUIFileName_ =  MicroService::instance().DataDir() + "/newOUIFile.txt";
 		CurrentOUIFileName_ = MicroService::instance().DataDir() + "/current_oui.txt";

+		bool Recovered = false;
+		Poco::File	OuiFile(CurrentOUIFileName_);
+		if(OuiFile.exists()) {
+			std::unique_lock	Lock(LocalMutex_);
+			Recovered = ProcessFile(CurrentOUIFileName_,OUIs_);
+			if(Recovered) {
+				poco_notice(Logger(),
+								 fmt::format("Recovered last OUI file - {}", CurrentOUIFileName_));
+			}
+		} else {
+			poco_notice(Logger(),
+							 fmt::format("No existing OUIFile.", CurrentOUIFileName_));
+		}
+
 		UpdaterCallBack_ = std::make_unique<Poco::TimerCallback<OUIServer>>(*this, &OUIServer::onTimer);
-		Timer_.setStartInterval(30 * 1000);  // first run in 5 minutes
+		if(Recovered) {
+			Timer_.setStartInterval(60 * 60 * 1000); // first run in 1 hour
+		} else {
+			Timer_.setStartInterval(30 * 1000); // first run in 5 minutes
+		}
 		Timer_.setPeriodicInterval(7 * 24 * 60 * 60 * 1000);
 		Timer_.start(*UpdaterCallBack_, MicroService::instance().TimerPool());
 		return 0;
@@ -102,6 +120,8 @@ namespace OpenWifi {
 			return;
 		Updating_ = true;

+		poco_information(Logger(),"Starting to process OUI file...");
+
 		//	fetch data from server, if not available, just use the file we already have.
 		Poco::File	Current(CurrentOUIFileName_);
 		if(Current.exists()) {
@@ -122,7 +142,7 @@ namespace OpenWifi {

 		OUIMap TmpOUIs;
 		if(GetFile(LatestOUIFileName_) && ProcessFile(LatestOUIFileName_, TmpOUIs)) {
-			std::lock_guard G(Mutex_);
+			std::unique_lock G(LocalMutex_);
 			OUIs_ = std::move(TmpOUIs);
 			LastUpdate_ = OpenWifi::Now();
 			Poco::File F1(CurrentOUIFileName_);
@@ -134,16 +154,18 @@ namespace OpenWifi {
 		} else if(OUIs_.empty()) {
 			if(ProcessFile(CurrentOUIFileName_, TmpOUIs)) {
 				LastUpdate_ = OpenWifi::Now();
-				std::lock_guard G(Mutex_);
+				std::unique_lock G(LocalMutex_);
 				OUIs_ = std::move(TmpOUIs);
 			}
 		}
 		Initialized_=true;
 		Updating_ = false;
+		poco_information(Logger(),"Done processing OUI file...");
 	}

 	std::string OUIServer::GetManufacturer(const std::string &MAC) {
-		std::lock_guard Guard(Mutex_);
+		std::shared_lock 	Lock(LocalMutex_);
+
 		auto Manufacturer = OUIs_.find(Utils::SerialNumberToOUI(MAC));
 		if(Manufacturer != OUIs_.end())
 			return Manufacturer->second;
--- a/src/OUIServer.h
+++ b/src/OUIServer.h
@@ -4,6 +4,8 @@

 #pragma once

+#include <shared_mutex>
+
 #include "framework/MicroService.h"
 #include "Poco/Timer.h"

@@ -30,6 +32,7 @@ namespace OpenWifi {
 		[[nodiscard]] bool ProcessFile(const std::string &FileName, OUIMap &Map);

 	  private:
+		std::shared_mutex	LocalMutex_;
 		uint64_t 			LastUpdate_ = 0 ;
 		bool 				Initialized_ = false;
 		OUIMap 				OUIs_;
--- a/src/RADIUS_proxy_server.cpp
+++ b/src/RADIUS_proxy_server.cpp
@@ -3,9 +3,8 @@
 //

 #include "RADIUS_proxy_server.h"
-#include "DeviceRegistry.h"
 #include "RADIUS_helpers.h"
-
+#include "AP_WS_Server.h"
 namespace OpenWifi {

 	const int SMALLEST_RADIUS_PACKET = 20+19+4;
@@ -147,8 +146,8 @@ namespace OpenWifi {
 		auto CallingStationID = P.ExtractCallingStationID();
 		auto CalledStationID = P.ExtractCalledStationID();

-		poco_information(Logger(), fmt::format("Accounting Packet received for {}, CalledStationID: {}, CallingStationID:{}",SerialNumber, CalledStationID, CallingStationID));
-		DeviceRegistry()->SendRadiusAccountingData(SerialNumber,P.Buffer(),P.Size());
+		poco_debug(Logger(), fmt::format("Accounting Packet received for {}, CalledStationID: {}, CallingStationID:{}",SerialNumber, CalledStationID, CallingStationID));
+		AP_WS_Server()->SendRadiusAccountingData(SerialNumber,P.Buffer(),P.Size());
 	}

 	void RADIUS_proxy_server::OnAuthenticationSocketReadable(const Poco::AutoPtr<Poco::Net::ReadableNotification>& pNf) {
@@ -169,8 +168,8 @@ namespace OpenWifi {
 		auto CallingStationID = P.ExtractCallingStationID();
 		auto CalledStationID = P.ExtractCalledStationID();

-		poco_information(Logger(), fmt::format("Authentication Packet received for {}, CalledStationID: {}, CallingStationID:{}",SerialNumber, CalledStationID, CallingStationID));
-		DeviceRegistry()->SendRadiusAuthenticationData(SerialNumber,P.Buffer(),P.Size());
+		poco_debug(Logger(), fmt::format("Authentication Packet received for {}, CalledStationID: {}, CallingStationID:{}",SerialNumber, CalledStationID, CallingStationID));
+		AP_WS_Server()->SendRadiusAuthenticationData(SerialNumber,P.Buffer(),P.Size());
 	}

 	void RADIUS_proxy_server::OnCoASocketReadable(const Poco::AutoPtr<Poco::Net::ReadableNotification>& pNf) {
@@ -191,38 +190,61 @@ namespace OpenWifi {
 		auto CallingStationID = P.ExtractCallingStationID();
 		auto CalledStationID = P.ExtractCalledStationID();

-		poco_information(Logger(), fmt::format("CoA Packet received for {}, CalledStationID: {}, CallingStationID:{}",SerialNumber, CalledStationID, CallingStationID));
-		DeviceRegistry()->SendRadiusCoAData(SerialNumber,P.Buffer(),P.Size());
+		poco_debug(Logger(), fmt::format("CoA Packet received for {}, CalledStationID: {}, CallingStationID:{}",SerialNumber, CalledStationID, CallingStationID));
+		AP_WS_Server()->SendRadiusCoAData(SerialNumber,P.Buffer(),P.Size());
 	}

 	void RADIUS_proxy_server::SendAccountingData(const std::string &serialNumber, const char *buffer, std::size_t size) {
-		RADIUS::RadiusPacket	P((unsigned char *)buffer,size);
-		auto Destination = P.ExtractProxyStateDestination();
-		auto CallingStationID = P.ExtractCallingStationID();
-		auto CalledStationID = P.ExtractCalledStationID();
-		Poco::Net::SocketAddress	Dst(Destination);

-		std::lock_guard	G(Mutex_);
-		bool UseRADSEC = false;
-		auto FinalDestination = Route(radius_type::acct, Dst, P, UseRADSEC);
-		if(UseRADSEC) {
-			Poco::Net::SocketAddress	RSP(FinalDestination.host(),0);
-			auto DestinationServer = RADSECservers_.find(RSP);
-			if(DestinationServer!=end(RADSECservers_)) {
-				DestinationServer->second->SendData(serialNumber, (const unsigned char *)buffer, size);
-			}
-		} else {
-			auto AllSent =
-				SendData(Dst.family() == Poco::Net::SocketAddress::IPv4 ? *AccountingSocketV4_
-																		: *AccountingSocketV6_,
-						 (const unsigned char *)buffer, size, FinalDestination);
-			if (!AllSent)
-				poco_error(Logger(),fmt::format("{}: Could not send Accounting packet packet to {}.",
+		if(Pools_.empty() || !enabled_)
+			return;
+
+		try {
+			RADIUS::RadiusPacket P((unsigned char *)buffer, size);
+			auto Destination = P.ExtractProxyStateDestination();
+			auto CallingStationID = P.ExtractCallingStationID();
+			auto CalledStationID = P.ExtractCalledStationID();
+			Poco::Net::SocketAddress Dst(Destination);
+
+			std::lock_guard G(Mutex_);
+			bool UseRADSEC = false;
+			auto FinalDestination = Route(radius_type::acct, Dst, P, UseRADSEC);
+			if (UseRADSEC) {
+				Poco::Net::SocketAddress RSP(FinalDestination.host(), 0);
+				auto DestinationServer = RADSECservers_.find(RSP);
+				if (DestinationServer != end(RADSECservers_)) {
+					DestinationServer->second->SendData(serialNumber, (const unsigned char *)buffer,
+														size);
+				}
+			} else {
+				if ((Dst.family() == Poco::Net::SocketAddress::IPv4 &&
+					 AccountingSocketV4_ == nullptr) ||
+					(Dst.family() == Poco::Net::SocketAddress::IPv6 &&
+					 AccountingSocketV6_ == nullptr)) {
+					poco_debug(
+						Logger(),
+						fmt::format(
+							"ACCT: Trying to use RADIUS GW PROXY but not configured. Device={}",
+							serialNumber));
+					return;
+				}
+				auto AllSent =
+					SendData(Dst.family() == Poco::Net::SocketAddress::IPv4 ? *AccountingSocketV4_
+																			: *AccountingSocketV6_,
+							 (const unsigned char *)buffer, size, FinalDestination);
+				if (!AllSent)
+					poco_error(Logger(),
+							   fmt::format("{}: Could not send Accounting packet packet to {}.",
 										   serialNumber, Destination));
-			else
-				poco_information(Logger(), fmt::format(
-					"{}: Sending Accounting Packet to {}, CalledStationID: {}, CallingStationID:{}",
-					serialNumber, FinalDestination.toString(), CalledStationID, CallingStationID));
+				else
+					poco_debug(Logger(), fmt::format("{}: Sending Accounting Packet to {}, CalledStationID: {}, CallingStationID:{}",
+													 serialNumber, FinalDestination.toString(),
+													 CalledStationID, CallingStationID));
+			}
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		} catch (...) {
+			poco_warning(Logger(),fmt::format("Bad RADIUS ACCT Packet from {}. Dropped.",serialNumber));
 		}
 	}

@@ -231,64 +253,101 @@ namespace OpenWifi {
 	}

 	void RADIUS_proxy_server::SendAuthenticationData(const std::string &serialNumber, const char *buffer, std::size_t size) {
-		RADIUS::RadiusPacket	P((unsigned char *)buffer,size);
-		auto Destination = P.ExtractProxyStateDestination();
-		auto CallingStationID = P.ExtractCallingStationID();
-		auto CalledStationID = P.ExtractCalledStationID();
-		Poco::Net::SocketAddress	Dst(Destination);

-		std::lock_guard	G(Mutex_);
-		bool UseRADSEC = false;
-		auto FinalDestination = Route(radius_type::auth, Dst, P, UseRADSEC);
-		if(UseRADSEC) {
-			Poco::Net::SocketAddress	RSP(FinalDestination.host(),0);
-			auto DestinationServer = RADSECservers_.find(RSP);
-			if(DestinationServer!=end(RADSECservers_)) {
-				DestinationServer->second->SendData(serialNumber, (const unsigned char *)buffer, size);
-			}
-		} else {
-			auto AllSent =
-				SendData(Dst.family() == Poco::Net::SocketAddress::IPv4 ? *AuthenticationSocketV4_
-																		: *AuthenticationSocketV6_,
-						 (const unsigned char *)buffer, size, FinalDestination);
-			if (!AllSent)
-				poco_error(Logger(),fmt::format("{}: Could not send Authentication packet packet to {}.",
+		if(Pools_.empty() || !enabled_)
+			return;
+
+		try {
+			RADIUS::RadiusPacket	P((unsigned char *)buffer,size);
+			auto Destination = P.ExtractProxyStateDestination();
+			auto CallingStationID = P.ExtractCallingStationID();
+			auto CalledStationID = P.ExtractCalledStationID();
+			Poco::Net::SocketAddress	Dst(Destination);
+
+			std::lock_guard	G(Mutex_);
+			bool UseRADSEC = false;
+			auto FinalDestination = Route(radius_type::auth, Dst, P, UseRADSEC);
+			if(UseRADSEC) {
+				Poco::Net::SocketAddress	RSP(FinalDestination.host(),0);
+				auto DestinationServer = RADSECservers_.find(RSP);
+				if(DestinationServer!=end(RADSECservers_)) {
+					DestinationServer->second->SendData(serialNumber, (const unsigned char *)buffer, size);
+				}
+			} else {
+				if ((Dst.family() == Poco::Net::SocketAddress::IPv4 &&
+					 AuthenticationSocketV4_ == nullptr) ||
+					(Dst.family() == Poco::Net::SocketAddress::IPv6 &&
+					 AuthenticationSocketV6_ == nullptr)) {
+					poco_debug(
+						Logger(),
+						fmt::format("AUTH: Trying to use RADIUS GW PROXY but not configured. Device={}",
+									serialNumber));
+					return;
+				}
+				auto AllSent =
+					SendData(Dst.family() == Poco::Net::SocketAddress::IPv4 ? *AuthenticationSocketV4_
+																			: *AuthenticationSocketV6_,
+							 (const unsigned char *)buffer, size, FinalDestination);
+				if (!AllSent)
+					poco_error(Logger(),
+							   fmt::format("{}: Could not send Authentication packet packet to {}.",
 										   serialNumber, Destination));
-			else
-				poco_information(Logger(), fmt::format("{}: Sending Authentication Packet to {}, CalledStationID: {}, CallingStationID:{}",
-												 serialNumber, FinalDestination.toString(),
-												 CalledStationID, CallingStationID));
+				else
+					poco_debug(Logger(), fmt::format("{}: Sending Authentication Packet to {}, CalledStationID: {}, CallingStationID:{}",
+													 serialNumber, FinalDestination.toString(),
+													 CalledStationID, CallingStationID));
+			}
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		} catch (...) {
+			poco_warning(Logger(),fmt::format("Bad RADIUS AUTH Packet from {}. Dropped.",serialNumber));
 		}
+
 	}

 	void RADIUS_proxy_server::SendCoAData(const std::string &serialNumber, const char *buffer, std::size_t size) {
-		RADIUS::RadiusPacket	P((unsigned char *)buffer,size);
-		auto Destination = P.ExtractProxyStateDestination();

-		if(Destination.empty()) {
-			Destination = "0.0.0.0:0";
-		}
+		if(Pools_.empty() || !enabled_)
+			return;

-		Poco::Net::SocketAddress	Dst(Destination);
-		std::lock_guard	G(Mutex_);
-		bool UseRADSEC = false;
-		auto FinalDestination = Route(radius_type::coa, Dst, P, UseRADSEC);
-		if(UseRADSEC) {
-			Poco::Net::SocketAddress	RSP(FinalDestination.host(),0);
-			auto DestinationServer = RADSECservers_.find(RSP);
-			if(DestinationServer!=end(RADSECservers_)) {
-				DestinationServer->second->SendData(serialNumber, (const unsigned char *)buffer, size);
+		try {
+			RADIUS::RadiusPacket	P((unsigned char *)buffer,size);
+			auto Destination = P.ExtractProxyStateDestination();
+
+			if(Destination.empty()) {
+				Destination = "0.0.0.0:0";
 			}
-		} else {
-			auto AllSent = SendData(Dst.family() == Poco::Net::SocketAddress::IPv4 ? *CoASocketV4_
-																				   : *CoASocketV6_,
-									(const unsigned char *)buffer, size, FinalDestination);
-			if (!AllSent)
-				poco_error(Logger(),fmt::format("{}: Could not send CoA packet packet to {}.",
-										   serialNumber, Destination));
-			else
-				poco_information(Logger(), fmt::format("{}: Sending CoA Packet to {}", serialNumber,
-												 FinalDestination.toString()));
+
+			Poco::Net::SocketAddress	Dst(Destination);
+			std::lock_guard	G(Mutex_);
+			bool UseRADSEC = false;
+			auto FinalDestination = Route(radius_type::coa, Dst, P, UseRADSEC);
+			if(UseRADSEC) {
+				Poco::Net::SocketAddress	RSP(FinalDestination.host(),0);
+				auto DestinationServer = RADSECservers_.find(RSP);
+				if(DestinationServer!=end(RADSECservers_)) {
+					DestinationServer->second->SendData(serialNumber, (const unsigned char *)buffer, size);
+				}
+			} else {
+				if( (Dst.family() == Poco::Net::SocketAddress::IPv4 && CoASocketV4_== nullptr) ||
+					(Dst.family() == Poco::Net::SocketAddress::IPv6 && CoASocketV6_== nullptr)) {
+					poco_debug(Logger(),fmt::format("CoA: Trying to use RADIUS GW PROXY but not configured. Device={}",serialNumber));
+					return;
+				}
+				auto AllSent = SendData(Dst.family() == Poco::Net::SocketAddress::IPv4 ? *CoASocketV4_
+																					   : *CoASocketV6_,
+										(const unsigned char *)buffer, size, FinalDestination);
+				if (!AllSent)
+					poco_error(Logger(),fmt::format("{}: Could not send CoA packet packet to {}.",
+											   serialNumber, Destination));
+				else
+					poco_debug(Logger(), fmt::format("{}: Sending CoA Packet to {}", serialNumber,
+													 FinalDestination.toString()));
+			}
+		} catch (const Poco::Exception &E) {
+			Logger().log(E);
+		} catch (...) {
+			poco_warning(Logger(),fmt::format("Bad RADIUS CoA/DM Packet from {}. Dropped.",serialNumber));
 		}
 	}

@@ -481,7 +540,9 @@ namespace OpenWifi {
 			} break;
 			}
 		}
-		return DefaultRoute(rtype, RequestedAddress, P, UseRADSEC);
+
+		UseRADSEC = false;
+		return RequestedAddress;
 	}

 	Poco::Net::SocketAddress RADIUS_proxy_server::ChooseAddress(std::vector<Destination> &Pool, const Poco::Net::SocketAddress & OriginalAddress) {
--- a/src/RADSECserver.h
+++ b/src/RADSECserver.h
@@ -19,7 +19,7 @@
 #include "Poco/TemporaryFile.h"

 #include "RADIUS_helpers.h"
-#include "DeviceRegistry.h"
+#include "AP_WS_Server.h"

 namespace OpenWifi {

@@ -53,11 +53,11 @@ namespace OpenWifi {
 					// std::cout << serial_number << "    Sending " << P.PacketType() << "  "  << length << " bytes" << std::endl;
 					int sent_bytes;
 					if (P.VerifyMessageAuthenticator(Server_.radsecSecret)) {
-						Logger_.debug(fmt::format("{}: {} Sending {} bytes", serial_number,
+						poco_debug(Logger_,fmt::format("{}: {} Sending {} bytes", serial_number,
 												  P.PacketType(), length));
 						sent_bytes = Socket_->sendBytes(buffer, length);
 					} else {
-						Logger_.debug(fmt::format("{}: {} Sending {} bytes", serial_number,
+						poco_debug(Logger_,fmt::format("{}: {} Sending {} bytes", serial_number,
 												  P.PacketType(), length));
 						P.ComputeMessageAuthenticator(Server_.radsecSecret);
 						sent_bytes = Socket_->sendBytes(P.Buffer(), length);
@@ -77,20 +77,32 @@ namespace OpenWifi {
 				auto NumberOfReceivedBytes = Socket_->receiveBytes(Buffer,sizeof(Buffer));
 				if(NumberOfReceivedBytes>40) {
 					RADIUS::RadiusPacket P(Buffer,NumberOfReceivedBytes);
-					// P.Log(std::cout);
-					// std::cout << "RADSEC: " << P.PacketType() << "  "  << (int) P.PacketTypeInt() << "   Received " << NumberOfReceivedBytes << " bytes" << std::endl;
 					if (P.IsAuthentication()) {
 						auto SerialNumber = P.ExtractSerialNumberFromProxyState();
-						Logger_.debug(fmt::format("{}: {} Received {} bytes.", SerialNumber, P.PacketType(), NumberOfReceivedBytes));
-						DeviceRegistry()->SendRadiusAuthenticationData(
-							SerialNumber, Buffer,
-							NumberOfReceivedBytes);
+						if(!SerialNumber.empty()) {
+							poco_debug(Logger_,
+									   fmt::format("{}: {} Received {} bytes.", SerialNumber,
+												   P.PacketType(), NumberOfReceivedBytes));
+							AP_WS_Server()->SendRadiusAuthenticationData(SerialNumber, Buffer,
+																		 NumberOfReceivedBytes);
+						} else {
+							poco_debug(Logger_,
+									   fmt::format("Invalid AUTH packet received in proxy dropped. No serial number Source={}",
+									Socket_->address().toString()));
+						}
 					} else if (P.IsAccounting()) {
 						auto SerialNumber = P.ExtractSerialNumberFromProxyState();
-						Logger_.debug(fmt::format("{}: {} Received {} bytes.", SerialNumber, P.PacketType(), NumberOfReceivedBytes));
-						DeviceRegistry()->SendRadiusAccountingData(
-							SerialNumber, Buffer,
-							NumberOfReceivedBytes);
+						if(!SerialNumber.empty()) {
+							poco_debug(Logger_,
+									   fmt::format("{}: {} Received {} bytes.", SerialNumber,
+												   P.PacketType(), NumberOfReceivedBytes));
+							AP_WS_Server()->SendRadiusAccountingData(SerialNumber, Buffer,
+																	 NumberOfReceivedBytes);
+						} else {
+							poco_debug(Logger_,
+									   fmt::format("Invalid ACCT packet received in proxy dropped. No serial number Source={}",
+												   Socket_->address().toString()));
+						}
 					} else if (P.IsAuthority()) {
 					}
 				} else {
--- a/src/RESTAPI/RESTAPI_RPC.cpp
+++ b/src/RESTAPI/RESTAPI_RPC.cpp
@@ -8,7 +8,7 @@
 #include "RESTAPI_RPC.h"

 #include "CommandManager.h"
-#include "DeviceRegistry.h"
+#include "AP_WS_Server.h"
 #include "StorageService.h"
 #include "framework/ow_constants.h"
 #include "ParseWifiScan.h"
@@ -48,11 +48,11 @@ namespace OpenWifi::RESTAPI_RPC {
 		// 	then we should just add the command to
 		//	the DB and let it figure out when to deliver the command.
 		auto SerialNumberInt = Utils::SerialNumberToInt(Cmd.SerialNumber);
-		if (Cmd.RunAt || (!DeviceRegistry()->Connected(SerialNumberInt) && RetryLater)) {
+		if (Cmd.RunAt || (!AP_WS_Server()->Connected(SerialNumberInt) && RetryLater)) {
 			Logger.information(fmt::format("{},{}: Command will be run in the future or when device is connected again.", Cmd.UUID, RPCID));
 			SetCommandStatus(Cmd, Request, Response, Handler, Storage::CommandExecutionType::COMMAND_PENDING, Logger);
 			return;
-		} else if ((!DeviceRegistry()->Connected(SerialNumberInt) && !RetryLater)){
+		} else if ((!AP_WS_Server()->Connected(SerialNumberInt) && !RetryLater)){
 			Logger.information(fmt::format("{},{}: Command canceled. Device is not connected. Command will not be retried.", Cmd.UUID, RPCID));
 			return SetCommandStatus(Cmd, Request, Response, Handler, Storage::CommandExecutionType::COMMAND_FAILED, Logger);
 		}
--- a/src/RESTAPI/RESTAPI_device_commandHandler.cpp
+++ b/src/RESTAPI/RESTAPI_device_commandHandler.cpp
@@ -13,7 +13,6 @@

 #include "AP_WS_Server.h"
 #include "CentralConfig.h"
-#include "DeviceRegistry.h"
 #include "FileUploader.h"
 #include "RESTAPI_RPC.h"
 #include "RESTAPI_device_commandHandler.h"
@@ -60,7 +59,7 @@ namespace OpenWifi {
 		} else if (Command_ == RESTAPI::Protocol::STATUS) {
 			return GetStatus();
 		} else if (Command_ == RESTAPI::Protocol::RTTY) {
-			if(!DeviceRegistry()->Connected(SerialNumberInt_)) {
+			if(!AP_WS_Server()->Connected(SerialNumberInt_)) {
 				CallCanceled(Command_.c_str(), RESTAPI::Errors::DeviceNotConnected);
 				return BadRequest(RESTAPI::Errors::DeviceNotConnected);
 			}
@@ -165,7 +164,7 @@ namespace OpenWifi {
 		for(const auto &Command:PostCommands) {
 			if(Command_==Command.Command) {
 				Poco::Thread::current()->setName(fmt::format("{}:{}:{}",Command.Command, TransactionId_,SerialNumber_));
-				if(Command.RequireConnection && !DeviceRegistry()->Connected(SerialNumberInt_)) {
+				if(Command.RequireConnection && !AP_WS_Server()->Connected(SerialNumberInt_)) {
 					CallCanceled(Command.Command, RESTAPI::Errors::DeviceNotConnected);
 					return BadRequest(RESTAPI::Errors::DeviceNotConnected);
 				}
@@ -216,7 +215,7 @@ namespace OpenWifi {
 										Poco::Thread::current()->id()));
 		if (QB_.LastOnly) {
 			std::string Stats;
-			if (DeviceRegistry()->GetStatistics(SerialNumber_, Stats)) {
+			if (AP_WS_Server()->GetStatistics(SerialNumber_, Stats)) {
 				Poco::JSON::Parser P;
 				if (Stats.empty())
 					Stats = uCentralProtocol::EMPTY_JSON_DOC;
@@ -263,7 +262,7 @@ namespace OpenWifi {
 										Poco::Thread::current()->id()));
 		GWObjects::ConnectionState State;

-		if (DeviceRegistry()->GetState(SerialNumber_, State)) {
+		if (AP_WS_Server()->GetState(SerialNumber_, State)) {
 			Poco::JSON::Object RetObject;
 			State.to_json(RetObject);
 			return ReturnObject(RetObject);
@@ -319,7 +318,7 @@ namespace OpenWifi {

 		if (QB_.LastOnly) {
 			GWObjects::HealthCheck	HC;
-			if (DeviceRegistry()->GetHealthcheck(SerialNumber_, HC)) {
+			if (AP_WS_Server()->GetHealthcheck(SerialNumber_, HC)) {
 				Poco::JSON::Object	Answer;
 				HC.to_json(Answer);
 				return ReturnObject(Answer);
@@ -509,7 +508,7 @@ namespace OpenWifi {
 				Params.stringify(ParamStream);
 				Cmd.Details = ParamStream.str();

-				// DeviceRegistry()->SetPendingUUID(SerialNumber_, NewUUID);
+				// AP_WS_Server()->SetPendingUUID(SerialNumber_, NewUUID);
 				return RESTAPI_RPC::WaitForCommand(CMD_RPC,true,Cmd, Params, *Request, *Response, timeout, nullptr, this, Logger_);
 			}
 			return BadRequest(RESTAPI::Errors::RecordNotUpdated);
@@ -1025,16 +1024,16 @@ namespace OpenWifi {
 			if(!StatusOnly) {
 				if (KafkaOnly) {
 					if (Interval) {
-						DeviceRegistry()->SetKafkaTelemetryReporting(CMD_RPC,IntSerialNumber, Interval, Lifetime);
+						AP_WS_Server()->SetKafkaTelemetryReporting(CMD_RPC,IntSerialNumber, Interval, Lifetime);
 						Answer.set("action", "Kafka telemetry started.");
 						Answer.set("uuid", CMD_UUID);
 					} else {
-						DeviceRegistry()->StopKafkaTelemetry(CMD_RPC,IntSerialNumber);
+						AP_WS_Server()->StopKafkaTelemetry(CMD_RPC,IntSerialNumber);
 						Answer.set("action", "Kafka telemetry stopped.");
 					}
 				} else {
 					if (Interval) {
-						DeviceRegistry()->SetWebSocketTelemetryReporting(CMD_RPC,IntSerialNumber, Interval,
+						AP_WS_Server()->SetWebSocketTelemetryReporting(CMD_RPC,IntSerialNumber, Interval,
 																				  Lifetime);
 						std::string EndPoint;
 						if (TelemetryStream()->CreateEndpoint(Utils::SerialNumberToInt(SerialNumber_), EndPoint, CMD_UUID)) {
@@ -1047,7 +1046,7 @@ namespace OpenWifi {
 						}
 					} else {
 						Answer.set("action", "WebSocket telemetry stopped.");
-						DeviceRegistry()->StopWebSocketTelemetry(CMD_RPC,IntSerialNumber);
+						AP_WS_Server()->StopWebSocketTelemetry(CMD_RPC,IntSerialNumber);
 					}
 				}
 			} else {
@@ -1058,7 +1057,7 @@ namespace OpenWifi {
 			uint64_t TelemetryWebSocketCount, TelemetryKafkaCount, TelemetryInterval,
 				TelemetryWebSocketTimer, TelemetryKafkaTimer, TelemetryWebSocketPackets,
 				TelemetryKafkaPackets;
-			DeviceRegistry()->GetTelemetryParameters(IntSerialNumber,TelemetryRunning,
+			AP_WS_Server()->GetTelemetryParameters(IntSerialNumber,TelemetryRunning,
 															  TelemetryInterval,
 															  TelemetryWebSocketTimer,
 															  TelemetryKafkaTimer,
--- a/src/RESTAPI/RESTAPI_device_helper.h
+++ b/src/RESTAPI/RESTAPI_device_helper.h
@@ -6,17 +6,17 @@

 #include "RESTObjects/RESTAPI_GWobjects.h"
 #include "StorageService.h"
-#include "DeviceRegistry.h"
+#include "AP_WS_Server.h"

 namespace OpenWifi {

 	inline void CompleteDeviceInfo(const GWObjects::Device & Device, Poco::JSON::Object & Answer) {
 		GWObjects::ConnectionState	CS;
-		DeviceRegistry()->GetState(Device.SerialNumber,CS);
+		AP_WS_Server()->GetState(Device.SerialNumber,CS);
 		GWObjects::HealthCheck		HC;
-		DeviceRegistry()->GetHealthcheck(Device.SerialNumber, HC);
+		AP_WS_Server()->GetHealthcheck(Device.SerialNumber, HC);
 		std::string 	Stats;
-		DeviceRegistry()->GetStatistics(Device.SerialNumber, Stats);
+		AP_WS_Server()->GetStatistics(Device.SerialNumber, Stats);

 		Poco::JSON::Object	DeviceInfo;
 		Device.to_json(DeviceInfo);
--- a/src/RESTAPI/RESTAPI_devices_handler.cpp
+++ b/src/RESTAPI/RESTAPI_devices_handler.cpp
@@ -16,6 +16,7 @@
 #include "RESTAPI/RESTAPI_device_helper.h"
 #include "Poco/StringTokenizer.h"
 #include "framework/orm.h"
+#include "AP_WS_Server.h"

 namespace OpenWifi {

@@ -61,7 +62,7 @@ namespace OpenWifi {
 			GWObjects::DeviceConnectionStatistics	DCS;
 			Poco::JSON::Object	Answer;

-			DeviceRegistry()->AverageDeviceStatistics(DCS.connectedDevices,DCS.averageConnectionTime, DCS.connectingDevices);
+			AP_WS_Server()->AverageDeviceStatistics(DCS.connectedDevices,DCS.averageConnectionTime, DCS.connectingDevices);
 			DCS.to_json(Answer);
 			return ReturnObject(Answer);
 		}
--- a/src/RESTAPI/RESTAPI_radiusProxyConfig_handler.cpp
+++ b/src/RESTAPI/RESTAPI_radiusProxyConfig_handler.cpp
@@ -41,6 +41,8 @@ namespace OpenWifi {
 				return BadRequest(RESTAPI::Errors::PoolNameInvalid);
 			}
 			for(const auto &config:{pool.acctConfig,pool.authConfig,pool.coaConfig}) {
+				if(config.servers.empty())
+					continue;
 				if(config.strategy!="random" && config.strategy!="round_robin" && config.strategy!="weighted") {
 					return BadRequest(RESTAPI::Errors::InvalidRadiusProxyStrategy);
 				}
--- a/src/RESTObjects/RESTAPI_GWobjects.cpp
+++ b/src/RESTObjects/RESTAPI_GWobjects.cpp
@@ -11,7 +11,7 @@

 #include "Daemon.h"
 #ifdef	TIP_GATEWAY_SERVICE
-#include "DeviceRegistry.h"
+#include "AP_WS_Server.h"
 #include "CapabilitiesCache.h"
 #endif

@@ -57,7 +57,7 @@ namespace OpenWifi::GWObjects {
 #ifdef TIP_GATEWAY_SERVICE
 		ConnectionState ConState;

-		if (DeviceRegistry()->GetState(SerialNumber, ConState)) {
+		if (AP_WS_Server()->GetState(SerialNumber, ConState)) {
 			ConState.to_json(Obj);
 		} else {
 			field_to_json(Obj,"ipAddress", "");
--- a/src/TelemetryClient.cpp
+++ b/src/TelemetryClient.cpp
@@ -4,7 +4,7 @@

 #include "framework/MicroService.h"
 #include "AP_WS_Connection.h"
-#include "DeviceRegistry.h"
+#include "AP_WS_Server.h"
 #include "TelemetryClient.h"
 #include "TelemetryStream.h"
 #include "CommandManager.h"
@@ -94,7 +94,7 @@ namespace OpenWifi {

 	void TelemetryClient::SendTelemetryShutdown() {
 		poco_information(Logger(),fmt::format("TELEMETRY-SHUTDOWN({}): Closing.",CId_));
-		DeviceRegistry()->StopWebSocketTelemetry(CommandManager()->NextRPCId(), SerialNumber_);
+		AP_WS_Server()->StopWebSocketTelemetry(CommandManager()->NextRPCId(), SerialNumber_);
 		TelemetryStream()->DeRegisterClient(UUID_);
 		delete this;
 	}
--- a/src/VenueBroadcaster.h
+++ b/src/VenueBroadcaster.h
@@ -6,7 +6,7 @@

 #include "framework/MicroService.h"
 #include "sdks/sdk_prov.h"
-#include "DeviceRegistry.h"
+#include "AP_WS_Server.h"

 namespace OpenWifi {

@@ -89,7 +89,7 @@ namespace OpenWifi {
 		}

 		inline void SendToDevice(const std::string &SerialNumber,const std::string &Payload) {
-			DeviceRegistry()->SendFrame(SerialNumber,Payload);
+			AP_WS_Server()->SendFrame(SerialNumber,Payload);
 		}

 		inline void run() final {
--- a/src/framework/MicroService.h
+++ b/src/framework/MicroService.h
@@ -97,8 +97,11 @@ using namespace std::chrono_literals;
 #include "Poco/Net/SocketNotification.h"
 #include "Poco/Base64Decoder.h"
 #include "Poco/ThreadLocal.h"
+#include "Poco/NullChannel.h"
+
 #include "cppkafka/cppkafka.h"

+#include "framework/MicroServiceErrorHandler.h"
 #include "framework/OpenWifiTypes.h"
 #include "framework/KafkaTopics.h"
 #include "framework/ow_constants.h"
@@ -106,6 +109,7 @@ using namespace std::chrono_literals;
 #include "nlohmann/json.hpp"
 #include "ow_version.h"
 #include "fmt/core.h"
+#include "framework/MicroServiceErrorHandler.h"

 #define _OWDEBUG_ std::cout<< __FILE__ <<":" << __LINE__ << std::endl;
 // #define _OWDEBUG_ Logger().debug(Poco::format("%s: %lu",__FILE__,__LINE__));
@@ -1360,32 +1364,6 @@ namespace OpenWifi {
        Poco::ExpireLRUCache<KeyType,Record>  Cache_{Size,Expiry};
    };

-    class MicroServiceErrorHandler : public Poco::ErrorHandler {
-	  public:
-		explicit MicroServiceErrorHandler(Poco::Util::Application &App) : App_(App) {}
-		inline void exception(const Poco::Exception & E) {
-		    Poco::Thread * CurrentThread = Poco::Thread::current();
-		    App_.logger().log(E);
-		    poco_error(App_.logger(), fmt::format("Poco::Exception occurred in name={} thr_id={}",
-												  CurrentThread->getName(), CurrentThread->id()));
-		}
-
-		inline void exception(const std::exception & E) {
-		    Poco::Thread * CurrentThread = Poco::Thread::current();
-			poco_warning(App_.logger(), fmt::format("std::exception in {}: {} thr_id={}",
-													CurrentThread->getName(),E.what(),
-													CurrentThread->id()));
-		}
-
-		inline void exception() {
-		    Poco::Thread * CurrentThread = Poco::Thread::current();
-			poco_warning(App_.logger(), fmt::format("generic exception in {} thr_id={}",
-													CurrentThread->getName(), CurrentThread->id()));
-		}
-	  private:
-		Poco::Util::Application	&App_;
-	};
-
 	class BusEventManager : public Poco::Runnable {
 	  public:
 		explicit BusEventManager(Poco::Logger &L) : Logger_(L) {
@@ -3100,7 +3078,7 @@ namespace OpenWifi {

 	private:
 	    std::vector<std::unique_ptr<Poco::Net::HTTPServer>>   RESTServers_;
-	    Poco::ThreadPool	    Pool_{"x-rest",32,128};
+	    Poco::ThreadPool	    Pool_{"x-rest",8,128};
 	    RESTAPI_GenericServer   Server_;

        RESTAPI_ExtServer() noexcept:
@@ -3234,7 +3212,7 @@ namespace OpenWifi {
        const Poco::ThreadPool & Pool() { return Pool_; }
 	private:
 	    std::vector<std::unique_ptr<Poco::Net::HTTPServer>>   RESTServers_;
-	    Poco::ThreadPool	    Pool_{"i-rest",32,96};
+	    Poco::ThreadPool	    Pool_{"i-rest",4,64};
 	    RESTAPI_GenericServer   Server_;

        RESTAPI_IntServer() noexcept:
@@ -3431,7 +3409,7 @@ namespace OpenWifi {
        bool                        NoBuiltInCrypto_=false;
        Poco::JWT::Signer	        Signer_;
 		Poco::Logger				&Logger_;
-		Poco::ThreadPool				TimerPool_{"timer:pool",2,16};
+		Poco::ThreadPool				TimerPool_{"timer:pool",2,32};
 		std::unique_ptr<BusEventManager>	BusEventManager_;
    };

@@ -3596,23 +3574,43 @@ namespace OpenWifi {

            auto LoggingDestination = MicroService::instance().ConfigGetString("logging.type", "file");
            auto LoggingFormat = MicroService::instance().ConfigGetString("logging.format",
-                                                                          "%Y-%m-%d %H:%M:%S %s: [%p] %t");
-            if (LoggingDestination == "console") {
+                                                                          "%Y-%m-%d %H:%M:%S.%i %s: [%p][thr:%I] %t");
+			auto UseAsyncLogs_ = MicroService::instance().ConfigGetBool("logging.asynch",false);
+			if (LoggingDestination == "null") {
+				Poco::AutoPtr<Poco::NullChannel> DevNull(new Poco::NullChannel);
+				Poco::Logger::root().setChannel(DevNull);
+			} else if (LoggingDestination == "console") {
                Poco::AutoPtr<Poco::ConsoleChannel> Console(new Poco::ConsoleChannel);
-                Poco::AutoPtr<Poco::AsyncChannel> Async(new Poco::AsyncChannel(Console));
-                Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
-                Formatter->setProperty("pattern", LoggingFormat);
-                Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
-                        new Poco::FormattingChannel(Formatter, Async));
-                Poco::Logger::root().setChannel(FormattingChannel);
+				if(UseAsyncLogs_) {
+					Poco::AutoPtr<Poco::AsyncChannel> Async(new Poco::AsyncChannel(Console));
+					Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
+					Formatter->setProperty("pattern", LoggingFormat);
+					Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
+						new Poco::FormattingChannel(Formatter, Async));
+					Poco::Logger::root().setChannel(FormattingChannel);
+				} else {
+					Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
+					Formatter->setProperty("pattern", LoggingFormat);
+					Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
+						new Poco::FormattingChannel(Formatter, Console));
+					Poco::Logger::root().setChannel(FormattingChannel);
+				}
            } else if (LoggingDestination == "colorconsole") {
-                Poco::AutoPtr<Poco::ColorConsoleChannel> Console(new Poco::ColorConsoleChannel);
-                Poco::AutoPtr<Poco::AsyncChannel> Async(new Poco::AsyncChannel(Console));
-                Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
-                Formatter->setProperty("pattern", LoggingFormat);
-                Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
-                        new Poco::FormattingChannel(Formatter, Async));
-                Poco::Logger::root().setChannel(FormattingChannel);
+				Poco::AutoPtr<Poco::ColorConsoleChannel> ColorConsole(new Poco::ColorConsoleChannel);
+				if(UseAsyncLogs_) {
+					Poco::AutoPtr<Poco::AsyncChannel> Async(new Poco::AsyncChannel(ColorConsole));
+					Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
+					Formatter->setProperty("pattern", LoggingFormat);
+					Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
+						new Poco::FormattingChannel(Formatter, Async));
+					Poco::Logger::root().setChannel(FormattingChannel);
+				} else {
+					Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
+					Formatter->setProperty("pattern", LoggingFormat);
+					Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
+						new Poco::FormattingChannel(Formatter, ColorConsole));
+					Poco::Logger::root().setChannel(FormattingChannel);
+				}
            } else if (LoggingDestination == "sql") {
                //"CREATE TABLE T_POCO_LOG (Source VARCHAR, Name VARCHAR, ProcessId INTEGER, Thread VARCHAR, ThreadId INTEGER, Priority INTEGER, Text VARCHAR, DateTime DATE)"

@@ -3626,16 +3624,21 @@ namespace OpenWifi {
                FileChannel->setProperty("rotation", "10 M");
                FileChannel->setProperty("archive", "timestamp");
                FileChannel->setProperty("path", LoggingLocation);
-                Poco::AutoPtr<Poco::AsyncChannel> Async_File(new Poco::AsyncChannel(FileChannel));
-				Poco::AutoPtr<Poco::AsyncChannel> Async_Muxer(new Poco::AsyncChannel(LogMuxer()));
-                Poco::AutoPtr<Poco::SplitterChannel> Splitter(new Poco::SplitterChannel);
-				Splitter->addChannel(Async_File);
-				Splitter->addChannel(Async_Muxer);
-				Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
-                Formatter->setProperty("pattern", LoggingFormat);
-                Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
-                        new Poco::FormattingChannel(Formatter, Splitter));
-                Poco::Logger::root().setChannel(FormattingChannel);
+				if(UseAsyncLogs_) {
+					Poco::AutoPtr<Poco::AsyncChannel> Async_File(
+						new Poco::AsyncChannel(FileChannel));
+					Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
+					Formatter->setProperty("pattern", LoggingFormat);
+					Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
+						new Poco::FormattingChannel(Formatter, Async_File));
+					Poco::Logger::root().setChannel(FormattingChannel);
+				} else {
+					Poco::AutoPtr<Poco::PatternFormatter> Formatter(new Poco::PatternFormatter);
+					Formatter->setProperty("pattern", LoggingFormat);
+					Poco::AutoPtr<Poco::FormattingChannel> FormattingChannel(
+						new Poco::FormattingChannel(Formatter, FileChannel));
+					Poco::Logger::root().setChannel(FormattingChannel);
+				}
            }
            auto Level = Poco::Logger::parseLevel(MicroService::instance().ConfigGetString("logging.level", "debug"));
            Poco::Logger::root().setLevel(Level);
--- a/src/framework/MicroServiceErrorHandler.h
+++ b/src/framework/MicroServiceErrorHandler.h
@@ -0,0 +1,169 @@
+//
+// Created by stephane bourque on 2022-09-29.
+//
+
+#pragma once
+
+#include "fmt/format.h"
+#include "Poco/Util/Application.h"
+#include "Poco/ErrorHandler.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Net/SSLException.h"
+#include "Poco/JSON/Template.h"
+#include "Poco/Thread.h"
+
+namespace OpenWifi {
+
+	class MicroServiceErrorHandler : public Poco::ErrorHandler {
+	  public:
+		explicit MicroServiceErrorHandler(Poco::Util::Application &App) : App_(App) {
+		}
+
+		inline void exception(const Poco::Exception & Base) override {
+			try {
+				if(Poco::Thread::current()!= nullptr) {
+					t_name = Poco::Thread::current()->getName();
+					t_id = Poco::Thread::current()->id();
+				} else {
+					t_name = "startup_code";
+					t_id = 0;
+				}
+
+				App_.logger().log(Base);
+				Base.rethrow();
+
+			} catch (const Poco::Net::InvalidCertificateException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::Net::InvalidCertificateException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+			} catch (const Poco::Net::InvalidSocketException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::Net::InvalidSocketException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+			} catch (const Poco::Net::WebSocketException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::Net::WebSocketException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+			} catch (const Poco::Net::ConnectionResetException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::Net::ConnectionResetException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+			} catch (const Poco::Net::CertificateValidationException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::Net::CertificateValidationException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+			} catch (const Poco::Net::SSLConnectionUnexpectedlyClosedException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::Net::SSLConnectionUnexpectedlyClosedException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+			} catch (const Poco::Net::SSLContextException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::Net::SSLContextException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+			} catch (const Poco::Net::SSLException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::Net::SSLException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+
+			} catch (const Poco::Net::InvalidAddressException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::Net::InvalidAddressException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+
+			} catch (const Poco::Net::NetException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::Net::NetException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+
+			} catch (const Poco::IOException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::IOException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+			} catch (const Poco::RuntimeException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::RuntimeException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+			} catch (const Poco::JSON::JSONTemplateException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::JSON::JSONTemplateException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+			} catch (const Poco::JSON::JSONException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::JSON::JSONException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+			} catch (const Poco::ApplicationException &E) {
+				poco_error(App_.logger(), fmt::format("Poco::ApplicationException thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+			} catch (const Poco::Exception &E) {
+				poco_error(App_.logger(), fmt::format("Poco::Exception thr_name={} thr_id={} code={} text={} msg={} what={}",
+													  t_name, t_id, E.code(),
+													  E.displayText(),
+													  E.message(),
+													  E.what()));
+			} catch (...) {
+				poco_error(App_.logger(), fmt::format("Poco:Generic thr_name={}",t_name, t_id));
+			}
+		}
+
+		inline void exception(const std::exception & E) override {
+			if(Poco::Thread::current()!= nullptr) {
+				t_name = Poco::Thread::current()->getName();
+				t_id = Poco::Thread::current()->id();
+			} else {
+				t_name = "startup_code";
+				t_id = 0;
+			}
+			poco_warning(App_.logger(), fmt::format("std::exception in {}: {} thr_id={}",
+													t_name,E.what(),
+													t_id));
+		}
+
+		inline void exception() override {
+			if(Poco::Thread::current()!= nullptr) {
+				t_name = Poco::Thread::current()->getName();
+				t_id = Poco::Thread::current()->id();
+			} else {
+				t_name = "startup_code";
+				t_id = 0;
+			}
+			poco_warning(App_.logger(), fmt::format("generic exception in {} thr_id={}",
+													t_name, t_id));
+		}
+	  private:
+		Poco::Util::Application	&App_;
+		std::string		t_name;
+		int 			t_id=0;
+	};
+
+}
--- a/src/rttys/RTTYS_ClientConnection.cpp
+++ b/src/rttys/RTTYS_ClientConnection.cpp
@@ -64,7 +64,7 @@ namespace OpenWifi {
 		{
 			if(!Valid_ || !Registered_)
 				return;
-			std::shared_lock G(Mutex_);
+			std::lock_guard G(Mutex_);
 			try {
 				int flags;
 				Poco::Buffer<char> IncomingFrame(0);
--- a/src/rttys/RTTYS_ClientConnection.h
+++ b/src/rttys/RTTYS_ClientConnection.h
@@ -38,7 +38,7 @@ namespace OpenWifi {
 		std::unique_ptr<Poco::Net::WebSocket>	WS_;
 		Poco::Logger 							&Logger_;
 		std::string 							Sid_;
-		std::shared_mutex						Mutex_;
+		std::recursive_mutex					Mutex_;
 		volatile bool							Valid_=false;
 		volatile bool 							Registered_=false;

--- a/src/rttys/RTTYS_device.cpp
+++ b/src/rttys/RTTYS_device.cpp
@@ -39,6 +39,7 @@ namespace OpenWifi {
 	{
 //		std::thread T([=]() { CompleteConnection(); });
 //		T.detach();
+		inBuf_ = std::make_unique<Poco::FIFOBuffer>(RTTY_DEVICE_BUFSIZE);
 		CompleteConnection();
 	}

@@ -61,6 +62,7 @@ namespace OpenWifi {
 			socket_.setBlocking(false);
 			socket_.setKeepAlive(true);
 			socket_.setNoDelay(true);
+			socket_.setReceiveTimeout(Poco::Timespan(60*60,0));

 			registered_=true;
 			reactor_.addEventHandler(
@@ -124,22 +126,22 @@ namespace OpenWifi {

 		std::unique_lock G(M_);
 		try {
-			auto received_bytes = socket_.receiveBytes(inBuf_);
+			auto received_bytes = socket_.receiveBytes(*inBuf_);
 			if (received_bytes == 0) {
 				poco_information(Logger(), fmt::format("{}: Device Closing connection - 0 bytes received.",id_));
 				return EndConnection();
 			}

-			while (inBuf_.isReadable() && good) {
+			while (inBuf_->isReadable() && good) {
 				uint32_t msg_len = 0;
 				if (waiting_for_bytes_ != 0) {

 				} else {
-					if (inBuf_.used() >= RTTY_HDR_SIZE) {
-						auto *head = (unsigned char *)inBuf_.begin();
+					if (inBuf_->used() >= RTTY_HDR_SIZE) {
+						auto *head = (unsigned char *)inBuf_->begin();
 						last_command_ = head[0];
 						msg_len = head[1] * 256 + head[2];
-						inBuf_.drain(RTTY_HDR_SIZE);
+						inBuf_->drain(RTTY_HDR_SIZE);
 					} else {
 						good = false;
 						continue;
@@ -190,10 +192,9 @@ namespace OpenWifi {
 			}
 		} catch (const Poco::Exception &E) {
 			good = false;
-			Logger().log(E,__FILE__,__LINE__);
-			poco_warning(Logger(),fmt::format("{}: Exception. GW closing connection.", id_));
+			poco_warning(Logger(),fmt::format("{}: Exception: {} GW closing connection.", id_, E.what()));
 		} catch (const std::exception &E) {
-			poco_warning(Logger(),fmt::format("{}: Exception. GW closing connection.", id_));
+			poco_warning(Logger(),fmt::format("{}: std::exception: {}. GW closing connection.", id_, E.what()));
 			good = false;
 		}

@@ -326,9 +327,9 @@ namespace OpenWifi {
 	std::string RTTYS_Device_ConnectionHandler::ReadString() {
 		std::string Res;

-		while(inBuf_.used()) {
+		while(inBuf_->used()) {
 			char C;
-			inBuf_.read(&C,1);
+			inBuf_->read(&C,1);
 			if(C==0) {
 				break;
 			}
@@ -342,11 +343,11 @@ namespace OpenWifi {
 		bool good = true;
 		try {
 			//	establish if this is an old rtty or a new one.
-			old_rtty_ = (inBuf_[0] != 0x03);		//	rtty_proto_ver for full session ID inclusion
+			old_rtty_ = ((*inBuf_)[0] != 0x03);		//	rtty_proto_ver for full session ID inclusion
 			if(old_rtty_) {
 				session_length_ = 1;
 			} else {
-				inBuf_.drain(1); //	remove protocol if used.
+				inBuf_->drain(1); //	remove protocol if used.
 				session_length_ = RTTY_SESSION_ID_LENGTH;
 			}

@@ -382,12 +383,12 @@ namespace OpenWifi {
 		nlohmann::json doc;
 		char Error;
 		if(old_rtty_) {
-			inBuf_.read(&Error, 1);
-			inBuf_.read(&session_id_[0], session_length_);
+			inBuf_->read(&Error, 1);
+			inBuf_->read(&session_id_[0], session_length_);
 		} else {
 			char session[RTTY_SESSION_ID_LENGTH+1]{0};
-			inBuf_.read(&session[0], session_length_);
-			inBuf_.read(&Error, 1);
+			inBuf_->read(&session[0], session_length_);
+			inBuf_->read(&Error, 1);
 		}
 		doc["type"] = "login";
 		doc["err"] = Error;
@@ -398,9 +399,9 @@ namespace OpenWifi {
 	bool RTTYS_Device_ConnectionHandler::do_msgTypeLogout([[maybe_unused]] std::size_t msg_len) {
 		char session[RTTY_SESSION_ID_LENGTH];
 		if(old_rtty_) {
-			inBuf_.read(&session[0],1);
+			inBuf_->read(&session[0],1);
 		} else {
-			inBuf_.read(&session[0],RTTY_SESSION_ID_LENGTH);
+			inBuf_->read(&session[0],RTTY_SESSION_ID_LENGTH);
 		}
 		poco_information(Logger(),fmt::format("{}: Logout", id_));
 		return false;
@@ -409,31 +410,31 @@ namespace OpenWifi {
 	bool RTTYS_Device_ConnectionHandler::do_msgTypeTermData(std::size_t msg_len) {
 		bool good;
 		if(waiting_for_bytes_>0) {
-			if(inBuf_.used()<waiting_for_bytes_) {
-				waiting_for_bytes_ = waiting_for_bytes_ - inBuf_.used();
-				good = SendToClient((unsigned char *)inBuf_.begin(), (int) inBuf_.used());
-				inBuf_.drain();
+			if(inBuf_->used()<waiting_for_bytes_) {
+				waiting_for_bytes_ = waiting_for_bytes_ - inBuf_->used();
+				good = SendToClient((unsigned char *)inBuf_->begin(), (int) inBuf_->used());
+				inBuf_->drain();
 			} else {
-				good = SendToClient((unsigned char *)inBuf_.begin(), waiting_for_bytes_);
-				inBuf_.drain(waiting_for_bytes_);
+				good = SendToClient((unsigned char *)inBuf_->begin(), waiting_for_bytes_);
+				inBuf_->drain(waiting_for_bytes_);
 				waiting_for_bytes_ = 0 ;
 			}
 		} else {
 			if(old_rtty_) {
-				inBuf_.drain(1);
+				inBuf_->drain(1);
 				msg_len -= 1;
 			} else {
-				inBuf_.drain(RTTY_SESSION_ID_LENGTH);
+				inBuf_->drain(RTTY_SESSION_ID_LENGTH);
 				msg_len -= RTTY_SESSION_ID_LENGTH;
 			}
-			if(inBuf_.used()<msg_len) {
-				good = SendToClient((unsigned char *)inBuf_.begin(), inBuf_.used());
-				waiting_for_bytes_ = msg_len - inBuf_.used();
-				inBuf_.drain();
+			if(inBuf_->used()<msg_len) {
+				good = SendToClient((unsigned char *)inBuf_->begin(), inBuf_->used());
+				waiting_for_bytes_ = msg_len - inBuf_->used();
+				inBuf_->drain();
 			} else {
 				waiting_for_bytes_ = 0 ;
-				good = SendToClient((unsigned char *)inBuf_.begin(), msg_len);
-				inBuf_.drain(msg_len);
+				good = SendToClient((unsigned char *)inBuf_->begin(), msg_len);
+				inBuf_->drain(msg_len);
 			}
 		}
 		return good;
@@ -452,7 +453,7 @@ namespace OpenWifi {
 	bool RTTYS_Device_ConnectionHandler::do_msgTypeHeartbeat([[maybe_unused]] std::size_t msg_len) {
 		u_char MsgBuf[RTTY_HDR_SIZE + 16]{0};
 		if(msg_len)
-			inBuf_.drain(msg_len);
+			inBuf_->drain(msg_len);
 		MsgBuf[0] = msgTypeHeartbeat;
 		MsgBuf[1] = 0;
 		MsgBuf[2] = 0;
--- a/src/rttys/RTTYS_device.h
+++ b/src/rttys/RTTYS_device.h
@@ -51,9 +51,9 @@ namespace OpenWifi {
 		inline bool Valid() { return valid_; }

 	  private:
-		Poco::Net::StreamSocket   		socket_;
-		Poco::Net::SocketReactor		&reactor_;
-		Poco::FIFOBuffer 				inBuf_{RTTY_DEVICE_BUFSIZE};
+		Poco::Net::StreamSocket   			socket_;
+		Poco::Net::SocketReactor			&reactor_;
+		std::unique_ptr<Poco::FIFOBuffer> 	inBuf_;
 		Poco::Logger					&Logger_;

 		std::atomic_bool				valid_=false;
--- a/src/rttys/RTTYS_server.cpp
+++ b/src/rttys/RTTYS_server.cpp
@@ -108,7 +108,7 @@ namespace OpenWifi {
 		Utils::SetThreadName("rt:janitor");
 		static auto LastStats = OpenWifi::Now();

-		std::unique_lock Lock(LocalMutex_);
+		std::lock_guard 	Lock(LocalMutex_);
 		for(auto element=EndPoints_.begin();element!=EndPoints_.end();) {
 			if(element->second->TooOld()) {
 				auto c = fmt::format("Removing {}. Serial: {} Device connection time: {}s. Client connection time: {}s",
@@ -153,7 +153,7 @@ namespace OpenWifi {
 		while (NextNotification && NotificationManagerRunning_) {
 			auto Notification = dynamic_cast<RTTYS_Notification *>(NextNotification.get());
 			if (Notification != nullptr) {
-				std::unique_lock Lock(LocalMutex_);
+				std::lock_guard 	Lock(LocalMutex_);
 				auto It = EndPoints_.find(Notification->id_);
 				if (It != EndPoints_.end()) {
 					switch (Notification->type_) {
@@ -197,7 +197,7 @@ namespace OpenWifi {
 	}

 	bool RTTYS_server::SendToClient(const std::string &Id, const u_char *Buf, std::size_t Len) {
-		std::shared_lock 	Lock(LocalMutex_);
+		std::lock_guard 	Lock(LocalMutex_);

 		try {
 			auto It = EndPoints_.find(Id);
@@ -213,7 +213,7 @@ namespace OpenWifi {
 	}

 	bool RTTYS_server::SendToClient(const std::string &Id, const std::string &s) {
-		std::shared_lock 	Lock(LocalMutex_);
+		std::lock_guard 	Lock(LocalMutex_);

 		try {
 			auto It = EndPoints_.find(Id);
@@ -229,7 +229,7 @@ namespace OpenWifi {
 	}

 	bool RTTYS_server::SendKeyStrokes(const std::string &Id, const u_char *buffer, std::size_t len) {
-		std::shared_lock 	Lock(LocalMutex_);
+		std::lock_guard 	Lock(LocalMutex_);

 		auto It=EndPoints_.find(Id);
 		if(It==EndPoints_.end() || It->second==nullptr) {
@@ -247,7 +247,7 @@ namespace OpenWifi {
 	}

 	bool RTTYS_server::WindowSize(const std::string &Id, int cols, int rows) {
-		std::shared_lock 	Lock(LocalMutex_);
+		std::lock_guard 	Lock(LocalMutex_);

 		auto It=EndPoints_.find(Id);
 		if(It==EndPoints_.end() || It->second==nullptr) {
@@ -275,7 +275,7 @@ namespace OpenWifi {
 	}

 	bool RTTYS_server::ValidId(const std::string &Token) {
-		std::shared_lock 	Lock(LocalMutex_);
+		std::lock_guard 	Lock(LocalMutex_);
 		return EndPoints_.find(Token) != EndPoints_.end();
 	}

--- a/src/rttys/RTTYS_server.h
+++ b/src/rttys/RTTYS_server.h
@@ -276,7 +276,7 @@ namespace OpenWifi {
 		std::unique_ptr<Poco::TimerCallback<RTTYS_server>>  GCCallBack_;
 		std::list<std::unique_ptr<RTTYS_Device_ConnectionHandler>>	FailedDevices;
 		std::list<std::unique_ptr<RTTYS_ClientConnection>>			FailedClients;
-		std::shared_mutex 							LocalMutex_;
+		std::recursive_mutex 						LocalMutex_;

 		std::atomic_uint64_t 						TotalEndPoints_=0;
 		std::atomic_uint64_t 						FailedNumDevices_=0;
--- a/src/storage/storage_command.cpp
+++ b/src/storage/storage_command.cpp
@@ -13,7 +13,7 @@
 #include "Poco/Data/RecordSet.h"

 #include "Daemon.h"
-#include "DeviceRegistry.h"
+#include "AP_WS_Server.h"
 #include "StorageService.h"
 #include "FileUploader.h"

@@ -265,7 +265,7 @@ typedef Poco::Tuple<
 					Offset++;
 					GWObjects::CommandDetails R;
 					ConvertCommandRecord(i,R);
-					if (DeviceRegistry()->Connected(Utils::SerialNumberToInt(R.SerialNumber)))
+					if (AP_WS_Server()->Connected(Utils::SerialNumberToInt(R.SerialNumber)))
 						Commands.push_back(R);
 				}

@@ -476,7 +476,7 @@ typedef Poco::Tuple<
 			for(const auto &i : Records) {
 				GWObjects::CommandDetails R;
 				ConvertCommandRecord(i,R);
-				if (DeviceRegistry()->Connected(Utils::SerialNumberToInt(R.SerialNumber)))
+				if (AP_WS_Server()->Connected(Utils::SerialNumberToInt(R.SerialNumber)))
 					Commands.push_back(R);
 			}
 			return true;
--- a/src/storage/storage_device.cpp
+++ b/src/storage/storage_device.cpp
@@ -11,7 +11,7 @@
 #include "CentralConfig.h"
 #include "ConfigurationCache.h"
 #include "Daemon.h"
-#include "DeviceRegistry.h"
+#include "AP_WS_Server.h"
 #include "FindCountry.h"
 #include "OUIServer.h"
 #include "Poco/Data/RecordSet.h"
@@ -727,17 +727,17 @@ namespace OpenWifi {
 				UpdateCountedMap(Dashboard.deviceType, DeviceType);

 				GWObjects::ConnectionState	ConnState;
-				if(DeviceRegistry()->GetState(SerialNumber, ConnState)) {
+				if(AP_WS_Server()->GetState(SerialNumber, ConnState)) {
 					UpdateCountedMap(Dashboard.status, ConnState.Connected ? "connected" : "not connected");
 					UpdateCountedMap(Dashboard.certificates, ComputeCertificateTag(ConnState.VerifiedCertificate));
 					UpdateCountedMap(Dashboard.lastContact, ComputeUpLastContactTag(ConnState.LastContact));
 					GWObjects::HealthCheck	HC;
-					if(DeviceRegistry()->GetHealthcheck(SerialNumber,HC))
+					if(AP_WS_Server()->GetHealthcheck(SerialNumber,HC))
 						UpdateCountedMap(Dashboard.healths, ComputeSanityTag(HC.Sanity));
 					else
 						UpdateCountedMap(Dashboard.healths, ComputeSanityTag(100));
 					std::string LastStats;
-					if(DeviceRegistry()->GetStatistics(SerialNumber, LastStats) && !LastStats.empty()) {
+					if(AP_WS_Server()->GetStatistics(SerialNumber, LastStats) && !LastStats.empty()) {
 						Poco::JSON::Parser	P;

 						auto RawObject = P.parse(LastStats).extract<Poco::JSON::Object::Ptr>();
@@ -769,7 +769,6 @@ namespace OpenWifi {
 						UpdateCountedMap(Dashboard.associations, "2G", Associations_2G);
 						UpdateCountedMap(Dashboard.associations, "5G", Associations_5G);
 					}
-					UpdateCountedMap(Dashboard.status, ConnState.Connected ? "connected" : "not connected");
 				} else {
 					UpdateCountedMap(Dashboard.status, "not connected");
 				}
--- a/src/storage/storage_statistics.cpp
+++ b/src/storage/storage_statistics.cpp
@@ -6,7 +6,7 @@
 //	Arilia Wireless Inc.
 //

-#include "DeviceRegistry.h"
+#include "AP_WS_Server.h"
 #include "StorageService.h"

 namespace OpenWifi {
--- a/stop.sh
+++ b/stop.sh
@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-
-pidfilename="${UCENTRALGW_ROOT}/data/pidfile"
-
-if [[ -f "${pidfilename}" ]]
-then
-  kill -9 $(cat ${pidfilename})
-fi
--- a/ucentralgw.properties.aws
+++ b/ucentralgw.properties.aws
@@ -1,193 +0,0 @@
-#
-# uCentral protocol server for devices. This is where you point
-# all your devices. You can replace the * for address by the specific
-# address of one of your interfaces
-#
-ucentral.websocket.host.0.backlog = 500
-ucentral.websocket.host.0.rootca = $UCENTRALGW_ROOT/certs/root.pem
-ucentral.websocket.host.0.issuer = $UCENTRALGW_ROOT/certs/issuer.pem
-ucentral.websocket.host.0.cert = $UCENTRALGW_ROOT/certs/websocket-cert.pem
-ucentral.websocket.host.0.key = $UCENTRALGW_ROOT/certs/websocket-key.pem
-ucentral.websocket.host.0.clientcas = $UCENTRALGW_ROOT/certs/clientcas.pem
-ucentral.websocket.host.0.cas = $UCENTRALGW_ROOT/certs/cas
-ucentral.websocket.host.0.address = *
-ucentral.websocket.host.0.port = 15002
-ucentral.websocket.host.0.security = strict
-ucentral.websocket.host.0.key.password = mypassword
-ucentral.websocket.maxreactors = 20
-
-#
-# REST API access
-#
-ucentral.restapi.host.0.backlog = 100
-ucentral.restapi.host.0.security = relaxed
-ucentral.restapi.host.0.rootca = $UCENTRALGW_ROOT/certs/restapi-ca.pem
-ucentral.restapi.host.0.address = *
-ucentral.restapi.host.0.port = 16002
-ucentral.restapi.host.0.cert = $UCENTRALGW_ROOT/certs/restapi-cert.pem
-ucentral.restapi.host.0.key = $UCENTRALGW_ROOT/certs/restapi-key.pem
-ucentral.restapi.host.0.key.password = mypassword
-
-ucentral.internal.restapi.host.0.backlog = 100
-ucentral.internal.restapi.host.0.security = relaxed
-ucentral.internal.restapi.host.0.rootca = $UCENTRALGW_ROOT/certs/restapi-ca.pem
-ucentral.internal.restapi.host.0.address = *
-ucentral.internal.restapi.host.0.port = 17002
-ucentral.internal.restapi.host.0.cert = $UCENTRALGW_ROOT/certs/restapi-cert.pem
-ucentral.internal.restapi.host.0.key = $UCENTRALGW_ROOT/certs/restapi-key.pem
-ucentral.internal.restapi.host.0.key.password = mypassword
-
-#
-# Used to upload files to the service.
-# You should replace the 'name' vaalue with the IP address of your gateway or an FQDN
-# that your devices can reach
-#
-ucentral.fileuploader.host.0.backlog = 100
-ucentral.fileuploader.host.0.rootca = $UCENTRALGW_ROOT/certs/restapi-ca.pem
-ucentral.fileuploader.host.0.security = relaxed
-ucentral.fileuploader.host.0.address = *
-ucentral.fileuploader.host.0.name = ucentral.dpaas.arilia.com
-ucentral.fileuploader.host.0.port = 16003
-ucentral.fileuploader.host.0.cert = $UCENTRALGW_ROOT/certs/restapi-cert.pem
-ucentral.fileuploader.host.0.key = $UCENTRALGW_ROOT/certs/restapi-key.pem
-ucentral.fileuploader.host.0.key.password = mypassword
-ucentral.fileuploader.path = $UCENTRALGW_ROOT/uploads
-ucentral.fileuploader.maxsize = 10000
-
-#
-# Generic section that all microservices must have
-#
-ucentral.service.key = $UCENTRALGW_ROOT/certs/restapi-key.pem
-ucentral.service.key.password = mypassword
-ucentral.system.data = $UCENTRALGW_ROOT/data
-ucentral.system.debug = true
-ucentral.system.uri.private = https://localhost:17002
-ucentral.system.uri.public = https://ucentral.dpaas.arilia.com:16002
-ucentral.system.uri.ui = https://ucentral-ui.arilia.com
-ucentral.system.commandchannel = /tmp/app.ucentralgw
-
-#
-# Gateway Microservice Specific Section
-#
-ucentral.autoprovisioning = true
-ucentral.devicetypes.0 = AP:linksys_ea8300,edgecore_eap101,linksys_e8450-ubi
-ucentral.devicetypes.1 = SWITCH:edgecore_ecs4100-12ph
-ucentral.devicetypes.2 = IOT:esp32
-oui.download.uri = https://standards-oui.ieee.org/oui/oui.txt
-firmware.autoupdate.policy.default = auto
-
-#
-# rtty
-#
-rtty.enabled = true
-rtty.server = rtty-tip.arilia.com
-rtty.port = 5912
-rtty.token = 96181c567b4d0d98c50f127230068fa8
-rtty.timeout = 60
-rtty.viewport = 5913
-
-#############################
-# Generic information for all micro services
-#############################
-#
-# NLB Support
-#
-alb.enable = true
-alb.port = 16102
-
-#
-# Kafka
-#
-ucentral.kafka.group.id = gateway
-ucentral.kafka.client.id = gateway1
-ucentral.kafka.enable = true
-ucentral.kafka.brokerlist = a1.arilia.com:9092
-# ucentral.kafka.brokerlist = debfarm1-node-c.arilia.com:9092
-ucentral.kafka.auto.commit = false
-ucentral.kafka.queue.buffering.max.ms = 50
-
-#
-# This section select which form of persistence you need
-# Only one selected at a time. If you select multiple, this service will die if a horrible
-# death and might make your beer flat.
-#
-storage.type = sqlite
-#storage.type = postgresql
-#storage.type = mysql
-#storage.type = odbc
-
-storage.type.sqlite.db = devices.db
-storage.type.sqlite.idletime = 120
-storage.type.sqlite.maxsessions = 128
-
-storage.type.postgresql.maxsessions = 64
-storage.type.postgresql.idletime = 60
-storage.type.postgresql.host = localhost
-storage.type.postgresql.username = stephb
-storage.type.postgresql.password = snoopy99
-storage.type.postgresql.database = ucentral
-storage.type.postgresql.port = 5432
-storage.type.postgresql.connectiontimeout = 60
-
-storage.type.mysql.maxsessions = 64
-storage.type.mysql.idletime = 60
-storage.type.mysql.host = localhost
-storage.type.mysql.username = stephb
-storage.type.mysql.password = snoopy99
-storage.type.mysql.database = ucentral
-storage.type.mysql.port = 3306
-storage.type.mysql.connectiontimeout = 60
-
-archiver.enabled = true
-archiver.schedule = 03:00
-archiver.db.0.name = healthchecks
-archiver.db.0.keep = 7
-archiver.db.1.name = statistics
-archiver.db.1.keep = 7
-archiver.db.2.name = devicelogs
-archiver.db.2.keep = 7
-archiver.db.3.name = commandlist
-archiver.db.3.keep = 7
-
-
-########################################################################
-########################################################################
-#
-# Logging: please leave as is for now.
-#
-########################################################################
-
-logging.formatters.f1.class = PatternFormatter
-logging.formatters.f1.pattern = %s: [%p] %t
-logging.formatters.f1.times = UTC
-logging.channels.c1.class = ConsoleChannel
-logging.channels.c1.formatter = f1
-
-# This is where the logs will be written. This path MUST exist
-logging.channels.c2.class = FileChannel
-logging.channels.c2.path = $UCENTRALGW_ROOT/logs/log
-logging.channels.c2.formatter.class = PatternFormatter
-logging.channels.c2.formatter.pattern = %Y-%m-%d %H:%M:%S %s: [%p] %t
-logging.channels.c2.rotation = 20 M
-logging.channels.c2.archive = timestamp
-logging.channels.c2.purgeCount = 20
-logging.channels.c3.class = ConsoleChannel
-logging.channels.c3.pattern = %s: [%p] %t
-
-# External Channel
-logging.loggers.root.channel = c2
-logging.loggers.root.level = debug
-
-# Inline Channel with PatternFormatter
-# logging.loggers.l1.name = logger1
-# logging.loggers.l1.channel.class = ConsoleChannel
-# logging.loggers.l1.channel.pattern = %s: [%p] %t
-# logging.loggers.l1.level = information
-# SplitterChannel
-# logging.channels.splitter.class = SplitterChannel
-# logging.channels.splitter.channels = l1,l2
-# logging.loggers.l2.name = logger2
-# logging.loggers.l2.channel = splitter
-
-
-
--- a/wait-for-postgres.sh
+++ b/wait-for-postgres.sh
@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 # wait-for-postgres.sh

 set -e
@@ -20,7 +20,7 @@ if [ "$1" = '/openwifi/owgw' -a "$(id -u)" = '0' ]; then
    if [ "$RUN_CHOWN" = 'true' ]; then
      chown -R "$OWGW_USER": "$OWGW_ROOT" "$OWGW_CONFIG"
    fi
-    exec su-exec "$OWGW_USER" "$@"
+    exec gosu "$OWGW_USER" "$@"
 fi

 exec "$@"
Author	SHA1	Message	Date
TIP Automation User	6ce7436992	Chg: update image tag in helm values to v2.7.1	2022-10-19 23:07:27 +00:00
TIP Automation User	cf2ad4fa5a	Chg: update image tag in helm values to v2.7.1-RC2	2022-10-14 19:14:55 +00:00
Stephane Bourque	d8257265da	Merge pull request #266 from Telecominfraproject/master https://telecominfraproject.atlassian.net/browse/WIFI-11226	2022-10-14 11:53:10 -07:00
Stephane Bourque	159d8112da	Merge pull request #261 from Telecominfraproject/update-mac-build Update macOS build instruction	2022-10-14 11:50:32 -07:00
Stephane Bourque	fc58822dd8	Merge pull request #265 from Telecominfraproject/WIFI-11162 https://telecominfraproject.atlassian.net/browse/WIFI-11226	2022-10-14 10:43:04 -07:00
stephb9959	ce4c47f568	https://telecominfraproject.atlassian.net/browse/WIFI-11226 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-14 10:41:22 -07:00
Stephane Bourque	2d026fbcd8	Merge pull request #264 from Telecominfraproject/WIFI-11162 https://telecominfraproject.atlassian.net/browse/WIFI-11225	2022-10-14 09:29:39 -07:00
Stephane Bourque	79f1a75a96	Merge branch 'master' into WIFI-11162	2022-10-14 09:29:31 -07:00
stephb9959	b5a1da8649	https://telecominfraproject.atlassian.net/browse/WIFI-11162 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-14 09:21:29 -07:00
stephb9959	87511d39e7	https://telecominfraproject.atlassian.net/browse/WIFI-11162 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-14 09:15:28 -07:00
stephb9959	f0921a9bee	https://telecominfraproject.atlassian.net/browse/WIFI-11162 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-14 09:09:53 -07:00
stephb9959	d136b77b43	https://telecominfraproject.atlassian.net/browse/WIFI-11162 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-14 08:57:23 -07:00
stephb9959	b2b29fe00e	https://telecominfraproject.atlassian.net/browse/WIFI-11162 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-14 08:42:07 -07:00
stephb9959	5e1e6c964f	https://telecominfraproject.atlassian.net/browse/WIFI-11162 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-14 08:36:24 -07:00
TIP Automation User	66825a1103	Chg: update image tag in helm values to v2.7.1-RC1	2022-10-11 17:32:44 +00:00
Stephane Bourque	7e6a566996	Merge pull request #263 from Telecominfraproject/master Creating 2.7.1 release	2022-10-11 10:26:41 -07:00
stephb9959	c3a4b97ba9	Merge remote-tracking branch 'origin/master'	2022-10-11 09:22:47 -07:00
stephb9959	4cb39e3ebc	Merge remote-tracking branch 'origin/master' Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-11 09:22:37 -07:00
Dmitry Dunaev	2be1301542	Merge pull request #262 from Telecominfraproject/security/wifi-11170--docker-image-version [WIFI-11170] Chg: upgrade base Debian image	2022-10-11 14:56:47 +03:00
Dmitry Dunaev	83f54c3203	[WIFI-11170] Chg: upgrade base Debian image Signed-off-by: Dmitry Dunaev <dmitry@opsfleet.com>	2022-10-11 14:56:01 +03:00
Jun Woo Shin	d7ddd4a491	Update macOS build instruction Signed-off-by: Jun Woo Shin <jwoos@fb.com>	2022-10-10 16:18:21 -04:00
stephb9959	090fc89b75	Merge remote-tracking branch 'origin/master'	2022-10-10 08:49:49 -07:00
stephb9959	e5fad8efa5	https://telecominfraproject.atlassian.net/browse/WIFI-11162 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-10 08:49:36 -07:00
Dmitry Dunaev	7fa0266545	Chg: helm log level to debug for testing Signed-off-by: Dmitry Dunaev <dmitry@opsfleet.com>	2022-10-07 11:11:36 +03:00
stephb9959	a4821577d8	Removed unneeded files	2022-10-06 10:56:58 -07:00
stephb9959	9f67845ba2	Removed unneeded files	2022-10-06 10:53:45 -07:00
stephb9959	f9bc2f3e99	Removed unneeded files	2022-10-06 10:49:33 -07:00
stephb9959	8bba101ef7	https://telecominfraproject.atlassian.net/browse/WIFI-11012 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-06 10:35:14 -07:00
stephb9959	cc6cf3bdd4	Merge remote-tracking branch 'origin/master' # Conflicts: # build	2022-10-06 10:06:29 -07:00
stephb9959	b1685ad765	https://telecominfraproject.atlassian.net/browse/WIFI-11012 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-06 10:04:33 -07:00
TIP Automation User	a373a24ee1	Chg: update image tag in helm values to v2.7.0	2022-10-05 11:32:46 +00:00
TIP Automation User	3d6e5e00bb	Chg: update image tag in helm values to v2.7.0-RC6	2022-10-05 02:45:44 +00:00
jaspreetsachdev	e7d3b4b151	Merge pull request #260 from Telecominfraproject/master WIFI-10942	2022-10-04 22:38:13 -04:00
stephb9959	332fec8f9c	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-04 14:11:31 -07:00
stephb9959	25bc8e2b56	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-04 12:29:05 -07:00
stephb9959	71bb83d7de	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-04 11:55:14 -07:00
stephb9959	8871151cf4	Merge remote-tracking branch 'origin/master' # Conflicts: # src/AP_WS_Process_connect.cpp	2022-10-04 11:54:32 -07:00
stephb9959	32f672698d	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-04 11:54:11 -07:00
stephb9959	16a2495346	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-04 11:27:00 -07:00
stephb9959	426f2d81ac	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-04 11:13:58 -07:00
stephb9959	3be3920929	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-04 11:04:55 -07:00
stephb9959	fcac2065ec	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-04 10:45:40 -07:00
stephb9959	26b4697d61	Merge remote-tracking branch 'origin/master'	2022-10-04 10:13:40 -07:00
stephb9959	c7fb094497	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-04 10:13:32 -07:00
stephb9959	52a83e5fa1	Merge remote-tracking branch 'origin/master'	2022-10-04 10:08:29 -07:00
stephb9959	abb8ac8575	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-04 10:06:48 -07:00
stephb9959	957e1bae89	Merge remote-tracking branch 'origin/master'	2022-10-04 09:25:54 -07:00
stephb9959	710553f224	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-04 09:25:43 -07:00
jaspreetsachdev	4569b5aefc	changed to information level logging	2022-10-04 11:34:37 -04:00
jaspreetsachdev	b12c060c97	changed to information level logging	2022-10-04 11:34:02 -04:00
jaspreetsachdev	1c49c05e12	changed debug to information	2022-10-04 11:32:58 -04:00
stephb9959	956a71e21f	Merge pull request #258 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-03 23:06:16 -07:00
stephb9959	09576ab5b2	Merge pull request #258 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-03 22:59:00 -07:00
stephb9959	220ca58fa3	Merge pull request #258 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-03 22:49:55 -07:00
stephb9959	6a4546f803	Merge pull request #258 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-03 19:20:44 -07:00
stephb9959	a988fbc1a5	Merge pull request #258 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-03 19:07:12 -07:00
stephb9959	8741a407e8	Merge remote-tracking branch 'origin/master'	2022-10-03 17:05:48 -07:00
Stephane Bourque	3a8b5369eb	Merge pull request #258 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-03 17:05:33 -07:00
Stephane Bourque	41634904e8	Merge pull request #258 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-03 16:59:19 -07:00
Stephane Bourque	3beb6032e9	Merge branch 'master' into WIFI-10942	2022-10-03 16:59:11 -07:00
stephb9959	92e33342cb	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-03 16:57:24 -07:00
Stephane Bourque	033f3fc626	Merge pull request #257 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-03 16:27:19 -07:00
stephb9959	4b0521e40a	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-03 16:10:39 -07:00
Stephane Bourque	9144377472	Merge pull request #256 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-03 13:34:21 -07:00
Stephane Bourque	ee8671876a	Merge branch 'master' into WIFI-10942	2022-10-03 13:34:15 -07:00
stephb9959	56de1fea0b	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-10-03 13:32:20 -07:00
Stephane Bourque	92db23751d	Merge pull request #255 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-03 13:17:12 -07:00
stephb9959	7da8f44a8e	https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-03 13:16:18 -07:00
Stephane Bourque	d1d44b3aa2	Merge pull request #254 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-03 11:52:16 -07:00
Stephane Bourque	cf061d0c21	Merge branch 'master' into WIFI-10942	2022-10-03 11:52:09 -07:00
Stephane Bourque	85c4218a6a	https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-03 11:50:38 -07:00
TIP Automation User	c3a51487c0	Chg: update image tag in helm values to v2.7.0-RC5	2022-10-03 11:14:15 +00:00
Dmitry Dunaev	dd44d0504d	Merge pull request #253 from Telecominfraproject/master [WIFI-10581] Add: postgresql-client in Dockerfile	2022-10-03 14:03:55 +03:00
Dmitry Dunaev	4cd9b47f23	Merge pull request #252 from Telecominfraproject/fix/wifi-10581--postgres-client [WIFI-10581] Add: postgresql-client in Dockerfile	2022-10-03 11:22:27 +03:00
Dmitry Dunaev	86c04b185e	[WIFI-10581] Add: postgresql-client in Dockerfile Signed-off-by: Dmitry Dunaev <dmitry@opsfleet.com>	2022-10-03 11:12:00 +03:00
Stephane Bourque	a6ff0ab197	Merge pull request #251 from Telecominfraproject/master https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-02 10:30:26 -07:00
Stephane Bourque	8b1056eb59	Merge pull request #250 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-02 10:26:23 -07:00
Stephane Bourque	2b6206c6c5	https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-10-02 10:24:22 -07:00
Stephane Bourque	b5c3b101d3	Merge pull request #179 from Telecominfraproject/WIFI-10581-switch-images-to-debian-slim [WIFI-10581] Switch microservice Docker images from Alpine to Debian-slim	2022-10-02 09:47:51 -07:00
Stephane Bourque	f60fed173d	Merge branch 'master' into WIFI-10581-switch-images-to-debian-slim	2022-10-02 09:47:21 -07:00
TIP Automation User	9202893b77	Chg: update image tag in helm values to v2.7.0-RC4	2022-09-30 19:48:53 +00:00
Stephane Bourque	7b1920b7b2	Merge pull request #249 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-09-30 11:40:29 -07:00
stephb9959	cafd757593	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-09-30 11:35:12 -07:00
stephb9959	ff7a806f67	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-09-30 11:33:30 -07:00
TIP Automation User	f264a2e556	Chg: update image tag in helm values to v2.7.0-RC3	2022-09-30 16:31:25 +00:00
Stephane Bourque	f11751ac89	Merge pull request #248 from Telecominfraproject/WIFI-10942 https://telecominfraproject.atlassian.net/browse/WIFI-10942	2022-09-30 08:55:04 -07:00
stephb9959	fa9d59852a	https://telecominfraproject.atlassian.net/browse/WIFI-10942 Signed-off-by: stephb9959 <stephane.bourque@gmail.com>	2022-09-30 08:18:47 -07:00
Johann Hoffmann	f68ecd421d	Fix self-signed cert file extension for Debian Signed-off-by: Johann Hoffmann <johann.hoffmann@mailbox.org>	2022-08-19 17:20:16 +02:00
Johann Hoffmann	0e582b10ce	Create necessary library links in Docker image Signed-off-by: Johann Hoffmann <johann.hoffmann@mailbox.org>	2022-08-19 16:15:32 +02:00
Johann Hoffmann	4bfa8054cc	Add ca-certificates package to build base image Signed-off-by: Johann Hoffmann <johann.hoffmann@mailbox.org>	2022-08-18 13:15:32 +02:00
Johann Hoffmann	c36d4bcad1	Switch to Debian-slim base images Signed-off-by: Johann Hoffmann <johann.hoffmann@mailbox.org>	2022-08-17 18:07:24 +02:00