void QxThreadPool::initServices()
{
QMutexLocker locker(& m_mutex);
qRegisterMetaType<qx::service::QxTransaction_ptr>("qx::service::QxTransaction_ptr");
qRegisterMetaType<qx::service::QxTransaction_ptr>("QxTransaction_ptr");
for (long l = 0; l < QxConnect::getSingleton()->getThreadCount(); l++)
{
QxThread * pNewThread = new QxThread(this);
QObject::connect(pNewThread, SIGNAL(error(const QString &, qx::service::QxTransaction_ptr)), this, SIGNAL(error(const QString &, qx::service::QxTransaction_ptr)));
QObject::connect(pNewThread, SIGNAL(transactionStarted(qx::service::QxTransaction_ptr)), this, SIGNAL(transactionStarted(qx::service::QxTransaction_ptr)));
QObject::connect(pNewThread, SIGNAL(transactionFinished(qx::service::QxTransaction_ptr)), this, SIGNAL(transactionFinished(qx::service::QxTransaction_ptr)));
m_lstAllServices.append(pNewThread);
m_lstAvailable.enqueue(pNewThread);
pNewThread->start();
}
}
//-----------------------------------------------------------------------------
IBPP::Statement& MetadataLoader::getStatement(const std::string& sql)
{
Q_ASSERT(transactionStarted());
IBPP::Statement stmt;
IBPPStatementListIterator it = findStatement(sql);
if (it != statementsM.end())
{
stmt = (*it);
statementsM.erase(it);
}
else
{
stmt = IBPP::StatementFactory(databaseM, transactionM, sql);
}
statementsM.push_front(stmt);
limitListSize();
return statementsM.front();
}
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);
}
//-----------------------------------------------------------------------------
IBPP::Statement MetadataLoader::createStatement(const std::string& sql)
{
Q_ASSERT(transactionStarted());
return IBPP::StatementFactory(databaseM, transactionM, sql);
}
//-----------------------------------------------------------------------------
IBPP::Blob MetadataLoader::createBlob()
{
Q_ASSERT(transactionStarted());
return IBPP::BlobFactory(databaseM, transactionM);
}
