/// Try so solve a Node
RenderAf * AfNodeSolve::trySolve( std::list<RenderAf*> & i_renders_list, MonitorContainer * i_monitoring)
{
RenderAf * render = v_solve( i_renders_list, i_monitoring);
if( NULL == render )
{
// Was not solved
return NULL;
}
// Node solved successfully:
// Store solve cycle
m_solve_cycle = sm_solve_cycle;
// Calculace new need value as node got some more resource
// ( nodes shoud increment resource value in solve function )
v_calcNeed();
// Icrement solve cycle
sm_solve_cycle++;
// Returning that node was solved
return render;
}
void UserAf::v_refresh( time_t currentTime, AfContainer * pointer, MonitorContainer * monitoring)
{
/* if( isLocked() )
{
return;
}*/
//printf("UserAf::refresh: \"%s\"\n", getName().toUtf8().data());
int _numjobs = m_jobslist.getCount();
if(( _numjobs == 0) && ( false == isPermanent()))
{
if( m_zombietime )
{
if( (currentTime-m_zombietime) > af::Environment::getUserZombieTime() )
{
appendLog( std::string("ZOMBIETIME: " + af::itos( af::Environment::getUserZombieTime()) + " seconds with no job."));
v_setZombie( monitoring);
return;
}
}
else
{
m_zombietime = currentTime;
}
return;
}
else m_zombietime = 0;
int _numrunningjobs = 0;
int _runningtasksnumber = 0;
{
AfListIt jobsListIt( &m_jobslist);
for( AfNodeSrv *job = jobsListIt.node(); job != NULL; jobsListIt.next(), job = jobsListIt.node())
{
if( ((JobAf*)job)->isRunning())
{
_numrunningjobs++;
_runningtasksnumber += ((JobAf*)job)->getRunningTasksNumber();
}
}
}
if((( _numrunningjobs != m_running_jobs_num ) ||
( _numjobs != m_jobs_num ) ||
( _runningtasksnumber != m_running_tasks_num )) &&
monitoring )
monitoring->addEvent( af::Msg::TMonitorUsersChanged, m_id);
m_jobs_num = _numjobs;
m_running_jobs_num = _numrunningjobs;
m_running_tasks_num = _runningtasksnumber;
// Update solving parameters:
v_calcNeed();
}
void JobAf::v_refresh( time_t currentTime, AfContainer * pointer, MonitorContainer * monitoring)
{
RenderContainer * renders = (RenderContainer*)pointer;
if( m_deletion )
{
for( int b = 0; b < m_blocks_num; b++)
m_blocks[b]->v_refresh( currentTime, renders, monitoring);
if( getRunningTasksNumber() == 0 ) deleteNode( NULL, monitoring);
}
if( isLocked() ) return;
// for database and monitoring
uint32_t old_state = m_state;
uint32_t jobchanged = 0;
// check job dependences
checkDepends();
//check wait time
{
bool wasWaiting = m_state & AFJOB::STATE_WAITTIME_MASK;
if( m_time_wait > currentTime ) m_state = m_state | AFJOB::STATE_WAITTIME_MASK;
else m_state = m_state & (~AFJOB::STATE_WAITTIME_MASK);
bool nowWaining = m_state & AFJOB::STATE_WAITTIME_MASK;
if( wasWaiting != nowWaining) jobchanged = af::Monitor::EVT_jobs_change;
}
//
// Update blocks (blocks will uptate its tasks):
for( int b = 0; b < m_blocks_num; b++)
if( m_blocks[b]->v_refresh( currentTime, renders, monitoring))
jobchanged = af::Monitor::EVT_jobs_change;
// Check block depends after all block refreshed,
// as states can be changed during refresh.
// ( some block can be DONE after refresh )
for( int b = 0; b < m_blocks_num; b++)
if( m_blocks[b]->checkDepends( monitoring))
jobchanged = af::Monitor::EVT_jobs_change;
//
// job state calculation
m_state = m_state | AFJOB::STATE_DONE_MASK;
m_state = m_state & (~AFJOB::STATE_RUNNING_MASK);
m_state = m_state & (~AFJOB::STATE_WARNING_MASK);
m_state = m_state & (~AFJOB::STATE_ERROR_MASK);
m_state = m_state & (~AFJOB::STATE_READY_MASK);
m_state = m_state & (~AFJOB::STATE_SKIPPED_MASK);
for( int b = 0; b < m_blocks_num; b++)
{
uint32_t state_block = m_blocks_data[b]->getState();
m_state = m_state | (state_block & AFJOB::STATE_RUNNING_MASK );
m_state = m_state | (state_block & AFJOB::STATE_WARNING_MASK );
m_state = m_state | (state_block & AFJOB::STATE_ERROR_MASK );
m_state = m_state | (state_block & AFJOB::STATE_READY_MASK );
m_state = m_state | (state_block & AFJOB::STATE_SKIPPED_MASK );
m_state = m_state & (state_block | (~AFJOB::STATE_DONE_MASK) );
}
if( m_state & AFJOB::STATE_WAITDEP_MASK ) m_state = m_state & (~AFJOB::STATE_READY_MASK);
if( m_state & AFJOB::STATE_WAITTIME_MASK ) m_state = m_state & (~AFJOB::STATE_READY_MASK);
if( m_state & AFJOB::STATE_DONE_MASK )
{
/// if job was not done, but now is done, we set job time_done
if(( old_state & AFJOB::STATE_DONE_MASK) == false )
{
m_time_done = currentTime;
if( m_time_started == 0 )
{
m_time_started = m_time_done;
appendLog("Started.");
}
appendLog("Done.");
jobchanged = af::Monitor::EVT_jobs_change;
store();
}
}
else
m_time_done = 0;
// Reset started time if job was started, but now no tasks are running or done
if(( m_time_started != 0 ) &&
( false == (m_state & AFJOB::STATE_RUNNING_MASK) ) &&
( false == (m_state & AFJOB::STATE_DONE_MASK) ) )
{
// Search if the job has at least one done task
bool has_done_tasks = false;
for( int b = 0; b < m_blocks_num; b++ )
{
if( m_blocks_data[b]->getProgressTasksDone() > 0 )
{
has_done_tasks = true;
break;
}
}
// If the job has done task(s) we not reset started time in any case
if( false == has_done_tasks ) m_time_started = currentTime;
}
if( m_state != old_state )
{
jobchanged = af::Monitor::EVT_jobs_change;
// If it is no job monitoring, job just came to server and it is first it refresh,
// so no change event and database storing needed
if( monitoring )
store();
// Proccess events:
if( m_id != AFJOB::SYSJOB_ID ) // skip system job
if( m_custom_data.size() || m_user->getCustomData().size())
{
std::vector<std::string> events;
// Collect events names:
if(( m_state & AFJOB::STATE_ERROR_MASK ) && ( false == ( old_state & AFJOB::STATE_ERROR_MASK )))
events.push_back("JOB_ERROR");
if(( m_state & AFJOB::STATE_DONE_MASK ) && ( false == ( old_state & AFJOB::STATE_DONE_MASK )))
events.push_back("JOB_DONE");
emitEvents(events);
}
}
if( m_thumb_changed || m_report_changed )
{
jobchanged = af::Monitor::EVT_jobs_change;
m_thumb_changed = false;
m_report_changed = false;
}
// Check age and delete if life finished:
if( m_id != AFJOB::SYSJOB_ID ) // skip system job
{
int result_lifetime = m_time_life;
if( result_lifetime < 0 ) result_lifetime = m_user->getJobsLifeTime(); // get default value from user
if((result_lifetime > 0) && ((currentTime - m_time_creation) > result_lifetime))
{
appendLog( std::string("Life %1 finished.") + af::time2strHMS( result_lifetime, true));
m_user->appendLog( std::string("Job \"") + m_name + "\" life " + af::time2strHMS( result_lifetime, true) + " finished.");
deleteNode( renders, monitoring);
jobchanged = af::Monitor::EVT_jobs_del, getId(), getUid();
}
}
if(( monitoring ) && ( jobchanged )) monitoring->addJobEvent( jobchanged, getId(), getUid());
// Update solving parameters:
v_calcNeed();
}
