bool MaemoSshDeployer::runInternal()
{
createConnection();
if (!m_connection->start())
return false;
if (stopRequested())
return true;
connect(m_connection.data(), SIGNAL(fileCopied(QString)),
this, SIGNAL(fileCopied(QString)));
return m_connection->transferFiles(m_deploySpecs);
}
void ManagerImpl::fetchSoftwareList(QThread */*qt*/, void */*data*/)
{
LONG result;
HKEY parent_key;
DWORD i;
bool smartphone = false;
if (Ce::rapiInit(pdaName)) {
msg = i18n("Retrieve software-list ...");
postManagerImplEvent(&ManagerImpl::beginEvent, 0, noBlock);
result = synce::CeRegOpenKeyEx(HKEY_LOCAL_MACHINE, QString("Security\\AppInstall").ucs2(), 0, 0, &parent_key);
if (ERROR_SUCCESS == result) smartphone = true;
else result = synce::CeRegOpenKeyEx(HKEY_LOCAL_MACHINE, QString("Software\\Apps").ucs2(), 0, 0, &parent_key);
for (i = 0; !stopRequested(); i++) {
WCHAR wide_name[MAX_PATH];
DWORD name_size = sizeof(wide_name);
HKEY program_key;
DWORD installed = 0;
DWORD value_size = sizeof(installed);
DWORD type;
result = synce::CeRegEnumKeyEx(parent_key, i, wide_name, &name_size, NULL, NULL, NULL, NULL);
if (ERROR_SUCCESS != result) {
break;
}
if (!smartphone) {
result = synce::CeRegOpenKeyEx(parent_key, wide_name, 0, 0, &program_key);
if (ERROR_SUCCESS != result) {
continue;
}
result = synce::CeRegQueryValueEx(program_key, QString("Instl").ucs2(), NULL, &type, (LPBYTE)&installed, &value_size);
}
synce::CeRegCloseKey(program_key);
if ((ERROR_SUCCESS == result && installed) || (ERROR_SUCCESS == result && smartphone)) {
postManagerImplEvent(&ManagerImpl::insertInstalledItemEvent, qstrdup(QString::fromUcs2(wide_name).ascii()), noBlock);
}
}
synce::CeRegCloseKey(parent_key);
Ce::rapiUninit();
postManagerImplEvent(&ManagerImpl::endEvent, NULL, noBlock);
}
}
void GstThread::run()
{
m_pipeline = new Pipeline(m_winId, m_videoLocation);
connect(m_pipeline, SIGNAL(showRequested()), this, SLOT(show()));
m_pipeline->start(); //it runs the gmainloop on win32
#ifndef WIN32
//works like the gmainloop on linux (GstEvent are handled)
connect(m_pipeline, SIGNAL(stopRequested()), this, SLOT(quit()));
exec();
#endif
m_pipeline->unconfigure();
}
bool MaemoSshRunner::runInternal()
{
createConnection();
connect(m_connection.data(), SIGNAL(remoteOutput(QByteArray)),
this, SLOT(handleRemoteOutput(QByteArray)));
initState();
if (!m_connection->start())
return false;
if (stopRequested())
return true;
waitForStop();
return !m_connection->hasError();
}
void * Connection::run()
{
reg("Connection");
while(!stopRequested())
{
while(!m_command_queue.empty()){
ConnectionCommand c = m_command_queue.pop_frontNoEx();
processCommand(c);
}
receive();
}
return nullptr;
}
void toEventQuery::start()
{
if ( Worker || Started || WorkDone )
throw tr("toEventQuery::start - can not restart already stared query");
Worker = new toEventQueryWorker(this, Connection, CancelCondition, SQL, Param);
Worker->moveToThread(Thread);
Thread->Slave = Worker;
// Connect to Worker's API
connect(Worker, SIGNAL(headers(toQColumnDescriptionList &, int)), // BG -> main
this, SLOT(slotDesc(toQColumnDescriptionList &, int)));
connect(Worker, SIGNAL(data(const ValuesList &)), // BG -> main
this, SLOT(slotData(const ValuesList &)));
connect(Worker, SIGNAL(error(const toConnection::exception &)), // BG -> main
this, SLOT(slotError(const toConnection::exception &)));
connect(Worker, SIGNAL(workDone()), // BG -> main
this, SLOT(slotFinished()));
connect(Worker, SIGNAL(rowsProcessed(unsigned long)), // BG -> main
this, SLOT(slotRowsProcessed(unsigned long)));
connect(this, SIGNAL(dataRequested()), Worker, SLOT(slotRead())); // main -> BG
connect(this, SIGNAL(consumed()), Worker, SLOT(slotRead())); // main -> BG
// Connect to QThread's API
// error handling
connect(Worker, SIGNAL(error(toConnection::exception const &)) // BG -> main
, this, SLOT(slotError(toConnection::exception const &)));
// initization
connect(Thread, SIGNAL(started()), Worker, SLOT(init())); // main -> BG
connect(Worker, SIGNAL(started()), this, SLOT(slotStarted()));// BG -> main
// finish
connect(Worker, SIGNAL(finished()), Thread, SLOT(quit())); // BG -> BG?? (quit event loop)
connect(Worker, SIGNAL(finished()), Worker, SLOT(deleteLater())); // BG -> BG
connect(Thread, SIGNAL(finished()), Thread, SLOT(deleteLater())); // BG -> main
connect(Thread, SIGNAL(destroyed()), this, SLOT(slotThreadEnd())); // main -> main
connect(this, SIGNAL(stopRequested()), Worker, SLOT(slotStop())); // main -> BG
TLOG(7, toDecorator, __HERE__) << "toEventQuery start" << std::endl;
// finally start the thread
Thread->start();
}
void FsRadProgressDlg::allowBackgroundProcessing()
{
for(;;)
{
for (int i = 0; i < 10; i++)
{
MSG msg;
if (!PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) break;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (!paused() || stopRequested()) break;
Sleep(100);
}
}
void ProgressDlg::setCurrentPercent(const float percent)
{
if (!stopRequested())
{
static float lastPercent = 23456.0f;
if (percent != lastPercent)
{
lastPercent = percent;
char dsp[20];
sprintf(dsp, "%.3f%%", percent);
currentTaskPercent.SetWindowText(dsp);
currentTaskProgress.SetPos(static_cast<int>(percent * 10.0f));
}
{
char disp[90];
memset(disp, 0, sizeof(disp));
currentTaskText.GetWindowText(disp, sizeof(disp));
char disp2[90];
#ifdef _DEBUG
sprintf(disp2, "%.2f%% - %s (DEBUG)", percent, disp);
#else
sprintf(disp2, "%.2f%% - %s", percent, disp);
#endif
SetWindowText(disp2);
}
}
// Update the timer, if it has changed
int thisTime = time(NULL);
if (thisTime != lastTime() && !paused())
{
lastTime() = thisTime;
int seconds = lastTime() - runtimeStart();
int minutes = seconds / 60; seconds -= minutes * 60;
int hours = minutes / 60; minutes -= hours * 60;
char dsp[90];
sprintf(dsp, "%02d:%02d:%02d", hours, minutes, seconds);
runtimeText.SetWindowText(dsp);
}
allowBackgroundProcessing();
}
Tab::Tab(const QUrl& url, QWidget* parent) : QWidget(parent) {
_webView = new WebView(url, this);
_toolBar = new ToolBar(_webView->history(), url, this);
_searchBar = new SearchBar(this);
_statusBar = new StatusBar(this);
_layout = new QVBoxLayout(this);
_layout->setMargin(0);
_layout->setSpacing(0);
_layout->addWidget(_toolBar, 0);
_layout->addWidget(_webView, 1);
_layout->addWidget(_searchBar, 0);
_layout->addWidget(_statusBar, 0);
_showSearchShortcut = new QShortcut(QKeySequence::Find, this);
_focusAddressShortcut = new QShortcut(Qt::Key_F6, this);
_searchBar->hide();
connect(_toolBar, SIGNAL(goBackRequested()), _webView, SLOT(back()));
connect(_toolBar, SIGNAL(goForwardRequested()), _webView, SLOT(forward()));
connect(_toolBar, SIGNAL(reloadRequested()), _webView, SLOT(reload()));
connect(_toolBar, SIGNAL(stopRequested()), _webView, SLOT(stop()));
connect(_toolBar, SIGNAL(loadRequested(const QUrl&)), _webView, SLOT(setFocus()));
connect(_toolBar, SIGNAL(loadRequested(const QUrl&)), _webView, SLOT(load(const QUrl&)));
connect(_webView, SIGNAL(urlChanged(const QUrl&)), _toolBar, SLOT(setUrl(const QUrl&)));
connect(_webView, SIGNAL(urlChanged(const QUrl&)), _toolBar, SLOT(updateActions()));
connect(_webView, SIGNAL(loadStarted()), _toolBar, SLOT(enableStopAction()));
connect(_webView, SIGNAL(loadFinished(bool)), _toolBar, SLOT(disableStopAction()));
connect(_webView, SIGNAL(titleChanged(const QString&)), this, SLOT(updateTitle()));
connect(_webView, SIGNAL(iconChanged()), this, SLOT(updateIcon()));
connect(_searchBar, SIGNAL(searchDataChanged(const QString&, bool, bool)), _webView,
SLOT(find(const QString&, bool, bool)));
connect(_searchBar, SIGNAL(closeRequested()), _searchBar, SLOT(hide()));
connect(_searchBar, SIGNAL(closeRequested()), _webView, SLOT(setFocus()));
connect(_webView->page(), SIGNAL(linkHovered(const QString&, const QString&, const QString&)),
_statusBar, SLOT(showMessage(const QString&)));
connect(_webView, SIGNAL(loadProgress(int)), _statusBar->progressBar(), SLOT(setValue(int)));
connect(_statusBar->slider(), SIGNAL(valueChanged(int)), _webView, SLOT(setZoom(int)));
connect(_showSearchShortcut, SIGNAL(activated()), _searchBar, SLOT(show()));
connect(_focusAddressShortcut, SIGNAL(activated()), _toolBar->addressBar(), SLOT(setFocus()));
}
void FsRadProgressDlg::setCurrentPercent(const float percent)
{
if (!stopRequested())
{
static float lastPercent = 23456.0f;
if (percent != lastPercent)
{
lastPercent = percent;
CString str;
str.Format(L"%.3f%%", percent);
currentTaskPercent.SetWindowText(str);
currentTaskProgress.SetPos(static_cast<int>(percent * 10.0f));
}
{
CString disp;
currentTaskText.GetWindowText(disp);
CString disp2;
disp2.Format(L"%.2f%% - %s", percent, (LPCWSTR)disp);
SetWindowText(disp2);
}
}
// Update the timer, if it has changed
auto thisTime = time(NULL);
if (thisTime != lastTime() && !paused())
{
lastTime() = thisTime;
auto seconds = lastTime() - runtimeStart();
auto minutes = seconds / 60; seconds -= minutes * 60;
auto hours = minutes / 60; minutes -= hours * 60;
CString dsp;
dsp.Format(L"%02d:%02d:%02d", hours, minutes, seconds);
runtimeText.SetWindowText(dsp);
}
allowBackgroundProcessing();
}
void toEventQuery::stop(void)
{
TLOG(7, toDecorator, __HERE__) << "toEventQuery stop a" << std::endl;
if (WorkDone)
return;
if (Thread && Thread->isRunning())
{
Utils::toBusy busy;
TLOG(7, toDecorator, __HERE__) << "toEventQuery stop Thread is running" << std::endl;
CancelCondition->Mutex.lock();
emit stopRequested();
bool succeeded = CancelCondition->WaitCondition.wait(&CancelCondition->Mutex, 1000); // possible wait for 1 sec
CancelCondition->Mutex.unlock();
if (!succeeded)
{
TLOG(7, toDecorator, __HERE__) << "toEventQuery stop bg did not respond" << std::endl;
if (Connection->ParentConnection.getTraits().hasAsyncBreak())
try
{
(*Connection)->cancel();
}
TOCATCH;
}
virtual bool mayRecordPlan() const {
return complete() && !stopRequested();
}
void RangeDeleter::doWork() {
_env->initThread();
while (!inShutdown() && !stopRequested()) {
string errMsg;
boost::scoped_ptr<OperationContext> txn(getGlobalServiceContext()->newOpCtx());
RangeDeleteEntry* nextTask = NULL;
{
boost::unique_lock<boost::mutex> sl(_queueMutex);
while (_taskQueue.empty()) {
_taskQueueNotEmptyCV.timed_wait(
sl, duration::milliseconds(kNotEmptyTimeoutMillis));
if (stopRequested()) {
log() << "stopping range deleter worker" << endl;
return;
}
if (_taskQueue.empty()) {
// Try to check if some deletes are ready and move them to the
// ready queue.
TaskList::iterator iter = _notReadyQueue.begin();
while (iter != _notReadyQueue.end()) {
RangeDeleteEntry* entry = *iter;
set<CursorId> cursorsNow;
{
if (entry->options.waitForOpenCursors) {
_env->getCursorIds(txn.get(),
entry->options.range.ns,
&cursorsNow);
}
}
set<CursorId> cursorsLeft;
std::set_intersection(entry->cursorsToWait.begin(),
entry->cursorsToWait.end(),
cursorsNow.begin(),
cursorsNow.end(),
std::inserter(cursorsLeft,
cursorsLeft.end()));
entry->cursorsToWait.swap(cursorsLeft);
if (entry->cursorsToWait.empty()) {
(*iter)->stats.queueEndTS = jsTime();
_taskQueue.push_back(*iter);
_taskQueueNotEmptyCV.notify_one();
iter = _notReadyQueue.erase(iter);
}
else {
logCursorsWaiting(entry);
++iter;
}
}
}
}
if (stopRequested()) {
log() << "stopping range deleter worker" << endl;
return;
}
nextTask = _taskQueue.front();
_taskQueue.pop_front();
_deletesInProgress++;
}
{
nextTask->stats.deleteStartTS = jsTime();
bool delResult = _env->deleteRange(txn.get(),
*nextTask,
&nextTask->stats.deletedDocCount,
&errMsg);
nextTask->stats.deleteEndTS = jsTime();
if (delResult) {
nextTask->stats.waitForReplStartTS = jsTime();
if (!_waitForMajority(txn.get(), &errMsg)) {
warning() << "Error encountered while waiting for replication: " << errMsg;
}
nextTask->stats.waitForReplEndTS = jsTime();
}
else {
warning() << "Error encountered while trying to delete range: "
<< errMsg << endl;
}
}
{
boost::lock_guard<boost::mutex> sl(_queueMutex);
NSMinMax setEntry(nextTask->options.range.ns,
nextTask->options.range.minKey,
nextTask->options.range.maxKey);
deletePtrElement(&_deleteSet, &setEntry);
_deletesInProgress--;
if (nextTask->notifyDone) {
nextTask->notifyDone->notifyOne();
}
}
recordDelStats(new DeleteJobStats(nextTask->stats));
delete nextTask;
nextTask = NULL;
}
}
bool RangeDeleter::deleteNow(OperationContext* txn,
const RangeDeleterOptions& options,
string* errMsg) {
if (stopRequested()) {
*errMsg = "deleter is already stopped.";
return false;
}
string dummy;
if (errMsg == NULL) errMsg = &dummy;
const string& ns(options.range.ns);
const BSONObj& min(options.range.minKey);
const BSONObj& max(options.range.maxKey);
NSMinMax deleteRange(ns, min, max);
{
boost::lock_guard<boost::mutex> sl(_queueMutex);
if (!canEnqueue_inlock(ns, min, max, errMsg)) {
return false;
}
_deleteSet.insert(&deleteRange);
// Note: count for pending deletes is an integral part of the shutdown story.
// Therefore, to simplify things, there is no "pending" state for deletes in
// deleteNow, the state transition is simply inProgress -> done.
_deletesInProgress++;
}
set<CursorId> cursorsToWait;
if (options.waitForOpenCursors) {
_env->getCursorIds(txn, ns, &cursorsToWait);
}
long long checkIntervalMillis = 5;
RangeDeleteEntry taskDetails(options);
taskDetails.stats.queueStartTS = jsTime();
for (; !cursorsToWait.empty(); sleepmillis(checkIntervalMillis)) {
logCursorsWaiting(&taskDetails);
set<CursorId> cursorsNow;
_env->getCursorIds(txn, ns, &cursorsNow);
set<CursorId> cursorsLeft;
std::set_intersection(cursorsToWait.begin(),
cursorsToWait.end(),
cursorsNow.begin(),
cursorsNow.end(),
std::inserter(cursorsLeft, cursorsLeft.end()));
cursorsToWait.swap(cursorsLeft);
if (stopRequested()) {
*errMsg = "deleter was stopped.";
boost::lock_guard<boost::mutex> sl(_queueMutex);
_deleteSet.erase(&deleteRange);
_deletesInProgress--;
if (_deletesInProgress == 0) {
_nothingInProgressCV.notify_one();
}
return false;
}
if (checkIntervalMillis < kMaxCursorCheckIntervalMillis) {
checkIntervalMillis *= 2;
}
}
taskDetails.stats.queueEndTS = jsTime();
taskDetails.stats.deleteStartTS = jsTime();
bool result = _env->deleteRange(txn,
taskDetails,
&taskDetails.stats.deletedDocCount,
errMsg);
taskDetails.stats.deleteEndTS = jsTime();
if (result) {
taskDetails.stats.waitForReplStartTS = jsTime();
result = _waitForMajority(txn, errMsg);
taskDetails.stats.waitForReplEndTS = jsTime();
}
{
boost::lock_guard<boost::mutex> sl(_queueMutex);
_deleteSet.erase(&deleteRange);
_deletesInProgress--;
if (_deletesInProgress == 0) {
_nothingInProgressCV.notify_one();
}
}
recordDelStats(new DeleteJobStats(taskDetails.stats));
return result;
}
void RangeDeleter::doWork() {
_env->initThread();
while (!inShutdown() && !stopRequested()) {
string errMsg;
RangeDeleteEntry* nextTask = NULL;
{
scoped_lock sl(_queueMutex);
while (_taskQueue.empty()) {
_taskQueueNotEmptyCV.timed_wait(
sl.boost(), duration::milliseconds(NotEmptyTimeoutMillis));
if (stopRequested()) {
log() << "stopping range deleter worker" << endl;
return;
}
if (_taskQueue.empty()) {
// Try to check if some deletes are ready and move them to the
// ready queue.
TaskList::iterator iter = _notReadyQueue.begin();
while (iter != _notReadyQueue.end()) {
RangeDeleteEntry* entry = *iter;
set<CursorId> cursorsNow;
{
boost::scoped_ptr<OperationContext> txn(getGlobalEnvironment()->newOpCtx());
_env->getCursorIds(txn.get(), entry->ns, &cursorsNow);
}
set<CursorId> cursorsLeft;
std::set_intersection(entry->cursorsToWait.begin(),
entry->cursorsToWait.end(),
cursorsNow.begin(),
cursorsNow.end(),
std::inserter(cursorsLeft,
cursorsLeft.end()));
entry->cursorsToWait.swap(cursorsLeft);
if (entry->cursorsToWait.empty()) {
(*iter)->stats.queueEndTS = jsTime();
_taskQueue.push_back(*iter);
_taskQueueNotEmptyCV.notify_one();
iter = _notReadyQueue.erase(iter);
}
else {
const unsigned long long int elapsedMillis =
entry->stats.queueStartTS.millis - curTimeMillis64();
if ( elapsedMillis > LogCursorsThresholdMillis &&
entry->timeSinceLastLog.millis > LogCursorsIntervalMillis) {
entry->timeSinceLastLog = jsTime();
logCursorsWaiting(entry->ns,
entry->min,
entry->max,
elapsedMillis,
entry->cursorsToWait);
}
++iter;
}
}
}
}
if (stopRequested()) {
log() << "stopping range deleter worker" << endl;
return;
}
nextTask = _taskQueue.front();
_taskQueue.pop_front();
_deletesInProgress++;
}
{
boost::scoped_ptr<OperationContext> txn(getGlobalEnvironment()->newOpCtx());
ReplTime lastOp;
nextTask->stats.deleteStartTS = jsTime();
bool delResult = _env->deleteRange(txn.get(),
*nextTask,
&nextTask->stats.deletedDocCount,
&lastOp,
&errMsg);
nextTask->stats.deleteEndTS = jsTime();
if (delResult) {
nextTask->stats.waitForReplStartTS = jsTime();
if (!_env->waitForReplication(lastOp,
DelWriteConcern,
WaitForReplTimeoutSecs,
&errMsg)) {
warning() << "Error encountered while waiting for replication: "
<< errMsg << endl;
}
nextTask->stats.waitForReplEndTS = jsTime();
}
else {
warning() << "Error encountered while trying to delete range: "
<< errMsg << endl;
}
}
{
scoped_lock sl(_queueMutex);
NSMinMax setEntry(nextTask->ns, nextTask->min, nextTask->max);
deletePtrElement(&_deleteSet, &setEntry);
_deletesInProgress--;
if (nextTask->notifyDone) {
nextTask->notifyDone->notifyOne();
}
}
recordDelStats(new DeleteJobStats(nextTask->stats));
delete nextTask;
nextTask = NULL;
}
}
void FsRadProgressDlg::setLabel10(const TCHAR* text)
{
if (!stopRequested()) label10.SetWindowText(text);
}
connect(&mInterface,SIGNAL(processorsDisconnected(int,int)), SLOT(check()));
connect(&mInterface,SIGNAL(inputPortConnected(QString,PortId,int)), SLOT(check()));
connect(&mInterface,SIGNAL(inputPortDisconnected(QString,PortId,int)), SLOT(check()));
connect(&mInterface, SIGNAL(filterCreated(FilterInfo,int)), SLOT(check()));
connect(&mInterface, SIGNAL(filterDeleted(FilterInfo)), SLOT(check()));
connect(&mInterface, SIGNAL(processorCreated(ProcessorInfo)), SLOT(check()));
connect(&mInterface, SIGNAL(processorDeleted(ProcessorInfo)), SLOT(check()));
connect(&mInterface, SIGNAL(cleared()), SLOT(check()));
connect(&mInterface, SIGNAL(executionFinished()), SLOT(onExecutionFinished()));
connect(&mInterface, SIGNAL(executionStarted()), SLOT(onExecutionStarted()));
connect(&mInterface, SIGNAL(makroInputCreated(QString,PortId,int)), SLOT(check()));
connect(&mInterface, SIGNAL(makroInputRemoved(PortId,int)), SLOT(check()));
// connect signals to olvis interface always QUEUED, to be sure gui has finished all repaints and animations
connect(this, SIGNAL(startRequested()),& mInterface, SLOT(start()), Qt::QueuedConnection);
connect(this, SIGNAL(stopRequested()), &mInterface, SLOT(stop()), Qt::QueuedConnection);
connect(this, SIGNAL(pauseRequested()), &mInterface, SLOT(pause()), Qt::QueuedConnection);
connect(this, SIGNAL(stepRequested(bool)), &mInterface, SLOT(step(bool)), Qt::QueuedConnection);
connect(this, SIGNAL(setTraceEnabled(bool)), &mInterface, SLOT(setTracingEnabled(bool)), Qt::QueuedConnection);
onExecutionFinished();
check();
}
void MainToolBar::initMenu(QMenu* fileMenu, QMenu* olvisMenu)
{
if(fileMenu->actions().size() > 0)
fileMenu->addSeparator();
if(olvisMenu->actions().size() > 0)
olvisMenu->addSeparator();
olvisMenu->addAction(ui->actionImageDisplays);
bool RangeDeleter::deleteNow(OperationContext* txn,
const std::string& ns,
const BSONObj& min,
const BSONObj& max,
const BSONObj& shardKeyPattern,
bool secondaryThrottle,
string* errMsg) {
if (stopRequested()) {
*errMsg = "deleter is already stopped.";
return false;
}
string dummy;
if (errMsg == NULL) errMsg = &dummy;
NSMinMax deleteRange(ns, min, max);
{
scoped_lock sl(_queueMutex);
if (!canEnqueue_inlock(ns, min, max, errMsg)) {
return false;
}
_deleteSet.insert(&deleteRange);
// Note: count for pending deletes is an integral part of the shutdown story.
// Therefore, to simplify things, there is no "pending" state for deletes in
// deleteNow, the state transition is simply inProgress -> done.
_deletesInProgress++;
}
set<CursorId> cursorsToWait;
_env->getCursorIds(txn, ns, &cursorsToWait);
long long checkIntervalMillis = 5;
if (!cursorsToWait.empty()) {
log() << "rangeDeleter waiting for " << cursorsToWait.size()
<< " cursors in " << ns << " to finish" << endl;
}
RangeDeleteEntry taskDetails(ns, min, max, shardKeyPattern, secondaryThrottle);
taskDetails.stats.queueStartTS = jsTime();
Date_t timeSinceLastLog;
for (; !cursorsToWait.empty(); sleepmillis(checkIntervalMillis)) {
const unsigned long long timeNow = curTimeMillis64();
const unsigned long long elapsedTimeMillis =
timeNow - taskDetails.stats.queueStartTS.millis;
const unsigned long long lastLogMillis = timeNow - timeSinceLastLog.millis;
if (elapsedTimeMillis > LogCursorsThresholdMillis &&
lastLogMillis > LogCursorsIntervalMillis) {
timeSinceLastLog = jsTime();
logCursorsWaiting(ns, min, max, elapsedTimeMillis, cursorsToWait);
}
set<CursorId> cursorsNow;
_env->getCursorIds(txn, ns, &cursorsNow);
set<CursorId> cursorsLeft;
std::set_intersection(cursorsToWait.begin(),
cursorsToWait.end(),
cursorsNow.begin(),
cursorsNow.end(),
std::inserter(cursorsLeft, cursorsLeft.end()));
cursorsToWait.swap(cursorsLeft);
if (stopRequested()) {
*errMsg = "deleter was stopped.";
scoped_lock sl(_queueMutex);
_deleteSet.erase(&deleteRange);
_deletesInProgress--;
if (_deletesInProgress == 0) {
_nothingInProgressCV.notify_one();
}
return false;
}
if (checkIntervalMillis < MaxCurorCheckIntervalMillis) {
checkIntervalMillis *= 2;
}
}
taskDetails.stats.queueEndTS = jsTime();
ReplTime lastOp;
taskDetails.stats.deleteStartTS = jsTime();
bool result = _env->deleteRange(txn,
taskDetails,
&taskDetails.stats.deletedDocCount,
&lastOp,
errMsg);
taskDetails.stats.deleteEndTS = jsTime();
if (result) {
taskDetails.stats.waitForReplStartTS = jsTime();
result = _env->waitForReplication(lastOp,
DelWriteConcern,
WaitForReplTimeoutSecs,
errMsg);
taskDetails.stats.waitForReplEndTS = jsTime();
}
{
scoped_lock sl(_queueMutex);
_deleteSet.erase(&deleteRange);
_deletesInProgress--;
if (_deletesInProgress == 0) {
_nothingInProgressCV.notify_one();
}
}
recordDelStats(new DeleteJobStats(taskDetails.stats));
return result;
}
void FsRadProgressDlg::setText9(const TCHAR* text)
{
if (!stopRequested()) text9.SetWindowText(text);
}
void* AsyncWorkerThread::run()
{
lua_State *L = getStack();
std::string script = getServer()->getBuiltinLuaPath() + DIR_DELIM + "init.lua";
try {
loadScript(script);
} catch (const ModError &e) {
errorstream << "Execution of async base environment failed: "
<< e.what() << std::endl;
FATAL_ERROR("Execution of async base environment failed");
}
int error_handler = PUSH_ERROR_HANDLER(L);
lua_getglobal(L, "core");
if (lua_isnil(L, -1)) {
FATAL_ERROR("Unable to find core within async environment!");
}
// Main loop
while (!stopRequested()) {
// Wait for job
LuaJobInfo toProcess = jobDispatcher->getJob();
if (!toProcess.valid || stopRequested()) {
continue;
}
lua_getfield(L, -1, "job_processor");
if (lua_isnil(L, -1)) {
FATAL_ERROR("Unable to get async job processor!");
}
luaL_checktype(L, -1, LUA_TFUNCTION);
// Call it
lua_pushlstring(L,
toProcess.serializedFunction.data(),
toProcess.serializedFunction.size());
lua_pushlstring(L,
toProcess.serializedParams.data(),
toProcess.serializedParams.size());
int result = lua_pcall(L, 2, 1, error_handler);
if (result) {
PCALL_RES(result);
toProcess.serializedResult = "";
} else {
// Fetch result
size_t length;
const char *retval = lua_tolstring(L, -1, &length);
toProcess.serializedResult = std::string(retval, length);
}
lua_pop(L, 1); // Pop retval
// Put job result
jobDispatcher->putJobResult(toProcess);
}
lua_pop(L, 2); // Pop core and error handler
return 0;
}
void *ServerThread::run()
{
DSTACK(FUNCTION_NAME);
BEGIN_DEBUG_EXCEPTION_HANDLER
f32 dedicated_server_step = g_settings->getFloat("dedicated_server_step");
m_server->AsyncRunStep(0.1, true);
auto time = porting::getTimeMs();
while (!stopRequested()) {
try {
m_server->getEnv().getMap().getBlockCacheFlush();
u32 time_now = porting::getTimeMs();
{
TimeTaker timer("Server AsyncRunStep()");
m_server->AsyncRunStep((time_now - time)/1000.0f);
}
time = time_now;
TimeTaker timer("Server Receive()");
// Loop used only when 100% cpu load or on old slow hardware.
// usually only one packet recieved here
u32 end_ms = porting::getTimeMs();
int sleep = (1000 * dedicated_server_step) - (end_ms - time_now);
auto sleep_min = m_server->overload ? 1000 : 50;
if (sleep < sleep_min)
sleep = sleep_min;
end_ms += sleep; //u32(1000 * dedicated_server_step/2);
for (u16 i = 0; i < 1000; ++i) {
if (!m_server->Receive(sleep)) {
//errorstream<<"Server: Recieve nothing=" << i << " per="<<porting::getTimeMs()-(end_ms-sleep)<<" sleep="<<sleep<<std::endl;
break;
}
if (i > 50 && porting::getTimeMs() > end_ms) {
//verbosestream<<"Server: Recieve queue overloaded: processed=" << i << " per="<<porting::getTimeMs()-(end_ms-sleep)<<" sleep="<<sleep << " eventssize=" << m_server->m_con.events_size()<<std::endl;
break;
}
}
auto events = m_server->m_con.events_size();
if (events) {
g_profiler->add("Server: Queue", events);
}
if (events > 500) {
if (!m_server->overload)
errorstream<<"Server: Enabling overload mode queue=" << events << "\n";
if (m_server->overload < events)
m_server->overload = events;
} else {
if (m_server->overload)
errorstream<<"Server: Disabling overload mode queue=" << events << "\n";
m_server->overload = 0;
}
} catch (con::NoIncomingDataException &e) {
//std::this_thread::sleep_for(std::chrono::milliseconds(10));
} catch (con::PeerNotFoundException &e) {
infostream<<"Server: PeerNotFoundException"<<std::endl;
} catch (ClientNotFoundException &e) {
} catch (con::ConnectionBindFailed &e) {
m_server->setAsyncFatalError(e.what());
#if !EXEPTION_DEBUG
} catch (LuaError &e) {
m_server->setAsyncFatalError("Lua: " + std::string(e.what()));
} catch (std::exception &e) {
errorstream << m_name << ": exception: "<<e.what()<<std::endl;
} catch (...) {
errorstream << m_name << ": Ooops..."<<std::endl;
#endif
}
}
END_DEBUG_EXCEPTION_HANDLER
return NULL;
}
bool RangeDeleter::deleteNow(const std::string& ns,
const BSONObj& min,
const BSONObj& max,
const BSONObj& shardKeyPattern,
bool secondaryThrottle,
string* errMsg) {
if (stopRequested()) {
*errMsg = "deleter is already stopped.";
return false;
}
string dummy;
if (errMsg == NULL) errMsg = &dummy;
NSMinMax deleteRange(ns, min, max);
{
scoped_lock sl(_queueMutex);
if (!canEnqueue_inlock(ns, min, max, errMsg)) {
return false;
}
_deleteSet.insert(&deleteRange);
_stats->incTotalDeletes_inlock();
// Note: count for pending deletes is an integral part of the shutdown story.
// Therefore, to simplify things, there is no "pending" state for deletes in
// deleteNow, the state transition is simply inProgress -> done.
_stats->incInProgressDeletes_inlock();
}
set<CursorId> cursorsToWait;
_env->getCursorIds(ns, &cursorsToWait);
long long checkIntervalMillis = 5;
if (!cursorsToWait.empty()) {
log() << "rangeDeleter waiting for " << cursorsToWait.size()
<< " cursors in " << ns << " to finish" << endl;
}
while (!cursorsToWait.empty()) {
set<CursorId> cursorsNow;
_env->getCursorIds(ns, &cursorsNow);
set<CursorId> cursorsLeft;
std::set_intersection(cursorsToWait.begin(),
cursorsToWait.end(),
cursorsNow.begin(),
cursorsNow.end(),
std::inserter(cursorsLeft, cursorsLeft.end()));
cursorsToWait.swap(cursorsLeft);
if (stopRequested()) {
*errMsg = "deleter was stopped.";
scoped_lock sl(_queueMutex);
_deleteSet.erase(&deleteRange);
_stats->decInProgressDeletes_inlock();
_stats->decTotalDeletes_inlock();
if (!_stats->hasInProgress_inlock()) {
_nothingInProgressCV.notify_one();
}
return false;
}
if (checkIntervalMillis < MaxCurorCheckIntervalMillis) {
checkIntervalMillis *= 2;
}
sleepmillis(checkIntervalMillis);
}
bool result = _env->deleteRange(ns, min, max, shardKeyPattern,
secondaryThrottle, errMsg);
{
scoped_lock sl(_queueMutex);
_deleteSet.erase(&deleteRange);
_stats->decInProgressDeletes_inlock();
_stats->decTotalDeletes_inlock();
if (!_stats->hasInProgress_inlock()) {
_nothingInProgressCV.notify_one();
}
}
return result;
}
void ProgressDlg::setText9(const fstl::string & text)
{
if (!stopRequested()) text9.SetWindowText(text.asArray());
}
void ProgressDlg::setLabel10(const fstl::string & text)
{
if (!stopRequested()) label10.SetWindowText(text.asArray());
}
void RangeDeleter::doWork() {
_env->initThread();
while (!inShutdown() && !stopRequested()) {
string errMsg;
RangeDeleteEntry* nextTask = NULL;
{
scoped_lock sl(_queueMutex);
while (_taskQueue.empty()) {
_taskQueueNotEmptyCV.timed_wait(
sl.boost(), duration::milliseconds(NotEmptyTimeoutMillis));
if (stopRequested()) {
log() << "stopping range deleter worker" << endl;
return;
}
if (_taskQueue.empty()) {
// Try to check if some deletes are ready and move them to the
// ready queue.
TaskList::iterator iter = _notReadyQueue.begin();
while (iter != _notReadyQueue.end()) {
RangeDeleteEntry* entry = *iter;
set<CursorId> cursorsNow;
_env->getCursorIds(entry->ns, &cursorsNow);
set<CursorId> cursorsLeft;
std::set_intersection(entry->cursorsToWait.begin(),
entry->cursorsToWait.end(),
cursorsNow.begin(),
cursorsNow.end(),
std::inserter(cursorsLeft,
cursorsLeft.end()));
entry->cursorsToWait.swap(cursorsLeft);
if (entry->cursorsToWait.empty()) {
_taskQueue.push_back(*iter);
_taskQueueNotEmptyCV.notify_one();
iter = _notReadyQueue.erase(iter);
}
else {
++iter;
}
}
}
}
if (stopRequested()) {
log() << "stopping range deleter worker" << endl;
return;
}
nextTask = _taskQueue.front();
_taskQueue.pop_front();
_stats->decPendingDeletes_inlock();
_stats->incInProgressDeletes_inlock();
}
if (!_env->deleteRange(nextTask->ns,
nextTask->min,
nextTask->max,
nextTask->shardKeyPattern,
nextTask->secondaryThrottle,
&errMsg)) {
warning() << "Error encountered while trying to delete range: "
<< errMsg << endl;
}
{
scoped_lock sl(_queueMutex);
NSMinMax setEntry(nextTask->ns, nextTask->min, nextTask->max);
deletePtrElement(&_deleteSet, &setEntry);
_stats->decInProgressDeletes_inlock();
_stats->decTotalDeletes_inlock();
if (nextTask->notifyDone) {
nextTask->notifyDone->notifyOne();
}
delete nextTask;
nextTask = NULL;
}
}
}
void *EmergeThread::run()
{
DSTACK(__FUNCTION_NAME);
BEGIN_DEBUG_EXCEPTION_HANDLER
v3s16 last_tried_pos(-32768,-32768,-32768); // For error output
v3s16 p;
u8 flags = 0;
map = (ServerMap *)&(m_server->m_env->getMap());
emerge = m_server->m_emerge;
mapgen = emerge->mapgen[id];
enable_mapgen_debug_info = emerge->mapgen_debug_info;
while (!stopRequested())
try {
if (!popBlockEmerge(&p, &flags)) {
qevent.wait();
continue;
}
last_tried_pos = p;
if (blockpos_over_limit(p))
continue;
bool allow_generate = flags & BLOCK_EMERGE_ALLOWGEN;
EMERGE_DBG_OUT("p=" PP(p) " allow_generate=" << allow_generate);
/*
Try to fetch block from memory or disk.
If not found and asked to generate, initialize generator.
*/
BlockMakeData data;
MapBlock *block = NULL;
std::map<v3s16, MapBlock *> modified_blocks;
if (getBlockOrStartGen(p, &block, &data, allow_generate) && mapgen) {
{
ScopeProfiler sp(g_profiler, "EmergeThread: Mapgen::makeChunk", SPT_AVG);
TimeTaker t("mapgen::make_block()");
mapgen->makeChunk(&data);
if (enable_mapgen_debug_info == false)
t.stop(true); // Hide output
}
{
//envlock: usually 0ms, but can take either 30 or 400ms to acquire
MutexAutoLock envlock(m_server->m_env_mutex);
ScopeProfiler sp(g_profiler, "EmergeThread: after "
"Mapgen::makeChunk (envlock)", SPT_AVG);
map->finishBlockMake(&data, modified_blocks);
block = map->getBlockNoCreateNoEx(p);
if (block) {
/*
Do some post-generate stuff
*/
v3s16 minp = data.blockpos_min * MAP_BLOCKSIZE;
v3s16 maxp = data.blockpos_max * MAP_BLOCKSIZE +
v3s16(1,1,1) * (MAP_BLOCKSIZE - 1);
// Ignore map edit events, they will not need to be sent
// to anybody because the block hasn't been sent to anybody
MapEditEventAreaIgnorer
ign(&m_server->m_ignore_map_edit_events_area,
VoxelArea(minp, maxp));
try { // takes about 90ms with -O1 on an e3-1230v2
m_server->getScriptIface()->environment_OnGenerated(
minp, maxp, mapgen->blockseed);
} catch (LuaError &e) {
m_server->setAsyncFatalError("Lua: " + std::string(e.what()));
}
EMERGE_DBG_OUT("ended up with: " << analyze_block(block));
m_server->m_env->activateBlock(block, 0);
}
}
}
/*
Set sent status of modified blocks on clients
*/
// Add the originally fetched block to the modified list
if (block)
modified_blocks[p] = block;
if (modified_blocks.size() > 0) {
m_server->SetBlocksNotSent(modified_blocks);
}
}
catch (VersionMismatchException &e) {
std::ostringstream err;
err << "World data version mismatch in MapBlock " << PP(last_tried_pos) << std::endl
<< "----" << std::endl
<< "\"" << e.what() << "\"" << std::endl
<< "See debug.txt." << std::endl
<< "World probably saved by a newer version of " PROJECT_NAME_C "."
<< std::endl;
m_server->setAsyncFatalError(err.str());
}
catch (SerializationError &e) {
std::ostringstream err;
err << "Invalid data in MapBlock " << PP(last_tried_pos) << std::endl
<< "----" << std::endl
<< "\"" << e.what() << "\"" << std::endl
<< "See debug.txt." << std::endl
<< "You can ignore this using [ignore_world_load_errors = true]."
<< std::endl;
m_server->setAsyncFatalError(err.str());
}
{
MutexAutoLock queuelock(emerge->queuemutex);
while (!blockqueue.empty())
{
v3s16 p = blockqueue.front();
blockqueue.pop();
std::map<v3s16, BlockEmergeData *>::iterator iter;
iter = emerge->blocks_enqueued.find(p);
if (iter == emerge->blocks_enqueued.end())
continue; //uh oh, queue and map out of sync!!
BlockEmergeData *bedata = iter->second;
delete bedata;
}
}
END_DEBUG_EXCEPTION_HANDLER(errorstream)
return NULL;
}
void *EmergeThread::run()
{
DSTACK(FUNCTION_NAME);
BEGIN_DEBUG_EXCEPTION_HANDLER
v3s16 pos;
m_map = (ServerMap *)&(m_server->m_env->getMap());
m_emerge = m_server->m_emerge;
m_mapgen = m_emerge->m_mapgens[id];
enable_mapgen_debug_info = m_emerge->enable_mapgen_debug_info;
try {
while (!stopRequested()) {
std::map<v3s16, MapBlock *> modified_blocks;
BlockEmergeData bedata;
BlockMakeData bmdata;
EmergeAction action;
MapBlock *block;
if (!popBlockEmerge(&pos, &bedata)) {
m_queue_event.wait();
continue;
}
if (blockpos_over_limit(pos))
continue;
bool allow_gen = bedata.flags & BLOCK_EMERGE_ALLOW_GEN;
EMERGE_DBG_OUT("pos=" PP(pos) " allow_gen=" << allow_gen);
action = getBlockOrStartGen(pos, allow_gen, &block, &bmdata);
if (action == EMERGE_GENERATED) {
{
ScopeProfiler sp(g_profiler,
"EmergeThread: Mapgen::makeChunk", SPT_AVG);
TimeTaker t("mapgen::make_block()");
m_mapgen->makeChunk(&bmdata);
if (enable_mapgen_debug_info == false)
t.stop(true); // Hide output
}
block = finishGen(pos, &bmdata, &modified_blocks);
}
runCompletionCallbacks(pos, action, bedata.callbacks);
if (block)
modified_blocks[pos] = block;
if (modified_blocks.size() > 0)
m_server->SetBlocksNotSent(modified_blocks);
}
} catch (VersionMismatchException &e) {
std::ostringstream err;
err << "World data version mismatch in MapBlock " << PP(pos) << std::endl
<< "----" << std::endl
<< "\"" << e.what() << "\"" << std::endl
<< "See debug.txt." << std::endl
<< "World probably saved by a newer version of " PROJECT_NAME_C "."
<< std::endl;
m_server->setAsyncFatalError(err.str());
} catch (SerializationError &e) {
std::ostringstream err;
err << "Invalid data in MapBlock " << PP(pos) << std::endl
<< "----" << std::endl
<< "\"" << e.what() << "\"" << std::endl
<< "See debug.txt." << std::endl
<< "You can ignore this using [ignore_world_load_errors = true]."
<< std::endl;
m_server->setAsyncFatalError(err.str());
}
END_DEBUG_EXCEPTION_HANDLER
return NULL;
}
void LocalMapping::Run()
{
//ros::Rate r(500);
//while(ros::ok())
while(true)
{
// Check if there are keyframes in the queue
if(CheckNewKeyFrames())
{
// Tracking will see that Local Mapping is busy
SetAcceptKeyFrames(false);
// BoW conversion and insertion in Map
ProcessNewKeyFrame();
// Check recent MapPoints
MapPointCulling();
// Triangulate new MapPoints
CreateNewMapPoints();
// Find more matches in neighbor keyframes and fuse point duplications
SearchInNeighbors();
mbAbortBA = false;
if(!CheckNewKeyFrames() && !stopRequested())
{
// Local BA
Optimizer::LocalBundleAdjustment(mpCurrentKeyFrame,&mbAbortBA);
// Check redundant local Keyframes
KeyFrameCulling();
mpMap->SetFlagAfterBA();
// Tracking will see Local Mapping idle
if(!CheckNewKeyFrames())
SetAcceptKeyFrames(true);
}
mpLoopCloser->InsertKeyFrame(mpCurrentKeyFrame);
}
// Safe area to stop
if(stopRequested())
{
Stop();
//ros::Rate r2(1000);
while(isStopped())
{
//r2.sleep();
boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
}
SetAcceptKeyFrames(true);
}
ResetIfRequested();
boost::this_thread::sleep(boost::posix_time::milliseconds(500));
}
}
void LocalMapping::RunClient() {
mbFinished = false;
while(1) {
// Tracking will see that Local Mapping is busy
SetAcceptKeyFrames(false);
// Check if there are keyframes in the queue
if(CheckNewKeyFrames()) {
// Get Communicator Mutex -> Comm cannot publish. Assure no publishing whilst changing data
// if(mpComm->mbStrictLock) unique_lock<mutex> lockComm(mpComm->mMutexForMapping);
if(mVerboseMode == -9) {
cout << "xxx Mapping --> Lock Mapping xxx" << endl;
}
if(mVerboseMode == -9) {
cout << "LockSleep: " << mpCC->mLockSleep << endl;
}
if(mpComm->mbStrictLock) while(!mpCC->LockMapping()) {
usleep(mpCC->mLockSleep);
}
if(mVerboseMode == -9) {
cout << "xxx Mapping --> Mapping Locked xxx" << endl;
}
// BoW conversion and insertion in Map
ProcessNewKeyFrame();
// Check recent MapPoints
MapPointCulling();
// Triangulate new MapPoints
CreateNewMapPoints();
if(!CheckNewKeyFrames()) {
// Find more matches in neighbor keyframes and fuse point duplications
SearchInNeighbors();
}
mbAbortBA = false;
if(!CheckNewKeyFrames() && !stopRequested()) {
// Local BA
if(mpMap->KeyFramesInMap() > 2) {
Optimizer::LocalBundleAdjustmentClient(mpCurrentKeyFrame, &mbAbortBA, mpMap, mpComm, mClientId);
}
// // Check redundant local Keyframes
// KeyFrameCulling();
}
if(mpComm->mbStrictLock) {
mpCC->UnLockMapping();
}
} else if(Stop()) {
// Safe area to stop
while(isStopped() && !CheckFinish()) {
usleep(mMappingRate);
}
if(CheckFinish()) {
break;
}
}
ResetIfRequested();
// Tracking will see that Local Mapping is busy
SetAcceptKeyFrames(true);
if(CheckFinish()) {
break;
}
usleep(mMappingRate);
}
SetFinish();
}
void ThreadServerPool::run(void)
{
try
{
// Create server socket
this->_socketServer = new TCPSocketServer(this->_port);
}
catch(const SocketException& exception)
{
// Send message
emit message("Starting server error : " +
QString::fromStdString(exception.what()));
return;
}
// Launch all threads client
foreach (ThreadClient* threadClient, this->_threadsClient)
threadClient->start();
// Main loop
while(true)
{
if (stopRequested())
break;
// Waiting client
try
{
emit message("Thread server : wainting client");
this->_socketClient = _socketServer->nextPendingConnection();
emit message("Thread server : client connected");
}
catch(const SocketException& exception)
{
delete this->_socketServer;
this->_socketServer = NULL;
// Send message
emit message("Thread server : stop waiting client : " +
QString::fromStdString(exception.what()));
continue;
}
// Check if the server is suspended
if (this->_suspended)
{
emit message("Thread server : Client rejected. Serer is suspended");
this->sendFAILMessage("Server suspended");
continue;
}
// Check if a thread is available for the newly connected client
if (clients.count() >= this->_threadsClientCount)
{
emit message("Thread server : no thread client available");
// Notify the client that connection is rejected
this->sendFAILMessage("Connection failure server full");
continue;
}
// Add newly connected client to the list
conditionMutex.lock();
clients.append(this->_socketClient);
++clientAvailable;
conditionMutex.unlock();
emit clientsCountChanged(clients.count());
this->_socketClient = NULL; // Thread client free socket
// Wakes one thread waiting a new client
clientsIsNotEmpty.wakeOne();
}
}
