void LogParser::onDataAvailable()
{
    QByteArray data = _serialPort->readAll();
    for(int i = 0; i < data.size(); i++)
    {
        _receivedDataQueue->enqueue((unsigned char)data.constData()[i]);
    }

    parseReceivedData();
}
// Server implementation
void ReasonerCommunication::messageReceivedCB(std::shared_ptr<ServerClientMessage> msg, const char * message_data, uint64_t buffer_size){

	ReasonerMessageDataType expectedResponse = parseReceivedData(message_data, buffer_size);

	//cout << "messageReceivedCB: " << (int) expectedResponse << endl;


	// always send a response
	ReasonerMessageData rmsd;

	// TODO check against our role if we can provide the requested data

	rmsd.containedData = expectedResponse;
	rmsd.reasonerID = this->reasonerID;

	switch (expectedResponse){
	case (ReasonerMessageDataType::PROCESS) : {
		shared_ptr<ProcessHealth> payload (new ProcessHealth()); //= cb.getProcessHealth(); FIXME
		assert(payload);
		rmsd.messagePayload = &* payload;
		msg->isendResponse(& rmsd);
		break;
	}
	case (ReasonerMessageDataType::NODE) : {
		shared_ptr<NodeHealth> payload = cb.getNodeHealth();
		assert(payload);

		rmsd.messagePayload = &* payload;
		msg->isendResponse(& rmsd);
		break;
	}
	case (ReasonerMessageDataType::SYSTEM) : {
		shared_ptr<SystemHealth> payload = cb.getSystemHealth();
		assert(payload);
		rmsd.messagePayload = &* payload;
		msg->isendResponse(& rmsd);
		break;
	}
	default:{
		rmsd.messagePayload = nullptr;
		msg->isendResponse(& rmsd);
	}
	}
}
Esempio n. 3
0
void AbstractHost::readCallback(ev::io &watcher, int revents)
{
	int bytesRead = -1;
	char errorBuffer[128] = {'\0'};
	memset(receiveBuffer, 0, 4096);

	bytesRead = recv(hostSocket, (void*)receiveBuffer, 4096, 0);
	if(bytesRead < 0 && !(errno == EAGAIN || errno == EWOULDBLOCK))
	{
//		strerror_r(errno,errorBuffer,128);
//		throw std::runtime_error("Host socket read failed: "+std::string(errorBuffer));
		throw std::runtime_error("Host socket read failed: "+std::string(strerror_r(errno,errorBuffer,128)));

	}
	else if (bytesRead == 0)
	{
		closeSocket();
	}

	parseReceivedData();
}
Esempio n. 4
0
void JumpropesCommon::HttpClient::done() {
   parseReceivedData();
   stop();

   onStatusUpdate.execute( JRHTTPSTATUS_DONE );
}
void LogParser::parseReceivedData()
{
    if(_receivedDataQueue->size() < 3)
        return;

    unsigned char start = _receivedDataQueue->dequeue();
    while(start != 0xDD && !_receivedDataQueue->isEmpty())
    {
        if(start != 0xFF) // skip bytes received when cable disconnected
            qDebug() << "skipping unexpected data" << QString().sprintf("0x%02x", start);

        start = _receivedDataQueue->dequeue();
    }

 /*   if(_receivedDataQueue->size() >= 1)
    {
        if(_receivedDataQueue->at(0) != LOG_TYPE_STRING &&
                _receivedDataQueue->at(0) !=LOG_TYPE_PHY_RX_RES &&
                _receivedDataQueue->at(0) != LOG_TYPE_DLL_RX_RES)
        {
            qWarning(qPrintable(QString().sprintf("Unexpected type: 0x%02x, skipping ...", _receivedDataQueue->at(0))));
            return;
        }
    }
*/
    if(_receivedDataQueue->size() < 2 || _receivedDataQueue->size() < _receivedDataQueue->at(1) + 2)
    {
        //  not a full packet, reinsert header and wait for more data ...
        _receivedDataQueue->insert(0, 0xDD);
        return;
    }

    u8 type = _receivedDataQueue->dequeue();
    u8 len = _receivedDataQueue->dequeue();

    if(type == LOG_TYPE_STRING)
    {
        QString msg;
        for(int i = 0; i < len; i++)
        {
            msg += QString(_receivedDataQueue->dequeue());
        }

        emit logMessageReceived(msg);
    }
    if(type == LOG_TYPE_PHY_RX_RES)
    {
        QByteArray packetData;
        unsigned char byte;
        for(int i = 0; i < len; i++)
        {
            byte = _receivedDataQueue->dequeue();
            packetData.append(byte);
        }

        Packet p;
        p.parsePhyRx(packetData);
        _packets.append(p);
    }
    if(type == LOG_TYPE_DLL_RX_RES)
    {
        QByteArray packetData;
        unsigned char byte;
        for(int i = 0; i < len; i++)
        {
            byte = _receivedDataQueue->dequeue();
            packetData.append(byte);
        }

        if(_packets.isEmpty())
        {
            qWarning("Received a DllRx while packets empty, probably the first log message received, skipping ...");
            return;
        }

        Packet lastPacket = _packets.last();
        if(lastPacket.hasDllInformation())
        {
            QString msg = "Out of sync, got DLL data while current packet instance already has parsed DLL data";
            qCritical(msg.toLocal8Bit());
            qDebug() << msg;
        }

        lastPacket.parseDllRx(packetData);

        emit logMessageReceived(lastPacket.toString());
        emit packetParsed(lastPacket);
    }

    parseReceivedData();
}
void ReasonerCommunication::messageResponseCB(BareMessage * msg, char * buffer, uint64_t buffer_size){
	if ( msg->user_ptr == (size_t) ReasonerMessageDataType::NONE ){
		return;
	}
	parseReceivedData(buffer, buffer_size);
}