scottk/wlan-cloud-analytics
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/wlan-cloud-analytics.git synced 2025-10-30 18:07:48 +00:00
Code Issues Packages Projects Releases 10 Wiki Activity

Adding time point recording.

Browse Source
This commit is contained in:
stephb9959
2022-03-21 22:36:21 -07:00
parent f96a9502be
commit d6a9138e4b
21 changed files with 888 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.idea/.name generated Normal file
View File

@@ -0,0 +1 @@
owanalytics

7
.idea/dictionaries/stephb.xml generated Normal file
View File

@@ -0,0 +1,7 @@
<component name="ProjectDictionaryState">
<dictionary name="stephb">
<words>
<w>bourque</w>
</words>
</dictionary>
</component>

2
CMakeLists.txt
View File

@@ -84,7 +84,7 @@ add_executable(owanalytics
src/RESTAPI/RESTAPI_routers.cpp src/RESTAPI/RESTAPI_routers.cpp
src/Daemon.cpp src/Daemon.h src/Daemon.cpp src/Daemon.h
src/Dashboard.h src/Dashboard.cpp src/Dashboard.h src/Dashboard.cpp
src/StorageService.cpp src/StorageService.h src/RESTObjects/RESTAPI_AnalyticsObjects.cpp src/RESTObjects/RESTAPI_AnalyticsObjects.h src/StateReceiver.cpp src/StateReceiver.h src/VenueWatcher.cpp src/VenueWatcher.h src/VenueCoordinator.cpp src/VenueCoordinator.h src/sdks/SDK_prov.cpp src/sdks/SDK_prov.h src/storage/storage_boards.cpp src/storage/storage_boards.h src/RESTAPI/RESTAPI_board_list_handler.cpp src/RESTAPI/RESTAPI_board_list_handler.h src/RESTAPI/RESTAPI_board_handler.cpp src/RESTAPI/RESTAPI_board_handler.h src/RESTAPI/RESTAPI_analytics_db_helpers.h src/APStats.cpp src/APStats.h src/dict_ssid.h src/dict_ue.h src/dict_bssid.h src/DeviceStatusReceiver.cpp src/DeviceStatusReceiver.h src/RESTAPI/RESTAPI_board_devices_handler.cpp src/RESTAPI/RESTAPI_board_devices_handler.h src/HealthReceiver.cpp src/HealthReceiver.h src/StatFunc.h) src/StorageService.cpp src/StorageService.h src/RESTObjects/RESTAPI_AnalyticsObjects.cpp src/RESTObjects/RESTAPI_AnalyticsObjects.h src/StateReceiver.cpp src/StateReceiver.h src/VenueWatcher.cpp src/VenueWatcher.h src/VenueCoordinator.cpp src/VenueCoordinator.h src/sdks/SDK_prov.cpp src/sdks/SDK_prov.h src/storage/storage_boards.cpp src/storage/storage_boards.h src/RESTAPI/RESTAPI_board_list_handler.cpp src/RESTAPI/RESTAPI_board_list_handler.h src/RESTAPI/RESTAPI_board_handler.cpp src/RESTAPI/RESTAPI_board_handler.h src/RESTAPI/RESTAPI_analytics_db_helpers.h src/APStats.cpp src/APStats.h src/dict_ssid.h src/dict_ue.h src/dict_bssid.h src/DeviceStatusReceiver.cpp src/DeviceStatusReceiver.h src/RESTAPI/RESTAPI_board_devices_handler.cpp src/RESTAPI/RESTAPI_board_devices_handler.h src/HealthReceiver.cpp src/HealthReceiver.h src/StatFunc.h src/RESTAPI/RESTAPI_board_timepoint_handler.cpp src/RESTAPI/RESTAPI_board_timepoint_handler.h src/storage/storage_timepoints.cpp src/storage/storage_timepoints.h)
target_link_libraries(owanalytics PUBLIC target_link_libraries(owanalytics PUBLIC
${Poco_LIBRARIES} ${MySQL_LIBRARIES} ${Poco_LIBRARIES} ${MySQL_LIBRARIES}

2
build
View File

@@ -1 +1 @@
12 20

260
openapi/owanalytics.yaml
View File

@@ -230,6 +230,213 @@ components:
items: items:
$ref: '#/components/schemas/DeviceInfo' $ref: '#/components/schemas/DeviceInfo'
MSDU_entry:
type: object
properties:
rx_msdu:
type: integer
format: int64
tx_msdu:
type: integer
format: int64
tx_msdu_failed:
type: integer
format: int64
tx_msdu_retries:
type: integer
format: int64
UE_rate:
type: object
properties:
bitrate:
type: integer
format: int64
mcs:
type: integer
format: int64
nss:
type: integer
format: int64
chwidth:
type: integer
format: int64
ht:
type: boolean
sgi:
type:
boolean
UETimePoint:
type: object
properties:
association_bssid:
type: integer
format: int64
station:
type: integer
format: int64
rssi:
type: integer
format: int64
tx_bytes:
type: integer
format: int64
rx_bytes:
type: integer
format: int64
tx_duration:
type: integer
format: int64
rx_packets:
type: integer
format: int64
tx_packets:
type: integer
format: int64
tx_retries:
type: integer
format: int64
tx_failed:
type: integer
format: int64
connected:
type: integer
format: int64
inactive:
type: integer
format: int64
tx_rate:
$ref: '#/components/schemas/UE_rate'
rx_rate:
$ref: '#/components/schemas/UE_rate'
msdus:
type: array
items:
$ref: '#/components/schemas/MSDU_entry'
SSIDTimePoint:
type: object
properties:
bssid:
type: string
mode:
type: string
ssid:
type: string
associations:
type: array
items:
$ref: '#/components/schemas/UETimePoint'
APTimePoint:
type: object
properties:
collisions:
type: integer
format: int64
multicast:
type: integer
format: int64
rx_bytes:
type: integer
format: int64
rx_dropped:
type: integer
format: int64
rx_errors:
type: integer
format: int64
rx_packets:
type: integer
format: int64
tx_bytes:
type: integer
format: int64
tx_dropped:
type: integer
format: int64
tx_errors:
type: integer
format: int64
tx_packets:
type: integer
format: int64
RadioTimePoint:
type: object
properties:
band:
type: integer
format: int64
radio_channel:
type: integer
format: int64
active_ms:
type: integer
format: int64
busy_ms:
type: integer
format: int64
receive_ms:
type: integer
format: int64
transmit_ms:
type: integer
format: int64
tx_power:
type: integer
format: int64
channel:
type: integer
format: int64
temperature:
type: integer
format: int64
noise:
type: integer
format: int64
DeviceTimePoint:
type: object
properties:
timestamp:
type: integer
format: int64
ap_data:
$ref: '#/components/schemas/APTimePoint'
ssid_data:
type: array
items:
$ref: '#/components/schemas/SSIDTimePoint'
radio_data:
type: array
items:
$ref: '#/components/schemas/RadioTimePoint'
device_info:
$ref: '#/components/schemas/DeviceInfo'
DeviceTimePointList:
type: object
properties:
points:
type: array
items:
$ref: '#/components/schemas/DeviceTimePoint'
DeviceTimePointStats:
type: object
properties:
firstPoint:
type: integer
format: int64
lastPoint:
type: integer
format: int64
count:
type: integer
format: int64
######################################################################################### #########################################################################################
## ##
## These are endpoints that all services in the OPenWiFI stack must provide ## These are endpoints that all services in the OPenWiFI stack must provide
@@ -603,6 +810,59 @@ paths:
404: 404:
$ref: '#/components/responses/NotFound' $ref: '#/components/responses/NotFound'
/board/{id}/timepoint:
get:
tags:
- Board data
summary: retrieve board data for a given time period.
operationId: getBoardTimepoint
parameters:
- in: path
name: id
schema:
type: string
format: uuid
required: true
- in: query
name: fromDate
schema:
type: integer
required: false
- in: query
name: endDate
schema:
type: integer
required: false
- in: query
name: maxRecords
schema:
type: integer
default: 100
required: false
- in: query
name: stats
schema:
type: boolean
required: false
responses:
200:
description: Successfull retrieval of timepoints
content:
application/json:
schema:
oneOf:
- $ref: '#/components/schemas/DeviceTimePointList'
- $ref: '#/components/schemas/DeviceTimePointStats'
400:
$ref: '#/components/responses/BadRequest'
403:
$ref: '#/components/responses/Unauthorized'
404:
$ref: '#/components/responses/NotFound'
/iptocountry: /iptocountry:
get: get:
tags: tags:

47
src/APStats.cpp
View File

@@ -4,6 +4,7 @@
#include "APStats.h" #include "APStats.h"
#include "dict_ssid.h" #include "dict_ssid.h"
#include "StorageService.h"
namespace OpenWifi { namespace OpenWifi {
@@ -94,16 +95,12 @@ namespace OpenWifi {
auto ref = radio["$ref"]; auto ref = radio["$ref"];
auto radio_parts = Poco::StringTokenizer(ref, "/"); auto radio_parts = Poco::StringTokenizer(ref, "/");
if(radio_parts.count()==3) if(radio_parts.count()==3)
radio_location = std::atoi(radio_parts[2].c_str()); radio_location = std::strtol(radio_parts[2].c_str(), nullptr,10);
} }
} }
std::string bssid, mode, ssid_name; GetJSON("bssid",ssid,SSIDTP.bssid, std::string{""});
GetJSON("bssid",ssid,bssid, std::string{""}); GetJSON("mode",ssid,SSIDTP.mode, std::string{""} );
SSIDTP.bssid = Utils::MACToInt(bssid); GetJSON("ssid",ssid,SSIDTP.ssid, std::string{""} );
GetJSON("mode",ssid,mode, std::string{""} );
SSIDTP.mode = AnalyticsObjects::SSID_Mode(mode);
GetJSON("ssid",ssid,ssid_name, std::string{""} );
SSIDTP.ssid = SSID_DICT()->Add(ssid_name);
if (ssid.contains("associations") && ssid["associations"].is_array()) { if (ssid.contains("associations") && ssid["associations"].is_array()) {
auto associations = ssid["associations"]; auto associations = ssid["associations"];
auto it = radio_band.find(radio_location); auto it = radio_band.find(radio_location);
@@ -118,11 +115,7 @@ namespace OpenWifi {
} }
for(const auto &association:associations) { for(const auto &association:associations) {
AnalyticsObjects::UETimePoint TP; AnalyticsObjects::UETimePoint TP;
std::string association_bssid,station; GetJSON("station",association,TP.station, std::string{} );
GetJSON("bssid",association,association_bssid, std::string{""} );
GetJSON("station",association,station, std::string{} );
TP.association_bssid = Utils::MACToInt(association_bssid);
TP.station = Utils::MACToInt(station);
GetJSON("rssi",association,TP.rssi, (int64_t)0 ); GetJSON("rssi",association,TP.rssi, (int64_t)0 );
GetJSON("tx_bytes",association,TP.tx_bytes, (uint64_t)0 ); GetJSON("tx_bytes",association,TP.tx_bytes, (uint64_t)0 );
GetJSON("rx_bytes",association,TP.rx_bytes, (uint64_t)0 ); GetJSON("rx_bytes",association,TP.rx_bytes, (uint64_t)0 );
@@ -137,7 +130,7 @@ namespace OpenWifi {
if(association.contains("msdu") && association["msdu"].is_array()) { if(association.contains("msdu") && association["msdu"].is_array()) {
auto msdus = association["msdu"]; auto msdus = association["msdu"];
for(const auto &msdu:msdus) { for(const auto &msdu:msdus) {
AnalyticsObjects::msdu_entry E; AnalyticsObjects::MSDU_entry E;
GetJSON("rx_msdu",msdu,E.rx_msdu, (uint64_t)0 ); GetJSON("rx_msdu",msdu,E.rx_msdu, (uint64_t)0 );
GetJSON("tx_msdu",msdu,E.tx_msdu, (uint64_t)0 ); GetJSON("tx_msdu",msdu,E.tx_msdu, (uint64_t)0 );
GetJSON("tx_msdu_failed",msdu,E.tx_msdu_failed, (uint64_t)0 ); GetJSON("tx_msdu_failed",msdu,E.tx_msdu_failed, (uint64_t)0 );
@@ -146,6 +139,26 @@ namespace OpenWifi {
} }
} }
if(association.contains("tx_rate")) {
auto tx_rate = association["tx_rate"];
GetJSON("bitrate",tx_rate,TP.tx_rate.bitrate, (uint64_t)0 );
GetJSON("mcs",tx_rate,TP.tx_rate.mcs, (uint64_t)0 );
GetJSON("nss",tx_rate,TP.tx_rate.nss, (uint64_t)0 );
GetJSON("chwidth",tx_rate,TP.tx_rate.chwidth, (uint64_t)0 );
GetJSON("ht",tx_rate,TP.tx_rate.ht, false );
GetJSON("sgi",tx_rate,TP.tx_rate.sgi, false );
}
if(association.contains("rx_rate")) {
auto rx_rate = association["rx_rate"];
GetJSON("bitrate",rx_rate,TP.rx_rate.bitrate, (uint64_t)0 );
GetJSON("mcs",rx_rate,TP.rx_rate.mcs, (uint64_t)0 );
GetJSON("nss",rx_rate,TP.rx_rate.nss, (uint64_t)0 );
GetJSON("chwidth",rx_rate,TP.rx_rate.chwidth, (uint64_t)0 );
GetJSON("ht",rx_rate,TP.rx_rate.ht, false );
GetJSON("sgi",rx_rate,TP.rx_rate.sgi, false );
}
SSIDTP.associations.push_back(TP); SSIDTP.associations.push_back(TP);
} }
} }
@@ -161,11 +174,17 @@ namespace OpenWifi {
std::cout << Utils::IntToSerialNumber(mac_) << ": stats failed parsing." ; std::cout << Utils::IntToSerialNumber(mac_) << ": stats failed parsing." ;
std::cout << *State << std::endl; std::cout << *State << std::endl;
} }
DTP.id = MicroService::instance().CreateUUID();
DTP.boardId = boardId_;
StorageService()->TimePointsDB().CreateRecord(DTP);
DTP_.push_back(DTP); DTP_.push_back(DTP);
if(DTP_.size()>1000) { if(DTP_.size()>1000) {
DTP_.erase(DTP_.begin()); DTP_.erase(DTP_.begin());
} }
std::cout << "Serial: " << Utils::IntToSerialNumber(mac_) << " points: " << DTP_.size() << std::endl; std::cout << "Serial: " << Utils::IntToSerialNumber(mac_) << " points: " << DTP_.size() << std::endl;
} }

