void tst_IrcCommand::testQuote() { QScopedPointer<IrcCommand> cmd1(IrcCommand::createQuote("CUSTOM")); QVERIFY(cmd1.data()); QCOMPARE(cmd1->type(), IrcCommand::Quote); QVERIFY(cmd1->toString().contains(QRegExp("\\bCUSTOM\\b"))); QScopedPointer<IrcCommand> cmd2(IrcCommand::createQuote(QStringList() << "FOO" << "BAR")); QVERIFY(cmd2.data()); QCOMPARE(cmd2->type(), IrcCommand::Quote); QVERIFY(cmd2->toString().contains(QRegExp("\\bFOO\\b"))); QVERIFY(cmd2->toString().contains(QRegExp("\\bBAR\\b"))); }
void tst_IrcCommand::testPart() { QScopedPointer<IrcCommand> cmd1(IrcCommand::createPart("chan")); QVERIFY(cmd1.data()); QCOMPARE(cmd1->type(), IrcCommand::Part); QVERIFY(cmd1->toString().contains(QRegExp("\\bPART\\b"))); QVERIFY(cmd1->toString().contains(QRegExp("\\bchan\\b"))); QScopedPointer<IrcCommand> cmd2(IrcCommand::createPart(QStringList() << "chan1" << "chan2")); QVERIFY(cmd2.data()); QCOMPARE(cmd2->type(), IrcCommand::Part); QVERIFY(cmd2->toString().contains(QRegExp("\\bPART\\b"))); QVERIFY(cmd2->toString().contains(QRegExp("\\bchan1\\b"))); QVERIFY(cmd2->toString().contains(QRegExp("\\bchan2\\b"))); }
int main() { int i, j, k, n, m, ins; scanf("%d %d", &n, &m); scanf("%s", s); while (m--) { scanf("%s %d", cmd, &ins); switch (ins) { case 1: scanf("%d %d %c", &i, &j, &c); cmd1(i, j, c); break; case 2: scanf("%d %d %d", &i, &j, &k); cmd2(i, j, k); break; case 3: scanf("%d", &k); cmd3(k, n); break; case 4: scanf("%d %d", &i, &j); cmd4(i, j); break; } } printf("%s\n", s); return 0; }
void tst_IrcCommand::testCapability() { QScopedPointer<IrcCommand> cmd1(IrcCommand::createCapability("sub", QString("cap"))); QVERIFY(cmd1.data()); QCOMPARE(cmd1->type(), IrcCommand::Capability); QVERIFY(cmd1->toString().contains(QRegExp("\\bCAP\\b"))); QVERIFY(cmd1->toString().contains(QRegExp("\\bsub\\b"))); QVERIFY(cmd1->toString().contains(QRegExp("\\bcap\\b"))); QScopedPointer<IrcCommand> cmd2(IrcCommand::createCapability("sub", QStringList() << "cap1" << "cap2")); QVERIFY(cmd2.data()); QCOMPARE(cmd2->type(), IrcCommand::Capability); QVERIFY(cmd2->toString().contains(QRegExp("\\bCAP\\b"))); QVERIFY(cmd2->toString().contains(QRegExp("\\bsub\\b"))); QVERIFY(cmd2->toString().contains(QRegExp("\\bcap1\\b"))); QVERIFY(cmd2->toString().contains(QRegExp("\\bcap2\\b"))); }
TEST(IndexUpdateCommandTest, TestParseArgs) { IndexUpdateCommand cmd(IndexUpdateCommand::IndexOp::UPDATE); vector<string> strargs = {"insert", "--stdin", "energy"}; auto args = create_args(strargs); EXPECT_EQ(0, cmd.parse_args(args.size(), &args[0])); EXPECT_TRUE(cmd.use_stdin_); EXPECT_EQ("energy", cmd.name_); EXPECT_EQ(IndexUpdateCommand::IndexOp::UPDATE, cmd.op_); IndexUpdateCommand cmd1(IndexUpdateCommand::IndexOp::UPDATE); strargs = {"insert", "energy", "file0", "key0", "file1", "key1"}; args = create_args(strargs); EXPECT_EQ(0, cmd1.parse_args(args.size(), &args[0])); EXPECT_EQ("energy", cmd1.name_); EXPECT_EQ(2, cmd1.index_data_.size()); // Missing file,key pair. IndexUpdateCommand cmd2(IndexUpdateCommand::IndexOp::UPDATE); strargs = {"insert", "energy", "file0", "key0", "file1", "key1", "file2"}; args = create_args(strargs); EXPECT_EQ(-1, cmd2.parse_args(args.size(), &args[0])); }
int ACE_TMAIN (int argc, ACE_TCHAR** argv) { Kokyu::ConfigInfoSet config_info(3); int hi_prio, me_prio, lo_prio; int sched_policy=ACE_SCHED_FIFO; Kokyu::Dispatcher_Attributes attrs; if (parse_args (argc, argv) == -1) return 0; if (ACE_OS::strcasecmp(sched_policy_str.c_str(), "fifo") == 0) { sched_policy = ACE_SCHED_FIFO; } else if (ACE_OS::strcasecmp(sched_policy_str.c_str(), "other") == 0) { sched_policy = ACE_SCHED_OTHER; } else if (ACE_OS::strcasecmp(sched_policy_str.c_str(), "rr") == 0) { sched_policy = ACE_SCHED_RR; } attrs.sched_policy (sched_policy); hi_prio = ACE_Sched_Params::priority_max (sched_policy); me_prio = ACE_Sched_Params::previous_priority (sched_policy, hi_prio); lo_prio = ACE_Sched_Params::previous_priority (sched_policy, me_prio); config_info[0].preemption_priority_ = 1; config_info[0].thread_priority_ = hi_prio ; config_info[0].dispatching_type_ = Kokyu::FIFO_DISPATCHING; config_info[1].preemption_priority_ = 2; config_info[1].thread_priority_ = me_prio; config_info[1].dispatching_type_ = Kokyu::FIFO_DISPATCHING; config_info[2].preemption_priority_ = 3; config_info[2].thread_priority_ = lo_prio; config_info[2].dispatching_type_ = Kokyu::FIFO_DISPATCHING; attrs.config_info_set_ = config_info; ACE_DEBUG ((LM_DEBUG, "before create_dispatcher\n" )); auto_ptr<Kokyu::Dispatcher> disp (Kokyu::Dispatcher_Factory::create_dispatcher (attrs)); ACE_ASSERT (disp.get() != 0); MyCommand cmd1(1), cmd2(2), cmd3(3); Kokyu::QoSDescriptor qos1, qos2, qos3; qos1.preemption_priority_ = 2; ACE_DEBUG ((LM_DEBUG, "Priority of command1 is %d\n", qos1.preemption_priority_)); qos2.preemption_priority_ = 3; ACE_DEBUG ((LM_DEBUG, "Priority of command2 is %d\n", qos2.preemption_priority_)); qos3.preemption_priority_ = 1; ACE_DEBUG ((LM_DEBUG, "Priority of command3 is %d\n", qos3.preemption_priority_)); if (disp->dispatch (&cmd1, qos1) == -1 || disp->dispatch (&cmd2, qos2) == -1 || disp->dispatch (&cmd3, qos3) == -1) ACE_ERROR_RETURN ((LM_ERROR, "Error in dispatching command object\n"), -1); if (disp->activate () == -1) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Error activating dispatcher. ") ACE_TEXT ("You might not have superuser privileges ") ACE_TEXT ("to run FIFO class. Try \"-p other\"\n")), -1); } disp->shutdown (); ACE_DEBUG ((LM_DEBUG, "after shutdown\n")); return 0; }
void TestPageCommands::testMakePageSpread() { KWDocument document; KWPageManager *manager = document.pageManager(); KWPageStyle style("pagestyle1"); const KoPageLayout oldLayout = style.pageLayout(); KoPageLayout layout = style.pageLayout(); manager->addPageStyle(style); KWPage page1 = manager->appendPage(style); QCOMPARE(page1.width(), layout.width); QCOMPARE(page1.pageNumber(), 1); QCOMPARE(page1.pageSide(), KWPage::Right); QCOMPARE(manager->pageCount(), 1); // make it a pagespread KWPageStyle pageSpread = style; pageSpread.detach("dummy"); layout.leftMargin = -1; layout.rightMargin = -1; layout.pageEdge = 7; layout.bindingSide = 13; pageSpread.setPageLayout(layout); KWPageStylePropertiesCommand cmd1(&document, style, pageSpread); cmd1.redo(); QCOMPARE(page1.pageNumber(), 1); QCOMPARE(page1.pageSide(), KWPage::Right); QCOMPARE(page1.width(), style.pageLayout().width); QCOMPARE(manager->pageCount(), 1); KoPageLayout newLayout = style.pageLayout(); QCOMPARE(newLayout.width, layout.width); QCOMPARE(newLayout.leftMargin, layout.leftMargin); QCOMPARE(newLayout.rightMargin, layout.rightMargin); QCOMPARE(newLayout.pageEdge, layout.pageEdge); QCOMPARE(newLayout.bindingSide, layout.bindingSide); cmd1.undo(); QCOMPARE(page1.width(), oldLayout.width); QCOMPARE(page1.pageNumber(), 1); QCOMPARE(page1.pageSide(), KWPage::Right); QCOMPARE(manager->pageCount(), 1); // create another page. So we have 2 single sided pages. (Right/Left) KWPage page2 = manager->appendPage(style); QCOMPARE(page2.width(), oldLayout.width); QCOMPARE(page2.pageNumber(), 2); QCOMPARE(page2.pageSide(), KWPage::Left); QCOMPARE(manager->pageCount(), 2); // avoid reusing cmd1 as that assumes the constructor doesn't do anything. Which is // not a restriction we put on the command. (i.e. that doesn't *have* to work) KWPageStylePropertiesCommand cmd2(&document, style, pageSpread); cmd2.redo(); QCOMPARE(page1.width(), style.pageLayout().width); QCOMPARE(page1.pageNumber(), 1); QCOMPARE(page1.pageSide(), KWPage::Right); QCOMPARE(page2.pageNumber(), 2); QEXPECT_FAIL("", "Not done yet", Abort); QCOMPARE(page2.pageSide(), KWPage::PageSpread); QCOMPARE(page2.width(), style.pageLayout().width * 2); QCOMPARE(manager->pageCount(), 3); cmd2.undo(); // test for page side etc. QCOMPARE(page1.width(), oldLayout.width); QCOMPARE(page1.pageNumber(), 1); QCOMPARE(page1.pageSide(), KWPage::Right); QCOMPARE(page2.pageNumber(), 2); QCOMPARE(page2.pageSide(), KWPage::Left); QCOMPARE(page2.width(), oldLayout.width); QCOMPARE(manager->pageCount(), 2); }
void CCmd_ListOpStat::PreProcess(BOOL& done) { int i; POSITION pos; CCmd_ListOp cmd1(m_pClient); // Set up and run ListOp synchronously cmd1.Init(NULL, RUN_SYNC); cmd1.SetChkForSyncs(m_ChkForSyncs); cmd1.SetWarnIfLocked(m_WarnIfLocked); if(cmd1.Run(m_pFileSpecs, m_Command, m_ChangeNumber, m_NewType)) { m_FatalError= cmd1.GetError(); done=TRUE; if (m_ChkForSyncs) { CStringList * pSyncList = cmd1.GetSyncList(); if (!pSyncList->IsEmpty()) { for( pos= pSyncList->GetHeadPosition(); pos!= NULL; ) m_Unsynced.AddHead( pSyncList->GetNext(pos) ); CStringList * pEditList = cmd1.GetList(); for( pos= pEditList->GetHeadPosition(); pos!= NULL; ) { CString txt = pEditList->GetNext(pos); if ((i = txt.Find(_T('#'))) != -1) txt = txt.Left(i); m_RevertIfCancel.AddHead( txt ); } } else m_ChkForSyncs = FALSE; } } else { m_ErrorTxt= _T("Unable to Run ListOp"); m_FatalError=TRUE; } // Extract the CStringList from ListOp, which has filtered // results for the command. Note that Errors, warnings and // gee-whiz info have been thrown to the status window and // are not in the list CStringList *strList= cmd1.GetList(); // Check for huge file sets, where incremental screen update can take // a very looong time to complete. We are more tolerant for repoens, // because they involve updates in only one pane if(!m_FatalError && m_Command== P4REOPEN && strList->GetCount() > (3 * MAX_FILESEEKS)) { m_HitMaxFileSeeks= TRUE; TheApp()->StatusAdd(_T("CCmd_ListOpStat/P4REOPEN hit MAX_FILESEEKS - blowing off incremental update"), SV_DEBUG); } else if(!m_FatalError && m_Command!= P4REOPEN && strList->GetCount() > MAX_FILESEEKS) { m_HitMaxFileSeeks= TRUE; TheApp()->StatusAdd(_T("CCmd_ListOpStat hit MAX_FILESEEKS - blowing off incremental update"), SV_DEBUG); } // In the usual case of zero to a few hundred files, gather ostat-like info // for each file so that screen updates can be completed else if(!m_FatalError && strList->GetCount() > 0) { // Save a copy of the stringlist. for( pos= strList->GetHeadPosition(); pos!= NULL; ) m_StrListOut.AddHead( strList->GetNext(pos) ); // See if we need to run Ostat if(m_Command==P4EDIT || m_Command==P4DELETE) { // Set up and run ostat synchronously CCmd_Ostat cmd2(m_pClient); cmd2.Init(NULL, RUN_SYNC); if(cmd2.Run(FALSE, m_ChangeNumber)) m_FatalError= cmd2.GetError(); else { m_ErrorTxt= _T("Unable to Run Ostat"); m_FatalError=TRUE; } CObArray const *array= cmd2.GetArray(); if(!m_FatalError && array->GetSize() > 0) { // Save a copy of the oblist. for( int i=0; i < array->GetSize(); i++ ) m_StatList.AddHead( array->GetAt(i) ); } } else PrepareStatInfo(); } // Post the completion message if(!m_FatalError) { CString message; int already = 0; int reopened = 0; switch(m_Command) { case P4EDIT: for( pos= strList->GetHeadPosition(); pos!= NULL; ) { CString str = strList->GetNext(pos); if (str.Find(_T(" - currently opened ")) != -1) already++; else if (str.Find(_T(" - reopened ")) != -1) reopened++; } message.FormatMessage(IDS_OPENED_n_FILES_FOR_EDIT, strList->GetCount() - already - reopened); if (reopened) message.FormatMessage(IDS_s_n_FILES_REOPENED, message, reopened); if (already) message.FormatMessage(IDS_s_n_FILES_ALREADY_OPENED, message, already); break; case P4REOPEN: message.FormatMessage(IDS_REOPENED_n_FILES, strList->GetCount()); break; case P4REVERT: case P4VIRTREVERT: m_OutputError = cmd1.GetOutputErrFlag(); message.FormatMessage(m_OutputError ? IDS_ERROR_REVERTING_n_FILES : IDS_REVERTED_n_FILES, strList->GetCount()); break; case P4REVERTUNCHG: m_OutputError = cmd1.GetOutputErrFlag(); if (m_OutputError) message.FormatMessage(IDS_ERROR_REVERTING_n_FILES, strList->GetCount()); else if (m_NbrChgedFilesReverted) message.FormatMessage(IDS_REVERTED_n_FILES_n_CHG_n_UNCHG, m_NbrChgedFilesReverted + strList->GetCount(), m_NbrChgedFilesReverted, strList->GetCount()); else message.FormatMessage(IDS_REVERTED_n_FILES, strList->GetCount()); break; case P4LOCK: message.FormatMessage(IDS_LOCKED_n_FILES, strList->GetCount()); break; case P4UNLOCK: message.FormatMessage(IDS_UNLOCKED_n_FILES, strList->GetCount()); break; case P4DELETE: for( pos= strList->GetHeadPosition(); pos!= NULL; ) { CString str = strList->GetNext(pos); if (str.Find(_T(" - currently opened ")) != -1) already++; else if (str.Find(_T(" - reopened ")) != -1) reopened++; } message.FormatMessage(IDS_OPENED_n_FILES_FOR_DELETE, strList->GetCount() - already - reopened); if (reopened) message.FormatMessage(IDS_s_n_FILES_REOPENED, message, reopened); if (already) message.FormatMessage(IDS_s_n_FILES_ALREADY_OPENED, message, already); break; case P4ADD: message.FormatMessage(IDS_OPENED_n_FILES_FOR_ADD, strList->GetCount()); break; default: ASSERT(0); } if(!message.IsEmpty()) TheApp()->StatusAdd( message, SV_COMPLETION ); } done=TRUE; }
int main(int argc, char* argv[]) { ExplorationShared shared; EBehavior behavior(&shared); EBWaitIdle waitStart("Start"); EBWaitIdle waitMotion1("ArmPositioning"); EBWaitIdle waitMotion2("Turn1"); EBWaitIdle waitMotion3("Turn2"); EBWaitIdle waitMotion4("Turn3"); EBWaitIdle waitMotion5("Turn4"); EBWaitIdle waitMotion6("Turn5"); EBWaitIdle waitMotion7("Final pos"); EBWaitIdle waitMotion8("Going back to rest"); EBWaitIdle endState1("end1"); EBWaitIdle endState2("end2"); EBWaitIdle stateInhibitHandTracking("Inhibit hand tracking"); EBWaitIdle stateEnableHandTracking("Enable hand tracking"); EBWaitIdle position1Wait("Position1 done"); EBWaitIdle position2Wait("Position2 done"); EBWaitIdle position3Wait("Position3 done"); EBWaitDeltaT position2Train(6); EBWaitDeltaT position3Train(6); EBWaitDeltaT position4Train(6); EBWaitIdle position2("Waiting arm done"); EBWaitIdle position3("Waiting arm done"); EBWaitIdle position4("Waiting arm done"); EBWaitIdle waitArmAck("Wait armAck"); EBWaitDeltaT dT1(6); EBWaitDeltaT dT2(0.2); EBWaitDeltaT dT3OneSecond(3); EBWaitDeltaT dTHandClosing(0.1); EBWaitDeltaT waitArmSeemsToRest(5); EBBehaviorOutput startTrain(YBVKFTrainStart); EBBehaviorOutput startSequence(YBVKFStart); EBBehaviorOutput stopTrain(YBVKFTrainStop); EBBehaviorOutput stop(YBVKFStop); EBSimpleOutput forceOpen(YBVGraspRflxForceOpen); EBSimpleOutput parkArm(YBVArmForceRestingTrue); // output: enable and disable hand tracking system EBEnableTracker enableHandTracking; EBInhibitTracker inhibitHandTracking; EBOutputCommand cmd1(YBVArmForceNewCmd, YVector(_nJoints, pos1)); EBOutputCommand cmd2(YBVArmForceNewCmd, YVector(_nJoints, pos2)); EBOutputCommand cmd3(YBVArmForceNewCmd, YVector(_nJoints, pos3)); // EBOutputCommand cmd4(YBVArmForceNewCmd, YVector(_nJoints, pos4)); // EBOutputCommand cmd5(YBVArmForceNewCmd, YVector(_nJoints, pos5)); // EBOutputCommand cmd6(YBVArmForceNewCmd, YVector(_nJoints, pos6)); EBOutputCommand cmd7(YBVArmForceNewCmd, YVector(_nJoints, pos7)); EBOutputCommand cmd8(YBVArmForceNewCmd, YVector(_nJoints, pos8)); EBOutputCommand cmd9(YBVArmForceNewCmd, YVector(_nJoints, pos9)); EBOutputCommand cmd10(YBVArmForceNewCmd, YVector(_nJoints, pos10)); EBSimpleInput armDone(YBVArmDone); EBSimpleInput handDone(YBVHandDone); EBSimpleInput start(YBVKFExplorationStart); EBSimpleInput start2(YBVGraspRflxClutch); EBSimpleInput armAck(YBVArmIssuedCmd); EBSimpleInput armNAck(YBVArmIsBusy); behavior.setInitialState(&waitStart); behavior.add(&start, &waitStart, &waitMotion1, &cmd1); behavior.add(&start2, &waitStart, &dTHandClosing, &enableHandTracking); behavior.add(NULL, &dTHandClosing, &waitArmAck, &cmd1); behavior.add(&armAck, &waitArmAck, &stateEnableHandTracking, &startSequence); behavior.add(&armNAck, &waitArmAck, &waitArmSeemsToRest, &inhibitHandTracking); behavior.add(NULL, &waitArmSeemsToRest, &waitStart, &forceOpen); behavior.add(NULL, &stateEnableHandTracking, &waitMotion1, &enableHandTracking); behavior.add(&armDone, &waitMotion1, &dT3OneSecond); // wait some extra time before issueing the startKF signal behavior.add(NULL, &dT3OneSecond, &dT1, &startTrain); // july 21/04 behavior.add(NULL, &dT1, &waitMotion6); behavior.add(NULL, &waitMotion6, &position1Wait, &stopTrain); // position2 behavior.add(NULL, &position1Wait, &position2, &cmd7); behavior.add(&armDone, &position2, &position2Train, &startTrain); behavior.add(NULL, &position2Train, &position2Wait, &stopTrain); //position3 behavior.add(NULL, &position2Wait, &position3, &cmd8); behavior.add(&armDone, &position3, &position3Train, &startTrain); behavior.add(NULL, &position3Train, &position3Wait, &stopTrain); //position 4 behavior.add(NULL, &position3Wait, &position4, &cmd9); behavior.add(&armDone, &position4, &position4Train, &startTrain); behavior.add(NULL, &position4Train, &stateInhibitHandTracking, &stopTrain); behavior.add(NULL, &stateInhibitHandTracking, &dT2); /* behavior.add(NULL, &dT1, &waitMotion2, &cmd2); // behavior.add(&armDone, &waitMotion1, &waitMotion2, &cmd2); behavior.add(&armDone, &waitMotion2, &waitMotion3, &cmd3); behavior.add(&armDone, &waitMotion3, &waitMotion4, &cmd4); behavior.add(&armDone, &waitMotion4, &waitMotion5, &cmd5); behavior.add(&armDone, &waitMotion5, &waitMotion6, &cmd6); behavior.add(&armDone, &waitMotion6, &dT2, &stopKF); */ behavior.add(NULL, &dT2, &waitMotion7, &cmd10); behavior.add(&armDone, &waitMotion7, &waitMotion8, &forceOpen); behavior.add(&handDone, &waitMotion8, &endState1, &parkArm); behavior.add(NULL, &endState1, &endState2, &inhibitHandTracking); behavior.add(NULL, &endState2, &waitStart, &stop); behavior.Begin(); behavior.loop(); return 0; }
// ---------------------------------------------------------------------------- int main() { send_to_venue_command_ptr cmd1( new send_to_venue_command ); pass_thru_stage stage; stage.process( cmd1 ); }
// thread to steal tasks it ready queue length becomes zero void* worksteal(void* args) { //cout << "entered worksteal thread" << endl; Worker *worker = (Worker*) args; /*int min_lines = worker->svrclient.memberList.size(); //min_lines++; string filename(file_worker_start); //string cmd("wc -l "); //cmd = cmd + filename + " | awk {\'print $1\'}"; string cmd("ls -l "); cmd.append(shared); cmd.append("startinfo*"); cmd.append(" | wc -l"); string result = executeShell(cmd); //cout << "server: minlines = " << min_lines << " cmd = " << cmd << " result = " << result << endl; while(atoi(result.c_str()) < min_lines) { sleep(2); //cout << "server: " << worker.selfIndex << " minlines = " << min_lines << " cmd = " << cmd << " result = " << result << endl; result = executeShell(cmd); } cout << "server: " << worker->selfIndex << " minlines = " << min_lines << " cmd = " << cmd << " result = " << result << endl;*/ int num = worker->svrclient.memberList.size() - 1; stringstream num_ss; num_ss << num; //min_lines++; string cmd1("cat "); cmd1.append(shared); cmd1.append("startinfo"); cmd1.append(num_ss.str()); cmd1.append(" | wc -l"); string result1 = executeShell(cmd1); //cout << "server: minlines = " << min_lines << " cmd = " << cmd << " result = " << result << endl; while (atoi(result1.c_str()) < 1) { usleep(ws_sleep); result1 = executeShell(cmd1); } //cout << "worksteal started: server: " << worker->selfIndex << " minlines = " << 1 << " cmd = " << cmd1 << " result = " << result1 << endl; while (work_steal_signal) { //while(ready_queue->get_length() > 0) { } while (rqueue.size() > 0) { } usleep(1000); // If there are no waiting ready tasks, do work stealing //if (worker.num_nodes > 1 && ready_queue->get_length() < 1) if (worker->num_nodes > 1 && rqueue.size() < 1) { int32_t success = worker->steal_task(); // Do work stealing until succeed while (success == 0) { failed_attempts++; if (failed_attempts >= fail_threshold) { work_steal_signal = 0; cout << worker->selfIndex << " stopping worksteal" << endl; break; } usleep(worker->poll_interval); success = worker->steal_task(); } failed_attempts = 0; //cout << "Received " << success << " tasks" << endl; } } }
MpodCrate::MpodCrate(string ip, string name) { // first check connection by trying to get MAC address from frontend board string cmd0("snmpget -Oqv -v 2c -m +WIENER-CRATE-MIB -c public "); string cmd1("snmpwalk -Oqv -v 2c -m +WIENER-CRATE-MIB -c public "); string cmd(cmd0+ip+" macAddress.0"); FILE *io; char buff[512]; int MakeConnection = 0; int Tries=0; while (!MakeConnection && Tries<10) { Tries++; if( (io = popen(cmd.c_str(),"r")) ) { MakeConnection = 1; } } if (MakeConnection) { fgets(buff, sizeof(buff), io); string res(buff); res.erase(0,1); res.erase(res.size()-1,1); res.erase(res.size()-1,1); MacAddress = res.c_str(); if (DEBUG) { cout<<"MAC address is "<<res<<endl; } pclose(io); } else { cout<<"MpodCrate:: Error make connection to "<<ip<<endl; } Name = name; cmd = cmd0+ip+" ipDynamicAddress.0"; io = popen(cmd.c_str(),"r"); fgets(buff, sizeof(buff), io); pclose(io); string res(buff); res.erase(res.size()-1); IP = res; if (DEBUG) { cout<<"Dynamic IP address is "<<IP<<endl; } cmd = cmd0+ip+" psSerialNumber.0"; io = popen(cmd.c_str(),"r"); fgets(buff, sizeof(buff), io); pclose(io); res = buff; SerialNumber = atoi(res.c_str()); if (DEBUG) { cout<<"Crate Serial Number is "<<SerialNumber<<endl; } cmd = cmd0+ip+" outputNumber.0"; io = popen(cmd.c_str(),"r"); fgets(buff, sizeof(buff), io); pclose(io); res = buff; Nchannels = atoi(res.c_str()); if (DEBUG) { cout<<"Number of channels found in crate: "<<Nchannels<<endl; } cmd = cmd1+ip+" outputName"; io = popen(cmd.c_str(),"r"); // initialize counters and channel name list for (int i=0; i<10; i++) { NChanMod[i]=0; } if (!ChannelNames.empty()) { ChannelNames.clear(); } while(fgets(buff, sizeof(buff), io)) { string res(buff); res.erase(res.size()-1); ChannelNames.push_back(res); if (DEBUG>2) { cout<<"Channel Name: "<<res<<endl; } res.erase(0,1); int ChanNum = atoi(res.c_str()); if (ChanNum<100) { NChanMod[0]++; } else if (ChanNum<200) { NChanMod[1]++; } else if (ChanNum<300) { NChanMod[2]++; } else if (ChanNum<400) { NChanMod[3]++; } else if (ChanNum<500) { NChanMod[4]++; } else if (ChanNum<600) { NChanMod[5]++; } else if (ChanNum<700) { NChanMod[6]++; } else if (ChanNum<800) { NChanMod[7]++; } else if (ChanNum<900) { NChanMod[8]++; } else if (ChanNum<1000) { NChanMod[9]++; } } Nmodules=0; for (int i=0; i<10; i++) { if (NChanMod[i]>0) { Nmodules++; ModuleNames[i] = GetModuleType(i); } } if (DEBUG==9) { cout<<"Crate has Serial Number "<<SerialNumber<<endl; cout<<"Total Number of Channels "<<Nchannels<<endl; cout<<"Total Number of Modules "<<Nmodules<<endl; } CrateVector.push_back(this); }
boost::system::error_code Connector::connect( SocketType & peer1, NetName const & netname, boost::system::error_code & ec) { typedef typename SocketType::protocol_type::socket socket; typedef typename socket::endpoint_type endpoint_type; socket & peer(peer1); // we should use the real socket type, not the child type if (netname.is_digit()) { return connect(peer, netname.endpoint(), ec); } if (!started_) { canceled_ = canceled_forever_; stat_.reset(); connect_started_ = false; boost::asio::detail::mutex::scoped_lock lock(mutex_); if (canceled_) { ec = boost::asio::error::operation_aborted; canceled_ = false; } else { lock.unlock(); resolver_iterator_ = resolver_.resolve(netname, ec); lock.lock(); } stat_.resolve_time = stat_.elapse(); if (ec) { return ec; } else if (canceled_) { canceled_ = false; return ec = boost::asio::error::operation_aborted; } started_ = true; } ResolverIterator end; for (; resolver_iterator_ != end; ++resolver_iterator_) { if (!connect_started_) { Endpoint const & e = *resolver_iterator_; { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (canceled_) { ec = boost::asio::error::operation_aborted; canceled_ = false; } else { if (peer.is_open()) { peer.close(ec); } boost::asio::socket_base::non_blocking_io cmd1(non_block_); #ifndef UNDER_CE boost::asio::socket_base::receive_time_out cmd2(time_out_); #endif ec || peer.open(endpoint_type(e).protocol(), ec) || peer.io_control(cmd1, ec) #ifndef UNDER_CE || peer.set_option(cmd2, ec) #endif ; } } if (ec) { break; } LOG_TRACE("[connect] try server, ep: " << e.to_string()); start_connect(peer, e, ec); } else { ec = boost::asio::error::would_block; } if (ec == boost::asio::error::would_block) { pool_connect(peer, ec); } if (ec != boost::asio::error::would_block) { if (!ec) { post_connect(peer, ec); } else { boost::system::error_code ec1; post_connect(peer, ec1); } } if (!ec || ec == boost::asio::error::would_block || canceled_) { break; } LOG_DEBUG("[connect] failed, ep: " << resolver_iterator_->to_string() << ",ec: " << ec.message()); } // for if ((!ec || ec == boost::asio::error::would_block) && canceled_) { ec = boost::asio::error::operation_aborted; } if (ec != boost::asio::error::would_block) { stat_.connect_time = stat_.elapse(); started_ = false; canceled_ = false; } return ec; }
boost::system::error_code Connector::connect( SocketType & peer1, Endpoint const & endpoint, boost::system::error_code & ec) { typedef typename SocketType::protocol_type::socket socket; typedef typename socket::endpoint_type endpoint_type; socket & peer(peer1); // we should use the real socket type, not the child type if (!started_) { canceled_ = canceled_forever_; stat_.reset(); stat_.resolve_time = 0; if (ec) { return ec; } { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (canceled_) { ec = boost::asio::error::operation_aborted; canceled_ = false; } else if (peer.is_open()) { peer.close(ec); } boost::asio::socket_base::non_blocking_io cmd1(non_block_); #ifndef UNDER_CE boost::asio::socket_base::receive_time_out cmd2(time_out_); #endif ec || peer.open(endpoint_type(endpoint).protocol(), ec) || peer.io_control(cmd1, ec) #ifndef UNDER_CE || peer.set_option(cmd2, ec) #endif ; started_ = true; } connect_started_ = false; if (ec) return ec; start_connect(peer, endpoint, ec); } else { ec = boost::asio::error::would_block; } if (ec == boost::asio::error::would_block) { pool_connect(peer, ec); } if (ec == boost::asio::error::would_block) { if (time_out_ && stat_.elapse() > time_out_) { ec = boost::asio::error::timed_out; } } if (ec != boost::asio::error::would_block) { if (!ec) { post_connect(peer, ec); } else { boost::system::error_code ec1; post_connect(peer, ec1); } stat_.connect_time = stat_.elapse(); started_ = false; canceled_ = false; } return ec; }