コード例 #1
0
ファイル: renderaf.cpp プロジェクト: RISEFX/cgru
void RenderAf::wolWake(  MonitorContainer * i_monitoring, const std::string & i_msg)
{
	if( i_msg.size())
		appendLog( i_msg);

	if( isOnline())
	{
		appendLog("Can't wake up online render.");
		return;
	}
	if( isWOLFalling())
	{
		appendLog("Can't wake up render which is just falling a sleep.");
		return;
	}

	if( m_netIFs.size() < 1)
	{
		appendLog("Can't perform Wake-On-Line operations. No network interfaces information.");
		return;
	}

	appendLog("Sending WOL wake request.");
	setWOLWaking( true);
	m_wol_operation_time = time( NULL);
	store();
	if( i_monitoring ) i_monitoring->addEvent( af::Monitor::EVT_renders_change, m_id);

	std::ostringstream str;
	v_jsonWrite( str, af::Msg::TRendersList);

	SysJob::AddWOLCommand( str.str(), "", m_name, m_name);
}
コード例 #2
0
ファイル: renderaf.cpp プロジェクト: RISEFX/cgru
void RenderAf::setRegistered()
{
	getFarmHost();

	if( isFromStore())
	{
		appendLog("Initialized from store.");
	}
	else
	{
		m_time_register = time( NULL);
		setStoreDir( AFCommon::getStoreDirRender( *this));
		store();
		appendLog("Registered.");
	}

	af::Client::setRegisterTime();

	m_task_start_finish_time = 0;
	m_wol_operation_time = 0;
	m_idle_time = time(NULL);
	m_busy_time = m_idle_time;

	if( isOnline()) appendLog("Registered online.");
	else appendLog("Registered offline.");
}
コード例 #3
0
ファイル: qfit.cpp プロジェクト: teukkam/qfit
void qfit::startFitClicked()
{
    if(filePath->text().isEmpty()) {
        appendLog("Select a file to open!");
        return;
    }
    double error = -1;

    // retrive error from the QLineEdit
    if(customError->isChecked()) {
        error = errorValue->text().toDouble();
        if(error <= 0.0) {
            appendLog("Custom error is not valid, a default one of 1.0 will be used");
            error = 1;
        }
    }

    if(Data::ReadFile(filePath->text().toLatin1().data(), xdata, ydata, yerrors, error)) {
        appendLog("Error opening file");
        return;
    }

    // start fittools
    delete fit;
    if(error <= 0)
        fit = new FitTools(xdata, ydata, yerrors, fit_type);
    else
        fit = new FitTools(xdata, ydata, error, fit_type);
    fit->Fit();
    printResult();

#ifdef Qwt6_FOUND
    plotData();
#endif
}
コード例 #4
0
void
MultiShot::updateLog( bool start )
{
    QString prefix;
    QString suffix;
    if( start ) {
	prefix = "start ";
	suffix = " (" + QString::number( shotSeq->frames );
	if( shotSeq->frames == 1 ) suffix += " image)";
	else		       suffix += " images)";
    }
    else {
	prefix = "end ";
	suffix = "";
    }
    switch( shotSeq->type ) {
	case ShotSeq::ExposureBracketingManual:
	case ShotSeq::ExposureBracketingAv:
	    appendLog( prefix + "exposure bracketing" + suffix );
	    break;
	case ShotSeq::FocusBracketing:
	    appendLog( prefix + "focus bracketing" + suffix );
	    break;
	case ShotSeq::Interval:
	    appendLog( prefix + "interval shooting" + suffix );
	    break;
	case ShotSeq::Stitch:
	    appendLog( prefix + "panorama shooting" + suffix );
	    break;
    }
}
コード例 #5
0
ファイル: renderaf.cpp プロジェクト: RISEFX/cgru
void RenderAf::offline( JobContainer * jobs, uint32_t updateTaskState, MonitorContainer * monitoring, bool toZombie )
{
	setOffline();
	setBusy( false);
	if( isWOLFalling())
	{
		setWOLFalling( false);
		setWOLSleeping( true);
	}

	if( jobs && updateTaskState)
		ejectTasks( jobs, monitoring, updateTaskState);

	// There is need to send pending tasks to offline render.
	m_re.clearTaskExecs();

	appendLog( m_hres.v_generateInfoString());

	if( toZombie )
	{
		AFCommon::QueueLog("Render Deleting: " + v_generateInfoString( false));
		appendLog("Waiting for deletion.");
		setZombie();
//		AFCommon::saveLog( getLog(), af::Environment::getRendersDir(), m_name);
		if( monitoring ) monitoring->addEvent( af::Monitor::EVT_renders_del, m_id);
	}
	else
	{
		AFCommon::QueueLog("Render Offline: " + v_generateInfoString( false));
		appendLog("Offline.");
		m_time_launch = 0;
		if( monitoring ) monitoring->addEvent( af::Monitor::EVT_renders_change, m_id);
		store();
	}
}
コード例 #6
0
ファイル: qfit.cpp プロジェクト: teukkam/qfit
void qfit::changeFitType(int state)
{
    switch(state) {
    case FitTools::LINEAR_FIT:
        fit_type = FitTools::LINEAR_FIT;
        appendLog("Fit Linear set");
        break;
    case FitTools::SLOPE_FIT:
        fit_type = FitTools::SLOPE_FIT;
        appendLog("Fit Slope set");
        break;
    case FitTools::HORIZONTAL_FIT:
        fit_type = FitTools::HORIZONTAL_FIT;
        appendLog("Fit Horizontal set");
        break;
    case FitTools::EXPONENTIAL_FIT:
        fit_type = FitTools::EXPONENTIAL_FIT;
        appendLog("Fit Exponential set");
        break;
    case FitTools::LOGARITHMIC_FIT:
        fit_type = FitTools::LOGARITHMIC_FIT;
        appendLog("Fit Logarithmic set");
        break;
    }
}
コード例 #7
0
ファイル: LuaCore.cpp プロジェクト: hunbernd/Lua4RS
void LuaCore::setUi(Lua4RSWidget *ui)
{
    _ui = ui;

    QObject::connect(this, SIGNAL(appendLog(QString)), _ui, SLOT(appendLog(QString)));
    QObject::connect(this, SIGNAL(appendOutput(QString)), _ui, SLOT(appendOutput(QString)));
    QObject::connect(this, SIGNAL(clearOutput()), _ui, SLOT(clearOutput()));
}
コード例 #8
0
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();
}
コード例 #9
0
ファイル: renderaf.cpp プロジェクト: RISEFX/cgru
void RenderAf::deregister( JobContainer * jobs, MonitorContainer * monitoring )
{
	if( isOffline())
	{
		appendLog("Render deregister request - offline already.");
		return;
	}
	appendLog("Render deregister request.");
	offline( jobs, af::TaskExec::UPRenderDeregister, monitoring);
}
コード例 #10
0
ファイル: task.cpp プロジェクト: Spudster3/cgru
void Task::refresh( time_t currentTime, RenderContainer * renders, MonitorContainer * monitoring, int & errorHostId)
{
//printf("Task::refresh:\n");
   bool changed = false;

   // forgive error hosts
   if(( false == errorHosts.empty() ) && ( block->getErrorsForgiveTime() > 0 ))
   {
      std::list<std::string>::iterator hIt = errorHosts.begin();
      std::list<int>::iterator cIt = errorHostsCounts.begin();
      std::list<time_t>::iterator tIt = errorHostsTime.begin();
      while( hIt != errorHosts.end() )
         if( currentTime - *tIt > block->getErrorsForgiveTime())
         {
            appendLog( std::string("Forgived error host \"") + *hIt + "\" since " + af::time2str(*tIt) + ".");
            hIt = errorHosts.erase( hIt);
            cIt = errorHostsCounts.erase( cIt);
            tIt = errorHostsTime.erase( tIt);
         }
         else
         {
            hIt++;
            cIt++;
            tIt++;
         }
    }

   if( renders != NULL )
   {
      if( run ) changed = run->refresh( currentTime, renders, monitoring, errorHostId);
      else
      {
         // Retry errors:
         if((progress->state & AFJOB::STATE_ERROR_MASK) && (progress->errors_count <= block->getErrorsRetries()))
         {
            progress->state = progress->state |   AFJOB::STATE_READY_MASK;
            progress->state = progress->state & (~AFJOB::STATE_ERROR_MASK);
            appendLog( std::string("Automatically retrying error task") + af::itos( progress->errors_count) + " of " + af::itos( block->getErrorsRetries()) + ".");
            if( changed == false) changed = true;
         }
      }
   }

   if( changed)
   {
      monitor( monitoring);
      updateDatabase();
   }
   deleteRunningZombie();
}
コード例 #11
0
ファイル: branchsrv.cpp プロジェクト: CGRU/cgru
void BranchSrv::logAction(const Action & i_action, const std::string & i_node_name)
{
	if (i_action.log.empty())
		return;

	appendLog(std::string("Action[") + i_action.type + "][" +  i_node_name + "]: " + i_action.log);
}
コード例 #12
0
void
MultiShot::stopButtonClicked()
{
    appendLog( "sequence cancelled" );
    emit cancelSequence();
    //finishSeq();
}
コード例 #13
0
ファイル: Client.cpp プロジェクト: mrdeveloperdude/OctoMY
void Client::countSend(qint64 written)
{
	const qint64 now=QDateTime::currentMSecsSinceEpoch();
	if(mLastSendTime<=0) {
		mLastSendTime=now-1;
	}
	const qint64 delta=now-mLastSendTime;
	mLastSendTime=now;
	mDeltaTime=delta/1000.0f;
	mTimeoutAccumulator += mDeltaTime;
	if (mConnected && ( mTimeoutAccumulator > TIMEOUT_TRESHOLD )) {
		qDebug()<<"CLIENT "<< mSignature.toString() <<" timed out";
		mConnected=false;
	}
	if(mConnected) {
		mReliabilitySystem.update(mDeltaTime);
		mRlowControl.update( mDeltaTime, mReliabilitySystem.roundTripTime() * 1000.0f );
	}
	if(mConnected!=mLastConnected) {
		mLastConnected=mConnected;
		mRlowControl.reset();
		appendLog("CLIENT: New flow state: " +QString(mConnected?"CONNECTED":"DISCONNECTED")+ " for "+mSignature.toString());
	}
	mReliabilitySystem.packetSent(written);
}
コード例 #14
0
void KeyFile::readHead(KeyFileHeader &header, bool log) {
  read(0, &header, sizeof(KeyFileHeader));

  if(log && isBackLogged()) {
    appendLog(0, &header, sizeof(KeyFileHeader));
  }
}
コード例 #15
0
ファイル: qfit.cpp プロジェクト: teukkam/qfit
int qfit::printResult()
{
    stringstream sout;
    fit->printResult(sout);
    appendLog(sout.str().c_str());
    return 0;
}
コード例 #16
0
void Simulator::init(Project &prj, BodyFactory &factory){
    initWorld(prj, factory, *this, pairs);
    initRTS(prj, receivers);
    std::cout << "number of receivers:" << receivers.size() << std::endl;
    m_totalTime = prj.totalTime();
    m_logTimeStep = prj.logTimeStep();
    m_kinematicsOnly = prj.kinematicsOnly();

    OpenHRP::CollisionSequence& collisions = state.collisions;

    collisions.length(pairs.size());
    for(size_t colIndex=0; colIndex < pairs.size(); ++colIndex){
        hrp::ColdetLinkPairPtr linkPair = pairs[colIndex];
        hrp::Link *link0 = linkPair->link(0);
        hrp::Link *link1 = linkPair->link(1);
        OpenHRP::LinkPair& pair = collisions[colIndex].pair;
        pair.charName1 = CORBA::string_dup(link0->body->name().c_str());
        pair.charName2 = CORBA::string_dup(link1->body->name().c_str());
        pair.linkName1 = CORBA::string_dup(link0->name.c_str());
        pair.linkName2 = CORBA::string_dup(link1->name.c_str());
    }

    m_nextLogTime = 0;
    appendLog();
}
コード例 #17
0
ファイル: MainWindow.cpp プロジェクト: newdebug/NewDebug
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow),
//    m_parseHtml(new ParseHtml),
    m_httpDownload(new HttpDownload())
{
    ui->setupUi(this);
    ui->progressBar->setValue(0);

//    QThread* thread = new QThread;
//    m_httpDownload->moveToThread(thread);
//    thread->start();

    connect(ui->downloadBtn, SIGNAL(clicked()),
            this, SLOT(startDownload()));

    connect(m_httpDownload, SIGNAL(updateDownloadProgressbar(qint64, qint64)),
            this, SLOT(updateProgressbar(qint64, qint64)));
    connect(m_httpDownload, SIGNAL(outputLog(QString)),
            this, SLOT(appendLog(QString)));
    connect(m_httpDownload, SIGNAL(htmlCount(int)),
            this, SLOT(updateHtmlCount(int)));

    connect(m_httpDownload, SIGNAL(imgCount(int)),
            this, SLOT(updateImgCount(int)));

//    connect(m_parseHtml, SIGNAL(updateLog(QStringList)),
//                this, SLOT(appendLog(QStringList)));

//    connect(m_parseHtml, SIGNAL(downloadImg(QString)),
//                this, SLOT(downloadImg(QString)));
//    connect(m_parseHtml, SIGNAL(updateCount(int)),
//                this, SLOT(updateCount(int)));
}
コード例 #18
0
ファイル: useraf.cpp プロジェクト: sachinpore/cgru
UserAf::UserAf( const std::string & username, const std::string & host):
    afsql::DBUser( username, host),
    AfNodeSrv( this)
{
    construct();
    appendLog("Registered from job.");
}
コード例 #19
0
ファイル: branchsrv.cpp プロジェクト: CGRU/cgru
BranchSrv::BranchSrv(BranchSrv * i_parent, const std::string & i_path):
	af::Branch(i_path),
	m_parent(i_parent),
	AfNodeSolve(this)
{
	appendLog("Created from job.");
}
コード例 #20
0
ファイル: useraf.cpp プロジェクト: sachinpore/cgru
UserAf::UserAf( int uid):
    afsql::DBUser( uid),
    AfNodeSrv( this)
{
    construct();
    appendLog("Registered from database.");
}
コード例 #21
0
ファイル: branchsrv.cpp プロジェクト: CGRU/cgru
void BranchSrv::addBranch(BranchSrv * i_branch)
{
	appendLog(std::string("Adding a branch: ") + i_branch->getName());

	m_branches_list.add(i_branch);

	m_branches_num++;
}
コード例 #22
0
ファイル: branchsrv.cpp プロジェクト: CGRU/cgru
void BranchSrv::removeBranch(BranchSrv * i_branch)
{
	appendLog(std::string("Removing a branch: ") + i_branch->getName());

	m_branches_list.remove(i_branch);

	m_branches_num--;
}
コード例 #23
0
ファイル: useraf.cpp プロジェクト: sachinpore/cgru
void UserAf::v_setZombie( MonitorContainer * i_monitoring)
{
    AFCommon::QueueLog("Deleting user: "******"Became a zombie.");
    AFCommon::saveLog( getLog(), af::Environment::getUsersLogsDir(), m_name, af::Environment::getAfNodeLogsRotate());
}
コード例 #24
0
ファイル: useraf.cpp プロジェクト: g-LuL/cgru
void UserAf::removeJob( JobAf * i_job)
{
	appendLog( std::string("Removing a job: ") + i_job->getName());

	m_jobslist.remove( i_job );

	m_jobs_num--;
}
コード例 #25
0
ファイル: mainwindow.cpp プロジェクト: Paukert/quickbox
void MainWindow::processDriverRawData(const QByteArray& data)
{
	QSettings settings;
	if(settings.value("comm/debug/showRawComData").toBool()) {
		QString msg = SIMessageData::dumpData(data);
		appendLog(qf::core::Log::LOG_DEB, trUtf8("DriverRawData: %1").arg(msg));
	}
}
コード例 #26
0
ファイル: useraf.cpp プロジェクト: g-LuL/cgru
void UserAf::logAction( const Action & i_action, const std::string & i_node_name)
{
	if( i_action.log.empty())
		return;

	appendLog( std::string("Action[") + i_action.type + "][" +  i_node_name + "]: " + i_action.log);
	updateTimeActivity();
}
コード例 #27
0
ファイル: useraf.cpp プロジェクト: sachinpore/cgru
UserAf::UserAf( JSON & i_object):
    afsql::DBUser(),
    AfNodeSrv( this)
{
    jsonRead( i_object);
    construct();
    appendLog("Registered.");
}
コード例 #28
0
ファイル: useraf.cpp プロジェクト: g-LuL/cgru
void UserAf::deleteNode( MonitorContainer * i_monitoring)
{
	AFCommon::QueueLog("Deleting user: "******"Became a zombie.");

	setZombie();

	if( i_monitoring ) i_monitoring->addEvent( af::Monitor::EVT_users_del, m_id);
}
コード例 #29
0
ファイル: mainwindow.cpp プロジェクト: Paukert/quickbox
void MainWindow::processSIMessage(const SIMessageData& msg_data)
{
	qfLogFuncFrame();
	//appendLog(qf::core::Log::LOG_INFO, trUtf8("processSIMessage command: %1 , type: %2").arg(SIMessageData::commandName(msg_data.command())).arg(msg_data.type()));
	if(msg_data.type() == SIMessageData::MsgCardReadOut) {
		SIMessageCardReadOut msg(msg_data);
		appendLogPre(qf::core::Log::LOG_DEB, msg.dump());
		appendLog(qf::core::Log::LOG_INFO, trUtf8("card: %1").arg(msg.cardNumber()));
		/*
		SICliScriptDriver *drv = theApp()->scriptDriver();
		try {
			QVariantList args;
			args << msg.toVariant();
			QScriptValue sv = drv->callExtensionFunction("onCardReadOut", args);
			QString ret_type = sv.property("retType").toString();
			if(ret_type == "error") {
				QString err = sv.property("error").toString();
				/// tady by to melo zacit vriskat
				appendLog(qf::core::Log::LOG_ERR, sv.property("message").toString());
			}
			else if(ret_type == "info") {
				//QString info = sv.property("info").toString();
				appendLog(qf::core::Log::LOG_INFO, sv.property("message").toString());
			}
		}
		catch(std::exception &e) {
			appendLog(qf::core::Log::LOG_ERR, e.what());
		}
		catch(...) {
			appendLog(qf::core::Log::LOG_ERR, tr("Unknown exception"));
		}
		*/
	}
	else if(msg_data.type() == SIMessageData::MsgCardEvent) {
		appendLogPre(qf::core::Log::LOG_DEB, msg_data.dump());
		if(msg_data.command() == SIMessageData::CmdSICard5DetectedExt) {
			QByteArray data(1, 0);
			data[0] = 0;
			emit sendSICommand(SIMessageData::CmdGetSICard5Ext, data);
		}
		else if(msg_data.command() == SIMessageData::CmdSICard6DetectedExt) {
			QByteArray data(2, 0);
			data[0] = 1;
			data[1] = 8;
			emit sendSICommand(SIMessageData::CmdGetSICard6Ext, data);
		}
		else if(msg_data.command() == SIMessageData::CmdSICard8AndHigherDetectedExt) {
			QByteArray data(2, 0);
			data[0] = 1;
			data[1] = 8;
			emit sendSICommand(SIMessageData::CmdGetSICard8Ext, data);
		}
	}
	else {
		appendLogPre(qf::core::Log::LOG_DEB, msg_data.dump());
	}
}
コード例 #30
0
ファイル: UIYabause.cpp プロジェクト: SaracenOne/yabause
void UIYabause::errorReceived( const QString& error, bool internal )
{
	if ( internal ) {
		appendLog( error.toLocal8Bit().constData() );
	}
	else {
		CommonDialogs::information( error );
	}
}