12
src/APStats.h
View File

@@ -18,7 +18,10 @@ namespace OpenWifi {
class AP { class AP {
public: public:
explicit AP(uint64_t mac) : mac_(mac) { explicit AP(uint64_t mac, const std::string &BoardId) :
mac_(mac),
boardId_(BoardId)
{
DI_.serialNumber = Utils::IntToSerialNumber(mac); DI_.serialNumber = Utils::IntToSerialNumber(mac);
} }
@@ -28,8 +31,9 @@ namespace OpenWifi {
const AnalyticsObjects::DeviceInfo & Info() const { return DI_; } const AnalyticsObjects::DeviceInfo & Info() const { return DI_; }
private: private:
uint64_t mac_=0; uint64_t mac_=0;
AnalyticsObjects::DeviceInfo DI_; std::string boardId_;
std::vector<AnalyticsObjects::DeviceTimePoint> DTP_; AnalyticsObjects::DeviceInfo DI_;
std::vector<AnalyticsObjects::DeviceTimePoint> DTP_;
}; };
} }

39
src/RESTAPI/RESTAPI_board_timepoint_handler.cpp Normal file
View File

@@ -0,0 +1,39 @@
//
// Created by stephane bourque on 2022-03-21.
//
#include "RESTAPI_board_timepoint_handler.h"
#include "StorageService.h"
namespace OpenWifi {
void RESTAPI_board_timepoint_handler::DoGet() {
auto id = GetBinding("id","");
if(id.empty()) {
return BadRequest(RESTAPI::Errors::MissingUUID);
}
AnalyticsObjects::BoardInfo B;
if(!StorageService()->BoardsDB().GetRecord("id",id,B)) {
return NotFound();
}
auto fromDate = GetParameter("fromDate",0);
auto endDate = GetParameter("endDate",0);
auto maxRecords = GetParameter("maxRecords",100);
auto stats = GetBoolParameter("stats");
if(stats) {
AnalyticsObjects::DeviceTimePointStats DTPS;
Poco::JSON::Object Answer;
DB_.GetStats(id,DTPS);
DTPS.to_json(Answer);
return ReturnObject(Answer);
}
AnalyticsObjects::DeviceTimePointList Points;
StorageService()->TimePointsDB().SelectRecords(fromDate, endDate, maxRecords, Points.points);
Poco::JSON::Object Answer;
Points.to_json(Answer);
return ReturnObject(Answer);
}
}

