bool afqt::recvMessage( QTcpSocket * qSocket, af::Msg * msg)
{
char * buffer = msg->buffer();
int bytes = readdata( qSocket, buffer, af::Msg::SizeHeader, af::Msg::SizeBuffer);
if( bytes < af::Msg::SizeHeader)
{
AFERROR("qtcom::recvMessage: read message header.\n");
return false;
}
msg->readHeader( bytes);
int msgtype = msg->type();
int datalen = msg->int32();
if( msgtype >= af::Msg::TDATA)
{
buffer = msg->buffer(); // buffer may be changed to fit new size
int readlen = datalen - bytes + af::Msg::SizeHeader;
if( readlen > 0)
{
bytes = readdata( qSocket, buffer+bytes, readlen, readlen);
if( bytes < readlen)
{
AFERROR("qtcom::recvMessage: read message data.\n");
msg->setInvalid();
return false;
}
}
}
return true;
}
void Dialog::caseMessage( af::Msg * msg)
{
//AFINFO("void Dialog::caseMessage( Msg msg)\n");
if( msg == NULL)
{
AFERROR("Dialog::caseMessage: msg == NULL\n");
return;
}
#ifdef AFOUTPUT
msg->stdOut();
#endif
switch( msg->type())
{
case af::Msg::TClientExitRequest:
case af::Msg::TVersionMismatch:
case af::Msg::TMagicMismatch:
{
emit stop();
break;
}
case af::Msg::TTalkId:
{
if( talk->getId())
{
if( msg->int32() != talk->getId()) connectionLost();
}
else
{
if( msg->int32())
{
talk->setId( msg->int32());
qthreadClientUp->setUpMsg( new af::Msg( af::Msg::TTalkUpdateId, talk->getId(), true));
}
else connectionLost();
}
break;
}
case af::Msg::TTalksList:
{
upOnline( *msg);
break;
}
case af::Msg::TTalkData:
{
af::MCTalkmessage amsg( msg);
std::string user, text;
amsg.getUser( user);
amsg.getText( text);
appendMessage( afqt::stoq( user), afqt::stoq( text));
break;
}
default:
AFERROR("Dialog::caseMessage Unknown message recieved.\n");
msg->stdOut();
}
delete msg;
}
MonitorWindow::MonitorWindow():
connected(false),
usersSelectionCount(0),
initialized(false )
{
qServer = new afqt::QServer( this);
qthreadClientUp = new afqt::QThreadClientUp( this, false, af::Environment::getMonitorUpdatePeriod(), af::Environment::getMonitorConnectRetries());
qthreadClientSend = new afqt::QThreadClientSend( this);
if( qServer->isInitialized() == false )
{
AFERROR("MonitorWindow::MonitorWindow: Server initialization failed.\n");
return;
}
username = afqt::stoq( af::Environment::getUserName());
hostname = afqt::stoq( af::Environment::getHostName());
setWindowTitle("MonitorWindow::" + username + "@" + hostname + ":(connecting...)");
QMenu * viewMenu = menuBar()->addMenu("View");
QDockWidget * dock;
dock = new QDockWidget( "Renders", this);
rendersList = new ListRenders( dock);
dock->setWidget( rendersList);
addDockWidget( Qt::LeftDockWidgetArea, dock);
viewMenu->addAction( dock->toggleViewAction());
dock = new QDockWidget( "Users", this);
usersList = new ListUsers( dock);
dock->setWidget( usersList);
addDockWidget( Qt::RightDockWidgetArea, dock);
viewMenu->addAction( dock->toggleViewAction());
dock = new QDockWidget( "Jobs", this);
jobsList = new ListJobs( dock);
dock->setWidget( jobsList);
addDockWidget( Qt::RightDockWidgetArea, dock);
viewMenu->addAction( dock->toggleViewAction());
nodesList[ MTRenders ] = rendersList;
nodesList[ MTUsers ] = usersList;
nodesList[ MTJobs ] = jobsList;
connect( usersList, SIGNAL( itemSelectionChanged()), this, SLOT( usersSelectionChanged()));
connect( qServer, SIGNAL( newMsg( af::Msg*)), this, SLOT( caseMessage( af::Msg*)));
connect( qthreadClientUp, SIGNAL( newMsg( af::Msg*)), this, SLOT( caseMessage( af::Msg*)));
connect( qthreadClientSend, SIGNAL( newMsg( af::Msg*)), this, SLOT( caseMessage( af::Msg*)));
connect( qthreadClientUp, SIGNAL( connectionLost() ), this, SLOT( connectionLost()));
connect( qthreadClientSend, SIGNAL( connectionLost() ), this, SLOT( connectionLost()));
monitor = new MonitorHost();
initialized = true;
monitor->stdOut();
sendRegister();
}
bool afqt::recvMessage( QTcpSocket * qSocket, af::Msg * msg)
{
char * buffer = msg->buffer();
int bytes = readdata( qSocket, buffer, af::Msg::SizeHeader, af::Msg::SizeBuffer);
if( bytes < af::Msg::SizeHeader)
{
AFERROR("qtcom::recvMessage: read message header.\n");
return false;
}
// msg->readHeader( bytes);
// Header offset is variable on not binary header (for example HTTP)
int header_offset = af::processHeader( msg, bytes);
if( header_offset < 0)
return false;
if( msg->type() >= af::Msg::TDATA)
{
buffer = msg->buffer(); // buffer may be changed to fit new size
bytes -= header_offset;
// int readlen = msg->dataLen() - bytes + af::Msg::SizeHeader;
int readlen = msg->dataLen() - bytes;
if( readlen > 0)
{
//bytes = readdata( qSocket, buffer+bytes, readlen, readlen);
bytes = readdata( qSocket, buffer + af::Msg::SizeHeader + bytes, readlen, readlen);
//bytes = ::readdata( desc, buffer + af::Msg::SizeHeader + bytes, readlen, readlen);
if( bytes < readlen)
{
AFERROR("qtcom::recvMessage: read message data.\n");
msg->setInvalid();
return false;
}
}
}
return true;
}
Dialog::Dialog():
connected(false),
init(false )
{
qServer = new afqt::QServer( this);
qthreadClientUp = new afqt::QThreadClientUp( this, false, af::Environment::getTalkUpdatePeriod(), af::Environment::getTalkConnectRetries());
qthreadClientSend = new afqt::QThreadClientSend( this);
if( qServer->isInitialized() == false )
{
AFERROR("Dialog::Dialog: Server initialization failed.\n");
return;
}
username = af::Environment::getUserName();
hostname = af::Environment::getHostName();
setWindowTitle((std::string("Talk::") + username + "@" + hostname + ":(connecting...)").c_str());
editor = new Editor(this);
textView = new TextView( this, afqt::stoq( username));
usersList = new UsersList( this, afqt::stoq( username));
QHBoxLayout *hlayout = new QHBoxLayout( this);
QVBoxLayout *vlayout = new QVBoxLayout();
hlayout->addLayout( vlayout);
hlayout->addWidget( usersList);
vlayout->addWidget( textView);
vlayout->addWidget( editor);
connect( qServer, SIGNAL( newMsg( af::Msg*)), this, SLOT( caseMessage( af::Msg*)));
connect( qthreadClientUp, SIGNAL( newMsg( af::Msg*)), this, SLOT( caseMessage( af::Msg*)));
connect( qthreadClientUp, SIGNAL( connectionLost() ), this, SLOT( connectionLost()));
connect( editor, SIGNAL( sendMessage()), this, SLOT( sendMessage()));
connect( textView, SIGNAL( activated()), this, SLOT( activated()));
connect( usersList, SIGNAL( activated()), this, SLOT( activated()));
connect( editor, SIGNAL( activated()), this, SLOT( activated()));
tray = new Tray( this, QString::fromUtf8( username.c_str()));
connect( tray, SIGNAL( hideRaiseDialog()), this, SLOT( hideRaiseDialog()));
talk = new TalkHost();
init = true;
talk->stdOut();
sendRegister();
}
void MonitorWindow::caseMessage( af::Msg *msg)
{
//AFINFO("void MonitorWindow::caseMessage( Msg msg)\n");
if( msg == NULL)
{
AFERROR("MonitorWindow::caseMessage: msg == NULL\n");
return;
}
#ifdef AFOUTPUT
msg->stdOut();
#endif
switch( msg->type())
{
case af::Msg::TClientExitRequest:
case af::Msg::TVersionMismatch:
case af::Msg::TMagicMismatch:
{
emit stop();
break;
}
case af::Msg::TMonitorId:
{
if( monitor->getId() != 0 )
{
if( msg->int32() != monitor->getId()) connectionLost();
}
else
{
if( msg->int32() == 0)
{
connectionLost();
}
else
{
monitor->setId( msg->int32());
connectionEstablished();
af::Msg * msg = new af::Msg( af::Msg::TMonitorUpdateId, monitor->getId(), true);
qthreadClientUp->setUpMsg( msg);
}
}
break;
}
default:
for( int t = 0; t < MTLast; t++) if( nodesList[t]->caseMessage( msg)) break;
}
delete msg;
}
void Task::v_start( af::TaskExec * taskexec, int * runningtaskscounter, RenderAf * render, MonitorContainer * monitoring)
{
if( m_block->m_data->isMultiHost())
{
if( m_run )
((TaskRunMulti*)(m_run))->addHost( taskexec, render, monitoring);
else
m_run = new TaskRunMulti( this, taskexec, m_progress, m_block, render, monitoring, runningtaskscounter);
return;
}
if( m_run)
{
AFERROR("Task is already running.")
delete taskexec;
return;
}
m_run = new TaskRun( this, taskexec, m_progress, m_block, render, monitoring, runningtaskscounter);
}
int AfList::add( AfNodeSrv *node)
{
// m_rw_lock.WriteLock();
int index = -1;
std::list<AfNodeSrv*>::iterator it = std::find( nodes_list.begin(), nodes_list.begin(), node);
if( *it == node )
{
AFERROR("AfList::add: node already exists.\n");
return index;
}
else
{
if( nodes_list.size() != 0 )
{
std::list<AfNodeSrv*>::iterator it = nodes_list.begin();
std::list<AfNodeSrv*>::iterator end_it = nodes_list.end();
bool lessPriorityFound = false;
while( it != end_it)
{
index++;
if( **it >= *node ) { it++; continue;}
nodes_list.insert( it, node);
lessPriorityFound = true;
break;
}
if( lessPriorityFound == false )
nodes_list.push_back( node);
}
else
nodes_list.push_back( node);
index++;
node->m_lists.push_back( this);
}
return index;
}
AfContainerLock::AfContainerLock( AfContainer* afcontainer, LockType locktype):
container(afcontainer),
type(locktype)
{
switch( type )
{
case READLOCK:
{
container->ReadLock();
break;
}
case WRITELOCK:
{
container->WriteLock();
break;
}
default:
AFERROR("AfContainerLock::AfContainerLock: invalid lock type.");
}
}
const QHostAddress afqt::toQAddress( const af::Address & address)
{
QHostAddress qaddr;
switch( address.getFamily())
{
case af::Address::IPv4:
{
uint32_t ipv4;
memcpy( &ipv4, address.getAddrData(), 4);
qaddr.setAddress( htonl(ipv4));
break;
}
case af::Address::IPv6:
qaddr.setAddress( (quint8*)(address.getAddrData()));
break;
default:
AFERROR("Address::setQAddress: Unknown address family.\n");
}
return qaddr;
}
int AfList::add( AfNodeSolve *node)
{
int index = -1;
for( std::list<AfNodeSolve*>::const_iterator it = m_nodes_list.begin(); it != m_nodes_list.end(); it++)
if( *it == node )
{
AFERROR("AfList::add: node already exists.");
return index;
}
if( m_nodes_list.size() != 0 )
{
std::list<AfNodeSolve*>::iterator it = m_nodes_list.begin();
std::list<AfNodeSolve*>::iterator end_it = m_nodes_list.end();
bool lessPriorityFound = false;
while( it != end_it)
{
index++;
if((*it)->priority() >= node->priority())
{
it++;
continue;
}
m_nodes_list.insert( it, node);
lessPriorityFound = true;
break;
}
if( lessPriorityFound == false )
m_nodes_list.push_back( node);
}
else
m_nodes_list.push_back( node);
index++;
node->m_lists.push_back( this);
return index;
}
void af::jsonActionStart( std::ostringstream & i_str, const std::string & i_type, const std::string & i_mask, const std::vector<int> & i_ids)
{
i_str << "{\"action\":{";
i_str << "\n\"user_name\":\"" << af::Environment::getUserName() << "\"";
i_str << ",\n\"host_name\":\"" << af::Environment::getHostName() << "\"";
i_str << ",\n\"type\":\"" << i_type << "\"";
if( i_mask.size())
i_str << ",\n\"mask\":\"" << i_mask << "\"";
else
{
i_str << ",\n\"ids\":[";
if( i_ids.size() == 0 )
{
AFERROR("af::jsonActionStart: And mask and ids are empty.")
}
for( int i = 0; i < i_ids.size(); i++)
{
if( i ) i_str << ",";
i_str << i_ids[i];
}
i_str << "]";
}
}
int afqt::readdata( QTcpSocket * qSocket, char* data, int len_min, int len_max)
{
AFINFA("qtcom::readdata: trying to recieve %d bytes.\n", len_min);
int bytes = 0;
while( bytes < len_min)
{
qSocket->waitForReadyRead( WAITFORREADYREAD);
int r = qSocket->read( data+bytes, len_max);
if( r < 0)
{
AFERRPE("qtcom::readdata::read");
return 0;
}
if( r == 0)
{
AFERROR("qtcom::readdata:: read 0 bytes.\n");
return 0;
}
bytes += r;
AFINFA("qtcom::readdata::read %d bytes.\n", r);
}
return bytes;
}
bool afqt::connect( const af::Address & address, QTcpSocket * qSocket)
{
if( qSocket->state() != QAbstractSocket::ConnectedState)
{
// QHostAddress addr;
// address->setQAddress( addr);
// qSocket->connectToHost( addr, address->getPortHBO());
qSocket->connectToHost( afqt::toQAddress( address), address.getPortHBO());
if( qSocket->waitForConnected( WAITFORCONNECTED) == false)
{
AFERROR("afqt::connect: Can't connect to address:")
printf(" %s", address.v_generateInfoString().c_str());
printf(" Q = %s", afqt::toQAddress( address).toString().toUtf8().data());
printf("\n");
return false;
}
}
else
{
AFERROR("afqt::connect: Socket seems to be already connected.\n")
}
return true;
}
void AfList::moveNodes( const std::vector<int32_t> & i_list, int i_type)
{
#ifdef AFOUTPUT
printf("AfList::moveNodes:\n");
#endif
//
// ensure in proper type
//
switch ( i_type)
{
case MoveUp: case MoveDown: case MoveTop: case MoveBottom: break;
default:
AFERRAR("AfList::moveNodes: Invalid type = %d\n", i_type);
return;
}
//
// return if no nodes ids to move
//
if( i_list.size() == 0)
{
AFERROR("AfList::moveNodes: Move nodes ids list is empty.\n");
return;
}
//
// creating move nodes list
//
std::list<AfNodeSrv*> move_list;
std::list<AfNodeSrv*>::iterator it_begin = nodes_list.begin();
std::list<AfNodeSrv*>::iterator it_end = nodes_list.end();
std::list<AfNodeSrv*>::iterator it = it_begin;
while( it != it_end)
{
for( unsigned n = 0; n < i_list.size(); n++)
{
if( (*it)->m_node->m_id == i_list[n] )
{
#ifdef AFOUTPUT
//printf("Found a node \"%s\"-%d\n", (*it)->getName().c_str(), (*it)->m_node->m_id);
printf("Found a node \"%s\"-%d\n", (*it)->m_node->m_name.c_str(), (*it)->m_node->m_id );
#endif
move_list.push_back( *it);
break;
}
}
it++;
}
//
// return if it os no nodes to move
//
if( move_list.size() == 0 )
{
AFERROR("AfList::moveNodes: Can't find nodes with such ids.\n");
return;
}
//
// moving nodes in move list
//
std::list<AfNodeSrv*>::iterator it_move_begin = move_list.begin();
std::list<AfNodeSrv*>::iterator it_move_end = move_list.end();
std::list<AfNodeSrv*>::iterator it_move;
if(( i_type == MoveDown) || ( i_type == MoveTop)) it_move = it_move_end;
else it_move = it_move_begin;
for(;;)
{
AfNodeSrv * node;
if(( i_type == MoveDown) || ( i_type == MoveTop))
{
if( it_move == it_move_begin ) break;
it_move--;
node = *it_move;
}
else
{
if( it_move == it_move_end ) break;
node = *it_move;
it_move++;
}
#ifdef AFOUTPUT
//printf("Processing node \"%s\"-%d\n", node->getName().c_str(), node->getId());
printf("Processing node \"%s\"-%d\n", node->m_node->m_name.c_str(), node->m_node->m_id );
#endif
std::list<AfNodeSrv*>::iterator it_insert = nodes_list.begin();
while( it_insert != it_end)
{
if((*it_insert) == node) break;
it_insert++;
}
if( it_insert == it_end)
{
AFERRAR("AfList::moveNodes: Lost node - \"%s\" - %d.\n", node->m_node->m_name.c_str(), node->m_node->m_id);
continue;
}
switch ( i_type)
{
case MoveUp:
{
#ifdef AFOUTPUT
printf("AfList::MoveUp:\n");
#endif
if( it_insert == it_begin)
{
#ifdef AFOUTPUT
printf("Node is already at top.\n");
#endif
continue;
}
it_insert--;
if( **it_insert != *node)
{
#ifdef AFOUTPUT
printf("Node above has another priority\n");
#endif
continue;
}
break;
}
case MoveDown:
{
#ifdef AFOUTPUT
printf("AfList::MoveDown:\n");
#endif
it_insert++;
if( it_insert == it_end)
{
#ifdef AFOUTPUT
printf("Node is already at bottom.\n");
#endif
continue;
}
if( **it_insert != *node )
{
#ifdef AFOUTPUT
printf("Node below has another priority\n");
#endif
continue;
}
it_insert++;
break;
}
case MoveTop:
{
#ifdef AFOUTPUT
printf("AfList::MoveTop:\n");
#endif
if( it_insert == it_begin)
{
#ifdef AFOUTPUT
printf("Node is already at top.\n");
#endif
continue;
}
for(;;)
{
it_insert--;
if( **it_insert != *node )
{
it_insert++;
break;
}
if( it_insert == it_begin) break;
}
break;
}
case MoveBottom:
{
it_insert++;
if( it_insert == it_end)
{
#ifdef AFOUTPUT
printf("Node is already at bottom.\n");
#endif
continue;
}
#ifdef AFOUTPUT
printf("AfList::MoveBottom:\n");
#endif
for(;;)
{
if( **it_insert != *node ) break;
it_insert++;
if( it_insert == it_end) break;
}
break;
}
}
if( it_insert == it_end)
{
#ifdef AFOUTPUT
printf("Pushing node back\n");
#endif
nodes_list.remove( node);
nodes_list.push_back( node);
continue;
}
AfNodeSrv * node_move = (*it_insert);
if( node_move == NULL)
{
AFERROR("AfList::moveNodes: node_move == NULL\n");
continue;
}
if( node_move == node )
{
#ifdef AFOUTPUT
printf("Node is already at it's position.\n");
#endif
continue;
}
#ifdef AFOUTPUT
//printf("Inserting at \"%s\"-%d\n", node_move->getName().c_str(), node_move->getId());
printf("Inserting at \"%s\"-%d\n", node_move->m_node->m_name.c_str(), node_move->m_node->m_id );
#endif
nodes_list.remove( node);
nodes_list.insert( it_insert, node);
}
}
int main(int argc, char *argv[])
{
Py_InitializeEx(0);
// Set signals handlers:
#ifdef WINNT
signal( SIGINT, sig_int);
signal( SIGTERM, sig_int);
signal( SIGSEGV, sig_int);
#else
struct sigaction actint;
bzero( &actint, sizeof(actint));
actint.sa_handler = sig_int;
sigaction( SIGINT, &actint, NULL);
sigaction( SIGTERM, &actint, NULL);
sigaction( SIGSEGV, &actint, NULL);
// SIGPIPE signal catch:
struct sigaction actpipe;
bzero( &actpipe, sizeof(actpipe));
actpipe.sa_handler = sig_pipe;
sigaction( SIGPIPE, &actpipe, NULL);
#endif
// Initialize environment and try to append python path:
af::Environment ENV( af::Environment::AppendPythonPath | af::Environment::SolveServerName, argc, argv);
if( !ENV.isValid())
{
AFERROR("main: Environment initialization failed.\n");
exit(1);
}
// Fill command arguments:
ENV.addUsage("-nimby", "Set initial state to 'nimby'.");
ENV.addUsage("-NIMBY", "Set initial state to 'NIMBY'.");
ENV.addUsage( std::string("-cmd") + " [command]", "Run command only, do not connect to server.");
ENV.addUsage("-res", "Check host resources only and quit.");
ENV.addUsage("-nor", "No output redirection.");
// Help mode, usage is alredy printed, exiting:
if( ENV.isHelpMode() )
return 0;
// Check resources and exit:
if( ENV.hasArgument("-res"))
{
af::Host host;
af::HostRes hostres;
GetResources( host, hostres, true);
af::sleep_msec(100);
GetResources( host, hostres);
printf("\n");
host.v_stdOut( true);
hostres.v_stdOut( true);
Py_Finalize();
return 0;
}
// Run command and exit
if( ENV.hasArgument("-cmd"))
{
std::string command;
ENV.getArgument("-cmd", command);
printf("Test command mode:\n%s\n", command.c_str());
pid_t m_pid;
int status;
pid_t pid = 0;
#ifdef WINNT
PROCESS_INFORMATION m_pinfo;
if( af::launchProgram( &m_pinfo, command, "", 0, 0, 0))
m_pid = m_pinfo.dwProcessId;
DWORD result = WaitForSingleObject( m_pinfo.hProcess, 0);
if ( result == WAIT_OBJECT_0)
{
GetExitCodeProcess( m_pinfo.hProcess, &result);
status = result;
pid = m_pid;
}
else if ( result == WAIT_FAILED )
{
pid = -1;
}
#else
m_pid = af::launchProgram( command, "", 0, 0, 0);
pid = waitpid( m_pid, &status, 0);
#endif
Py_Finalize();
return 0;
}
// Create temp directory, if it does not exist:
if( af::pathMakePath( ENV.getStoreFolder(), af::VerboseOn ) == false) return 1;
RenderHost * render = RenderHost::getInstance();
uint64_t cycle = 0;
while( AFRunning)
{
// Update machine resources:
if( cycle % af::Environment::getRenderUpResourcesPeriod() == 0)
render->getResources();
// Let tasks to do their work:
render->refreshTasks();
// Update server (send info and receive an answer):
af::Msg * answer = render->updateServer();
// React on a server answer:
msgCase( answer, *render);
// Close windows on windows:
#ifdef WINNT
render->windowsMustDie();
#endif
// Increment cycle:
cycle++;
#ifdef AFOUTPUT
printf("=============================================================\n\n");
#endif
// Sleep till the next heartbeat:
if( AFRunning )
af::sleep_sec( af::Environment::getRenderHeartbeatSec());
}
delete render;
Py_Finalize();
AF_LOG << "Exiting render.";
return 0;
}
void sig_pipe(int signum)
{
AFERROR("AFRender SIGPIPE");
}
/** This is a main run cycle thread entry point
**/
void threadRunCycle( void * i_args)
{
AFINFO("ThreadRun::run:")
ThreadArgs * a = (ThreadArgs*)i_args;
while( AFRunning)
{
#ifdef _DEBUG
printf("...................................\n");
#endif
/**/
{
//
// Lock containers:
//
AFINFO("ThreadRun::run: Locking containers...")
AfContainerLock jLock( a->jobs, AfContainerLock::WRITELOCK);
AfContainerLock lLock( a->renders, AfContainerLock::WRITELOCK);
AfContainerLock mlock( a->monitors, AfContainerLock::WRITELOCK);
AfContainerLock tlock( a->talks, AfContainerLock::WRITELOCK);
AfContainerLock ulock( a->users, AfContainerLock::WRITELOCK);
//
// Messages reaction:
//
AFINFO("ThreadRun::run: React on incoming messages:")
/*
Process all messages in our message queue. We do it without
waiting so that the job solving below can run just after.
NOTE: I think this should be a waiting operation in a different
thread. The job solving below should be put asleep using a
semaphore and woke up when something changes. We need to avoid
the Sleep() function below.
*/
af::Msg *message;
while( message = a->msgQueue->popMsg( af::AfQueue::e_no_wait) )
{
threadRunCycleCase( a, message );
}
//
// Refresh data:
//
AFINFO("ThreadRun::run: Refreshing data:")
a->talks ->refresh( NULL, a->monitors);
a->monitors ->refresh( NULL, a->monitors);
a->jobs ->refresh( a->renders, a->monitors);
a->renders ->refresh( a->jobs, a->monitors);
a->users ->refresh( NULL, a->monitors);
//
// Jobs sloving:
//
{
AFINFO("ThreadRun::run: Solving jobs:")
RenderContainerIt rendersIt( a->renders);
std::list<int> rIds;
{
// ask every ready render to produce a task
for( RenderAf *render = rendersIt.render(); render != NULL; rendersIt.next(), render = rendersIt.render())
{
if( render->isReady())
{
// store render Id if it produced a task
if( a->users->solve( render, a->monitors))
{
rIds.push_back( render->getId());
continue;
}
}
// Render not solved, needed to update render status
render->notSolved();
}
}
// cycle on renders, which produced a task
static const int renders_cycle_limit = 100000;
int renders_cycle = 0;
while( rIds.size())
{
renders_cycle++;
if( renders_cycle > renders_cycle_limit )
{
AFERROR("Renders solve cycles limit reached.");
break;
}
AFINFA("ThreadRun::run: Renders on cycle: %d", int(rIds.size()))
std::list<int>::iterator rIt = rIds.begin();
while( rIt != rIds.end())
{
RenderAf * render = rendersIt.getRender( *rIt);
if( render->isReady())
{
if( a->users->solve( render, a->monitors))
{
rIt++;
continue;
}
}
// delete render id from list if it can't produce a task
rIt = rIds.erase( rIt);
}
}
}
//
// Wake-On-Lan:
//
{
AFINFO("ThreadRun::run: Wake-On-Lan:")
RenderContainerIt rendersIt( a->renders);
{
for( RenderAf *render = rendersIt.render(); render != NULL; rendersIt.next(), render = rendersIt.render())
{
if( render->isWOLWakeAble())
{
if( a->users->solve( render, a->monitors))
{
render->wolWake( a->monitors, std::string("Automatic waking by a job."));
continue;
}
}
}
}
}
//
// Dispatch events to monitors:
//
AFINFO("ThreadRun::run: dispatching monitor events:")
a->monitors->dispatch();
//
// Free Containers:
//
AFINFO("ThreadRun::run: deleting zombies:")
a->talks ->freeZombies();
a->monitors ->freeZombies();
a->renders ->freeZombies();
a->jobs ->freeZombies();
a->users ->freeZombies();
}
//
// Sleeping
//
AFINFO("ThreadRun::run: sleeping...")
af::sleep_sec( 1);
}
}
int main(int argc, char *argv[])
{
Py_InitializeEx(0);
uint32_t env_flags = af::Environment::AppendPythonPath;
#ifdef WINNT
env_flags = env_flags | af::Environment::Verbose; // Verbose environment initialization
#else
//
// interrupt signal catch:
struct sigaction actint;
bzero( &actint, sizeof(actint));
actint.sa_handler = sig_int;
sigaction( SIGINT, &actint, NULL);
sigaction( SIGTERM, &actint, NULL);
sigaction( SIGSEGV, &actint, NULL);
// SIGPIPE signal catch:
struct sigaction actpipe;
bzero( &actpipe, sizeof(actpipe));
actpipe.sa_handler = sig_pipe;
sigaction( SIGPIPE, &actpipe, NULL);
#endif
af::Environment ENV( env_flags, argc, argv); // Silent environment initialization
if( !ENV.isValid())
{
AFERROR("main: Environment initialization failed.")
exit(1);
}
afqt::init( ENV.getWatchWaitForConnected(), ENV.getWatchWaitForReadyRead(), ENV.getWatchWaitForBytesWritten());
afqt::QEnvironment QENV( "watch");
if( !QENV.isValid())
{
AFERROR("main: QEnvironment initialization failed.")
exit(1);
}
QApplication app(argc, argv);
app.setWindowIcon( QIcon( afqt::stoq( ENV.getCGRULocation()) + "/icons/afwatch.png"));
#if QT_VERSION >= 0x050000
app.setStyle("fusion");
#else
app.setStyle("plastique");
#endif
MonitorHost monitor;
Dialog dialog;
if( !dialog.isInitialized())
{
AFERROR("main: Dialog initialization failed.")
exit(1);
}
Watch watch( &dialog, &app);
dialog.show();
QObject::connect( &dialog, SIGNAL( stop()), &app, SLOT( quit()));
int status = app.exec();
af::destroy();
Py_Finalize();
AFINFA("main: QApplication::exec: returned status = %d", status)
return status;
}
#include "monitorhost.h"
#include "watch.h"
#include <QApplication>
#include <QtGui/QIcon>
#define AFOUTPUT
#undef AFOUTPUT
#include "../include/macrooutput.h"
#ifndef WINNT
//####################### interrupt signal handler ####################################
#include <signal.h>
void sig_pipe(int signum)
{
AFERROR("afanasy:: SIGPIPE:")
}
void sig_int(int signum)
{
qApp->quit();
}
//#####################################################################################
#endif
int main(int argc, char *argv[])
{
Py_InitializeEx(0);
uint32_t env_flags = af::Environment::AppendPythonPath;
#ifdef WINNT
env_flags = env_flags | af::Environment::Verbose; // Verbose environment initialization
#else
