void TestTaskManager::fail_registerMachine_command_not_found() { TaskManager *manager = new TaskManager(); QSignalSpy sig_reg(manager, SIGNAL(registerMachineStatus(TaskStatus, QString))); QVariantList response; TaskStatus status; QString reason; // Fail to register with a non-existent tarsnap dir. manager->registerMachine("fake-user", "fake-password", "fake-machine", "fake.key", "/fake/dir", "/tmp/gui-test-tarsnap-cache"); QTest::qWait(TASK_CMDLINE_WAIT_MS); // Get failure message. QVERIFY(sig_reg.count() == 1); response = sig_reg.takeFirst(); status = response.at(0).value<TaskStatus>(); reason = response.at(1).toString(); QVERIFY(status == TaskStatus::Failed); QVERIFY(reason == "Could not find the command-line program"); delete manager; }
void ZoneServerImplementation::printInfo() { lock(); TaskManager* taskMgr = Core::getTaskManager(); StringBuffer msg; if (taskMgr != NULL) msg << taskMgr->getInfo(false) << endl; //msg << "MessageQueue - size = " << processor->getMessageQueue()->size() << endl; float packetloss; if (totalSentPackets + totalSentPackets == 0) packetloss = 0.0f; else packetloss = (100 * totalResentPackets) / (totalResentPackets + totalSentPackets); #ifndef WITH_STM msg << "sent packets = " << totalSentPackets << ", resent packets = " << totalResentPackets << " [" << packetloss << "%]" << endl; #endif msg << dec << currentPlayers << " users connected (" << maximumPlayers << " max, " << totalPlayers << " total, " << totalDeletedPlayers << " deleted)" << endl; #ifndef WITH_STM msg << ObjectManager::instance()->getInfo() << endl; if (playerManager != NULL) msg << dec << playerManager->getOnlineZoneClientMap()->getDistinctIps() << " total distinct ips connected"; #endif unlock(); info(msg.toString(), true); }
void TaskManagerTest::testError() { TaskManager tm; TaskObserver to; tm.addObserver(Observer<TaskObserver, TaskStartedNotification>(to, &TaskObserver::taskStarted)); tm.addObserver(Observer<TaskObserver, TaskCancelledNotification>(to, &TaskObserver::taskCancelled)); tm.addObserver(Observer<TaskObserver, TaskFailedNotification>(to, &TaskObserver::taskFailed)); tm.addObserver(Observer<TaskObserver, TaskFinishedNotification>(to, &TaskObserver::taskFinished)); tm.addObserver(Observer<TaskObserver, TaskProgressNotification>(to, &TaskObserver::taskProgress)); AutoPtr<TestTask> pTT = new TestTask; tm.start(pTT.duplicate()); assert (pTT->progress() == 0); Thread::sleep(200); pTT->cont(); while (pTT->progress() != 0.5) Thread::sleep(50); assert (to.progress() == 0.5); assert (to.started()); assert (pTT->state() == Task::TASK_RUNNING); TaskManager::TaskList list = tm.taskList(); assert (list.size() == 1); assert (tm.count() == 1); pTT->fail(); pTT->cont(); while (pTT->state() != Task::TASK_FINISHED) Thread::sleep(50); assert (pTT->state() == Task::TASK_FINISHED); assert (to.finished()); assert (to.error() != 0); while (tm.count() == 1) Thread::sleep(50); list = tm.taskList(); assert (list.empty()); }
void TestTaskManager::fail_registerMachine_empty_key() { TARSNAP_CLI_OR_SKIP; TaskManager *manager = new TaskManager(); QSignalSpy sig_reg(manager, SIGNAL(registerMachineStatus(TaskStatus, QString))); QVariantList response; TaskStatus status; QString reason; // Fail to register with a key that doesn't support --fsck-prune. manager->registerMachine("fake-user", "fake-password", "fake-machine", "empty.key", tarsnapPath, "/tmp/gui-test-tarsnap-cache"); QTest::qWait(TASK_CMDLINE_WAIT_MS); // Get failure message. QVERIFY(sig_reg.count() == 1); response = sig_reg.takeFirst(); status = response.at(0).value<TaskStatus>(); reason = response.at(1).toString(); QVERIFY(status == TaskStatus::Failed); QVERIFY(reason.contains("tarsnap: Key file has unreasonable size")); delete manager; }
void validate(const TaskManager& tasks, const ItemManager& items, std::ostream& os){ auto taskEnd = tasks.cend(); auto itemEnd = items.cend(); const int EQUAL = 0; bool isAvailable; // enumerate all tiems for (auto item = items.cbegin(); item != itemEnd; ++item) { isAvailable = false; // enumerate all tasks, compare each task with item destination for (auto singleTask = tasks.cbegin(); singleTask != taskEnd; ++singleTask) { if((item->getDestination()).compare(singleTask->getName()) == EQUAL){ isAvailable = true; break; } } if (isAvailable == false) { os << item->getDestination() << " is unavailable\n"; } } }
/// Worker Worker routine. /// This is the routine every worker thread runs. /// The worker thread continuously asks for Tasks and executes them. /// /// Note that worker threads are NOT guarenteed to ever call Worker.exit() /// before the program ends. void workerLoop ( Worker * me, void* args ) { task_worker_args* wargs = (task_worker_args*) args; TaskManager* tasks = wargs->tasks; TaskingScheduler * sched = wargs->scheduler; sched->onWorkerStart(); StateTimer::setThreadState( StateTimer::FINDWORK ); StateTimer::enterState_findwork(); Task nextTask; while ( true ) { // block until receive work or termination reached if (!tasks->getWork(&nextTask)) break; // quitting time sched->num_active_tasks++; StateTimer::setThreadState( StateTimer::USER ); StateTimer::enterState_user(); { GRAPPA_PROFILE( exectimer, "user_execution", "", GRAPPA_USER_GROUP ); nextTask.execute(); } StateTimer::setThreadState( StateTimer::FINDWORK ); sched->num_active_tasks--; sched->thread_yield( ); // yield to the scheduler } }
int main() { CanStorage c_list; MoneyKeeper mk; ioHandler ioh; TaskManager tm; // load from file. ioh.loadCanStorage("canlist.txt", c_list); while (1) { int menu = ioh.getMenu(); if (menu == EXIT) break; // 프로그램 종료 switch (menu) { case COIN_DEPOSIT: // 동전투입 tm.insertCoin(mk); break; case ITEM_SELECTION: // 상품선택 tm.selectMenu(mk, c_list); break; case CHANGE_RETURN: // 잔돈반환 tm.returnCoin(mk); break; case EXIT: // 프로그램 종료 return 0; } } }
void TestTaskManager::get_version() { TARSNAP_CLI_OR_SKIP; TaskManager *manager = new TaskManager(); QSignalSpy sig_ver(manager, SIGNAL(tarsnapVersion(QString))); QString ver_str; // We start off with no version signal. QVERIFY(sig_ver.count() == 0); // Get version number manager->getTarsnapVersion(""); QTest::qWait(TASK_CMDLINE_WAIT_MS); QVERIFY(sig_ver.count() == 1); ver_str = sig_ver.takeFirst().at(0).toString(); // Verify that it's a real version number for(const QString &part : ver_str.split(".")) { for(int i = 0; i < part.size(); i++) { QVERIFY(part[i].isDigit()); } } // Get a failure manager->getTarsnapVersion("fake-dir"); QTest::qWait(TASK_CMDLINE_WAIT_MS); QVERIFY(sig_ver.count() == 1); ver_str = sig_ver.takeFirst().at(0).toString(); QVERIFY(ver_str.isEmpty()); delete manager; }
void TestTaskManager::sleep_cancel() { // Set up the manager. TaskManager *manager = new TaskManager(); QSignalSpy sig_message(manager, SIGNAL(message(QString, QString))); // Set up a task. TarsnapTask *task = new TarsnapTask(); QSignalSpy sig_started(task, SIGNAL(started(QVariant))); task->setCommand("/bin/sh"); task->setArguments(QStringList(get_script("sleep-9-exit-0.sh"))); task->setData(QString("started-9")); // Start running it, wait a second. manager->startTask(task); QTest::qWait(1000); QVERIFY(sig_started.count() == 1); QVERIFY(sig_started.takeFirst().at(0).value<QString>() == "started-9"); QVERIFY(sig_message.count() == 0); // Cancel it manager->stopTasks(false, true, false); QVERIFY(sig_message.count() == 1); QVERIFY(sig_message.takeFirst().at(0).value<QString>() == "Stopped running tasks."); QTest::qWait(1000); // task is deleted by the task manager delete manager; }
bool test_task_fai(TaskManager& task_manager, const Waypoints &waypoints) { task_manager.set_factory(TaskBehaviour::FACTORY_FAI_GENERAL); AbstractTaskFactory &fact = task_manager.get_factory(); const Waypoint *wp; task_report(task_manager, "# adding start\n"); wp = waypoints.lookup_id(1); if (wp) { OrderedTaskPoint *tp = fact.createStart(*wp); if (!fact.append(*tp)) { return false; } delete tp; } task_manager.setActiveTaskPoint(0); task_manager.resume(); task_report(task_manager, "# adding intermdiate\n"); wp = waypoints.lookup_id(2); if (wp) { OrderedTaskPoint *tp = fact.createIntermediate(*wp); if (!fact.append(*tp, false)) { return false; } delete tp; } task_report(task_manager, "# adding intermdiate\n"); wp = waypoints.lookup_id(3); if (wp) { OrderedTaskPoint *tp = fact.createIntermediate(*wp); if (!fact.append(*tp,false)) { return false; } delete tp; } task_report(task_manager, "# adding finish\n"); wp = waypoints.lookup_id(1); if (wp) { OrderedTaskPoint *tp = fact.createFinish(*wp); if (!fact.append(*tp,false)) { return false; } delete tp; } task_report(task_manager, "# checking task\n"); if (!fact.validate()) { return false; } if (!task_manager.check_ordered_task()) { return false; } return true; }
int main() { IoHandler ioh; MatrixGraph mg; ListGraph lg; TaskManager tm; while (1) { char menu = ioh.getMenu(); switch (menu) { case 's': // 탐색 case 'S': tm.searchGraph(mg, lg); break; case 'm': // 최소비용 신장트리 case 'M': break; case 't': // 위상정렬 case 'T': break; case 'q': // 종료 case 'Q': exit(1); } } system("pause"); return 0; }
void ChartProjection::Set(const PixelRect &rc, const TaskManager &task, const GeoPoint &fallback_loc) { const GeoPoint center = task.GetTaskCenter(fallback_loc); const fixed radius = max(fixed(10000), task.GetTaskRadius(fallback_loc)); set_projection(rc, center, radius); }
bool test_task_or(TaskManager& task_manager, const Waypoints &waypoints) { const Waypoint *wp; task_manager.SetFactory(TaskFactoryType::FAI_OR); AbstractTaskFactory &fact = task_manager.GetFactory(); task_report(task_manager, "# adding start\n"); wp = waypoints.LookupId(1); if (wp) { OrderedTaskPoint *tp = fact.CreateStart(*wp); if (!fact.Append(*tp)) { return false; } delete tp; } task_manager.SetActiveTaskPoint(0); task_manager.Resume(); task_report(task_manager, "# adding intermediate\n"); wp = waypoints.LookupId(2); if (wp) { OrderedTaskPoint *tp = fact.CreateIntermediate(*wp); if (!fact.Append(*tp)) { return false; } delete tp; } task_report(task_manager, "# adding finish\n"); wp = waypoints.LookupId(1); if (wp) { OrderedTaskPoint *tp = fact.CreateFinish(*wp); if (!fact.Append(*tp)) { return false; } delete tp; } fact.UpdateStatsGeometry(); task_report(task_manager, "# checking task..\n"); if (!fact.Validate()) { return false; } if (!task_manager.CheckOrderedTask()) { return false; } return true; }
int main(const ArgVec& args) { if (!_helpRequested) { TaskManager tm; tm.start(new SampleTask); waitForTerminationRequest(); tm.cancelAll(); tm.joinAll(); } return Application::EXIT_OK; }
static void CreateDefaultTask(TaskManager &task_manager, const Waypoints &way_points) { const TCHAR start_name[] = _T("Bergneustadt"); task_manager.set_factory(OrderedTask::FACTORY_MIXED); AbstractTaskFactory &factory = task_manager.get_factory(); const Waypoint *wp; OrderedTaskPoint *tp; wp = way_points.lookup_name(start_name); if (wp != NULL) { tp = factory.createStart(AbstractTaskFactory::START_LINE, *wp); if (!factory.append(tp, false)) { fprintf(stderr, "Failed to create start point\n"); } } else { fprintf(stderr, "No start waypoint\n"); } wp = way_points.lookup_name(_T("Uslar")); if (wp != NULL) { tp = factory.createIntermediate(AbstractTaskFactory::AST_CYLINDER, *wp); if (!factory.append(tp, false)) { fprintf(stderr, "Failed to create turn point\n"); } } else { fprintf(stderr, "No turn point\n"); } wp = way_points.lookup_name(_T("Suhl Goldlaut")); if (wp != NULL) { tp = factory.createIntermediate(AbstractTaskFactory::AST_CYLINDER, *wp); if (!factory.append(tp, false)) { fprintf(stderr, "Failed to create turn point\n"); } } else { fprintf(stderr, "No turn point\n"); } wp = way_points.lookup_name(start_name); if (wp != NULL) { tp = factory.createFinish(AbstractTaskFactory::FINISH_LINE, *wp); if (!factory.append(tp, false)) { fprintf(stderr, "Failed to create finish point\n"); } } else { fprintf(stderr, "No finish waypoint\n"); } }
AirspaceWarningManager::AirspaceWarningManager(const Airspaces& airspaces, const AIRCRAFT_STATE &state, const TaskManager &task_manager, const fixed& prediction_time_glide, const fixed& prediction_time_filter): m_airspaces(airspaces), m_prediction_time_glide(prediction_time_glide), m_prediction_time_filter(prediction_time_filter), m_perf_glide(task_manager.get_glide_polar()), m_state_filter(state, prediction_time_filter), m_perf_filter(m_state_filter), m_task(task_manager), m_glide_polar(task_manager.get_glide_polar()) { }
// _RequestThread int32 AuthenticationServer::_RequestThread() { TaskManager taskManager; while (!fTerminating) { taskManager.RemoveDoneTasks(); // read the request KMessage request; status_t error = request.ReceiveFrom(fRequestPort); if (error != B_OK) continue; // get the parameters const char* context = NULL; const char* server = NULL; const char* share = NULL; bool badPassword = true; request.FindString("context", &context); request.FindString("server", &server); request.FindString("share", &share); request.FindBool("badPassword", &badPassword); if (!context || !server || !share) continue; String foundUser; String foundPassword; if (!badPassword && _GetAuthentication(context, server, share, &foundUser, &foundPassword)) { _SendRequestReply(request.ReplyPort(), request.ReplyToken(), error, false, foundUser.GetString(), foundPassword.GetString()); } else { // we need to ask the user: create a task that does it UserDialogTask* task = new(nothrow) UserDialogTask(this, context, server, share, badPassword, request.ReplyPort(), request.ReplyToken()); if (!task) { ERROR(("AuthenticationServer::_RequestThread(): ERROR: " "failed to allocate ")); continue; } status_t error = taskManager.RunTask(task); if (error != B_OK) { ERROR(("AuthenticationServer::_RequestThread(): Failed to " "start server info task: %s\n", strerror(error))); continue; } } } return 0; }
TaskManager& TaskManager::instance() { Kernel::Singleton* s = Kernel::Framework::instance().getSingleton("TaskManager"); if (s == nullptr) { TaskManager *f = new TaskManager("TaskManager"); Kernel::Framework::instance().registerSingleton("TaskManager",f); return *f; } else { TaskManager *f = static_cast<TaskManager*>(s); f->registerDelayed(); return *f; } }
void RenderSpeed(Canvas &canvas, const PixelRect rc, const ChartLook &chart_look, const FlightStatistics &fs, const NMEAInfo &nmea_info, const DerivedInfo &derived_info, const TaskManager &task) { ChartRenderer chart(chart_look, canvas, rc); if (!fs.task_speed.HasResult() || !task.CheckOrderedTask()) { chart.DrawNoData(); return; } chart.ScaleXFromData(fs.task_speed); chart.ScaleYFromData(fs.task_speed); chart.ScaleYFromValue(0); chart.ScaleXFromValue(fs.task_speed.GetMinX()); DrawLegs(chart, task, nmea_info, derived_info, true); chart.DrawXGrid(0.5, ChartLook::STYLE_THINDASHPAPER, 0.5, true); chart.DrawYGrid(Units::ToSysTaskSpeed(10), ChartLook::STYLE_THINDASHPAPER, 10, true); chart.DrawLineGraph(fs.task_speed, ChartLook::STYLE_MEDIUMBLACK); chart.DrawTrend(fs.task_speed, ChartLook::STYLE_BLUETHIN); chart.DrawXLabel(_T("t"), _T("hr")); chart.DrawYLabel(_T("h"), Units::GetTaskSpeedName()); }
ProtectedTaskManager(TaskManager &_task_manager, const TaskBehaviour& tb, TaskEvents& te, Airspaces &airspaces) :Guard<TaskManager>(_task_manager), task_behaviour(tb), task_events(te), m_airspaces(airspaces), m_route(_task_manager.get_glide_polar(), m_airspaces) {}
void TestTaskManager::initTestCase() { QCoreApplication::setOrganizationName(TEST_NAME); ConsoleLog::initializeConsoleLog(); // This is to "warm up" the command-line tasks. TaskManager *manager = new TaskManager(); QSignalSpy sig_ver(manager, SIGNAL(tarsnapVersion(QString))); manager->getTarsnapVersion(""); // Wait for task to finish while(sig_ver.count() == 0) QTest::qWait(TASK_CMDLINE_WAIT_MS); delete manager; }
static void DrawLegs(ChartRenderer &chart, const TaskManager &task_manager, const NMEAInfo& basic, const DerivedInfo& calculated, const bool task_relative) { const TaskStats &task_stats = calculated.ordered_task_stats; if (!task_stats.start.task_started) return; const auto start_time = task_relative ? basic.time - task_stats.total.time_elapsed : calculated.flight.takeoff_time; const OrderedTask &task = task_manager.GetOrderedTask(); for (unsigned i = 0, n = task.TaskSize(); i < n; ++i) { const OrderedTaskPoint &tp = task.GetTaskPoint(i); if (!IsTaskLegVisible(tp)) continue; auto x = tp.GetEnteredState().time - start_time; if (x >= 0) { x /= 3600; chart.DrawLine(x, chart.GetYMin(), x, chart.GetYMax(), ChartLook::STYLE_REDTHICK); } } }
bool test_task_or(TaskManager& task_manager, const Waypoints &waypoints) { const Waypoint *wp; task_manager.set_factory(OrderedTask::FACTORY_TOURING); AbstractTaskFactory &fact = task_manager.get_factory(); task_report(task_manager, "# adding start\n"); wp = waypoints.lookup_id(1); if (wp) { if (!fact.append(fact.createStart(*wp))) { return false; } } task_manager.setActiveTaskPoint(0); task_manager.resume(); task_report(task_manager, "# adding intermediate\n"); wp = waypoints.lookup_id(2); if (wp) { if (!fact.append(fact.createIntermediate(*wp))) { return false; } } task_report(task_manager, "# adding finish\n"); wp = waypoints.lookup_id(1); if (wp) { if (!fact.append(fact.createFinish(*wp))) { return false; } } task_report(task_manager, "# checking task..\n"); if (!fact.validate()) { return false; } if (!task_manager.check_ordered_task()) { return false; } return true; }
void task_report(const TaskManager &task_manager, const char *text) { AircraftState ac; if (verbose) { printf("%s",text); const AbstractTask *task = task_manager.GetActiveTask(); if (task != NULL) { switch (task->GetType()) { case TaskType::NONE: printf("# task is none\n"); break; case TaskType::ORDERED: printf("# task is ordered\n"); task_manager.GetFactory().UpdateGeometry(); break; case TaskType::ABORT: printf("# task is abort\n"); break; case TaskType::GOTO: printf("# task is goto\n"); break; } TaskPointVisitorPrint tpv; task->AcceptTaskPointVisitor(tpv); printf("# - dist nominal %g\n", (double)task->GetStats().distance_nominal); if (task->GetType() == TaskType::ORDERED && task->GetStats().distance_max > task->GetStats().distance_min) { printf("# - dist max %g\n", (double)task->GetStats().distance_max); printf("# - dist min %g\n", (double)task->GetStats().distance_min); } } PrintHelper::taskmanager_print(task_manager, ac); } if (interactive>1) { WaitPrompt(); } }
static unsigned GetBestAlternateID(const TaskManager &tm) { const auto &alternates = tm.GetAlternates(); return alternates.empty() ? unsigned(-1) : alternates.front().waypoint.id; }
void executeScript(string script) { if (script.find("setCentralCommandHostInfo") != std::string::npos) { TaskManager *taskManager = TaskManager::getInstance(); int substr_pos = script.find("@") + 1; string value_str = script.substr(substr_pos); vector<string>value_str_values = Valter::split(value_str, '@'); taskManager->getTcpInterface()->setCentralCommandHostIP(value_str_values[0]); taskManager->getTcpInterface()->setCentralCommandHostIPPort(atoi(Valter::stringToCharPtr(value_str_values[1]))); qDebug("[TaskManager] Central Command Host IP Address:%s Port:%d", taskManager->getTcpInterface()->getCentralCommandHostIP().c_str(), taskManager->getTcpInterface()->getCentralCommandHostIPPort()); return; } TaskManager::getInstance()->processScript(script); }
//do all the tasks from a file void Executor::ExecuteFile(std::string name) { ResourceManager resources; //init resource manager TaskManager tasks; //init task manager tasks.FromFile(name); //parsem file tasks.SortTasks(); //do topological sort Task* temp; while((temp=tasks.GetTask())!=NULL) { //find and execute appropriate action std::map<std::string,executive>::iterator found=functions.find(temp->type); if(found==functions.end()) Log::AddMessage("Unsupported task: "+temp->type,Log::ERR); Log::AddMessage("Task "+temp->name+" started...",Log::LOW); (*found).second(resources,temp); Log::AddMessage("Task "+temp->name+" finished",Log::LOW); } }
bool test_task_dash(TaskManager& task_manager, const Waypoints &waypoints) { WaypointPtr wp; task_manager.SetFactory(TaskFactoryType::TOURING); AbstractTaskFactory &fact = task_manager.GetFactory(); task_report(task_manager, "# adding start\n"); wp = waypoints.LookupId(1); if (wp) { OrderedTaskPoint *tp = fact.CreateStart(std::move(wp)); if (!fact.Append(*tp)) { return false; } delete tp; } task_manager.SetActiveTaskPoint(0); task_manager.Resume(); task_report(task_manager, "# adding finish\n"); wp = waypoints.LookupId(3); if (wp) { OrderedTaskPoint *tp = fact.CreateFinish(std::move(wp)); if (!fact.Append(*tp)) { return false; } delete tp; } fact.UpdateStatsGeometry(); task_report(task_manager, "# checking task..\n"); if (!fact.Validate()) { return false; } if (!task_manager.CheckOrderedTask()) { return false; } return true; }
// _ServerInfoConnectionListener int32 NetFSServer::_ServerInfoConnectionListener() { if (fServerInfoConnectionListenerSocket < 0) return B_BAD_VALUE; TaskManager taskManager; // accept a incoming connection while (!fTerminating) { int fd = -1; do { taskManager.RemoveDoneTasks(); fd = accept(fServerInfoConnectionListenerSocket, NULL, 0); if (fd < 0) { status_t error = errno; if (error != B_INTERRUPTED) return error; if (fTerminating) return B_OK; } } while (fd < 0); // get a fresh server info ServerInfo info; status_t error = _GetServerInfo(info); if (error != B_OK) { closesocket(fd); return error; } // create a server info sender thread ServerInfoSender* sender = new(std::nothrow) ServerInfoSender(fd, info); if (!sender || sender->Init() != B_OK) { closesocket(fd); delete sender; } taskManager.RunTask(sender); } return B_OK; }
int main( void ){ initSocket(); int row = 0; int col = 0; list<string> l; l.push_back("hi"); l.push_back("hello"); l.push_back("nemo"); TaskManager tm; tm.addQueue( l ); tm.addTaskToSpecifyQueue(Task(), l); tm.showAll(); HANDLE h = tm.startProcessThread( &tm , run ); return 0; }