detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-06-23 01:58:00 +02:00
Code Issues Actions Packages Releases Activity

changed constructor

Browse Source
This commit is contained in:
Erik Frojdh
2019-01-24 11:12:24 +01:00
parent c3472f295b
commit a1c0d28ddb
16 changed files with 113 additions and 334 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
slsSupportLib/include/ClientInterface.h
View File

@ -3,6 +3,7 @@
#include "sls_detector_defs.h"
#include "MySocketTCP.h"
#include "ClientSocket.h"
/**
@ -20,18 +21,13 @@ public:
* @param n for debugging purposes (useful only for client side)
* @param t string to identify type (Detector, Receiver) for printouts (useful only for client side)
*/
ClientInterface(MySocketTCP *socket, int n=-1, std::string t="");
ClientInterface(int n, sls::ClientSocket&& s);
/**
* destructor
*/
virtual ~ClientInterface() = default;
/**
* Set the datasocket
* @param socket the data socket
*/
void SetSocket(MySocketTCP *socket);
/**
* Receive ret, mess or retval from Server
@ -58,95 +54,18 @@ public:
char* mess = 0);
/** only Receiver
* Server sends result to client (also set ret to force_update if different clients)
* @param update true if one must update if different clients, else false
* @param ret success of operation
* @param retval pointer to result
* @param retvalSize size of result
* @param mess message
* @returns success of operation
*/
int Server_SendResult(bool update, int ret, void* retval, int retvalSize, char* mess = 0);
/** only Receiver
* Server receives arguments and checks if base object is null (if checkbase is true)
* checking base object is null (for receiver only when it has not been configured yet)
* @param ret pointer to success of operation
* @param mess message
* @param arg pointer to argument
* @param sizeofArg size of argument
* @param checkbase if true, checks if base object is null and sets ret and mess accordingly
* @param base pointer to base object
* @returns fail if socket crashes while reading arguments, else fail
*/
int Server_ReceiveArg(int& ret, char* mess, void* arg, int sizeofArg,bool checkbase=false, void* base=NULL);
/** only Receiver
* Server verifies if it is unlocked,
* sets and prints appropriate message if it is locked and different clients
* @param ret pointer to success
* @param mess message
* @param lockstatus status of lock
* @returns success of operaton
*/
int Server_VerifyLock(int& ret, char* mess, int lockstatus);
/** only Receiver
* Server verifies if it is unlocked and idle,
* sets and prints appropriate message if it is locked and different clients
* @param ret pointer to success
* @param mess message
* @param lockstatus status of lock
* @param status status of server
* @param fnum function number for error message
* @returns success of operaton
*/
int Server_VerifyLockAndIdle(int& ret, char* mess, int lockstatus, slsDetectorDefs::runStatus status, int fnum);
/** only Receiver
* Server sets and prints error message for null object error (receiver only)
* @param ret pointer to success that will be set to FAIL
* @param mess message
*/
void Server_NullObjectError(int& ret, char* mess);
/** only Receiver
* Servers prints error message for socket crash when reading
* @returns always FAIL
*/
int Server_SocketCrash();
/** only Receiver
* Servers sets and prints error message for locked server
* @param ret pointer to success that will be set to FAIL
* @param mess message
* @returns success of operaton
*/
int Server_LockedError(int& ret, char* mess);
/** only Receiver
* Servers sets and prints error message for server not being idle
* @param ret pointer to success that will be set to FAIL
* @param mess message
* @param fnum function number for error message
* @returns success of operaton
*/
int Server_NotIdleError(int& ret, char* mess, int fnum);
private:
/**
* socket for data acquisition
*/
MySocketTCP *mySocket;
sls::ClientSocket socket_;
/** index for client debugging purposes */
int index;
/** string for type to differentiate between Detector & Receiver in printouts */
std::string type;
};

3
slsSupportLib/include/ClientSocket.h
View File

@ -10,8 +10,9 @@ namespace sls{
class ClientSocket: public DataSocket{
public:
ClientSocket(const std::string& hostname, uint16_t port_number);
int connect();
private:
struct sockaddr_in serverAddr {};
};
}; //namespace sls

6
slsSupportLib/include/DataSocket.h
View File