32
src/RESTAPI/RESTAPI_board_timepoint_handler.h Normal file
View File

@@ -0,0 +1,32 @@
//
// Created by stephane bourque on 2022-03-21.
//
#pragma once
#include "framework/MicroService.h"
#include "StorageService.h"
namespace OpenWifi {
class RESTAPI_board_timepoint_handler : public RESTAPIHandler {
public:
RESTAPI_board_timepoint_handler(const RESTAPIHandler::BindingMap &bindings, Poco::Logger &L, RESTAPI_GenericServer & Server, uint64_t TransactionId, bool Internal)
: RESTAPIHandler(bindings, L,
std::vector<std::string>{
Poco::Net::HTTPRequest::HTTP_GET,
Poco::Net::HTTPRequest::HTTP_OPTIONS},
Server,
TransactionId,
Internal){}
static const std::list<const char *> PathName() { return std::list<const char *>{"/api/v1/board/{id}/timepoint"}; };
private:
TimePointDB & DB_=StorageService()->TimePointsDB();
void DoGet() final;
void DoPost() final {};
void DoPut() final {};
void DoDelete() final {};
};
}

13
src/RESTAPI/RESTAPI_routers.cpp
View File

@@ -6,26 +6,31 @@
#include "RESTAPI/RESTAPI_board_list_handler.h" #include "RESTAPI/RESTAPI_board_list_handler.h"
#include "RESTAPI/RESTAPI_board_handler.h" #include "RESTAPI/RESTAPI_board_handler.h"
#include "RESTAPI/RESTAPI_board_devices_handler.h" #include "RESTAPI/RESTAPI_board_devices_handler.h"
#include "RESTAPI/RESTAPI_board_timepoint_handler.h"
namespace OpenWifi { namespace OpenWifi {
Poco::Net::HTTPRequestHandler * RESTAPI_ExtRouter(const char *Path, RESTAPIHandler::BindingMap &Bindings, Poco::Net::HTTPRequestHandler * RESTAPI_ExtRouter(const char *Path, RESTAPIHandler::BindingMap &Bindings,
Poco::Logger & L, RESTAPI_GenericServer & S, uint64_t TransactionId) { Poco::Logger & L, RESTAPI_GenericServer & S,
uint64_t TransactionId) {
return RESTAPI_Router< return RESTAPI_Router<
RESTAPI_system_command, RESTAPI_system_command,
RESTAPI_board_devices_handler, RESTAPI_board_devices_handler,
RESTAPI_board_handler, RESTAPI_board_handler,
RESTAPI_board_list_handler RESTAPI_board_list_handler,
RESTAPI_board_timepoint_handler
>(Path,Bindings,L, S, TransactionId); >(Path,Bindings,L, S, TransactionId);
} }
Poco::Net::HTTPRequestHandler * RESTAPI_IntRouter(const char *Path, RESTAPIHandler::BindingMap &Bindings, Poco::Net::HTTPRequestHandler * RESTAPI_IntRouter(const char *Path, RESTAPIHandler::BindingMap &Bindings,
Poco::Logger & L, RESTAPI_GenericServer & S, uint64_t TransactionId) { Poco::Logger & L, RESTAPI_GenericServer & S,
uint64_t TransactionId) {
return RESTAPI_Router_I< return RESTAPI_Router_I<
RESTAPI_system_command, RESTAPI_system_command,
RESTAPI_board_devices_handler, RESTAPI_board_devices_handler,
RESTAPI_board_handler, RESTAPI_board_handler,
RESTAPI_board_list_handler RESTAPI_board_list_handler,
RESTAPI_board_timepoint_handler
>(Path, Bindings, L, S, TransactionId); >(Path, Bindings, L, S, TransactionId);
} }

167
src/RESTObjects/RESTAPI_AnalyticsObjects.cpp
View File

@@ -129,8 +129,31 @@ namespace OpenWifi::AnalyticsObjects {
return false; return false;
} }
void UE_rate::to_json(Poco::JSON::Object &Obj) const {
field_to_json(Obj,"bitrate",bitrate);
field_to_json(Obj,"mcs",mcs);
field_to_json(Obj,"nss",nss);
field_to_json(Obj,"ht",ht);
field_to_json(Obj,"sgi",sgi);
field_to_json(Obj,"chwidth",chwidth);
}
bool UE_rate::from_json(const Poco::JSON::Object::Ptr &Obj) {
try {
field_from_json(Obj,"bitrate",bitrate);
field_from_json(Obj,"mcs",mcs);
field_from_json(Obj,"nss",nss);
field_from_json(Obj,"ht",ht);
field_from_json(Obj,"sgi",sgi);
field_from_json(Obj,"chwidth",chwidth);
return true;
} catch(...) {
}
return false;
}
void UETimePoint::to_json(Poco::JSON::Object &Obj) const { void UETimePoint::to_json(Poco::JSON::Object &Obj) const {
field_to_json(Obj,"association_bssid",association_bssid);
field_to_json(Obj,"station",station); field_to_json(Obj,"station",station);
field_to_json(Obj,"rssi",rssi); field_to_json(Obj,"rssi",rssi);
field_to_json(Obj,"tx_bytes",tx_bytes); field_to_json(Obj,"tx_bytes",tx_bytes);
@@ -142,6 +165,30 @@ namespace OpenWifi::AnalyticsObjects {
field_to_json(Obj,"tx_failed",tx_failed); field_to_json(Obj,"tx_failed",tx_failed);
field_to_json(Obj,"connected",connected); field_to_json(Obj,"connected",connected);
field_to_json(Obj,"inactive",inactive); field_to_json(Obj,"inactive",inactive);
field_to_json(Obj,"tx_rate",tx_rate);
field_to_json(Obj,"rx_rate",rx_rate);
}
bool UETimePoint::from_json(const Poco::JSON::Object::Ptr &Obj) {
try {
field_from_json(Obj,"station",station);
field_from_json(Obj,"rssi",rssi);
field_from_json(Obj,"tx_bytes",tx_bytes);
field_from_json(Obj,"rx_bytes",rx_bytes);
field_from_json(Obj,"tx_duration",tx_duration);
field_from_json(Obj,"rx_packets",rx_packets);
field_from_json(Obj,"tx_packets",tx_packets);
field_from_json(Obj,"tx_retries",tx_retries);
field_from_json(Obj,"tx_failed",tx_failed);
field_from_json(Obj,"connected",connected);
field_from_json(Obj,"inactive",inactive);
field_from_json(Obj,"tx_rate",tx_rate);
field_from_json(Obj,"rx_rate",rx_rate);
return true;
} catch(...) {
}
return false;
} }
void APTimePoint::to_json(Poco::JSON::Object &Obj) const { void APTimePoint::to_json(Poco::JSON::Object &Obj) const {
@@ -158,13 +205,46 @@ namespace OpenWifi::AnalyticsObjects {
field_to_json(Obj,"tx_packets",tx_packets); field_to_json(Obj,"tx_packets",tx_packets);
} }
void msdu_entry::to_json(Poco::JSON::Object &Obj) const { bool APTimePoint::from_json(const Poco::JSON::Object::Ptr &Obj) {
try {
field_from_json(Obj,"collisions",collisions);
field_from_json(Obj,"multicast",multicast);
field_from_json(Obj,"rx_bytes",rx_bytes);
field_from_json(Obj,"rx_dropped",rx_dropped);
field_from_json(Obj,"rx_errors",rx_errors);
field_from_json(Obj,"rx_packets",rx_packets);
field_from_json(Obj,"tx_bytes",tx_bytes);
field_from_json(Obj,"tx_packets",tx_packets);
field_from_json(Obj,"tx_dropped",tx_dropped);
field_from_json(Obj,"tx_errors",tx_errors);
field_from_json(Obj,"tx_packets",tx_packets);
return true;
} catch(...) {
}
return false;
}
void MSDU_entry::to_json(Poco::JSON::Object &Obj) const {
field_to_json(Obj,"rx_msdu",rx_msdu); field_to_json(Obj,"rx_msdu",rx_msdu);
field_to_json(Obj,"tx_msdu",tx_msdu); field_to_json(Obj,"tx_msdu",tx_msdu);
field_to_json(Obj,"tx_msdu_failed",tx_msdu_failed); field_to_json(Obj,"tx_msdu_failed",tx_msdu_failed);
field_to_json(Obj,"tx_msdu_retries",tx_msdu_retries); field_to_json(Obj,"tx_msdu_retries",tx_msdu_retries);
} }
bool MSDU_entry::from_json(const Poco::JSON::Object::Ptr &Obj) {
try {
field_from_json(Obj,"rx_msdu",rx_msdu);
field_from_json(Obj,"tx_msdu",tx_msdu);
field_from_json(Obj,"tx_msdu_failed",tx_msdu_failed);
field_from_json(Obj,"tx_msdu_retries",tx_msdu_retries);
return true;
} catch(...) {
}
return false;
}
void RadioTimePoint::to_json(Poco::JSON::Object &Obj) const { void RadioTimePoint::to_json(Poco::JSON::Object &Obj) const {
field_to_json(Obj,"band",band); field_to_json(Obj,"band",band);
field_to_json(Obj,"radio_channel",radio_channel); field_to_json(Obj,"radio_channel",radio_channel);
@@ -178,6 +258,25 @@ namespace OpenWifi::AnalyticsObjects {
field_to_json(Obj,"noise",noise); field_to_json(Obj,"noise",noise);
} }
bool RadioTimePoint::from_json(const Poco::JSON::Object::Ptr &Obj) {
try {
field_from_json(Obj,"band",band);
field_from_json(Obj,"radio_channel",radio_channel);
field_from_json(Obj,"active_ms",active_ms);
field_from_json(Obj,"busy_ms",busy_ms);
field_from_json(Obj,"receive_ms",receive_ms);
field_from_json(Obj,"transmit_ms",transmit_ms);
field_from_json(Obj,"tx_power",tx_power);
field_from_json(Obj,"channel",channel);
field_from_json(Obj,"temperature",temperature);
field_from_json(Obj,"noise",noise);
return true;
} catch(...) {
}
return false;
}
void SSIDTimePoint::to_json(Poco::JSON::Object &Obj) const { void SSIDTimePoint::to_json(Poco::JSON::Object &Obj) const {
field_to_json(Obj,"bssid",bssid); field_to_json(Obj,"bssid",bssid);
field_to_json(Obj,"mode",mode); field_to_json(Obj,"mode",mode);
@@ -185,11 +284,75 @@ namespace OpenWifi::AnalyticsObjects {
field_to_json(Obj,"associations",associations); field_to_json(Obj,"associations",associations);
} }
bool SSIDTimePoint::from_json(const Poco::JSON::Object::Ptr &Obj) {
try {
field_from_json(Obj,"bssid",bssid);
field_from_json(Obj,"mode",mode);
field_from_json(Obj,"ssid",ssid);
field_from_json(Obj,"associations",associations);
return true;
} catch(...) {
}
return false;
}
void DeviceTimePoint::to_json(Poco::JSON::Object &Obj) const { void DeviceTimePoint::to_json(Poco::JSON::Object &Obj) const {
field_to_json(Obj,"id",id);
field_to_json(Obj,"boardId",boardId);
field_to_json(Obj,"timestamp",timestamp); field_to_json(Obj,"timestamp",timestamp);
field_to_json(Obj,"ap_data",ap_data); field_to_json(Obj,"ap_data",ap_data);
field_to_json(Obj,"ssid_data",ssid_data); field_to_json(Obj,"ssid_data",ssid_data);
field_to_json(Obj,"radio_data",radio_data); field_to_json(Obj,"radio_data",radio_data);
field_to_json(Obj,"device_info",device_info); field_to_json(Obj,"device_info",device_info);
} }
bool DeviceTimePoint::from_json(const Poco::JSON::Object::Ptr &Obj) {
try {
field_from_json(Obj,"id",id);
field_from_json(Obj,"boardId",boardId);
field_from_json(Obj,"timestamp",timestamp);
field_from_json(Obj,"ap_data",ap_data);
field_from_json(Obj,"ssid_data",ssid_data);
field_from_json(Obj,"radio_data",radio_data);
field_from_json(Obj,"device_info",device_info);
return true;
} catch(...) {
}
return false;
}
void DeviceTimePointList::to_json(Poco::JSON::Object &Obj) const {
field_to_json(Obj,"points",points);
}
bool DeviceTimePointList::from_json(const Poco::JSON::Object::Ptr &Obj) {
try {
field_from_json(Obj,"points",points);
return true;
} catch(...) {
}
return false;
}
void DeviceTimePointStats::to_json(Poco::JSON::Object &Obj) const {
field_to_json(Obj,"firstPoint",firstPoint);
field_to_json(Obj,"lastPoint",lastPoint);
field_to_json(Obj,"count",count);
}
bool DeviceTimePointStats::from_json(const Poco::JSON::Object::Ptr &Obj) {
try {
field_from_json(Obj,"firstPoint",firstPoint);
field_from_json(Obj,"lastPoint",lastPoint);
field_from_json(Obj,"count",count);
return true;
} catch(...) {
}
return false;
}
} }

91
src/RESTObjects/RESTAPI_AnalyticsObjects.h
View File

@@ -28,7 +28,6 @@ namespace OpenWifi {
bool monitorSubVenues = false; bool monitorSubVenues = false;
void to_json(Poco::JSON::Object &Obj) const; void to_json(Poco::JSON::Object &Obj) const;
bool from_json(const Poco::JSON::Object::Ptr &Obj); bool from_json(const Poco::JSON::Object::Ptr &Obj);
}; };
@@ -37,7 +36,6 @@ namespace OpenWifi {
std::vector<VenueInfo> venueList; std::vector<VenueInfo> venueList;
void to_json(Poco::JSON::Object &Obj) const; void to_json(Poco::JSON::Object &Obj) const;
bool from_json(const Poco::JSON::Object::Ptr &Obj); bool from_json(const Poco::JSON::Object::Ptr &Obj);
inline bool operator<(const BoardInfo &bb) const { inline bool operator<(const BoardInfo &bb) const {
@@ -75,7 +73,6 @@ namespace OpenWifi {
double memory; double memory;
void to_json(Poco::JSON::Object &Obj) const; void to_json(Poco::JSON::Object &Obj) const;
bool from_json(const Poco::JSON::Object::Ptr &Obj); bool from_json(const Poco::JSON::Object::Ptr &Obj);
}; };
@@ -83,7 +80,6 @@ namespace OpenWifi {
std::vector<DeviceInfo> devices; std::vector<DeviceInfo> devices;
void to_json(Poco::JSON::Object &Obj) const; void to_json(Poco::JSON::Object &Obj) const;
bool from_json(const Poco::JSON::Object::Ptr &Obj); bool from_json(const Poco::JSON::Object::Ptr &Obj);
}; };
@@ -91,18 +87,30 @@ namespace OpenWifi {
band_2g = 0, band_5g = 1, band_6g = 2 band_2g = 0, band_5g = 1, band_6g = 2
}; };
struct msdu_entry { struct MSDU_entry {
uint64_t rx_msdu = 0, uint64_t rx_msdu = 0,
tx_msdu = 0, tx_msdu = 0,
tx_msdu_failed = 0, tx_msdu_failed = 0,
tx_msdu_retries = 0; tx_msdu_retries = 0;
void to_json(Poco::JSON::Object &Obj) const; void to_json(Poco::JSON::Object &Obj) const;
bool from_json(const Poco::JSON::Object::Ptr &Obj);
};
struct UE_rate {
uint64_t bitrate=0;
uint64_t mcs=0;
uint64_t nss=0;
bool ht=false;
bool sgi=false;
uint64_t chwidth=0;
void to_json(Poco::JSON::Object &Obj) const;
bool from_json(const Poco::JSON::Object::Ptr &Obj);
}; };
struct UETimePoint { struct UETimePoint {
uint64_t association_bssid = 0, std::string station;
station = 0;
int64_t rssi = 0; int64_t rssi = 0;
uint64_t tx_bytes = 0, uint64_t tx_bytes = 0,
rx_bytes = 0, rx_bytes = 0,
@@ -113,9 +121,12 @@ namespace OpenWifi {
tx_failed = 0, tx_failed = 0,
connected = 0, connected = 0,
inactive = 0; inactive = 0;
std::vector<msdu_entry> msdus; UE_rate tx_rate,
rx_rate;
std::vector<MSDU_entry> msdus;
void to_json(Poco::JSON::Object &Obj) const; void to_json(Poco::JSON::Object &Obj) const;
bool from_json(const Poco::JSON::Object::Ptr &Obj);
}; };
enum SSID_MODES { enum SSID_MODES {
@@ -145,12 +156,13 @@ namespace OpenWifi {
} }
struct SSIDTimePoint { struct SSIDTimePoint {
uint64_t bssid = 0, std::string bssid,
mode = 0, mode,
ssid = 0; ssid;
std::vector<UETimePoint> associations; std::vector<UETimePoint> associations;
void to_json(Poco::JSON::Object &Obj) const; void to_json(Poco::JSON::Object &Obj) const;
bool from_json(const Poco::JSON::Object::Ptr &Obj);
}; };
@@ -167,11 +179,12 @@ namespace OpenWifi {
tx_packets = 0; tx_packets = 0;
void to_json(Poco::JSON::Object &Obj) const; void to_json(Poco::JSON::Object &Obj) const;
bool from_json(const Poco::JSON::Object::Ptr &Obj);
}; };
struct RadioTimePoint { struct RadioTimePoint {
uint band = 0, uint64_t band = 0,
radio_channel = 0; radio_channel = 0;
uint64_t active_ms = 0, uint64_t active_ms = 0,
busy_ms = 0, busy_ms = 0,
receive_ms = 0, receive_ms = 0,
@@ -182,17 +195,63 @@ namespace OpenWifi {
noise = 0; noise = 0;
void to_json(Poco::JSON::Object &Obj) const; void to_json(Poco::JSON::Object &Obj) const;
bool from_json(const Poco::JSON::Object::Ptr &Obj);
}; };
struct DeviceTimePoint { struct DeviceTimePoint {
uint64_t timestamp = 0; std::string id;
APTimePoint ap_data; std::string boardId;
std::vector<SSIDTimePoint> ssid_data; uint64_t timestamp = 0;
APTimePoint ap_data;
std::vector<SSIDTimePoint> ssid_data;
std::vector<RadioTimePoint> radio_data; std::vector<RadioTimePoint> radio_data;
AnalyticsObjects::DeviceInfo device_info; AnalyticsObjects::DeviceInfo device_info;
void to_json(Poco::JSON::Object &Obj) const; void to_json(Poco::JSON::Object &Obj) const;
bool from_json(const Poco::JSON::Object::Ptr &Obj);
};
struct DeviceTimePointList {
std::vector<DeviceTimePoint> points;
void to_json(Poco::JSON::Object &Obj) const;
bool from_json(const Poco::JSON::Object::Ptr &Obj);
};
struct BandwidthAnalysisEntry {
uint64_t timestamp;
};
struct BandwidthAnalysis {
};
struct AverageValueSigned {
int64_t peak=0, avg=0, low=0;
};
struct AverageValueUnsigned {
uint64_t peak=0, avg=0, low=0;
};
struct RadioAnalysis {
uint64_t timestamp=0;
AverageValueSigned noise, temperature;
AverageValueUnsigned active_ms,
busy_ms,
transmit_ms,
receive_ms;
};
struct DeviceTimePointStats {
uint64_t firstPoint=0;
uint64_t lastPoint=0;
uint64_t count=0;
void to_json(Poco::JSON::Object &Obj) const;
bool from_json(const Poco::JSON::Object::Ptr &Obj);
}; };
} }
} }

