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;
}