Defining connection manager layout

piScan_backend/src/messages.h

@@ -13,11 +13,12 @@
 #include "readerwriterqueue.h"
 
 enum {
-	MAIN_THREAD,
+	SYSTEM_CONTROL,
 	SCANNER_SM,
 	DEMOD,
 	SERVER_MAN,
 	AUDIO_MAN,
+	CLIENT,
 };
 
 /* basic interthread message structure */
@@ -29,13 +30,17 @@ public:
 	void* const pData;
 };
 
+class ControllerMessage : public Message{
+
+};
+
 class ScannerMessage : public Message {
 public:
 	ScannerMessage(unsigned char src, unsigned char msgType, void* data) :
 		Message(src, SCANNER_SM, data), type(msgType) {}
 	const unsigned char type;
 	enum {
-		STATE_REQUEST = 0,
+		CLIENT_REQUEST,
 
 		STOP = 0xFF
 	};
@@ -63,6 +68,19 @@ public:
 	};
 };
 
+class ServerMessage : public Message {
+public:
+	enum {
+		CONTEXT_UPDATE,
+
+		NOTIFY_ALL_CLIENTS,
+		NOTIFY_USERS,
+		NOTIFY_VIEWERS,
+
+		STOP = 0xFF
+	};
+};
+
 /* interface for all classes using ITC */
 class MessageReceiver {
 public:

piScan_backend/src/server/BackendServer.h

@@ -8,7 +8,9 @@
 #ifndef BACKENDSERVER_H_
 #define BACKENDSERVER_H_
 
-class BackendServer {
+#include "messages.h"
+
+class BackendServer : public MessageReceiver {
 public:
 	BackendServer();
 	virtual ~BackendServer();

piScan_backend/src/server/Connection.cpp

@@ -0,0 +1,12 @@
+/*
+ * Connection.cpp
+ *
+ *  Created on: Feb 12, 2019
+ *      Author: ezra
+ */
+
+#include "ServerManager.h"
+
+
+
+

piScan_backend/src/server/ServerManager.cpp

@@ -7,12 +7,113 @@
 
 #include "ServerManager.h"
 
-ServerManager::ServerManager() {
-	// TODO Auto-generated constructor stub
+#define MAX_CONNECTIONS	5
+#define QUEUE_SIZE		64
+
+ServerManager::ServerManager(MessageReceiver central) :
+		_centralQueue(central), _queue(QUEUE_SIZE), _activeConnections(0), _connections(
+				MAX_CONNECTIONS) {
 
 }
 
-ServerManager::~ServerManager() {
-	// TODO Auto-generated destructor stub
+void ServerManager::start(){
+	//TODO
 }
 
+void ServerManager::allowConnections(){
+	//TODO
+}
+
+void ServerManager::disconnectClients(){
+	//TODO might need locks for array
+	for(int i = 0; i < MAX_CONNECTIONS; ++i){
+		Connection::Connection con = _connections[i];
+		if(con != NULL){
+			con.disconnect();
+		}
+	}
+}
+
+void ServerManager::_queueThreadFunc(void){
+	//todo break condition
+	while(1){
+		Message message;
+		if(_queue.try_dequeue(&message)){
+			if(message.destination != SERVER_MAN){
+				_centralQueue.giveMessage(message);
+			}
+			else{
+				//todo
+			}
+		}
+	}
+}
+
+void ServerManager::giveMessage(Message message){
+	_queue.enqueue(message);
+}
+
+ServerInterface::RequestResponse ServerManager::requestConnection(Connection::Connection client){
+	if(_activeConnections < MAX_CONNECTIONS){
+		_addConnection(client);
+		return RQ_ACCEPTED;
+	}
+	else{
+		delete client;
+		return RQ_DENIED;
+	}
+}
+
+ServerInterface::RequestResponse ServerManager::giveRequest(ClientRequest request){
+	if(_connections[request.src._handle] != request.src){
+		delete request;
+		return RQ_INVALID_HANDLE;
+	}
+	else if(request.src._level < ClientRequest::permissionMap[request.requestType]){
+		delete request;
+		return RQ_INSUFFICIENT_PERMISSION;
+	}
+
+	//todo new message, request passed as data
+	unsigned char dest = 0;
+	Message message;
+	switch(request.requestType){
+	case ClientRequest::SYSTEM_FUNCTION:
+		dest = SYSTEM_CONTROL;
+		break;
+	case ClientRequest::SCANNER_FUNCTION:
+		//dest = SCANNER_SM;
+		message = new ScannerMessage(CLIENT, ScannerMessage::CLIENT_REQUEST, request);
+		break;
+	case ClientRequest::DATABASE_RETRIEVE:
+		dest = SYSTEM_CONTROL;
+		break;
+	case ClientRequest::DATABASE_MODIFY:
+		dest = SYSTEM_CONTROL;
+		break;
+	case ClientRequest::CONFIG_RETRIEVE:
+		dest = SYSTEM_CONTROL;
+		break;
+	case ClientRequest::CONFIG_MODIFY:
+		dest = SYSTEM_CONTROL;
+		break;
+	}
+
+	this->giveMessage(message);
+	delete request;
+	return RQ_ACCEPTED;
+}
+
+void ServerManager::_handleMessage(Message message){
+	//TODO
+}
+
+void ServerManager::_addConnection(Connection::Connection client){
+	//TODO
+	for(int i = 0; i < MAX_CONNECTIONS; ++i){
+		if(_connections[i] == NULL){
+			_connections[i] = client;
+			client._handle = i;
+		}
+	}
+}

piScan_backend/src/server/ServerManager.h

@@ -8,10 +8,113 @@
 #ifndef SERVER_SERVERMANAGER_H_
 #define SERVER_SERVERMANAGER_H_
 
-class ServerManager {
+#include "messages.h"
+
+class Connection;
+class ClientRequest;
+class ServerInterface;
+class ServerManager;
+
+class Connection : public MessageReceiver {
 public:
-	ServerManager();
-	virtual ~ServerManager();
+	enum ConnectionLevel {
+		RECEIVE_ONLY,
+		VIEWER,
+		FULL_CONTROL,
+	};
+
+	enum AudioReceive {
+		AUDIO_NONE,
+		AUDIO_RECEIVE,
+	};
+
+	Connection(ConnectionLevel lvl, AudioReceive aud);
+
+	virtual void giveMessage(Message message) = 0;
+	void disconnect();
+
+private:
+	friend class ServerManager;
+	int _handle;
+	ConnectionLevel _level;
+	AudioReceive _audio;
+	ServerInterface _serverManager;
+
+	void _notifyDisconnected();
+};
+
+class ClientRequest : public Message {
+public:
+	enum {
+		REQUEST,
+		NOTIFY_DISCONNECTED,
+	};
+
+	enum RequestType {
+		SYSTEM_FUNCTION,
+		SCANNER_FUNCTION,
+		DATABASE_RETRIEVE,
+		DATABASE_MODIFY,
+		CONFIG_RETRIEVE,
+		CONFIG_MODIFY,
+	};
+
+	ClientRequest(Connection client, unsigned char dst);
+
+private:
+	static const Connection::ConnectionLevel permissionMap = {
+			[SYSTEM_FUNCTION] = Connection::ConnectionLevel::FULL_CONTROL,
+			[SCANNER_FUNCTION] = Connection::ConnectionLevel::FULL_CONTROL,
+			[DATABASE_RETRIEVE] = Connection::ConnectionLevel::VIEWER,
+			[DATABASE_MODIFY] = Connection::ConnectionLevel::FULL_CONTROL,
+			[CONFIG_RETRIEVE] = Connection::ConnectionLevel::VIEWER,
+			[CONFIG_MODIFY] = Connection::ConnectionLevel::FULL_CONTROL,
+	};
+
+	friend class ServerManager;
+	Connection src;
+	RequestType requestType;
+	void (*_callback)(void*);
+};
+
+class ServerInterface {
+public:
+	ServerInterface() = 0;
+	virtual ~ServerInterface();
+
+	enum RequestResponse {
+		RQ_ACCEPTED,
+		RQ_DENIED,
+		RQ_INSUFFICIENT_PERMISSION,
+		RQ_INVALID_HANDLE,
+	};
+
+	virtual RequestResponse requestConnection(Connection::Connection client) = 0;
+	virtual RequestResponse giveRequest(ClientRequest request) = 0;
+};
+
+class ServerManager : public MessageReceiver, ServerInterface {
+public:
+	ServerManager(MessageReceiver central);
+
+	void start();
+	void allowConnections();
+	void disconnectClients();
+	void giveMessage(Message message);
+protected:
+
+private:
+	moodycamel::ConcurrentQueue _queue;
+	int _activeConnections;
+	Connection _connections[];
+	MessageReceiver _centralQueue;
+
+	void _queueThreadFunc(void);
+	void _handleMessage(Message message);
+	void _addConnection(Connection::Connection client);
+	RequestResponse requestConnection(Connection::Connection client);
+	RequestResponse giveRequest(ClientRequest request);
+
 };
 
 #endif /* SERVER_SERVERMANAGER_H_ */