void ScriptEngineServer::stop()
{
try
{
_stopServer = true;
GD::bl->threadManager.join(_mainThread);
_out.printDebug("Debug: Waiting for script engine server's client threads to finish.");
{
std::lock_guard<std::mutex> stateGuard(_stateMutex);
for(std::map<int32_t, std::shared_ptr<ClientData>>::iterator i = _clients.begin(); i != _clients.end(); ++i)
{
closeClientConnection(i->second);
}
}
while(_clients.size() > 0)
{
collectGarbage();
if(_clients.size() > 0) std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
unlink(GD::socketPath.c_str());
}
catch(const std::exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(BaseLib::Exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(...)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
}
}
void
xpcc::hosted::CanUsb::close()
{
this->serialPort.write("C\r");
{
MutexGuard stateGuard(this->stateLock);
this->active = false;
}
this->thread->join();
delete this->thread;
this->thread = 0;
this->serialPort.close();
busState = BusState::Off;
}
xpcc::hosted::CanUsb::~CanUsb()
{
if (this->active)
{
{
MutexGuard stateGuard(this->stateLock);
this->active = false;
}
this->thread->join();
delete this->thread;
this->thread = 0;
}
this->serialPort.close();
while (this->serialPort.isOpen())
{
//wait for port to close;
}
}
void ScriptEngineServer::mainThread()
{
try
{
getFileDescriptor(true); //Deletes an existing socket file
std::shared_ptr<BaseLib::FileDescriptor> clientFileDescriptor;
while(!_stopServer)
{
try
{
//Don't lock _stateMutex => no synchronisation needed
if(_clients.size() > GD::bl->settings.scriptEngineServerMaxConnections())
{
collectGarbage();
if(_clients.size() > GD::bl->settings.scriptEngineServerMaxConnections())
{
_out.printError("Error: There are too many clients connected to me. Waiting for connections to close. You can increase the number of allowed connections in main.conf.");
std::this_thread::sleep_for(std::chrono::milliseconds(5000));
continue;
}
}
getFileDescriptor();
if(!_serverFileDescriptor || _serverFileDescriptor->descriptor == -1)
{
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
continue;
}
clientFileDescriptor = getClientFileDescriptor();
if(!clientFileDescriptor || clientFileDescriptor->descriptor == -1) continue;
}
catch(const std::exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
continue;
}
catch(BaseLib::Exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
continue;
}
catch(...)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
continue;
}
try
{
std::shared_ptr<ClientData> clientData = std::shared_ptr<ClientData>(new ClientData(clientFileDescriptor));
std::lock_guard<std::mutex> stateGuard(_stateMutex);
clientData->id = _currentClientID++;
_clients[clientData->id] = clientData;
GD::bl->threadManager.start(clientData->readThread, true, &ScriptEngineServer::readClient, this, clientData);
}
catch(const std::exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(BaseLib::Exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(...)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
}
}
GD::bl->fileDescriptorManager.close(_serverFileDescriptor);
}
catch(const std::exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(BaseLib::Exception& ex)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(...)
{
_out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
}
}
bool
xpcc::hosted::CanUsb::open(std::string deviceName, unsigned int serialBaudRate, xpcc::Can::Bitrate canBitrate)
{
if (this->serialPort.isOpen())
this->serialPort.close();
while (this->serialPort.isOpen())
{
// wait for port to close;
}
this->serialPort.setDeviceName(deviceName);
this->serialPort.setBaudRate(serialBaudRate);
if (this->serialPort.open())
{
XPCC_LOG_DEBUG << XPCC_FILE_INFO << "SerialPort opened in canusb" << xpcc::endl;
XPCC_LOG_DEBUG << XPCC_FILE_INFO << "write 'C'" << xpcc::endl;
this->serialPort.write("C\r");
xpcc::ShortTimeout timeout;
timeout.restart(500);
while (!timeout.isExpired())
{
}
char a;
while( this->serialPort.read(a) );
// Set CAN bitrate
XPCC_LOG_DEBUG << XPCC_FILE_INFO << "Set CAN bitrate" << xpcc::endl;
switch (canBitrate)
{
case kBps10:
this->serialPort.write("S0\r");
break;
case kBps20:
this->serialPort.write("S1\r");
break;
case kBps50:
this->serialPort.write("S2\r");
break;
case kBps100:
this->serialPort.write("S3\r");
break;
case kBps125:
this->serialPort.write("S4\r");
break;
case kBps250:
this->serialPort.write("S5\r");
break;
case kBps500:
this->serialPort.write("S6\r");
break;
case MBps1:
this->serialPort.write("S8\r");
break;
}
timeout.restart(500);
while (!this->serialPort.read(a))
{
if (timeout.isExpired())
{
XPCC_LOG_DEBUG << XPCC_FILE_INFO << "Timer expired" << xpcc::endl;
this->serialPort.close();
while (this->serialPort.isOpen())
{
// wait for port to close;
}
return false;
}
}
if (a != '\r')
{
XPCC_LOG_ERROR << XPCC_FILE_INFO << "Wrong answer on set CAN bitrate: " << xpcc::hex << (int) a << xpcc::endl;
this->serialPort.close();
while (this->serialPort.isOpen())
{
// wait for port to close;
}
return false;
}
// Open CAN channel
this->serialPort.write("O\r");
XPCC_LOG_DEBUG << XPCC_FILE_INFO << "written 'O'" << xpcc::endl;
timeout.restart(500);
while (!this->serialPort.read(a))
{
if (timeout.isExpired())
{
XPCC_LOG_DEBUG << XPCC_FILE_INFO << "Timer expired" << xpcc::endl;
this->serialPort.close();
while (this->serialPort.isOpen())
{
// wait for port to close;
}
return false;
}
}
if (a != '\r')
{
XPCC_LOG_ERROR << XPCC_FILE_INFO << "Wrong answer on O: " << xpcc::hex << (int) a << xpcc::endl;
this->serialPort.close();
while (this->serialPort.isOpen())
{
// wait for port to close;
}
return false;
}
{
MutexGuard stateGuard(this->stateLock);
this->active = true;
}
this->thread = new boost::thread(
boost::bind(&xpcc::hosted::CanUsb::update, this));
busState = BusState::Connected;
this->tmpRead.clear();
return true;
}
else
{
busState = BusState::Off;
XPCC_LOG_ERROR << XPCC_FILE_INFO << "Could not open Canusb" << xpcc::endl;
return false;
}
}
