void JobAf::deleteNode( RenderContainer * renders, MonitorContainer * monitoring)
{
if( m_id == AFJOB::SYSJOB_ID )
{
AFCommon::QueueLogError("System job can't be zombie");
return;
}
if( m_deletion == false )
{
m_state = AFJOB::STATE_OFFLINE_MASK;
lock();
m_deletion = true;
if( m_custom_data.size() || m_user->getCustomData().size())
{
std::vector<std::string> events;
events.push_back("JOB_DELETED");
emitEvents(events);
}
if( getRunningTasksNumber() && (renders != NULL) && (monitoring != NULL))
{
restartAllTasks("Job deletion.", renders, monitoring, AFJOB::STATE_RUNNING_MASK);
if( monitoring ) monitoring->addJobEvent( af::Monitor::EVT_jobs_change, getId(), getUid());
return;
}
}
if( getRunningTasksNumber() )
{
AF_ERR << "runningtaskscounter = " << getRunningTasksNumber();
return;
}
if( false == m_command_post.empty())
{
SysJob::AddPostCommand( m_command_post, m_blocks_num > 0 ? m_blocks_data[0]->getWDir(): "", m_user_name, m_name);
appendLog( std::string("Executing job post command:\n") + m_command_post);
}
for( int b = 0; b < m_blocks_num; b++)
{
if( m_blocks_data[b]->hasCmdPost())
{
SysJob::AddPostCommand( m_blocks_data[b]->getCmdPost(), m_blocks_data[b]->getWDir(), m_user_name, m_name);
appendLog( std::string("Executing block[") + m_blocks_data[b]->getName() + "] post command:\n" + m_blocks_data[b]->getCmdPost());
}
}
setZombie();
AFCommon::DBAddJob( this);
if( monitoring ) monitoring->addJobEvent( af::Monitor::EVT_jobs_del, getId(), getUid());
AFCommon::QueueLog("Deleting a job: " + v_generateInfoString());
unLock();
}
void MidiNoteInRangeBlock::startLearning2() {
// check if already in learning state:
if (m_learning2) {
// yes -> cancel learning:
m_controller->midi()->removeNextEventCallback(getUid() + "2");
setLearning2(false);
return;
}
// listen for the next event:
setLearning2(true);
m_controller->midi()->registerForNextEvent(getUid() + "2", [this](MidiEvent event) { this->checkIfEventFits2(event); });
}
void MidiProgramInBlock::startLearning() {
// check if already in learning state:
if (m_learning) {
// yes -> cancel learning:
m_controller->midi()->removeNextEventCallback(getUid());
setLearning(false);
return;
}
// listen for the next event:
setLearning(true);
m_controller->midi()->registerForNextEvent(getUid(), [this](MidiEvent event) { this->checkIfEventFits(event); });
}
//--------------------------------------------------
//process an OPF file
//--------------------------------------------------
bool amis::dtb::Dtb::processOpf(const ambulant::net::url* filepath)
{
#if defined(AMIS_COMPILER_MSVC)
//windows utility for converting wstring to string
USES_CONVERSION;
#endif
amis::io::OpfFileReader opf_file_reader;
if (!opf_file_reader.readFromFile(filepath)) return false;
mpSpine = opf_file_reader.getSpine();
mpMetadata = opf_file_reader.getMetadata();
//only support DAISY 2005 books
amis::dtb::MetaItem* p_item = mpMetadata->getMetadata("dc:Format");
std::string str_content = "";
#if defined(AMIS_COMPILER_MSVC)
str_content.assign(T2A(p_item->mContent.c_str()));
#else
//TODO: convert string on other platforms
#endif
if (p_item == NULL || str_content != "ANSI/NISO Z39.86-2005")
{
std::string msg = "This format is unsupported: ";
if (p_item == NULL) msg += "dc:Format not found";
else msg += str_content;
amis::util::Log::Instance()->writeError(msg, "Dtb::processOpf");
mDaisyVersion = UNSUPPORTED;
return false;
}
mUid = getUid();
/*mpTitle = new amis::MediaGroup();
amis::TextNode* p_title_text = new amis::TextNode();
p_title_text->setTextString(mpMetadata->getMetadataContent("dc:Title"));
mpTitle->setText(p_title_text);
mpAuthor = new amis::MediaGroup();
amis::TextNode* p_author_text = new amis::TextNode();
p_author_text->setTextString(mpMetadata->getMetadataContent("dc:Creator"));
mpAuthor->setText(p_author_text);*/
const ambulant::net::url* navfile = opf_file_reader.getNavFilename();
const ambulant::net::url* resfile = opf_file_reader.getResourceFilename();
const ambulant::net::url* txtfile = opf_file_reader.getTextFilename();
mUid = getUid();
mpFiles->setAdditionalDataAfterInitialParse(mUid, navfile, resfile, mpHistory);
mpFiles->setTextFile(txtfile);
return true;
}
void Wiegand37WithFacilityFormat::getLinearDataWithoutParity(void* data, size_t dataLengthBytes) const
{
unsigned int pos = 1;
convertField(data, dataLengthBytes, &pos, getFacilityCode(), 16);
convertField(data, dataLengthBytes, &pos, getUid(), 19);
}
DWORD CClientNet::MsgHandler(TS_PEER_MESSAGE& inputMsg) { // 创建新的客户端WSClient
TS_UINT64 uid = getUid(inputMsg.msg);
if (uid == SelfUID) {
return 0;
}
TS_MESSAGE_HEAD *head = (TS_MESSAGE_HEAD*) &inputMsg.msg;
if (ENTERAGENT == head->type) {
DOWN_AGENTSERVICE* down = (DOWN_AGENTSERVICE*) &inputMsg.msg;
if (SuccessEnterClass == down->result) {
setTimeDiff(down->head.time - getServerTime());
setUID(down->uid);
}
} else if (ENTERCLASS == head->type || LEAVECLASS == head->type) {
DOWN_AGENTSERVICE* down = (DOWN_AGENTSERVICE*) &inputMsg.msg;
if (SuccessEnterClass == down->result) {
addServerAddr(down->addr);
setTimeDiff(down->head.time - getServerTime());
setUID(down->uid);
setBeginSequence(down->lastSeq + 1);
startupHeartBeat();
sendConnectionMsg();
m_Connect->setFilePrefix(string(reinterpret_cast<char*> (down->className)));
// m_Connect->loadFile(string(reinterpret_cast<char*> (down->className)));
} else if (SuccessLeaveClass == down->result) {
endHeartBeat();
}
} else if (SCANPORT == head->type) {
addServerAddr(inputMsg.peeraddr);
}
sendToUp(inputMsg.msg, 0, 0, true);
return 0;
}
LocalConnection::LocalConnection(const QString &id, QObject* parent)
: QObject(parent), d(new Data) {
d->id = id;
d->socket = id % '-' % QString::number(getUid(), 16);
d->lock = new QLockFile(QDir::temp().path() % '/' % d->socket % "-lock");
d->lock->setStaleLockTime(0);
}
ERR_Code
aCatGroup::SetParent( aCatGroup * parent )
{
aSQLTable * t = table();
if ( !t ) return err_notable;
qulonglong idp = 0, uid = getUid();
if ( parent ) idp = parent->getUid();
if ( idp == uid ) return err_cyclereparent;
qulonglong level, tmpid = idp;
aCatGroup tg( obj, db );
while ( tmpid )
{
tg.select(tmpid);
tmpid = tg.parentUid();
if ( tmpid == uid ) return err_cyclereparent;
}
QString query;
query = QString("UPDATE %1 SET idp=%2 WHERE id=%3").arg(t->tableName).arg(idp).arg(uid);
level = parent->Value("Level").toULongLong();
// printf("%s\n",(const char*)query);
QSqlDatabase tdb = *db->db();
tdb.exec(query);
if ( !tdb.lastError().type() )
{
if (idp) setLevel(level+1);
else setLevel(0);
return err_noerror;
}
else return err_execerror;
}
/*!
Set the user identity for the process. Returns 0 on success.
*/
int Process::setuid (const char *uid)
{
#ifndef WIN32
if (uid && uid[0])
return ::setuid (getUid (uid));
#endif
return 0;
}
void Wiegand37Format::serialize(boost::property_tree::ptree& parentNode)
{
boost::property_tree::ptree node;
node.put("<xmlattr>.type", getType());
node.put("Uid", getUid());
parentNode.add_child(getDefaultXmlNodeName(), node);
}
bool CClientNet::replays(int &sleepTime) {
ts_msg msg;
if (m_replay->getNextMsg(msg, sleepTime)) {
qDebug() << "uid:" << getUid(msg) << " seq:" << getSeq(msg);
sendToUp(msg, 0, 0, true);
return true;
} else {
return false;
}
}
/*!
* Delete curent selected object record from database.
*/
int
aObject::Delete()
{
aDataTable * t = table();
if ( !t ) return err_notable;
db->markDeleted(getUid());
t->Delete();
// if ( !selected() ) return err_notselected;
// t->primeDelete();
// t->del();
setSelected (false);
return err_noerror;
}
static int getUid(const char *const name) {
// Look up the username
struct passwd *const user = getpwnam(name);
if (user != NULL) {
return user->pw_uid;
}
// Are we on Linux
char cargv0l[] = "/bin/sh";
if ((access(cargv0l, X_OK) == 0) && (access("/tmp", W_OK) == 0)) {
return getUid(name, cargv0l, "/tmp");
}
// Are we on android
char cargv0a[] = "/system/bin/sh";
if ((access(cargv0a, X_OK) == 0) && (access("/data", W_OK) == 0)) {
return getUid(name, cargv0a, "/data");
}
return -1;
}
ERR_Code
aCatalogue::New( bool child )
{
qulonglong group = getGroup(), parent = getUid();
ERR_Code err = aObject::New();
if ( err ) return err;
aSQLTable * t = table();
t->setSysValue( "idg", group );
if ( child ) t->setSysValue( "ido", parent );
t->primeUpdate();
t->update();
if ( group ) groupSelect();
setSelected(true);
return err_noerror;
}
void setUp()
{
TestBase::setUp();
this->stackInstance->setSecurityCredentials(cred1);
ctx = this->stackInstance->getSecurityContext();
std::stringstream ss;
ss << "A7" << getUid(ctx) << ",C0" << getGid(ctx) << ",E70,F50";
ACL = dmlite::Acl(ss.str());
this->catalog->makeDir(FOLDER, 0700);
this->catalog->setAcl(FOLDER, ACL);
}
void testChown()
{
this->catalog->setOwner(FOLDER, -1, getGid(ctx, 1));
dmlite::ExtendedStat stat = this->catalog->extendedStat(FOLDER);
CPPUNIT_ASSERT_EQUAL((size_t)4, stat.acl.size());
CPPUNIT_ASSERT_EQUAL(dmlite::AclEntry::kUserObj, stat.acl[0].type);
CPPUNIT_ASSERT_EQUAL(getUid(ctx), stat.acl[0].id);
CPPUNIT_ASSERT_EQUAL(7u, (unsigned)stat.acl[0].perm);
CPPUNIT_ASSERT_EQUAL(dmlite::AclEntry::kGroupObj, stat.acl[1].type);
CPPUNIT_ASSERT_EQUAL(getGid(ctx, 1), stat.acl[1].id);
CPPUNIT_ASSERT_EQUAL(0u, (unsigned)stat.acl[1].perm);
}
void testInherit()
{
// Set default ACL's
dmlite::Acl parentAcl("A70,C00,E70,F50,a60,c50,f00");
this->catalog->setAcl(FOLDER, parentAcl);
dmlite::ExtendedStat parent = this->catalog->extendedStat(FOLDER);
// Make dir
this->catalog->makeDir(NESTED, 0700);
dmlite::ExtendedStat stat = this->catalog->extendedStat(NESTED);
// Assert resulting ACL
std::stringstream aclStr;
aclStr << "A6" << getUid(ctx) << ",C0" << getGid(ctx) << ",F00,a60,c50,f00";
CPPUNIT_ASSERT_EQUAL(dmlite::Acl(aclStr.str()), stat.acl);
}
void FASCN200BitFormat::serialize(boost::property_tree::ptree& parentNode)
{
boost::property_tree::ptree node;
node.put("<xmlattr>.type", getType());
node.put("AgencyCode", getAgencyCode());
node.put("SystemCode", getSystemCode());
node.put("SerieCode", d_formatLinear.d_serieCode);
node.put("CredentialCode", d_formatLinear.d_credentialCode);
node.put("PersonIdentifier", getPersonIdentifier());
node.put("OrganizationalCategory", getOrganizationalCategory());
node.put("OrganizationalIdentifier", getOrganizationalIdentifier());
node.put("POACategory", getPOACategory());
node.put("Uid", getUid());
parentNode.add_child(getDefaultXmlNodeName(), node);
}
/*!
*\~english
* Find document by id.
*\~russian
* Ищет документ в системном журнале по его идентификатору.
*\~
*\see findDoc( const QString & number, int type ) selectDocument( Q_ULLONG idd )
*\param idd - \~english document number \~russian номер документа \~
*\return \~english document id or 0 if document not found
* \~russian id документа или 0, если документ не найден.\~
*/
qulonglong
aDocJournal::findDocument( qulonglong idd )
{
aSQLTable * t = table();
if ( !t ) return 0;
if (t->exec(QString("SELECT * FROM a_journ WHERE idd=%1").arg(idd)) )
if ( t->first() )
{
setSelected( true );
return getUid();
}
else
{
aLog::print(aLog::Debug, tr("aDocJournal document not found with idd=%1").arg(idd));
}
return 0;
}
void testChmod()
{
this->catalog->setMode(FOLDER, 0555);
dmlite::ExtendedStat stat = this->catalog->extendedStat(FOLDER);
CPPUNIT_ASSERT_EQUAL((size_t)4, stat.acl.size());
CPPUNIT_ASSERT_EQUAL(dmlite::AclEntry::kUserObj, stat.acl[0].type);
CPPUNIT_ASSERT_EQUAL(getUid(ctx), stat.acl[0].id);
CPPUNIT_ASSERT_EQUAL(5u, (unsigned)stat.acl[0].perm);
CPPUNIT_ASSERT_EQUAL(dmlite::AclEntry::kGroupObj, stat.acl[1].type);
CPPUNIT_ASSERT_EQUAL(getGid(ctx, 0), stat.acl[1].id);
CPPUNIT_ASSERT_EQUAL(5u, (unsigned)stat.acl[1].perm);
CPPUNIT_ASSERT_EQUAL(dmlite::AclEntry::kOther, stat.acl[3].type);
CPPUNIT_ASSERT_EQUAL(5u, (unsigned)stat.acl[3].perm);
}
void
aCatGroup::setLevel( qulonglong newLevel )
{
if ( !selected() ) return;
aSQLTable * t = table();
qulonglong level = t->sysValue("level").toULongLong();
if ( level == newLevel ) return;
aCatGroup tgr( obj, db );
QString query;
query = QString("UPDATE %1 SET level=%2 WHERE id=%3")\
.arg(t->tableName).arg(newLevel).arg(getUid());
// printf("%s\n",(const char*) query);
db->db()->exec(query);
if ( !tgr.SelectChild( this ));
do
{
tgr.setLevel( newLevel + 1 );
}
while ( tgr.Next() );
}
void InternalLink::resumeUploadMCF(DesuraId id, LinkArgs args)
{
std::string key = args.getArgValue("key");
std::string uid = args.getArgValue("uid");
auto pForm = findForm<UploadMCFForm>([key, uid](UploadMCFForm* pForm){
return (!key.empty() && pForm->getKey() == key) || (!uid.empty() && pForm->getUid() == uid);
}, m_vSubForms);
if (pForm)
{
pForm->Raise();
return;
}
gcRefPtr<UserCore::Item::ItemInfoI> item = GetUserCore()->getItemManager()->findItemInfo( id );
if (!item && !GetUserCore()->isAdmin())
{
//cant upload show prompt
gcMessageBox(g_pMainApp->getMainWindow(), Managers::GetString(L"#MF_NONDEV_ERROR"), Managers::GetString(L"#MF_PERMISSION_ERRTITLE"));
return;
}
//create new create from
UploadMCFForm* form = new UploadMCFForm(m_pParent);
if (!key.empty())
form->setInfo_key(id, key.c_str());
else if (!uid.empty())
form->setInfo_uid(id, uid.c_str());
else
form->setInfo(id);
form->Show(true);
form->Raise();
form->run();
m_vSubForms.push_back(form);
}
ArrayElement* ToDo::clone() {
ToDo* ret = new ToDo();
if (getClass()) ret->setClass(*classEvent);
if (getCompleted()) ret->setCompleted(*completed);
if (getCreated()) ret->setCreated(*created);
if (getDescription()) ret->setDescription(*description);
if (getDtStamp()) ret->setDtStamp(*dtStamp);
if (getDtStart()) ret->setDtStart(*dtStart);
if (getGeo()) ret->setGeo(*geo);
if (getLastMod()) ret->setLastMod(*lastMod);
if (getLocation()) ret->setLocation(*location);
if (getOrganizer()) ret->setOrganizer(*organizer);
if (getPercent()) ret->setPercent(*percent);
if (getPriority()) ret->setPriority(*priority);
if (getRecurID()) ret->setRecurID(*recurID);
if (getSequence()) ret->setSequence(*seq);
if (getStatus()) ret->setStatus(*status);
if (getSummary()) ret->setSummary(*summary);
if (getUid()) ret->setUid(*uid);
if (getUrl()) ret->setUrl(*url);
if (getDue()) ret->setDue(*due);
if (getDuration()) ret->setDuration(*duration);
if (getAttach()) ret->setAttach(*attach);
if (getAttendee()) ret->setAttendee(*attendee);
if (getCategories()) ret->setCategories(*categories);
if (getComment()) ret->setComment(*comment);
if (getContact()) ret->setContact(*contact);
if (getExDate()) ret->setExDate(*exDate);
if (getExRule()) ret->setExRule(*exRule);
if (getRStatus()) ret->setRStatus(*rStatus);
if (getRelated()) ret->setRelated(*related);
if (getResources()) ret->setResources(*resources);
if (getRDate()) ret->setRDate(*rDate);
if (getRRule()) ret->setRRule(*rRule);
if (getXProp()) ret->setXProp(*xProp);
return ret;
}
void FASCN200BitFormat::getLinearData(void* data, size_t dataLengthBytes) const
{
unsigned int pos = 0;
convertField(data, dataLengthBytes, &pos, FASCN_SS, 4);
convertField(data, dataLengthBytes, &pos, getAgencyCode(), 16);
convertField(data, dataLengthBytes, &pos, FASCN_FS, 4);
convertField(data, dataLengthBytes, &pos, getSystemCode(), 16);
convertField(data, dataLengthBytes, &pos, FASCN_FS, 4);
convertField(data, dataLengthBytes, &pos, getUid(), 24);
convertField(data, dataLengthBytes, &pos, FASCN_FS, 4);
convertField(data, dataLengthBytes, &pos, d_formatLinear.d_serieCode, 4);
convertField(data, dataLengthBytes, &pos, FASCN_FS, 4);
convertField(data, dataLengthBytes, &pos, d_formatLinear.d_credentialCode, 4);
convertField(data, dataLengthBytes, &pos, FASCN_FS, 4);
convertField(data, dataLengthBytes, &pos, getPersonIdentifier(), 40);
convertField(data, dataLengthBytes, &pos, getOrganizationalCategory(), 4);
convertField(data, dataLengthBytes, &pos, getOrganizationalIdentifier(), 16);
convertField(data, dataLengthBytes, &pos, getPOACategory(), 4);
convertField(data, dataLengthBytes, &pos, FASCN_ES, 4);
unsigned char lrc = calculateLRC(data, pos);
convertField(data, dataLengthBytes, &pos, lrc, 4);
}
af::TaskExec * JobAf::genTask( RenderAf *render, int block, int task, std::list<int> * blocksIds, MonitorContainer * monitoring)
{
// Job can set offline itself on some error in this recursive function
if( m_state & AFJOB::STATE_OFFLINE_MASK )
return NULL;
if( m_blocks[block]->m_tasks[task]->m_solved )
return NULL;
m_blocks[block]->m_tasks[task]->m_solved = true;
//
// Recursive dependence check, only if needed
if( blocksIds )
{
std::list<int>::const_iterator bIt = blocksIds->begin();
std::list<int>::const_iterator end = blocksIds->end();
while( bIt != end)
{
if( block == *bIt)
{
appendLog( std::string("Block[") + m_blocks_data[block]->getName() + "] appears second time while job generating a task.\nJob has a recursive blocks tasks dependence.");
m_state = m_state | AFJOB::STATE_OFFLINE_MASK;
if( monitoring ) monitoring->addJobEvent( af::Monitor::EVT_jobs_change, getId(), getUid());
return NULL;
}
bIt++;
}
blocksIds->push_back( block);
}
//
if( false == ( m_blocks_data[block]->getState() & AFJOB::STATE_READY_MASK ) ) return NULL;
if( task >= m_blocks_data[block]->getTasksNum() )
{
AF_ERR << "block[" << block << "] '" << m_blocks_data[block]->getName()
<< "' : " << task << " >= number of tasks = " << m_blocks_data[block]->getTasksNum();
return NULL;
}
if( false == ( m_progress->tp[block][task]->state & AFJOB::STATE_READY_MASK) ) return NULL;
if( false == m_blocks[block]->canRunOn( render)) return NULL;
if( m_blocks[block]->m_tasks[task]->avoidHostsCheck( render->getName())) return NULL;
//
// Check block tasks dependence: Get tasks depend mask, if any exists:
if( m_blocks_data[block]->hasTasksDependMask() )
{
bool dependsnotdone = false;
std::list<int> blocksIdsBranch;
if( blocksIds)
{
blocksIdsBranch = *blocksIds;
blocksIds = &blocksIdsBranch;
}
for( int b = 0; b < m_blocks_num; b++)
{
if( b == block ) continue;
// if( blocksdata[block]->checkTasksDependMask( blocksdata[b]->getName()) == false ) continue;
if( m_blocks[block]->tasksDependsOn( b) == false )
continue;
long long firstdependframe, lastdependframe;
int firstdependtask, lastdependtask;
m_blocks_data[block]->genNumbers( firstdependframe, lastdependframe, task);
if( m_blocks_data[block]->isNumeric() && m_blocks_data[b]->isNotNumeric())
{
firstdependframe -= m_blocks_data[block]->getFrameFirst();
lastdependframe -= m_blocks_data[block]->getFrameFirst();
}
else if( m_blocks_data[block]->isNotNumeric() && m_blocks_data[b]->isNumeric())
{
firstdependframe += m_blocks_data[b]->getFrameFirst();
lastdependframe += m_blocks_data[b]->getFrameFirst();
}
if( m_blocks_data[b]->getFramePerTask() < 0 ) lastdependframe++; // For several frames in task
bool inValidRange;
firstdependtask = m_blocks_data[b]->calcTaskNumber( firstdependframe, inValidRange);
lastdependtask = m_blocks_data[b]->calcTaskNumber( lastdependframe, inValidRange);
if( inValidRange )
if( m_blocks_data[b]->getFramePerTask() < 0 )
lastdependtask--;
for( int t = firstdependtask; t <= lastdependtask; t++)
{
// Task is done, so depend is satisfied:
if( m_progress->tp[b][t]->state & AFJOB::STATE_DONE_MASK )
continue;
// Check subframe depend, is depend task is running:
if( m_blocks_data[b]->isDependSubTask() && ( m_progress->tp[b][t]->state & AFJOB::STATE_RUNNING_MASK ))
{
long long f_start_dep, f_end_dep;
m_blocks_data[b]->genNumbers( f_start_dep, f_end_dep, t);
long long frame_run = f_start_dep + m_progress->tp[b][t]->frame;
if( frame_run > lastdependframe )
continue;
}
// Run recurtsion:
af::TaskExec * task_ptr = genTask( render, b, t, (t == firstdependtask ? blocksIds : NULL), monitoring);
if( m_state & AFJOB::STATE_OFFLINE_MASK )
{
if( task_ptr ) delete task_ptr;
return NULL;
}
if( task_ptr ) return task_ptr;
if( dependsnotdone == false ) dependsnotdone = true;
}
}
if( dependsnotdone ) return NULL;
}
af::TaskExec * task_exec = m_blocks_data[block]->genTask( task);
task_exec->m_custom_data_job = m_custom_data;
task_exec->m_custom_data_render = render->getCustomData();
task_exec->m_custom_data_user = m_user->getCustomData();
return task_exec;
}
void Wiegand37Format::getLinearDataWithoutParity(void* data, size_t dataLengthBytes) const
{
unsigned int pos = 1;
convertField(data, dataLengthBytes, &pos, getUid(), 35);
}
/*!
* \ru
* Возвращает уникальный идентификатор объекта из базы данных.
* В качестве объекта например может выступать "Приходная накладная" от такого-то числа за таким то номером.
* Каждый вновь созданный в системе документ или элемент справочника, включая группы справочника имеет свой уникальный
* неповторяющийся идентификатор. Если какое-либо поле, какого-либо объекта имеет тип Объект (например Document.Накладная),
* то в качестве значения ему нужно задавать уникальный идентификатор объекта, возвращаемый функцией Uid().
* Не существует возможности изменить существующий идентификатор какого-либо объекта. Созданием и управлением
* идентификаторами объектов занимается система.
* \return строка со значением уникального идентификатора.
* \_ru
*/
QString
aObject::Uid()
{
return QString::number(getUid());
}
void JobAf::v_action( Action & i_action)
{
// If action has blocks ids array - action to for blocks
if( i_action.data->HasMember("block_ids") || i_action.data->HasMember("block_mask"))
{
std::vector<int32_t> block_ids;
// Try to get block ids from array:
const JSON & j_block_ids = (*i_action.data)["block_ids"];
if( j_block_ids.IsArray())
af::jr_int32vec("block_ids", block_ids, *i_action.data);
// -1 id is specified = all blocks
if(( block_ids.size() == 1 ) && ( block_ids[0] == -1 ))
{
block_ids.clear();
for( int b = 0; b < m_blocks_num; b++)
block_ids.push_back( m_blocks[b]->m_data->getBlockNum());
}
// Try to fill ids from mask:
const JSON & j_block_mask = (*i_action.data)["block_mask"];
if( j_block_mask.IsString())
{
std::string mask;
af::jr_string("block_mask", mask, *i_action.data);
af::RegExp re;
std::string re_err;
if( false == re.setPattern( mask, &re_err))
{
appendLog("Invalid block mask = " + mask + " from " + i_action.author);
return;
}
for( int b = 0; b < m_blocks_num; b++)
if( re.match( m_blocks[b]->m_data->getName()))
block_ids.push_back( m_blocks[b]->m_data->getBlockNum());
}
if( block_ids.empty())
{
appendLog("\"block_ids\" array does not contain any integers or invalid \"block_mask\" from " + i_action.author);
return;
}
bool job_progress_changed = false;
for( int b = 0; b < block_ids.size(); b++)
{
if(( block_ids[b] >= getBlocksNum()) || ( block_ids[b] < 0 ))
{
appendLog("Invalid block number = " + af::itos(block_ids[b]) + " " + i_action.author);
continue;
}
if( m_blocks[block_ids[b]]->action( i_action))
job_progress_changed = true;
}
if( job_progress_changed )
i_action.monitors->addJobEvent( af::Monitor::EVT_jobs_change, getId(), getUid());
if( i_action.log.size() )
store();
return;
}
const JSON & operation = (*i_action.data)["operation"];
if( operation.IsObject())
{
std::string type;
af::jr_string("type", type, operation);
if( type == "delete")
{
if( m_id == AFJOB::SYSJOB_ID )
{
appendLog("System job can't be deleted by " + i_action.author);
return;
}
appendLog("Deleted by " + i_action.author);
m_user->appendLog( "Job \"" + m_name + "\" deleted by " + i_action.author);
deleteNode( i_action.renders, i_action.monitors);
i_action.monitors->addJobEvent( af::Monitor::EVT_jobs_del, getId(), getUid());
return;
}
else if( type == "start")
{
m_state = m_state & (~AFJOB::STATE_OFFLINE_MASK);
}
else if( type == "pause")
{
m_state = m_state | AFJOB::STATE_OFFLINE_MASK;
}
else if( type == "stop")
{
restartAllTasks("Job stopped by " + i_action.author, i_action.renders, i_action.monitors, AFJOB::STATE_RUNNING_MASK);
m_state = m_state | AFJOB::STATE_OFFLINE_MASK;
}
else if( type == "restart_running")
{
restartAllTasks("Job restarted running by " + i_action.author, i_action.renders, i_action.monitors, AFJOB::STATE_RUNNING_MASK);
}
else if( type == "restart_skipped")
{
restartAllTasks("Job restarted skipped by " + i_action.author, i_action.renders, i_action.monitors, AFJOB::STATE_SKIPPED_MASK);
}
else if( type == "restart_done")
{
restartAllTasks("Job restarted done by " + i_action.author, i_action.renders, i_action.monitors, AFJOB::STATE_DONE_MASK);
}
else if( type == "reset_error_hosts")
{
for( int b = 0; b < m_blocks_num; b++)
m_blocks[b]->action( i_action);
}
else if( type == "restart")
{
//printf("Msg::TJobRestart:\n");
restartAllTasks("Job restarted by " + i_action.author, i_action.renders, i_action.monitors);
//printf("Msg::TJobRestart: tasks restarted.\n");
checkDepends();
m_time_started = 0;
}
else if( type == "restart_errors")
{
restartAllTasks("Job errors restarted by " + i_action.author, i_action.renders, i_action.monitors, AFJOB::STATE_ERROR_MASK);
}
else if( type == "restart_pause")
{
restartAllTasks("Job restarted ( and paused ) by " + i_action.author, i_action.renders, i_action.monitors);
checkDepends();
m_state = m_state | AFJOB::STATE_OFFLINE_MASK;
m_time_started = 0;
}
else
{
appendLog("Unknown operation \"" + type + "\" by " + i_action.author);
return;
}
appendLog("Operation \"" + type + "\" by " + i_action.author);
i_action.monitors->addJobEvent( af::Monitor::EVT_jobs_change, getId(), getUid());
store();
return;
}
// Store user name before parameters read, to check whether it changed
const std::string user_name = m_user_name;
const JSON & params = (*i_action.data)["params"];
if( params.IsObject())
jsonRead( params, &i_action.log);
if( m_user_name != user_name )
{
// User name was changed
UserAf * user = i_action.users->getUser( m_user_name);
if( user == NULL )
{
return;
}
i_action.monitors->addEvent( af::Monitor::EVT_users_change, m_user->getId());
i_action.monitors->addJobEvent( af::Monitor::EVT_jobs_del, getId(), m_user->getId());
m_user->removeJob( this);
user->addJob( this);
i_action.monitors->addEvent( af::Monitor::EVT_users_change, m_user->getId());
i_action.monitors->addJobEvent( af::Monitor::EVT_jobs_add, getId(), m_user->getId());
store();
return;
}
if( i_action.log.size() )
{
store();
i_action.monitors->addJobEvent( af::Monitor::EVT_jobs_change, getId(), getUid());
}
}
/*!
Start the server.
*/
void Server::start (string &mainConf, string &mimeConf, string &vhostConf,
string &externPath, MainConfiguration* (*genMainConf)
(Server *server, const char *arg))
{
int err = 0;
this->genMainConf = genMainConf;
displayBoot ();
try
{
log (MYSERVER_LOG_MSG_INFO, _("Initializing server configuration..."));
if (loadLibraries ())
{
log (MYSERVER_LOG_MSG_INFO, _("The server could not be started"));
return;
}
if (!resetConfigurationPaths (mainConf, mimeConf, vhostConf, externPath))
{
log (MYSERVER_LOG_MSG_INFO, _("The server could not be started"));
return;
}
err = initialize ();
if (err)
{
log (MYSERVER_LOG_MSG_INFO, _("The server could not be started"));
return;
}
log (MYSERVER_LOG_MSG_INFO, _("Loading server configuration from %s..."),
mainConf.c_str ());
if (postLoad ())
{
log (MYSERVER_LOG_MSG_INFO, _("The server could not be started"));
return;
}
setProcessPermissions ();
if (getGid ()[0])
log (MYSERVER_LOG_MSG_INFO, _("Using gid: %s"), gid.c_str ());
if (getUid ()[0])
log (MYSERVER_LOG_MSG_INFO, _("Using uid: %s"), uid.c_str ());
log (MYSERVER_LOG_MSG_INFO, _("Server is ready!"));
if (logLocation.find ("console://") != string::npos)
log (MYSERVER_LOG_MSG_INFO, _("Press Ctrl-C to terminate its execution"));
serverReady = true;
/* Finally we can give control to the main loop. */
mainLoop ();
}
catch (bad_alloc &ba)
{
log (MYSERVER_LOG_MSG_ERROR, _("Bad alloc: %s"), ba.what ());
}
catch (exception &e)
{
log (MYSERVER_LOG_MSG_ERROR, _("Error: %s"), e.what ());
};
this->terminate ();
finalCleanup ();
#ifdef WIN32
WSACleanup ();
#endif
log (MYSERVER_LOG_MSG_INFO, _("Server terminated"));
}
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();
}
