void perfbarDraw() {
#ifndef IPHONE
CHECK(pstack.empty());
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, 1, 1, 0, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glBindTexture(GL_TEXTURE_2D, 0);
glBegin(GL_QUADS);
const float xmarg = 0.01;
const float xwid = xmarg * 0.9;
const float xstart = 1 - xmarg;
int megindent = 0;
const float scale = 60.f * (60.f / 70) / 1000000;
for(int i = 0; i < pchunks.size(); i++) {
double xps = xstart - xmarg * pchunks[i].indent;
double ys = (pchunks[i].start - start) * scale;
double ye = (pchunks[i].end - start) * scale;
glColor3f(pchunks[i].r, pchunks[i].g, pchunks[i].b);
glVertex2f(xps, ys);
glVertex2f(xps - xwid, ys);
glVertex2f(xps - xwid, ye);
glVertex2f(xps, ye);
megindent = max(megindent, pchunks[i].indent + 1);
}
glColor3f(1.0, 1.0, 1.0);
float xpind = xstart - xmarg * megindent;
glVertex2f(1, (1000000.f / 60) * scale);
glVertex2f(1, (1000000.f / 60) * scale + xwid);
glVertex2f(xpind, (1000000.f / 60) * scale + xwid);
glVertex2f(xpind, (1000000.f / 60) * scale);
// now let's print the mem bar as well
float memheight = memoryUsage() / 200000000.;
float mems = 1 - xwid / 4;
float meme = 1 - xwid * 3 / 4;
glColor3f(1.0, 1.0, 1.0);
glVertex2f(mems, 0);
glVertex2f(meme, 0);
glVertex2f(meme, memheight);
glVertex2f(mems, memheight);
glEnd();
#endif
}
qint64 memoryDiff(const qint64 aMemoryBefore)
{
int aAttempt=0;
while (aAttempt<10)
{
++aAttempt;
qint64 aMemoryUsed=memoryUsage();
if (aMemoryUsed>aMemoryBefore)
{
return aMemoryUsed-aMemoryBefore;
}
QThread::currentThread()->msleep(100);
}
return 0;
}
void MainWindow::testList(const QString aElementName)
{
T aValue;
// int aElemCount=15000000; // 1GB RAM free required
int aElemCount=15000000;
int lastRow=((CopyableTable*)ui->testsTabWidget->widget(0))->rowCount();
qint64 aStart;
qint64 aTimeStamp;
qint64 aMemoryUsed;
//------------------------------------------------------------
for (int i=0; i<ui->testsTabWidget->count(); ++i)
{
((CopyableTable*)ui->testsTabWidget->widget(i))->setRowCount(lastRow+1);
((CopyableTable*)ui->testsTabWidget->widget(i))->setItem(lastRow, 0, new TableNumericItem(QString::number(lastRow+1)));
}
((CopyableTable*)ui->testsTabWidget->widget(0))->setItem(lastRow, 1, new QTableWidgetItem(QString::number(aElemCount)+" \""+aElementName+"\": Memory, bytes ("+QString::number(sizeof(T))+" bytes per element)"));
((CopyableTable*)ui->testsTabWidget->widget(1))->setItem(lastRow, 1, new QTableWidgetItem(QString::number(aElemCount)+" \""+aElementName+"\": Time for appending, ms"));
((CopyableTable*)ui->testsTabWidget->widget(2))->setItem(lastRow, 1, new QTableWidgetItem(QString::number(aElemCount)+" \""+aElementName+"\": Time for clearing, ms"));
((CopyableTable*)ui->testsTabWidget->widget(3))->setItem(lastRow, 1, new QTableWidgetItem(QString::number(aElemCount)+" \""+aElementName+"\": Time for inserting, ms"));
((CopyableTable*)ui->testsTabWidget->widget(4))->setItem(lastRow, 1, new QTableWidgetItem(QString::number(aElemCount)+" \""+aElementName+"\": Time for cloning, ms"));
((CopyableTable*)ui->testsTabWidget->widget(5))->setItem(lastRow, 1, new QTableWidgetItem(QString::number(aElemCount)+" \""+aElementName+"\": Time for removing, ms"));
QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
//============================================================
// QT LIST
//============================================================
{
QList<T> aQtList;
aMemoryUsed=memoryUsage();
aStart=QDateTime::currentMSecsSinceEpoch();
for (int i=0; i<aElemCount; ++i)
{
aQtList.append(aValue);
}
aTimeStamp=QDateTime::currentMSecsSinceEpoch();
aMemoryUsed=memoryDiff(aMemoryUsed);
setItemAndScroll(((CopyableTable*)ui->testsTabWidget->widget(0)), lastRow, 2, QString::number(aMemoryUsed));
setItemAndScroll(((CopyableTable*)ui->testsTabWidget->widget(1)), lastRow, 2, QString::number(aTimeStamp-aStart));
//------------------------------------------------------------
aStart=QDateTime::currentMSecsSinceEpoch();
aQtList.clear();
aTimeStamp=QDateTime::currentMSecsSinceEpoch();
setItemAndScroll(((CopyableTable*)ui->testsTabWidget->widget(2)), lastRow, 2, QString::number(aTimeStamp-aStart));
//------------------------------------------------------------
srand(mRandomSeed);
aStart=QDateTime::currentMSecsSinceEpoch();
for (int i=0; i<aElemCount/100; ++i)
{
aQtList.insert(rand() % (aQtList.length()+1), aValue);
}
aTimeStamp=QDateTime::currentMSecsSinceEpoch();
setItemAndScroll(((CopyableTable*)ui->testsTabWidget->widget(3)), lastRow, 2, QString::number((aTimeStamp-aStart)*100));
//------------------------------------------------------------
aStart=QDateTime::currentMSecsSinceEpoch();
QList<T> aTempList=aQtList;
aTempList.detach();
aTimeStamp=QDateTime::currentMSecsSinceEpoch();
aTempList.clear();
setItemAndScroll(((CopyableTable*)ui->testsTabWidget->widget(4)), lastRow, 2, QString::number(aTimeStamp-aStart));
//------------------------------------------------------------
srand(mRandomSeed);
aStart=QDateTime::currentMSecsSinceEpoch();
while (aQtList.length()>0)
{
aQtList.removeAt(rand() % aQtList.length());
}
aTimeStamp=QDateTime::currentMSecsSinceEpoch();
setItemAndScroll(((CopyableTable*)ui->testsTabWidget->widget(5)), lastRow, 2, QString::number((aTimeStamp-aStart)*100));
}
//============================================================
// OPTIMAL LIST
//============================================================
{
OptimalList<T> aMyList;
aMemoryUsed=memoryUsage();
aStart=QDateTime::currentMSecsSinceEpoch();
for (int i=0; i<aElemCount; ++i)
{
aMyList.append(aValue);
}
aTimeStamp=QDateTime::currentMSecsSinceEpoch();
aMemoryUsed=memoryDiff(aMemoryUsed);
setAndCalculate(((CopyableTable*)ui->testsTabWidget->widget(0)), lastRow, QString::number(aMemoryUsed));
setAndCalculate(((CopyableTable*)ui->testsTabWidget->widget(1)), lastRow, QString::number(aTimeStamp-aStart));
//------------------------------------------------------------
aStart=QDateTime::currentMSecsSinceEpoch();
aMyList.clear();
aTimeStamp=QDateTime::currentMSecsSinceEpoch();
setAndCalculate(((CopyableTable*)ui->testsTabWidget->widget(2)), lastRow, QString::number(aTimeStamp-aStart));
//------------------------------------------------------------
srand(mRandomSeed);
aStart=QDateTime::currentMSecsSinceEpoch();
for (int i=0; i<aElemCount/100; ++i)
{
aMyList.insert(rand() % (aMyList.length()+1), aValue);
}
aTimeStamp=QDateTime::currentMSecsSinceEpoch();
setAndCalculate(((CopyableTable*)ui->testsTabWidget->widget(3)), lastRow, QString::number((aTimeStamp-aStart)*100));
//------------------------------------------------------------
aStart=QDateTime::currentMSecsSinceEpoch();
OptimalList<T> aTempList2=aMyList;
aTimeStamp=QDateTime::currentMSecsSinceEpoch();
aTempList2.clear();
setAndCalculate(((CopyableTable*)ui->testsTabWidget->widget(4)), lastRow, QString::number(aTimeStamp-aStart));
//------------------------------------------------------------
srand(mRandomSeed);
aStart=QDateTime::currentMSecsSinceEpoch();
while (aMyList.length()>0)
{
aMyList.removeAt(rand() % aMyList.length());
}
aTimeStamp=QDateTime::currentMSecsSinceEpoch();
setAndCalculate(((CopyableTable*)ui->testsTabWidget->widget(5)), lastRow, QString::number((aTimeStamp-aStart)*100));
}
}
void ProcessServer::updateDemon()
{
dword lastRegister = 0;
dword lastTimeSync = 0;
dword pingTime = 0;
while ( running() && !m_bShutdownCompleted )
{
Thread::sleep( 1000 );
if (! m_MetaClient.loggedIn() )
{
LOG_STATUS( "ProcessServer", "Establishing connection to the metaserver" );
// attempt to connect
if ( m_MetaClient.open( m_Context.metaAddress, m_Context.metaPort ) > 0 )
{
if ( m_MetaClient.login( m_Context.uid, m_Context.pw ) < 0 )
{
LOG_STATUS( "ProcessServer", "Failed to login to the metaserver" );
m_MetaClient.close(); // failed to login
}
else
{
LOG_STATUS( "ProcessServer", "Connected to the metaserver" );
// select the correct game
m_MetaClient.selectGame( m_Context.gameId );
}
}
}
m_MetaClient.update();
if ( m_MetaClient.loggedIn() )
{
if ( lastRegister < (Time::seconds() - REGISTER_TIME) )
{
AutoLock lock( &m_Lock );
MetaClient::Server server;
server.gameId = m_Context.gameId;
server.type = MetaClient::PROCESS_SERVER;
server.flags = 0;
server.name = m_Context.name;
server.shortDescription.format( "CPU: %d%%, MEM: %d%%", cpuUsage(), memoryUsage() );
server.description = server.shortDescription + "\n\n";
for(int i=0;i<m_ProcessList.size();i++)
{
Process & proc = m_ProcessList[ i ];
if ( (proc.flags & ProcessClient::PF_RUNNING) == 0 )
continue;
server.description += CharString().format( "%s\n", proc.name.cstr() );
}
server.address = m_Context.address;
server.port = m_Context.port;
server.maxClients = m_Context.maxClients;
server.clients = clientCount();
server.data = CharString().format("processGroup=%u;networkGroup=%u;processCount=%u;cpuUsage=%d;memoryUsage=%d",
m_Context.processGroup, m_Context.networkGroup, m_ProcessList.size(), cpuUsage(), memoryUsage() );
lock.release();
if ( m_MetaClient.registerServer( server ) < 0 )
lastRegister = (Time::seconds() - REGISTER_TIME) + 30; // failed, try again in 30 seconds
else
lastRegister = Time::seconds();
}
if ( m_Context.syncClock && lastTimeSync < (Time::seconds() - SYNC_CLOCKS_TIME) )
{
// get the current time from the metaserver
dword currentTime = m_MetaClient.getTime();
if ( currentTime > 0 )
{
LOG_STATUS( "ProcessServer", "Syncronizing system time to %s", Time::format( currentTime, "%c" ).cstr() );
if (! Time::setTime( currentTime ) )
LOG_STATUS( "ProcessServer", "Failed to set the system time!" );
lastTimeSync = Time::seconds();
}
else
{
LOG_STATUS( "ProcessServer", "Failed to syncronize system time from MetaServer!" );
lastTimeSync = (Time::seconds() - SYNC_CLOCKS_TIME) + 300; // try again in another 5 min
}
}
}
AutoLock lock( &m_Lock );
bool shutdownComplete = true; // have all child processes stopped
// check for log updates
for(int i=0;i<m_ActiveLog.size();i++)
{
dword logId = m_ActiveLog[ i ];
FileDisk & file = m_LogFile[ logId ];
try {
if ( file.position() > file.size() )
file.setPosition( 0 ); // file has been rotated... reset read position
dword read = file.size() - file.position();
if ( read > 0 )
{
if ( read > MAX_LOG_SIZE )
{
file.setPosition( file.size() - MAX_LOG_SIZE );
read = MAX_LOG_SIZE;
}
char * pLines = new char[ read + 1 ];
pLines[ read ] = 0;
file.read( pLines, read );
send( m_LogClient[ logId ], ProcessClient::CLIENT_RECV_LOG_UPDATE ) << logId << CharString(pLines);
delete [] pLines;
}
}
catch( FileDisk::FileError )
{
LOG_STATUS( "ProcessServer", CharString().format("Log Read Error, logFile = %s, logId = %u", file.fileName(), logId) );
// close the previously open file
file.close();
// attempt to reopen the file
file.open( file.fileName() );
}
}
// check process list
for(int i=0;i<m_ProcessList.size();i++)
{
Process & proc = m_ProcessList[ i ];
if ( m_ProcessInfo.find( proc.processId ).valid() )
{
ProcessInfo & info = m_ProcessInfo[ proc.processId ];
proc.flags |= ProcessClient::PF_RUNNING;
if ( (proc.flags & ProcessClient::PF_DISABLED) == 0 )
{
// make sure the process is still running
if (! ::Process::active( info.m_pHandle ) )
{
proc.flags &= ~ProcessClient::PF_RUNNING;
if ( ! m_Shutdown )
{
if ( info.m_nRestartTime != 0 && Time::seconds() < info.m_nRestartTime )
continue; // not time to restart yet, continue onto the next process..
// process has exited, increment the number of restarts, then calculate the next restart
// time increasing the wait time each time the process exits
info.m_nRestarts += 1;
info.m_nRestartTime = Time::seconds() + (60 * (info.m_nRestarts * info.m_nRestarts) );
int exitCode = ::Process::exitCode( info.m_pHandle );
::Process::close( info.m_pHandle );
CharString message;
message.format( "Process %u exit, name = %s, exec = %s, arg = %s, exitCode = %d, restarts = %u",
proc.processId, proc.name.cstr(), proc.executable.cstr(), proc.arguments.cstr(), exitCode, info.m_nRestarts );
LOG_STATUS( "ProcessServer", message );
// send report if exit code is negative
if ( exitCode < 0 )
m_MetaClient.sendChat( 0, CharString().format("/report %s", message.cstr()) );
// restart the process..
Path exePath( proc.executable );
void * pStart = ::Process::start( CharString().format("%s %s", exePath.file().cstr(), proc.arguments.cstr()),
exePath.directory() );
if ( pStart == NULL )
{
LOG_STATUS( "ProcessServer", "Process %u failed to restart", proc.processId );
m_ProcessInfo.remove( proc.processId );
proc.flags |= ProcessClient::PF_DISABLED;
}
else
{
LOG_STATUS( "ProcessServer", "Process %u restarted", proc.processId );
info.m_pHandle = pStart;
}
}
else
{
int exitCode = ::Process::exitCode( info.m_pHandle );
LOG_STATUS( "ProcessServer", "Process Stopped, name = %s, exitCode = %d", proc.name.cstr(), exitCode );
::Process::close( info.m_pHandle );
m_ProcessInfo.remove( proc.processId );
}
}
else if ( m_Shutdown )
{
shutdownComplete = false;
stopProcess( proc.processId );
}
else if ( info.m_nRestartTime != 0 && Time::seconds() > info.m_nRestartTime )
{
// process has been running long enough to clear the restart time.
info.m_nRestartTime = 0;
info.m_nRestarts = 0;
}
}
else
{
if (! ::Process::active( info.m_pHandle ) )
{
LOG_STATUS( "ProcessServer", "Process Stopped, name = %s", proc.name.cstr() );
::Process::close( info.m_pHandle );
m_ProcessInfo.remove( proc.processId );
}
else
stopProcess( proc.processId );
}
}
else
{
proc.flags &= ~ProcessClient::PF_RUNNING;
if ( (proc.flags & ProcessClient::PF_DISABLED) == 0 && !m_Shutdown )
{
LOG_STATUS( "ProcessServer", "Starting Process %u, name = %s, exec = %s, arg = %s",
proc.processId, proc.name.cstr(), proc.executable.cstr(), proc.arguments.cstr() );
Path exePath( proc.executable );
void * pStart = ::Process::start( CharString().format("%s %s", exePath.file().cstr(), proc.arguments.cstr()),
exePath.directory() );
if ( pStart == NULL )
{
proc.flags |= ProcessClient::PF_DISABLED;
LOG_STATUS( "ProcessServer", "Process %u Failed to Start, name = %s, exec = %s",
proc.processId, proc.name.cstr(), proc.executable.cstr() );
}
else
m_ProcessInfo[ proc.processId ].m_pHandle = pStart;
}
}
}
pingTime++;
if ( pingTime > 15 )
{
// ping all clients
for(int i=0;i<clientCount();i++)
send( client(i), ProcessClient::PING );
pingTime = 0;
}
// check for shutdown
if ( m_Shutdown && shutdownComplete )
{
m_bShutdownCompleted = true;
if ( m_RebootOnShutdown )
rebootMachine();
}
lock.release();
}
}
void ProcessServer::onReceive( dword client, byte message, const InStream & input )
{
//LOG_STATUS( "ProcessServer","onReceive, client = %u (%s), message = 0x%x", client, clientAddress(client), message );
switch( message )
{
case ProcessClient::SERVER_LOGIN:
{
dword job;
input >> job;
CharString uid;
input >> uid;
CharString md5;
input >> md5;
bool result = false;
MetaClient::Profile profile;
if ( m_MetaClient.loginByProxy( uid, md5, profile ) > 0 )
{
LOG_STATUS( "ProcessServer", CharString().format("Login %s, client %u (%s)", profile.name.cstr(), client, clientAddress(client)) );
result = (profile.flags & (MetaClient::ADMINISTRATOR|MetaClient::SERVER)) != 0;
}
else
LOG_STATUS( "ProcessServer", CharString().format("Login failed, client %u (%s)", client, clientAddress(client)) );
AutoLock lock( &m_Lock );
m_ClientValid[ client ] = result;
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << result;
}
break;
case ProcessClient::SERVER_SESSION_LOGIN:
{
dword job;
input >> job;
dword sessionId;
input >> sessionId;
bool result = false;
MetaClient::Profile profile;
if ( m_MetaClient.loginByProxy( sessionId, profile ) > 0 )
{
LOG_STATUS( "ProcessServer", CharString().format("Login %s, client %u (%s)", profile.name.cstr(), client, clientAddress(client)) );
result = (profile.flags & MetaClient::ADMINISTRATOR) != 0;
}
else
LOG_STATUS( "ProcessServer", CharString().format("Login failed, client %u (%s)", client, clientAddress(client)) );
AutoLock lock( &m_Lock );
m_ClientValid[ client ] = result;
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << result;
}
break;
case ProcessClient::SERVER_SEND_PROCESS_LIST:
if ( validateClient( client ) )
{
dword job;
input >> job;
// send process list to the server
AutoLock lock( &m_Lock );
send( client, ProcessClient::CLIENT_RECV_PROCESS_LIST ) << job << m_ProcessList;
}
break;
case ProcessClient::SERVER_SEND_CONFIG:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
CharString config;
CharString configFile;
if ( processId != 0 )
{
Process proc;
if ( findProcess( processId, proc ) )
configFile = proc.config;
}
else
configFile = m_Context.config;
LOG_STATUS( "ProcessServer", CharString().format("Send Config, client %u (%s), configFile = %s",
client, clientAddress(client), configFile.cstr()) );
// attempt to load the configuration file
char * pConfig = FileDisk::loadTextFile( configFile );
if ( pConfig != NULL )
{
config = pConfig;
delete [] pConfig;
}
send( client, ProcessClient::CLIENT_RECV_CONFIG ) << job << config;
}
break;
case ProcessClient::SERVER_RECV_CONFIG:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
CharString config;
input >> config;
bool jobDone = false;
CharString configFile;
if ( processId != 0 )
{
Process proc;
if ( findProcess( processId, proc ) )
configFile = proc.config;
}
else
configFile = m_Context.config;
LOG_STATUS( "ProcessServer", "Recv Config, client %u (%s), configFile = %s",
client, clientAddress(client), configFile.cstr() );
// save the new file
jobDone = FileDisk::saveTextFile( configFile, CharString( config ) );
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_SEND_LOG:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
CharString log;
CharString logFile;
if ( processId != 0 )
{
// send log of one of our processes
Process proc;
if ( findProcess( processId, proc ) )
logFile = proc.log;
}
else
logFile = m_Context.logFile;
FileDisk file;
if ( file.open( logFile ) )
{
dword size = file.size();
if ( size > MAX_LOG_SIZE )
{
file.setPosition( size - MAX_LOG_SIZE );
size = MAX_LOG_SIZE;
}
char * pLog = new char[ size + 1];
pLog[ size ] = 0;
file.read( pLog, size );
file.close();
// save to string
log = pLog;
// release allocated memory
delete [] pLog;
}
else
log = "Failed to open log file!";
send( client, ProcessClient::CLIENT_RECV_LOG ) << job << log;
}
break;
case ProcessClient::SERVER_ADD_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
Process proc;
input >> proc;
AutoLock lock( &m_Lock );
proc.processId = m_NextProcessId++;
m_ProcessList.push( proc );
LOG_STATUS( "ProcessServer", "Add Process, client = %u (%s), processId = %u, name = %s, exec = %s",
client, clientAddress(client), proc.processId, proc.name.cstr(), proc.executable.cstr() );
saveProcessList();
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << true;
}
break;
case ProcessClient::SERVER_SET_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
Process proc;
input >> proc;
bool jobDone = false;
AutoLock lock( &m_Lock );
int pi = findProcess( proc.processId );
if ( pi >= 0 )
{
m_ProcessList[pi] = proc;
jobDone = true;
LOG_STATUS( "ProcessServer", "Set Process, client = %u (%s), processId = %u, name = %s, exec = %s",
client, clientAddress(client), proc.processId, proc.name.cstr(), proc.executable.cstr() );
saveProcessList();
}
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_DEL_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
bool jobDone = false;
AutoLock lock( &m_Lock );
int pi = findProcess( processId );
if ( pi >= 0 )
{
LOG_STATUS( "ProcessServer", "Delete Process, name = %s, client = %u (%s), processId = %u",
m_ProcessList[pi].name.cstr(), client, clientAddress(client), processId );
// stop the actual process if any
if ( m_ProcessInfo.find( processId ).valid() )
{
::Process::stop( m_ProcessInfo[ processId ].m_pHandle );
m_ProcessInfo.remove( processId );
}
// remove from the list
m_ProcessList.remove( pi );
jobDone = true;
saveProcessList();
}
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_STOP_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
bool jobDone = false;
AutoLock lock( &m_Lock );
int pi = findProcess( processId );
if ( pi >= 0 )
{
m_ProcessList[ pi ].flags |= ProcessClient::PF_DISABLED;
jobDone = true;
LOG_STATUS( "ProcessServer", "Stop Process, name = %s, client = %u (%s), processId = %u",
m_ProcessList[pi].name.cstr(), client, clientAddress(client), processId );
saveProcessList();
}
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_START_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
bool jobDone = false;
AutoLock lock( &m_Lock );
int pi = findProcess( processId );
if ( pi >= 0 )
{
m_ProcessList[ pi ].flags &= ~ProcessClient::PF_DISABLED;
jobDone = true;
LOG_STATUS( "ProcessServer", "Start Process, name = %s, client = %u (%s), processId = %u",
m_ProcessList[pi].name.cstr(), client, clientAddress(client), processId );
saveProcessList();
}
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_RESTART_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
bool jobDone = false;
AutoLock lock( &m_Lock );
Process proc;
if ( findProcess( processId, proc ) )
{
if ( m_ProcessInfo.find( processId ).valid() )
{
jobDone = stopProcess( processId );
LOG_STATUS( "ProcessServer", "Restart Process, name = %s, client = %u (%s), processId = %u,",
proc.name.cstr(), client, clientAddress(client), processId );
}
}
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_SEND_STATUS:
if ( validateClient( client ) )
{
dword job;
input >> job;
AutoLock lock( &m_Lock );
ProcessClient::Status status;
status.processGroup = m_Context.processGroup;
status.networkGroup = m_Context.networkGroup;
status.cpuUsage = cpuUsage();
status.memoryUsage = memoryUsage();
status.processCount = 0;
for(int i=0;i<m_ProcessList.size();i++)
if ( (m_ProcessList[i].flags & ProcessClient::PF_RUNNING) != 0 )
status.processCount++;
send( client, ProcessClient::CLIENT_RECV_STATUS ) << job << status;
}
break;
case ProcessClient::SERVER_STOP_ALL:
if ( validateClient( client ) )
{
dword job;
input >> job;
bool jobDone = false;
AutoLock lock( &m_Lock );
for(int i=0;i<m_ProcessList.size();i++)
m_ProcessList[i].flags |= ProcessClient::PF_DISABLED;
saveProcessList();
jobDone = true;
LOG_STATUS( "ProcessServer", CharString().format("Stop All, client = %u (%s)", client, clientAddress(client)) );
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_START_ALL:
if ( validateClient( client ) )
{
dword job;
input >> job;
bool jobDone = false;
AutoLock lock( &m_Lock );
for(int i=0;i<m_ProcessList.size();i++)
m_ProcessList[i].flags &= ~ProcessClient::PF_DISABLED;
saveProcessList();
jobDone = true;
LOG_STATUS( "ProcessServer", CharString().format("Start All, client = %u (%s)", client, clientAddress(client)) );
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_RESTART_ALL:
if ( validateClient( client ) )
{
dword job;
input >> job;
bool jobDone = false;
AutoLock lock( &m_Lock );
for(int i=0;i<m_ProcessList.size();i++)
stopProcess( m_ProcessList[i].processId );
jobDone = true;
LOG_STATUS( "ProcessServer", CharString().format("Restart All, client = %u (%s)", client, clientAddress(client)) );
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_REBOOT:
if ( validateClient( client ) )
{
dword job;
input >> job;
bool jobDone = reboot();
if ( jobDone )
LOG_STATUS( "ProcessServer", CharString().format("Server Rebooting, client = %u (%s)", client, clientAddress(client)) );
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_EXIT:
if ( validateClient( client ) )
{
dword job;
input >> job;
// signal all running processes to stop
bool jobDone = shutdown();
if ( jobDone )
LOG_STATUS( "ProcessServer", CharString().format("Server Exiting, client = %u (%s)", client, clientAddress(client)) );
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_TERMINATE_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
bool jobDone = false;
AutoLock lock( &m_Lock );
Process proc;
if ( findProcess( processId, proc ) )
{
// just terminate the process
if ( m_ProcessInfo.find( processId ).valid() )
{
::Process::stop( m_ProcessInfo[ processId ].m_pHandle );
jobDone = true;
LOG_STATUS( "ProcessServer", "Terminated Process, name = %s, client = %u (%s), processId = %u,",
proc.name.cstr(), client, clientAddress(client), processId );
}
}
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_OPEN_LOG:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
CharString logFile;
if ( processId != 0 )
{
// send log of one of our processes
Process proc;
if ( findProcess( processId, proc ) )
logFile = proc.log;
}
else
logFile = m_Context.logFile;
dword logId = m_NextLogId++;
AutoLock lock( &m_Lock );
FileDisk & file = m_LogFile[ logId ];
if ( file.open( logFile ) )
{
LOG_STATUS( "ProcessServer", "Open Log, logFile = %s, logId = %u, clientId = %u", logFile.cstr(), logId, client );
m_ActiveLog.push( logId );
m_LogClient[ logId ] = client;
m_ClientLog[ client ].push( logId );
}
else
{
LOG_STATUS( "ProcessServer", "Open Log Failed, logFile = %s, clientId = %u", logFile.cstr(), client );
// failed to open file
m_LogFile.remove( logId );
// set id to 0 for error
logId = 0;
}
send( client, ProcessClient::CLIENT_RECV_LOG_ID ) << job << logId;
}
break;
case ProcessClient::SERVER_CLOSE_LOG:
if ( validateClient( client ) )
{
dword logId;
input >> logId;
AutoLock lock( &m_Lock );
LOG_STATUS( "ProcessServer", CharString().format("Close Log, logId = %u, client = %u", logId, client) );
m_ActiveLog.removeSearch( logId );
m_LogFile.remove( logId );
m_LogClient.remove( logId );
m_ClientLog[ client ].removeSearch( logId );
}
break;
case ProcessClient::SERVER_SEARCH_LOGS:
if ( validateClient( client ) )
{
dword job;
input >> job;
ProcessClient::SearchLogRequest req;
input >> req;
LOG_STATUS( "ProcessServer", CharString().format("Search Log, clientId = %u", client) );
CharString result;
if( req.filemask.find('/') >= 0 || req.filemask.find('\\') >= 0 )
{ // this should never happen, unless the user has a hacked client
LOG_STATUS( "ProcessServer", CharString().format("Search Log, invalid filemask received from clientId = %u", client) );
result = "Failed";
}
else
{
result = searchLogFiles( req.filemask, req.searchString, req.isRegExp, req.searchLevel, req.resolveClientId );
}
send( client, ProcessClient::CLIENT_RECV_SEARCHRESULT ) << job << result;
}
break;
case ProcessClient::PING:
send( client, ProcessClient::PONG );
break;
case ProcessClient::PONG:
break;
default:
{
LOG_ERROR( "ProcessServer", CharString().format("Bad Message, client = %u (%s), message = %d", client, clientAddress(client), message) );
removeClient( client );
}
break;
}
}
Resource::~Resource()
{
if (m_pResourceCache != nullptr) {
m_pResourceCache->decrementAllocation(memoryUsage());
}
}