@ -7,7 +7,11 @@ namespace sls {
class DataSocket {
public:
DataSocket(int socketId);
DataSocket(DataSocket&& move) noexcept;
DataSocket& operator=(DataSocket&& move) noexcept;
void swap(DataSocket& other) noexcept;
DataSocket(DataSocket const&) = delete;
DataSocket& operator=(DataSocket const&) = delete;
int getSocketId() const{
return socketId_;
}

117
slsSupportLib/src/ClientInterface.cpp
View File

@ -1,17 +1,12 @@
#include "ClientInterface.h"
#include "ClientSocket.h"
ClientInterface::ClientInterface(MySocketTCP *socket, int n, std::string t): mySocket(socket),
index(n),
type(t){}
void ClientInterface::SetSocket(MySocketTCP *socket) {
mySocket = socket;
}
ClientInterface::ClientInterface(int n, sls::ClientSocket&& s): socket_(std::move(s)),
index(n){}
void ClientInterface::Client_Receive(int& ret, char* mess, void* retval, int sizeOfRetval) {
// get result of operation
mySocket->ReceiveDataOnly(&ret,sizeof(ret));
socket_.receiveData(reinterpret_cast<char *>(&ret), sizeof(ret));
bool unrecognizedFunction = false;
if (ret == FAIL) {
@ -23,8 +18,8 @@ void ClientInterface::Client_Receive(int& ret, char* mess, void* retval, int siz
memset(mess, 0, MAX_STR_LENGTH);
}
// get error message
mySocket->ReceiveDataOnly(mess,MAX_STR_LENGTH);
cprintf(RED, "%s %d returned error: %s", type.c_str(), index, mess);
socket_.receiveData(mess,MAX_STR_LENGTH);
// cprintf(RED, "%s %d returned error: %s", type.c_str(), index, mess);
// unrecognized function, do not ask for retval
if(strstr(mess,"Unrecognized Function") != nullptr)
@ -35,7 +30,7 @@ void ClientInterface::Client_Receive(int& ret, char* mess, void* retval, int siz
}
// get retval
if (!unrecognizedFunction)
mySocket->ReceiveDataOnly(retval, sizeOfRetval);
socket_.receiveData( reinterpret_cast<char *>(retval), sizeOfRetval);
}
@ -44,100 +39,8 @@ int ClientInterface::Client_Send(int fnum,
void* retval, int sizeOfRetval,
char* mess) {
int ret = FAIL;
mySocket->SendDataOnly(&fnum,sizeof(fnum));
mySocket->SendDataOnly(args, sizeOfArgs);
socket_.sendData(reinterpret_cast<char *>(&fnum),sizeof(fnum));
socket_.sendData(reinterpret_cast<char *>(args), sizeOfArgs);
Client_Receive(ret, mess, retval, sizeOfRetval);
return ret;
}
int ClientInterface::Server_SendResult(bool update, int ret,
void* retval, int retvalSize, char* mess) {
// update if different clients
if (update && ret == OK && mySocket->differentClients)
ret = FORCE_UPDATE;
// send success of operation
mySocket->SendDataOnly(&ret,sizeof(ret));
if(ret == FAIL) {
// send error message
if (mess)
mySocket->SendDataOnly(mess, MAX_STR_LENGTH);
// debugging feature. should not happen.
else
FILE_LOG(logERROR) << "No error message provided for this failure. Will mess up TCP\n";
}
// send return value
mySocket->SendDataOnly(retval, retvalSize);
return ret;
}
int ClientInterface::Server_ReceiveArg(int& ret, char* mess, void* arg, int sizeofArg, bool checkbase, void* base) {
// client socket crash, cannot receive arguments
if (sizeofArg && mySocket->ReceiveDataOnly(arg, sizeofArg) < 0)
return Server_SocketCrash();
// check if server object created
if (checkbase && base == nullptr)
Server_NullObjectError(ret, mess);
// no crash
return OK;
}
int ClientInterface::Server_VerifyLock(int& ret, char* mess, int lockstatus) {
// server locked
if (mySocket->differentClients && lockstatus)
return Server_LockedError(ret, mess);
return ret;
}
int ClientInterface::Server_VerifyLockAndIdle(int& ret, char* mess, int lockstatus, slsDetectorDefs::runStatus status, int fnum) {
// server locked
if (mySocket->differentClients && lockstatus)
return Server_LockedError(ret, mess);
// server not idle for this command
if (status != slsDetectorDefs::IDLE)
return Server_NotIdleError(ret, mess, fnum);
return ret;
}
void ClientInterface::Server_NullObjectError(int& ret, char* mess) {
ret=FAIL;
strcpy(mess,"Receiver not set up. Please use rx_hostname first.\n");
FILE_LOG(logERROR) << mess;
}
int ClientInterface::Server_SocketCrash() {
FILE_LOG(logERROR) << "Reading from socket failed. Possible socket crash";
return FAIL;
}
int ClientInterface::Server_LockedError(int& ret, char* mess) {
ret = FAIL;
sprintf(mess,"Receiver locked by %s\n", mySocket->lastClientIP);
FILE_LOG(logERROR) << mess;
return ret;
}
int ClientInterface::Server_NotIdleError(int& ret, char* mess, int fnum) {
ret = FAIL;
sprintf(mess,"Can not execute %s when receiver is not idle\n",
getFunctionNameFromEnum((enum detFuncs)fnum));
FILE_LOG(logERROR) << mess;
return ret;
}
}

9
slsSupportLib/src/ClientSocket.cpp
View File

@ -19,17 +19,22 @@ ClientSocket::ClientSocket(const std::string &host, uint16_t port) : DataSocket(
}
//TODO! Erik, results could have multiple entries do we need to loop through them?
struct sockaddr_in serverAddr {};
// struct sockaddr_in serverAddr {};
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(port);
memcpy((char *)&serverAddr.sin_addr.s_addr,
&((struct sockaddr_in *)result->ai_addr)->sin_addr, sizeof(in_addr_t));
if (connect(getSocketId(), (struct sockaddr *)&serverAddr, sizeof(serverAddr)) != 0){
if (::connect(getSocketId(), (struct sockaddr *)&serverAddr, sizeof(serverAddr)) != 0){
freeaddrinfo(result);
throw std::runtime_error("ClientSocket ERROR: cannot connect to host\n");
}
freeaddrinfo(result);
}
int ClientSocket::connect(){
//used to reconnect after closing may be removed
return ::connect(getSocketId(), (struct sockaddr *)&serverAddr, sizeof(serverAddr));
}
}; //namespace sls

14
slsSupportLib/src/DataSocket.cpp
View File

@ -4,11 +4,23 @@
#include <cstring>
#include <iostream>
#include <unistd.h>
#include <algorithm>
namespace sls {
DataSocket::DataSocket(int socketId) : socketId_(socketId) {}
void DataSocket::swap(DataSocket& other) noexcept{
std::swap(socketId_, other.socketId_);
}
DataSocket::DataSocket(DataSocket&& move) noexcept{
move.swap(*this);
}
DataSocket& DataSocket::operator=(DataSocket&& move)noexcept{
move.swap(*this);
return *this;
}
size_t DataSocket::receiveData(char *buffer, size_t size) {
std::cout << "Sending\n";
size_t dataRead = 0;