Merge branch 'master' into v3.1.0

Dockerfile

@@ -1,7 +1,7 @@
 ARG DEBIAN_VERSION=11.5-slim
 ARG POCO_VERSION=poco-tip-v2
 ARG CPPKAFKA_VERSION=tip-v1
-ARG VALIJASON_VERSION=tip-v1.0.2
+ARG VALIJASON_VERSION=tip-v1
 ARG APP_NAME=owgw
 ARG APP_HOME_DIR=/openwifi
 

PROTOCOL.md

@@ -306,40 +306,8 @@ The device should answer:
          },
      "id" : <same number>
 }
-```
-
-#### Controller wants the device to apply a given fixed configuration
-
-Controller sends this command when it requires the device to apply fixed configuration, eg. country code. The device
-should respond with message indicating failure or success.
-
-```json
-{   "jsonrpc" : "2.0",
-    "method" : "fixedconfig",
-    "params" : {
-        "serial" : <serial number>,
-        "when" : Optional - <UTC time when to apply this config, 0 means immediate, this is a suggestion>
-        "country" : "<country-code>"
-     },
-}
-```
-
-The device should answer:
-```json
-{   "jsonrpc" : "2.0",
-    "result" : {
-        "serial": <serial number>,
-        "status": {
-            "error": 0 or an error number,
-            "text": <description of the error or success, eg. "Applied fixed config, rebooting">
-        },
-        "uuid": <UUID>
-    }
-}
 
 ```
-
-
 ##### The Answer
 The device can answer and tell the controller it has rejected certain parts of the config and potentially replaced them with
 appropriate values. This could be used to allow a device to replace frequencies for the regions it is located in. The device 

helm/values.yaml

@@ -9,7 +9,7 @@ fullnameOverride: ""
 images:
   owgw:
     repository: tip-tip-wlan-cloud-ucentral.jfrog.io/owgw
-    tag: master
+    tag: v3.1.0
     pullPolicy: Always
 #    regcred:
 #      registry: tip-tip-wlan-cloud-ucentral.jfrog.io

openapi/owgw.yaml

@@ -12,7 +12,7 @@ info:
     url: https://www.ucentral.info/support
 
 servers:
-  - url: 'https://localhost:16002/api/v1'
+  - url: 'https://localhost:16001/api/v1'
 
 security:
   - bearerAuth: []

src/RESTAPI/RESTAPI_RPC.cpp

@@ -25,23 +25,9 @@ namespace OpenWifi::RESTAPI_RPC {
 		if (StorageService()->AddCommand(Cmd.SerialNumber, Cmd, Status)) {
 			Poco::JSON::Object RetObj;
 			Cmd.to_json(RetObj);
-			if (Handler == nullptr) {
-				// nothing to process/return
-				return;
-			}
-			Poco::Net::HTTPResponse::HTTPStatus cmd_status = Poco::Net::HTTPResponse::HTTP_OK;
-            if (Cmd.ErrorCode > 0) {
-				// command returned error
-				cmd_status = Poco::Net::HTTPResponse::HTTP_BAD_REQUEST;
-				if (Cmd.Command == uCentralProtocol::CONFIGURE) {
-					// special handling for configure command
-					if (!Handler->GetBoolParameter("strict", false)) {
-						// in non-strict mode return success for failed configure command
-						cmd_status = Poco::Net::HTTPResponse::HTTP_OK;
-					}
-				}
-			}
-			return Handler->ReturnObject(RetObj, cmd_status);
+			if (Handler != nullptr)
+				return Handler->ReturnObject(RetObj);
+			return;
 		}
 		if (Handler != nullptr)
 			return Handler->ReturnStatus(Poco::Net::HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);
@@ -181,20 +167,6 @@ namespace OpenWifi::RESTAPI_RPC {
 				Cmd.AttachType = "";
 			}
 
-			// If the command fails on the device we should show it as failed and not return 200 OK
-			// exception is configure command which only reported failed in strict validation mode
-			if (Cmd.ErrorCode &&
-				(Cmd.Command != uCentralProtocol::CONFIGURE ||
-					(Cmd.Command == uCentralProtocol::CONFIGURE && Handler->GetBoolParameter("strict", false))
-				))
-			{
-				Logger.information(fmt::format(
-				"Command failed with error on device: {}  Reason: {}.",
-				Cmd.ErrorCode, Cmd.ErrorText));
-				return SetCommandStatus(Cmd, Request, Response, Handler,
-								Storage::CommandExecutionType::COMMAND_FAILED, Logger);
-			}
-
 			if (Cmd.ErrorCode == 0 && Cmd.Command == uCentralProtocol::CONFIGURE) {
 				//	we need to post a kafka event for this.
 				if (Params.has(uCentralProtocol::CONFIG) && Params.isObject(uCentralProtocol::CONFIG)) {
@@ -203,7 +175,6 @@ namespace OpenWifi::RESTAPI_RPC {
 					DeviceConfigurationChangeKafkaEvent KEvent(
 						Utils::SerialNumberToInt(Cmd.SerialNumber), Utils::Now(),
 						Config);
-						
 				}
 			}
 

src/RESTAPI/RESTAPI_device_commandHandler.cpp

@@ -167,10 +167,7 @@ namespace OpenWifi {
 		{APCommands::Commands::certupdate, false, true, &RESTAPI_device_commandHandler::CertUpdate, 60000ms},
 		{APCommands::Commands::transfer, false, true, &RESTAPI_device_commandHandler::Transfer, 60000ms},
 		{APCommands::Commands::script, false, true, &RESTAPI_device_commandHandler::Script, 60000ms},
-		{APCommands::Commands::powercycle, false, true, &RESTAPI_device_commandHandler::PowerCycle, 60000ms},
-		{APCommands::Commands::fixedconfig, false, true, &RESTAPI_device_commandHandler::FixedConfig, 120000ms},
-		{APCommands::Commands::cablediagnostics, false, true, &RESTAPI_device_commandHandler::CableDiagnostics, 120000ms},
-
+		{APCommands::Commands::powercycle, false, true, &RESTAPI_device_commandHandler::PowerCycle, 60000ms}
 	};
 
 	void RESTAPI_device_commandHandler::DoPost() {
@@ -1551,82 +1548,4 @@ namespace OpenWifi {
 										   Logger_);
 	}
 
-	// `fixedconfig` command is used set country propery on AP
-	// This handler uses `fixedconfig` command definitions
-	void RESTAPI_device_commandHandler::FixedConfig(
-		const std::string &CMD_UUID, uint64_t CMD_RPC, std::chrono::milliseconds timeout,
-		[[maybe_unused]] const GWObjects::DeviceRestrictions &Restrictions) {
-		poco_debug(Logger_, fmt::format("FIXEDCONFIG({},{}): TID={} user={} serial={}", CMD_UUID, CMD_RPC,
-										TransactionId_, Requester(), SerialNumber_));
-		// do not allow `fixedconfig` command for simulated devices
-		if(IsDeviceSimulated(SerialNumber_)) {
-			CallCanceled("FIXEDCONFIG", CMD_UUID, CMD_RPC, RESTAPI::Errors::SimulatedDeviceNotSupported);
-			return BadRequest(RESTAPI::Errors::SimulatedDeviceNotSupported);
-		}
-
-		// setup and validate fixedconfig object
-		GWObjects::FixedConfig fixed_config;
-		if(!fixed_config.from_json(ParsedBody_)) {
-			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-		}
-
-		// setup command message
-		GWObjects::CommandDetails Cmd;
-		Cmd.SerialNumber = SerialNumber_;
-		Cmd.SubmittedBy = Requester();
-		Cmd.UUID = CMD_UUID;
-		Cmd.Command = uCentralProtocol::FIXEDCONFIG;
-		std::ostringstream os;
-		ParsedBody_->stringify(os);
-		Cmd.Details = os.str();
-		Cmd.RunAt = 0;
-		Cmd.ErrorCode = 0;
-		Cmd.WaitingForFile = 0;
-
-		// send fixedconfig command to device and return status
-		return RESTAPI_RPC::WaitForCommand(CMD_RPC, APCommands::Commands::fixedconfig, false, Cmd,
-										   *ParsedBody_, *Request, *Response, timeout, nullptr, this,
-										   Logger_);
-	}
-
-	void RESTAPI_device_commandHandler::CableDiagnostics(
-		const std::string &CMD_UUID, uint64_t CMD_RPC,
-		[[maybe_unused]] std::chrono::milliseconds timeout,
-		[[maybe_unused]] const GWObjects::DeviceRestrictions &Restrictions) {
-
-		if(UserInfo_.userinfo.userRole != SecurityObjects::ROOT &&
-			UserInfo_.userinfo.userRole != SecurityObjects::ADMIN) {
-			CallCanceled("CABLEDIAGNOSTICS", CMD_UUID, CMD_RPC, RESTAPI::Errors::ACCESS_DENIED);
-			return UnAuthorized(RESTAPI::Errors::ACCESS_DENIED);
-		}
-
-		poco_debug(Logger_, fmt::format("CABLEDIAGNOSTICS({},{}): TID={} user={} serial={}", CMD_UUID,
-										CMD_RPC, TransactionId_, Requester(), SerialNumber_));
-
-		if(IsDeviceSimulated(SerialNumber_)) {
-			CallCanceled("CABLEDIAGNOSTICS", CMD_UUID, CMD_RPC, RESTAPI::Errors::SimulatedDeviceNotSupported);
-			return BadRequest(RESTAPI::Errors::SimulatedDeviceNotSupported);
-		}
-
-		GWObjects::CableDiagnostics	PR;
-		if(!PR.from_json(ParsedBody_)) {
-			return BadRequest(RESTAPI::Errors::MissingOrInvalidParameters);
-		}
-
-		GWObjects::CommandDetails Cmd;
-		Cmd.SerialNumber = SerialNumber_;
-		Cmd.SubmittedBy = Requester();
-		Cmd.UUID = CMD_UUID;
-		Cmd.Command = uCentralProtocol::CABLEDIAGNOSTICS;
-		std::ostringstream os;
-		ParsedBody_->stringify(os);
-		Cmd.Details = os.str();
-		Cmd.RunAt = PR.when;
-		Cmd.ErrorCode = 0;
-		Cmd.WaitingForFile = 0;
-
-		return RESTAPI_RPC::WaitForCommand(CMD_RPC, APCommands::Commands::cablediagnostics, false, Cmd,
-										   *ParsedBody_, *Request, *Response, timeout, nullptr, this,
-										   Logger_);
-	}
 } // namespace OpenWifi

src/RESTAPI/RESTAPI_device_commandHandler.h

@@ -70,10 +70,6 @@ namespace OpenWifi {
 					const GWObjects::DeviceRestrictions &R);
 		void PowerCycle(const std::string &UUID, uint64_t RPC, std::chrono::milliseconds timeout,
 					  const GWObjects::DeviceRestrictions &R);
-		void FixedConfig(const std::string &UUID, uint64_t RPC, std::chrono::milliseconds timeout,
-					  const GWObjects::DeviceRestrictions &R);
-		void CableDiagnostics(const std::string &UUID, uint64_t RPC, std::chrono::milliseconds timeout,
-					  const GWObjects::DeviceRestrictions &R);
 
 		static auto PathName() {
 			return std::list<std::string>{"/api/v1/device/{serialNumber}/{command}"};

src/RESTObjects/RESTAPI_GWobjects.cpp

@@ -799,24 +799,4 @@ namespace OpenWifi::GWObjects {
 		return false;
 	}
 
-	bool FixedConfig::from_json(const Poco::JSON::Object::Ptr &Obj) {
-		try {
-			field_from_json(Obj, "serial", serialNumber);
-			field_from_json(Obj, "country", country);
-			return true;
-		} catch (const Poco::Exception &E) {
-		}
-		return false;
-	}
-
-	bool CableDiagnostics::from_json(const Poco::JSON::Object::Ptr &Obj) {
-		try {
-			field_from_json(Obj, "serial", serialNumber);
-			field_from_json(Obj, "when", when);
-			field_from_json(Obj, "ports", ports);
-			return true;
-		} catch (const Poco::Exception &E) {
-		}
-		return false;
-	}
 } // namespace OpenWifi::GWObjects

src/RESTObjects/RESTAPI_GWobjects.h

@@ -532,19 +532,6 @@ namespace OpenWifi::GWObjects {
 		std::uint64_t 	when;
 		std::vector<PowerCyclePort> ports;
 
-		bool from_json(const Poco::JSON::Object::Ptr &Obj);
-	};
-	struct FixedConfig {
-		std::string 	serialNumber;
-		std::string 	country;
-
-		bool from_json(const Poco::JSON::Object::Ptr &Obj);
-	};
-	struct CableDiagnostics {
-		std::string 	serialNumber;
-		std::uint64_t 	when;
-		std::vector<std::string> ports;
-
 		bool from_json(const Poco::JSON::Object::Ptr &Obj);
 	};
 } // namespace OpenWifi::GWObjects

src/framework/ConfigurationValidator.cpp

@@ -2411,18 +2411,11 @@ static std::string DefaultAPSchema = R"foo(
                     "$ref": "#/$defs/interface.ssid.encryption"
                 },
                 "multi-psk": {
-                    "anyOf": [
-                        {
-                            "type": "array",
-                            "items": {
-                                "$ref": "#/$defs/interface.ssid.multi-psk"
-                            }
-                        },
-                        {
-                            "type": "boolean"
-                        }
-                    ]
-		},
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/interface.ssid.multi-psk"
+                    }
+                },
                 "rrm": {
                     "$ref": "#/$defs/interface.ssid.rrm"
                 },
@@ -6610,17 +6603,10 @@ static std::string DefaultSWITCHSchema = R"foo(
                     "$ref": "#/$defs/interface.ssid.encryption"
                 },
                 "multi-psk": {
-                    "anyOf": [
-                        {
-                            "type": "array",
-                            "items": {
-                                "$ref": "#/$defs/interface.ssid.multi-psk"
-                            }
-                        },
-                        {
-                            "type": "boolean"
-                        }
-                    ]
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/interface.ssid.multi-psk"
+                    }
                 },
                 "rrm": {
                     "$ref": "#/$defs/interface.ssid.rrm"

src/framework/KafkaManager.cpp

@@ -118,10 +118,6 @@ namespace OpenWifi {
 						Producer.poll((std::chrono::milliseconds) 0);
 					}
 				}
-				if (Queue_.size() == 0) {
-					// message queue is empty, flush all previously sent messages
-					Producer.flush();
-				}
 			} catch (const cppkafka::HandleException &E) {
 				poco_warning(Logger_,
 							 fmt::format("Caught a Kafka exception (producer): {}", E.what()));
@@ -130,6 +126,10 @@ namespace OpenWifi {
 			} catch (...) {
 				poco_error(Logger_, "std::exception");
 			}
+			if (Queue_.size() == 0) {
+				// message queue is empty, flush all previously sent messages
+				Producer.flush();
+			}
 			Note = Queue_.waitDequeueNotification();
 		}
 		Producer.flush();

src/framework/RESTAPI_Handler.h

@@ -552,8 +552,8 @@ namespace OpenWifi {
 
 		inline bool IsAuthorized(bool &Expired, bool &Contacted, bool SubOnly = false);
 
-		inline void ReturnObject(Poco::JSON::Object &Object, Poco::Net::HTTPResponse::HTTPStatus Status = Poco::Net::HTTPResponse::HTTP_OK) {
-			PrepareResponse(Status);
+		inline void ReturnObject(Poco::JSON::Object &Object) {
+			PrepareResponse();
 			if (Request != nullptr) {
 				//   can we compress ???
 				auto AcceptedEncoding = Request->find("Accept-Encoding");

src/framework/ow_constants.h

@@ -580,9 +580,6 @@ namespace OpenWifi::RESTAPI::Protocol {
 	static const char *INTERVAL = "interval";
 	static const char *UI = "UI";
 	static const char *BANDWIDTH = "bandwidth";
-
-	static const char *FIXEDCONFIG = "fixedconfig";
-	static const char *CABLEDIAGNOSTICS = "cable-diagnostics";
 } // namespace OpenWifi::RESTAPI::Protocol
 
 namespace OpenWifi::uCentralProtocol {
@@ -695,9 +692,6 @@ namespace OpenWifi::uCentralProtocol {
 	static const char *RRM = "rrm";
 	static const char *ACTIONS = "actions";
 
-	static const char *FIXEDCONFIG = "fixedconfig";
-	static const char *CABLEDIAGNOSTICS = "cable-diagnostics";
-
 } // namespace OpenWifi::uCentralProtocol
 
 namespace OpenWifi::uCentralProtocol::Events {
@@ -794,8 +788,6 @@ namespace OpenWifi::APCommands {
 		certupdate,
 		transfer,
 		powercycle,
-		fixedconfig,
-		cablediagnostics,
 		unknown
 	};
 
@@ -810,8 +802,7 @@ namespace OpenWifi::APCommands {
 		RESTAPI::Protocol::EVENTQUEUE,	 RESTAPI::Protocol::TELEMETRY,
 		RESTAPI::Protocol::PING,		 RESTAPI::Protocol::SCRIPT,
 		RESTAPI::Protocol::RRM,		 	 RESTAPI::Protocol::CERTUPDATE,
-		RESTAPI::Protocol::TRANSFER,	 RESTAPI::Protocol::POWERCYCLE,
-		RESTAPI::Protocol::FIXEDCONFIG,  RESTAPI::Protocol::CABLEDIAGNOSTICS
+		RESTAPI::Protocol::TRANSFER,	 RESTAPI::Protocol::POWERCYCLE
 	};
 
 	inline const char *to_string(Commands Cmd) { return uCentralAPCommands[(uint8_t)Cmd]; }