1
src/StatFunc.h
View File

@@ -68,6 +68,7 @@ namespace OpenWifi {
bool inited = false; bool inited = false;
uint64_t LastValue=0; uint64_t LastValue=0;
}; };
std::ostream & operator<<(std::ostream &os, const RelativeCounter &rc) { std::ostream & operator<<(std::ostream &os, const RelativeCounter &rc) {
os << rc.get() ; os << rc.get() ;
return os; return os;

2
src/StorageService.cpp
View File

@@ -18,6 +18,8 @@ namespace OpenWifi {
BoardsDB_ = std::make_unique<OpenWifi::BoardsDB>(dbType_,*Pool_, Logger()); BoardsDB_ = std::make_unique<OpenWifi::BoardsDB>(dbType_,*Pool_, Logger());
BoardsDB_->Create(); BoardsDB_->Create();
TimePointsDB_ = std::make_unique<OpenWifi::TimePointDB>(dbType_,*Pool_, Logger());
TimePointsDB_->Create();
Updater_.start(*this); Updater_.start(*this);

3
src/StorageService.h
View File

@@ -11,6 +11,7 @@
#include "framework/MicroService.h" #include "framework/MicroService.h"
#include "framework/StorageClass.h" #include "framework/StorageClass.h"
#include "storage/storage_boards.h" #include "storage/storage_boards.h"
#include "storage/storage_timepoints.h"
namespace OpenWifi { namespace OpenWifi {
class Storage : public StorageClass, Poco::Runnable { class Storage : public StorageClass, Poco::Runnable {
@@ -25,10 +26,12 @@ namespace OpenWifi {
void run() final; void run() final;
OpenWifi::BoardsDB & BoardsDB() { return *BoardsDB_; }; OpenWifi::BoardsDB & BoardsDB() { return *BoardsDB_; };
OpenWifi::TimePointDB & TimePointsDB() { return *TimePointsDB_; };
void onTimer(Poco::Timer & timer); void onTimer(Poco::Timer & timer);
private: private:
std::unique_ptr<OpenWifi::BoardsDB> BoardsDB_; std::unique_ptr<OpenWifi::BoardsDB> BoardsDB_;
std::unique_ptr<OpenWifi::TimePointDB> TimePointsDB_;
Poco::Thread Updater_; Poco::Thread Updater_;
std::atomic_bool Running_=false; std::atomic_bool Running_=false;
Poco::Timer Timer_; Poco::Timer Timer_;

2
src/VenueWatcher.cpp
View File

@@ -11,7 +11,7 @@ namespace OpenWifi {
void VenueWatcher::Start() { void VenueWatcher::Start() {
for(const auto &mac:SerialNumbers_) { for(const auto &mac:SerialNumbers_) {
auto ap = std::make_shared<AP>(mac); auto ap = std::make_shared<AP>(mac, boardId_);
APs_[mac ] = ap; APs_[mac ] = ap;
} }

27
src/VenueWatcher.h
View File

@@ -35,11 +35,10 @@ namespace OpenWifi {
class VenueWatcher : public Poco::Runnable { class VenueWatcher : public Poco::Runnable {
public: public:
explicit VenueWatcher(const std::string &id, Poco::Logger &L, const std::vector<uint64_t> & SerialNumbers) : explicit VenueWatcher(const std::string &boardId, Poco::Logger &L, const std::vector<uint64_t> & SerialNumbers) :
Id_(id), boardId_(boardId),
Logger_(L), Logger_(L),
SerialNumbers_(SerialNumbers) { SerialNumbers_(SerialNumbers) {
std::sort(SerialNumbers_.begin(),SerialNumbers_.end()); std::sort(SerialNumbers_.begin(),SerialNumbers_.end());
auto last = std::unique(SerialNumbers_.begin(),SerialNumbers_.end()); auto last = std::unique(SerialNumbers_.begin(),SerialNumbers_.end());
SerialNumbers_.erase(last,SerialNumbers_.end()); SerialNumbers_.erase(last,SerialNumbers_.end());
@@ -68,15 +67,17 @@ namespace OpenWifi {
void ModifySerialNumbers(const std::vector<uint64_t> &SerialNumbers); void ModifySerialNumbers(const std::vector<uint64_t> &SerialNumbers);
void GetDevices(std::vector<AnalyticsObjects::DeviceInfo> & DI); void GetDevices(std::vector<AnalyticsObjects::DeviceInfo> & DI);
void GetBandwidth(uint64_t start, uint64_t end, uint64_t interval , AnalyticsObjects::BandwidthAnalysis & BW);
private: private:
std::recursive_mutex Mutex_; std::recursive_mutex Mutex_;
std::string Id_; std::string boardId_;
Poco::NotificationQueue Queue_; Poco::NotificationQueue Queue_;
Poco::Logger &Logger_; Poco::Logger &Logger_;
Poco::Thread Worker_; Poco::Thread Worker_;
std::atomic_bool Running_=false; std::atomic_bool Running_=false;
std::vector<uint64_t> SerialNumbers_; std::vector<uint64_t> SerialNumbers_;
std::map<uint64_t, std::shared_ptr<AP>> APs_; std::map<uint64_t, std::shared_ptr<AP>> APs_;
}; };
} }

185
src/framework/MicroService.h
View File

@@ -71,6 +71,7 @@ using namespace std::chrono_literals;
#include "Poco/SimpleFileChannel.h" #include "Poco/SimpleFileChannel.h"
#include "Poco/Util/PropertyFileConfiguration.h" #include "Poco/Util/PropertyFileConfiguration.h"
#include "Poco/SplitterChannel.h" #include "Poco/SplitterChannel.h"
#include "Poco/JWT/Signer.h"
#include "cppkafka/cppkafka.h" #include "cppkafka/cppkafka.h"
@@ -379,6 +380,12 @@ namespace OpenWifi::RESTAPI_utils {
} }
} }
inline void field_from_json(const Poco::JSON::Object::Ptr &Obj, const char *Field, int64_t &Value) {
if(Obj->isObject(Field)) {
Value = Obj->get(Field);
}
}
template<class T> void field_from_json(const Poco::JSON::Object::Ptr &Obj, const char *Field, T &Value) { template<class T> void field_from_json(const Poco::JSON::Object::Ptr &Obj, const char *Field, T &Value) {
if(Obj->isObject(Field)) { if(Obj->isObject(Field)) {
Poco::JSON::Object::Ptr A = Obj->getObject(Field); Poco::JSON::Object::Ptr A = Obj->getObject(Field);
@@ -1350,6 +1357,22 @@ namespace OpenWifi {
} }
} }
[[nodiscard]] inline Poco::Net::ServerSocket CreateSocket(Poco::Logger &L) const {
Poco::Net::Context::Params P;
if (address_ == "*") {
Poco::Net::IPAddress Addr(Poco::Net::IPAddress::wildcard(
Poco::Net::Socket::supportsIPv6() ? Poco::Net::AddressFamily::IPv6
: Poco::Net::AddressFamily::IPv4));
Poco::Net::SocketAddress SockAddr(Addr, port_);
return Poco::Net::ServerSocket(SockAddr, backlog_);
} else {
Poco::Net::IPAddress Addr(address_);
Poco::Net::SocketAddress SockAddr(Addr, port_);
return Poco::Net::ServerSocket(SockAddr, backlog_);
}
}
inline void LogCertInfo(Poco::Logger &L, const Poco::Crypto::X509Certificate &C) const { inline void LogCertInfo(Poco::Logger &L, const Poco::Crypto::X509Certificate &C) const {
L.information("============================================================================================="); L.information("=============================================================================================");
L.information(Poco::format("> Issuer: %s", C.issuerName())); L.information(Poco::format("> Issuer: %s", C.issuerName()));
@@ -2863,33 +2886,6 @@ namespace OpenWifi {
RESTAPI_GenericServer &Server_; RESTAPI_GenericServer &Server_;
}; };
inline int RESTAPI_ExtServer::Start() {
Server_.InitLogging();
for(const auto & Svr: ConfigServersList_) {
Logger().information(Poco::format("Starting: %s:%s Keyfile:%s CertFile: %s", Svr.Address(), std::to_string(Svr.Port()),
Svr.KeyFile(),Svr.CertFile()));
auto Sock{Svr.CreateSecureSocket(Logger())};
Svr.LogCert(Logger());
if(!Svr.RootCA().empty())
Svr.LogCas(Logger());
Poco::Net::HTTPServerParams::Ptr Params = new Poco::Net::HTTPServerParams;
Params->setMaxThreads(50);
Params->setMaxQueued(200);
Params->setKeepAlive(true);
auto NewServer = std::make_unique<Poco::Net::HTTPServer>(new ExtRequestHandlerFactory(Server_), Pool_, Sock, Params);
NewServer->start();
RESTServers_.push_back(std::move(NewServer));
}
return 0;
}
class LogMuxer : public Poco::Channel { class LogMuxer : public Poco::Channel {
public: public:
@@ -3021,32 +3017,6 @@ namespace OpenWifi {
RESTAPI_GenericServer &Server_; RESTAPI_GenericServer &Server_;
}; };
inline int RESTAPI_IntServer::Start() {
Logger().information("Starting.");
Server_.InitLogging();
for(const auto & Svr: ConfigServersList_) {
Logger().information(Poco::format("Starting: %s:%s Keyfile:%s CertFile: %s", Svr.Address(), std::to_string(Svr.Port()),
Svr.KeyFile(),Svr.CertFile()));
auto Sock{Svr.CreateSecureSocket(Logger())};
Svr.LogCert(Logger());
if(!Svr.RootCA().empty())
Svr.LogCas(Logger());
auto Params = new Poco::Net::HTTPServerParams;
Params->setMaxThreads(50);
Params->setMaxQueued(200);
Params->setKeepAlive(true);
auto NewServer = std::make_unique<Poco::Net::HTTPServer>(new IntRequestHandlerFactory(Server_), Pool_, Sock, Params);
NewServer->start();
RESTServers_.push_back(std::move(NewServer));
}
return 0;
}
struct MicroServiceMeta { struct MicroServiceMeta {
uint64_t Id=0; uint64_t Id=0;
std::string Type; std::string Type;
@@ -3081,7 +3051,7 @@ namespace OpenWifi {
} }
[[nodiscard]] std::string Version() { return Version_; } [[nodiscard]] std::string Version() { return Version_; }
[[nodiscard]] const Poco::SharedPtr<Poco::Crypto::RSAKey> & Key() { return AppKey_; } // [[nodiscard]] const Poco::SharedPtr<Poco::Crypto::RSAKey> & Key() { return AppKey_; }
[[nodiscard]] inline const std::string & DataDir() { return DataDir_; } [[nodiscard]] inline const std::string & DataDir() { return DataDir_; }
[[nodiscard]] inline const std::string & WWWAssetsDir() { return WWWAssetsDir_; } [[nodiscard]] inline const std::string & WWWAssetsDir() { return WWWAssetsDir_; }
[[nodiscard]] bool Debug() const { return DebugMode_; } [[nodiscard]] bool Debug() const { return DebugMode_; }
@@ -3171,6 +3141,14 @@ namespace OpenWifi {
} }
} }
}
inline bool NoAPISecurity() const { return NoAPISecurity_; }
[[nodiscard]] inline std::string Sign(Poco::JWT::Token &T, const std::string &Algo) {
if(NoBuiltInCrypto_) {
return T.toString();
} else {
return Signer_.sign(T,Algo);
}
} }
private: private:
static MicroService * instance_; static MicroService * instance_;
@@ -3197,12 +3175,15 @@ namespace OpenWifi {
std::recursive_mutex InfraMutex_; std::recursive_mutex InfraMutex_;
std::default_random_engine RandomEngine_; std::default_random_engine RandomEngine_;
Poco::Util::PropertyFileConfiguration * PropConfigurationFile_ = nullptr; Poco::Util::PropertyFileConfiguration * PropConfigurationFile_ = nullptr;
std::string DAEMON_PROPERTIES_FILENAME; std::string DAEMON_PROPERTIES_FILENAME;
std::string DAEMON_ROOT_ENV_VAR; std::string DAEMON_ROOT_ENV_VAR;
std::string DAEMON_CONFIG_ENV_VAR; std::string DAEMON_CONFIG_ENV_VAR;
std::string DAEMON_APP_NAME; std::string DAEMON_APP_NAME;
uint64_t DAEMON_BUS_TIMER; uint64_t DAEMON_BUS_TIMER;
}; bool NoAPISecurity_=false;
bool NoBuiltInCrypto_=false;
Poco::JWT::Signer Signer_;
};
inline void MicroService::Exit(int Reason) { inline void MicroService::Exit(int Reason) {
std::exit(Reason); std::exit(Reason);
@@ -3325,10 +3306,19 @@ namespace OpenWifi {
} }
inline void MicroService::LoadMyConfig() { inline void MicroService::LoadMyConfig() {
std::string KeyFile = ConfigPath("openwifi.service.key"); NoAPISecurity_ = ConfigGetBool("openwifi.security.restapi.disable",false);
std::string KeyFilePassword = ConfigPath("openwifi.service.key.password" , "" ); std::string KeyFile = ConfigPath("openwifi.service.key","");
AppKey_ = Poco::SharedPtr<Poco::Crypto::RSAKey>(new Poco::Crypto::RSAKey("", KeyFile, KeyFilePassword)); if(!KeyFile.empty()) {
Cipher_ = CipherFactory_.createCipher(*AppKey_); std::string KeyFilePassword = ConfigPath("openwifi.service.key.password", "");
AppKey_ = Poco::SharedPtr<Poco::Crypto::RSAKey>(new Poco::Crypto::RSAKey("", KeyFile, KeyFilePassword));
Cipher_ = CipherFactory_.createCipher(*AppKey_);
Signer_.setRSAKey(AppKey_);
Signer_.addAllAlgorithms();
NoBuiltInCrypto_ = false;
} else {
NoBuiltInCrypto_ = true;
}
ID_ = Utils::GetSystemId(); ID_ = Utils::GetSystemId();
if(!DebugMode_) if(!DebugMode_)
DebugMode_ = ConfigGetBool("openwifi.system.debug",false); DebugMode_ = ConfigGetBool("openwifi.system.debug",false);
@@ -3658,10 +3648,14 @@ namespace OpenWifi {
} }
inline std::string MicroService::Encrypt(const std::string &S) { inline std::string MicroService::Encrypt(const std::string &S) {
if(NoBuiltInCrypto_)
return S;
return Cipher_->encryptString(S, Poco::Crypto::Cipher::Cipher::ENC_BASE64);; return Cipher_->encryptString(S, Poco::Crypto::Cipher::Cipher::ENC_BASE64);;
} }
inline std::string MicroService::Decrypt(const std::string &S) { inline std::string MicroService::Decrypt(const std::string &S) {
if(NoBuiltInCrypto_)
return S;
return Cipher_->decryptString(S, Poco::Crypto::Cipher::Cipher::ENC_BASE64);; return Cipher_->decryptString(S, Poco::Crypto::Cipher::Cipher::ENC_BASE64);;
} }
@@ -3713,7 +3707,68 @@ namespace OpenWifi {
SubSystemConfigPrefix_(std::move(SubSystemConfigPrefix)) { SubSystemConfigPrefix_(std::move(SubSystemConfigPrefix)) {
} }
inline int MicroService::main(const ArgVec &args) { inline int RESTAPI_ExtServer::Start() {
Server_.InitLogging();
for(const auto & Svr: ConfigServersList_) {
Logger().information(Poco::format("Starting: %s:%s Keyfile:%s CertFile: %s", Svr.Address(), std::to_string(Svr.Port()),
Svr.KeyFile(),Svr.CertFile()));
auto Sock{ MicroService::instance().NoAPISecurity() ? Svr.CreateSocket(Logger()) : Svr.CreateSecureSocket(Logger())};
if(MicroService::instance().NoAPISecurity()) {
Logger().information("Security has been disabled for APIs.");
} else {
Svr.LogCert(Logger());
if (!Svr.RootCA().empty())
Svr.LogCas(Logger());
}
Poco::Net::HTTPServerParams::Ptr Params = new Poco::Net::HTTPServerParams;
Params->setMaxThreads(50);
Params->setMaxQueued(200);
Params->setKeepAlive(true);
auto NewServer = std::make_unique<Poco::Net::HTTPServer>(new ExtRequestHandlerFactory(Server_), Pool_, Sock, Params);
NewServer->start();
RESTServers_.push_back(std::move(NewServer));
}
return 0;
}
inline int RESTAPI_IntServer::Start() {
Logger().information("Starting.");
Server_.InitLogging();
for(const auto & Svr: ConfigServersList_) {
Logger().information(Poco::format("Starting: %s:%s Keyfile:%s CertFile: %s", Svr.Address(), std::to_string(Svr.Port()),
Svr.KeyFile(),Svr.CertFile()));
auto Sock{ MicroService::instance().NoAPISecurity() ? Svr.CreateSocket(Logger()) : Svr.CreateSecureSocket(Logger())};
if(MicroService::instance().NoAPISecurity()) {
Logger().information("Security has been disabled for APIs.");
} else {
Svr.LogCert(Logger());
if (!Svr.RootCA().empty())
Svr.LogCas(Logger());
}
auto Params = new Poco::Net::HTTPServerParams;
Params->setMaxThreads(50);
Params->setMaxQueued(200);
Params->setKeepAlive(true);
auto NewServer = std::make_unique<Poco::Net::HTTPServer>(new IntRequestHandlerFactory(Server_), Pool_, Sock, Params);
NewServer->start();
RESTServers_.push_back(std::move(NewServer));
}
return 0;
}
inline int MicroService::main(const ArgVec &args) {
MyErrorHandler ErrorHandler(*this); MyErrorHandler ErrorHandler(*this);
Poco::ErrorHandler::set(&ErrorHandler); Poco::ErrorHandler::set(&ErrorHandler);

5
src/storage/storage_boards.cpp
View File

@@ -61,8 +61,3 @@ template<> void ORM::DB< OpenWifi::BoardDBRecordType, OpenWifi::AnalyticsObje
Out.set<5>(In.info.modified); Out.set<5>(In.info.modified);
Out.set<6>(OpenWifi::RESTAPI_utils::to_string(In.venueList)); Out.set<6>(OpenWifi::RESTAPI_utils::to_string(In.venueList));
} }
//
// Created by stephane bourque on 2022-03-11.
//
#include "storage_boards.h"

87
src/storage/storage_timepoints.cpp Normal file
View File

@@ -0,0 +1,87 @@
//
// Created by stephane bourque on 2022-03-21.
//
#include "storage_timepoints.h"
#include "framework/MicroService.h"
#include "framework/OpenWifiTypes.h"
namespace OpenWifi {
static ORM::FieldVec TimePoint_Fields{
// object info
ORM::Field{"id",64, true},
ORM::Field{"boardId",ORM::FieldType::FT_TEXT},
ORM::Field{"timestamp",ORM::FieldType::FT_BIGINT},
ORM::Field{"ap_data",ORM::FieldType::FT_TEXT},
ORM::Field{"ssid_data",ORM::FieldType::FT_TEXT},
ORM::Field{"radio_data",ORM::FieldType::FT_TEXT},
ORM::Field{"device_info",ORM::FieldType::FT_BIGINT}
};
static ORM::IndexVec TimePointDB_Indexes{
{ std::string("timepoint_board_index"),
ORM::IndexEntryVec{
{std::string("boardId"),
ORM::Indextype::ASC},
{std::string("timestamp"),
ORM::Indextype::ASC}} }
};
TimePointDB::TimePointDB( OpenWifi::DBType T, Poco::Data::SessionPool & P, Poco::Logger &L) :
DB(T, "timepoints", TimePoint_Fields, TimePointDB_Indexes, P, L, "tpo") {}
bool TimePointDB::Upgrade(uint32_t from, uint32_t &to) {
std::vector<std::string> Statements{
};
RunScript(Statements);
to = 2;
return true;
}
bool TimePointDB::GetStats(const std::string &id, AnalyticsObjects::DeviceTimePointStats &S) {
S.count = S.firstPoint = S.lastPoint = 0 ;
auto F = [&](const DB::RecordName &R) -> bool {
S.count++;
if(S.firstPoint==0) S.firstPoint=R.timestamp;
S.lastPoint=R.timestamp;
return true;
};
Iterate(F," boardId='" + id + "'");
return true;
}
bool TimePointDB::SelectRecords(uint64_t FromDate, uint64_t LastDate, uint64_t MaxRecords, std::vector<AnalyticsObjects::DeviceTimePoint> & Recs ) {
std::string WhereClause;
if(FromDate && LastDate) {
WhereClause = " (timestamp >= " + std::to_string(FromDate) + ") and ( timestamp <= " + std::to_string(LastDate) + " ) ";
} else if (FromDate) {
WhereClause = " (timestamp >= " + std::to_string(FromDate) + ") ";
} else if (LastDate) {
WhereClause = " ( timestamp <= " + std::to_string(LastDate) + " ) ";
}
GetRecords(0,MaxRecords,Recs,WhereClause," timestamp ASC ");
return true;
}
}
template<> void ORM::DB<OpenWifi::TimePointDBRecordType, OpenWifi::AnalyticsObjects::DeviceTimePoint>::Convert(const OpenWifi::TimePointDBRecordType &In, OpenWifi::AnalyticsObjects::DeviceTimePoint &Out) {
Out.id = In.get<0>();
Out.boardId = In.get<1>();
Out.timestamp = In.get<2>();
Out.ap_data = OpenWifi::RESTAPI_utils::to_object<OpenWifi::AnalyticsObjects::APTimePoint>(In.get<3>());
Out.ssid_data = OpenWifi::RESTAPI_utils::to_object_array<OpenWifi::AnalyticsObjects::SSIDTimePoint>(In.get<4>());
Out.radio_data = OpenWifi::RESTAPI_utils::to_object_array<OpenWifi::AnalyticsObjects::RadioTimePoint>(In.get<5>());
Out.device_info = OpenWifi::RESTAPI_utils::to_object<OpenWifi::AnalyticsObjects::DeviceInfo>(In.get<6>());
}
template<> void ORM::DB< OpenWifi::TimePointDBRecordType, OpenWifi::AnalyticsObjects::DeviceTimePoint>::Convert(const OpenWifi::AnalyticsObjects::DeviceTimePoint &In, OpenWifi::TimePointDBRecordType &Out) {
Out.set<0>(In.id);
Out.set<1>(In.boardId);
Out.set<2>(In.timestamp);
Out.set<3>(OpenWifi::RESTAPI_utils::to_string(In.ap_data));
Out.set<4>(OpenWifi::RESTAPI_utils::to_string(In.ssid_data));
Out.set<5>(OpenWifi::RESTAPI_utils::to_string(In.radio_data));
Out.set<6>(OpenWifi::RESTAPI_utils::to_string(In.device_info));
}

29
src/storage/storage_timepoints.h Normal file
View File

@@ -0,0 +1,29 @@
//
// Created by stephane bourque on 2022-03-21.
//
#pragma once
#include "framework/orm.h"
#include "RESTObjects/RESTAPI_AnalyticsObjects.h"
namespace OpenWifi {
typedef Poco::Tuple<
std::string,
std::string,
uint64_t,
std::string,
std::string,
std::string,
std::string
> TimePointDBRecordType;
class TimePointDB : public ORM::DB<TimePointDBRecordType, AnalyticsObjects::DeviceTimePoint> {
public:
TimePointDB( OpenWifi::DBType T, Poco::Data::SessionPool & P, Poco::Logger &L);
bool GetStats(const std::string &id, AnalyticsObjects::DeviceTimePointStats &S);
bool SelectRecords(uint64_t FromDate, uint64_t LastDate, uint64_t MaxRecords, DB::RecordVec & Recs);
private:
bool Upgrade(uint32_t from, uint32_t &to) override;
};
}