void QxTransaction::executeServer()
{
if (m_sServiceName.isEmpty()) { m_bMessageReturn = qx_bool(QX_ERROR_SERVICE_NOT_SPECIFIED, "[QxOrm] empty service name => cannot instantiate service and execute process"); return; }
if (m_sServiceMethod.isEmpty()) { m_bMessageReturn = qx_bool(QX_ERROR_SERVICE_NOT_SPECIFIED, "[QxOrm] empty service method => cannot execute process"); return; }
qx::service::IxService * ptr = qx::create_nude_ptr<qx::service::IxService>(m_sServiceName);
if (ptr == NULL) { m_bMessageReturn = qx_bool(QX_ERROR_SERVICE_INVALID, "[QxOrm] invalid service name => cannot instantiate service and execute process"); return; }
m_pServiceInstance = IxService_ptr(ptr);
m_pServiceInstance->registerClass();
m_pServiceInstance->setInputParameter(m_pInputParameter);
m_pServiceInstance->setServiceMethodName(m_sServiceMethod);
try
{
m_pServiceInstance->onBeforeProcess();
qx_bool bInvokeOk = qx::QxClassX::invoke(m_sServiceName, m_sServiceMethod, (* m_pServiceInstance));
if (! bInvokeOk) { m_bMessageReturn = qx_bool(QX_ERROR_SERVICE_INVALID, "[QxOrm] invalid service method => cannot execute process"); return; }
m_pOutputParameter = m_pServiceInstance->getOutputParameter_BaseClass();
m_bMessageReturn = m_pServiceInstance->getMessageReturn();
m_pServiceInstance->onAfterProcess();
}
catch (const qx::exception & x) { m_bMessageReturn = x.toQxBool(); }
catch (const std::exception & e) { QString msg(e.what()); if (msg.isEmpty()) { msg = "[QxOrm] unexpected error occured executing service method"; }; m_bMessageReturn = qx_bool(QX_ERROR_UNKNOWN, msg); }
catch (...) { m_bMessageReturn = qx_bool(QX_ERROR_UNKNOWN, "[QxOrm] unknown error occured executing service method"); }
m_pServiceInstance.reset();
}
void QxThread::doProcess(QTcpSocket & socket)
{
if (! socket.setSocketDescriptor(m_iSocketDescriptor))
{
Q_EMIT error("[QxOrm] invalid socket descriptor : cannot start transaction", QxTransaction_ptr());
return;
}
qx_bool bReadOk = readSocket(socket);
if (! bReadOk) {
Q_EMIT error(QString("[QxOrm] unable to read request from socket : '") + bReadOk.getDesc() + QString("'"), QxTransaction_ptr());
return;
}
if (! m_bIsRunning) {
return;
}
Q_EMIT transactionStarted(m_pTransaction);
try {
m_pTransaction->executeServer();
}
catch (const qx::exception & x) {
qx_bool xb = x.toQxBool();
m_pTransaction->setMessageReturn(xb);
}
catch (const std::exception & e) {
m_pTransaction->setMessageReturn(qx_bool(QX_ERROR_UNKNOWN, e.what()));
}
catch (...) {
m_pTransaction->setMessageReturn(qx_bool(QX_ERROR_UNKNOWN, "unknown error"));
}
if (! m_bIsRunning) {
return;
}
qx_bool bWriteOk = writeSocket(socket);
if (! bWriteOk) {
Q_EMIT error(QString("[QxOrm] unable to write reply to socket : '") + bWriteOk.getDesc() + QString("'"), m_pTransaction);
}
Q_EMIT transactionFinished(m_pTransaction);
}
void QxTransaction::executeClient(IxService * pService, const QString & sMethod)
{
if ((pService == NULL) || sMethod.isEmpty()) { qAssert(false); return; }
if (pService->getServiceName().isEmpty()) { pService->setMessageReturn(qx_bool(QX_ERROR_SERVICE_NOT_SPECIFIED, "[QxOrm] empty service name")); return; }
pService->registerClass();
QTcpSocket socket;
QString serverName = QxConnect::getSingleton()->getIp();
long serverPort = QxConnect::getSingleton()->getPort();
socket.connectToHost(serverName, serverPort);
if (! socket.waitForConnected(QxConnect::getSingleton()->getMaxWait()))
{ pService->setMessageReturn(qx_bool(QX_ERROR_SERVER_NOT_FOUND, "[QxOrm] unable to connect to server")); return; }
if (m_sTransactionId.isEmpty())
{ setTransactionId(QUuid::createUuid().toString()); }
setIpSource(socket.localAddress().toString());
setPortSource(socket.localPort());
setIpTarget(serverName);
setPortTarget(serverPort);
setServiceName(pService->getServiceName());
setServiceMethod(sMethod);
setTransactionBegin(QDateTime::currentDateTime());
setInputParameter(pService->getInputParameter_BaseClass());
qx_bool bWriteOk = writeSocket(socket);
if (! bWriteOk) { pService->setMessageReturn(qx_bool(QX_ERROR_SERVICE_WRITE_ERROR, QString("[QxOrm] unable to write request to socket : '") + bWriteOk.getDesc() + QString("'"))); return; }
qx_bool bReadOk = readSocket(socket);
if (! bReadOk) { pService->setMessageReturn(qx_bool(QX_ERROR_SERVICE_READ_ERROR, QString("[QxOrm] unable to read reply from socket : '") + bReadOk.getDesc() + QString("'"))); return; }
pService->setOutputParameter(getOutputParameter());
pService->setMessageReturn(getMessageReturn());
setTransactionEnd(QDateTime::currentDateTime());
socket.disconnectFromHost();
if (socket.state() != QAbstractSocket::UnconnectedState)
{ socket.waitForDisconnected(QxConnect::getSingleton()->getMaxWait()); }
}
qx_bool QxThread::writeSocket(QTcpSocket & socket)
{
if (! m_pTransaction) {
return qx_bool(QX_ERROR_SERVICE_NOT_SPECIFIED, "empty service transaction");
}
quint32 uiTransactionSize = 0;
IxParameter_ptr pInputBackup = m_pTransaction->getInputParameter();
m_pTransaction->setInputParameter(IxParameter_ptr());
m_pTransaction->setTransactionReplySent(QDateTime::currentDateTime());
qx_bool bWriteOk = QxTools::writeSocket(socket, (* m_pTransaction), uiTransactionSize);
m_pTransaction->setInputParameter(pInputBackup);
m_pTransaction->setOutputTransactionSize(uiTransactionSize);
return bWriteOk;
}
void CTestAll::init()
{
m_lId = 56;
m_oQxBool = qx_bool(true, "qx_bool description");
m_oStdString = "std::string text";
m_oQString = "QString text\nwith a new line";
m_oQDate = QDate::currentDate();
m_oQDateTime = QDateTime::currentDateTime();
m_oQTime = QTime::currentTime();
m_oQColor = QColor(255, 200, 200);
m_oQFont.setBold(true);
m_oQFont.setFamily("font family from qx test");
m_oQPoint = QPoint(8, 11);
m_oQRect = QRect(QPoint(52, 3), QPoint(574, 1112));
m_oQSize = QSize(1024, 768);
m_oQRegExp = QRegExp("qt reg exp");
m_oQUrl = QUrl("www.qxorm.com");
m_oQStringList << "str1" << "str2" << "str3" << "str4";
m_oQByteArray = QByteArray("QByteArray t\0ext\nwith a new line\0and null multi\0ple null char\0", 55);
m_oQVariant = QVariant(0.437);
m_oQObject.setProperty("prop_1", 1);
m_oQObject.setProperty("prop_2", 2);
QSharedPointer<CUser> u1(new CUser());
QSharedPointer<CUser> u2(new CUser());
m_oStdPair = std::make_pair(QPoint(2, 6), QRect(99, 55, 44, 22));
m_oStdList.push_back(QDateTime());
m_oStdList.push_back(QDateTime::currentDateTime());
m_oStdList.push_back(QDateTime());
m_oStdMap.insert(std::make_pair("1", u1));
m_oStdMap.insert(std::make_pair("2", u2));
m_oStdVector.push_back(QSharedPointer<qx::test::CPerson>(new qx::test::CPerson()));
m_oStdVector.push_back(QSharedPointer<qx::test::CPerson>(new CUser()));
}
