void SessionEntry::doubleClickAction() { Group* parent = getGroup(); if ( parent == NULL ) { gravUtil::logWarning( "SessionEntry::doubleClick: entry not grouped? " "(invalid session setup)\n" ); return; } Group* gParent = parent->getGroup(); if ( gParent == NULL ) { gravUtil::logWarning( "SessionEntry::doubleClick: parent not grouped? " "(invalid session setup)\n" ); return; } SessionManager* manager = dynamic_cast<SessionManager*>( gParent ); if ( manager == NULL ) { gravUtil::logWarning( "SessionEntry::doubleClick: not member of one of " "session manager's groups? (invalid session setup)\n" ); return; } manager->sessionEntryAction( this ); }
TEST_F(SessionManagerTest, CDFFailureTest) { LocalStore* memstore = new LocalStore(); SessionStore* store = new SessionStore(memstore); DummyErrorPeerMessageSenderFactory* factory = new DummyErrorPeerMessageSenderFactory(BILLING_REALM); MockChronosConnection* fake_chronos = new MockChronosConnection("http://localhost:1234"); SessionManager* mgr = new SessionManager(store, _dict, factory, fake_chronos, _diameter_stack); SessionStore::Session* sess = NULL; Message* start_msg = new Message("CALL_ID_FOUR", ORIGINATING, SCSCF, NULL, Rf::AccountingRecordType(2), 300, FAKE_TRAIL_ID); Message* interim_msg = new Message("CALL_ID_FOUR", ORIGINATING, SCSCF, NULL, Rf::AccountingRecordType(3), 300, FAKE_TRAIL_ID); // When a START message fails, we should not store the session or handle any subsequent messages mgr->handle(start_msg); sess = store->get_session_data("CALL_ID_FOUR", ORIGINATING, SCSCF, FAKE_TRAIL_ID); ASSERT_EQ(NULL, sess); mgr->handle(interim_msg); sess = store->get_session_data("CALL_ID_FOUR", ORIGINATING, SCSCF, FAKE_TRAIL_ID); ASSERT_EQ(NULL, sess); delete mgr; delete factory; delete fake_chronos; delete store; delete memstore; }
TEST_F(SessionManagerTest, CDFInterimUnknownTest) { LocalStore* memstore = new LocalStore(); SessionStore* store = new SessionStore(memstore); DummyPeerMessageSenderFactory* factory = new DummyPeerMessageSenderFactory(BILLING_REALM); MockChronosConnection* fake_chronos = new MockChronosConnection("http://localhost:1234"); SessionManager* mgr = new SessionManager(store, _dict, factory, fake_chronos, _diameter_stack); DummyUnknownErrorPeerMessageSenderFactory* fail_factory = new DummyUnknownErrorPeerMessageSenderFactory(BILLING_REALM); SessionManager* fail_mgr = new SessionManager(store, _dict, fail_factory, fake_chronos, _diameter_stack); SessionStore::Session* sess = NULL; Message* start_msg = new Message("CALL_ID_FOUR", ORIGINATING, SCSCF, NULL, Rf::AccountingRecordType(2), 300, FAKE_TRAIL_ID); Message* interim_msg = new Message("CALL_ID_FOUR", ORIGINATING, SCSCF, NULL, Rf::AccountingRecordType(3), 300, FAKE_TRAIL_ID); mgr->handle(start_msg); sess = store->get_session_data("CALL_ID_FOUR", ORIGINATING, SCSCF, FAKE_TRAIL_ID); ASSERT_NE((SessionStore::Session*)NULL, sess); EXPECT_EQ(1u, sess->acct_record_number); delete sess; sess = NULL; // When an INTERIM message fails with a 5002 "Session unknown" error, we should delete the session fail_mgr->handle(interim_msg); sess = store->get_session_data("CALL_ID_FOUR", ORIGINATING, SCSCF, FAKE_TRAIL_ID); ASSERT_EQ(NULL, sess); delete mgr; delete factory; delete fail_mgr; delete fail_factory; delete fake_chronos; delete store; delete memstore; }
extern "C" void Disconnect(int worldId) { SessionManager* pMgr = g_SessionManagers.Get(worldId); if (NULL != pMgr) { pMgr->SetSession(NULL); } }
void ProfileList::favoriteChanged(Profile::Ptr info,bool isFavorite) { SessionManager* manager = SessionManager::instance(); if ( isFavorite ) { QAction* action = new QAction(_group); action->setData( QVariant::fromValue(info) ); if ( _addShortcuts ) { action->setShortcut(manager->shortcut(info)); } updateAction(action,info); foreach(QWidget* widget,_registeredWidgets) widget->addAction(action); emit actionsChanged(_group->actions()); } else { QAction* action = actionForKey(info); if ( action ) { _group->removeAction(action); foreach(QWidget* widget,_registeredWidgets) widget->removeAction(action); emit actionsChanged(_group->actions()); } } updateEmptyAction(); }
ProfileList::ProfileList(bool addShortcuts , QObject* parent) : QObject(parent) , _addShortcuts(addShortcuts) , _emptyListAction(0) { // construct the list of favorite profiles _group = new QActionGroup(this); // Even when there are no favorite profiles, allow user to // create new tabs using the default profile from the menu _emptyListAction = new QAction(i18n("Default profile"),_group); // TODO - Handle re-sorts when user changes profile names SessionManager* manager = SessionManager::instance(); QList<Profile::Ptr> list = manager->sortedFavorites(); QListIterator<Profile::Ptr> iter(list); while (iter.hasNext()) { favoriteChanged(iter.next(), true); } connect( _group , SIGNAL(triggered(QAction*)) , this , SLOT(triggered(QAction*)) ); // listen for future changes to the profiles connect( manager , SIGNAL(favoriteStatusChanged(Profile::Ptr,bool)) , this , SLOT(favoriteChanged(Profile::Ptr,bool)) ); connect( manager , SIGNAL(shortcutChanged(Profile::Ptr,QKeySequence)) , this , SLOT(shortcutChanged(Profile::Ptr,QKeySequence)) ); connect( manager , SIGNAL(profileChanged(Profile::Ptr)) , this , SLOT(profileChanged(Profile::Ptr)) ); }
bool ObjectHost::connect( HostedObjectPtr ho, const SpaceObjectReference& sporef, const SpaceID& space, const TimedMotionVector3f& loc, const TimedMotionQuaternion& orient, const BoundingSphere3f& bnds, const String& mesh, const String& phy, const String& query, const String& zernike, ConnectedCallback connected_cb, MigratedCallback migrated_cb, StreamCreatedCallback stream_created_cb, DisconnectedCallback disconnected_cb ) { Sirikata::SerializationCheck::Scoped sc(&mSessionSerialization); if (mHostedObjects.find(sporef)!=mHostedObjects.end()) return false; SessionManager *sm = mSessionManagers[space]; String filtered_query = mQueryProcessor->connectRequest(ho, sporef, query); return sm->connect( sporef, loc, orient, bnds, mesh, phy, filtered_query, zernike, std::tr1::bind(&ObjectHost::wrappedConnectedCallback, this, HostedObjectWPtr(ho), _1, _2, _3, connected_cb), migrated_cb, std::tr1::bind(&ObjectHost::wrappedStreamCreatedCallback, this, HostedObjectWPtr(ho), _1, _2, stream_created_cb), std::tr1::bind(&ObjectHost::wrappedDisconnectedCallback, this, HostedObjectWPtr(ho), _1, _2, disconnected_cb) ); }
int closeTxns(const int& start, const int& end) { int first=start; int last=end; int totalClosed=0; for (int idx=first; idx<last ; idx++) { try { SessionManager::TxnID tmp = manager->getTxnID(idx+1000); if (tmp.valid == true) { manager->committed(tmp); CPPUNIT_ASSERT(tmp.valid==false); totalClosed++; } } catch (exception& e) { cerr << e.what() << endl; continue; } } return totalClosed; } //closeTxns
TEST_F(SessionManagerTest, NewCallTest) { LocalStore* memstore = new LocalStore(); SessionStore* store = new SessionStore(memstore); DummyPeerMessageSenderFactory* factory = new DummyPeerMessageSenderFactory(BILLING_REALM); MockChronosConnection* fake_chronos = new MockChronosConnection("http://localhost:1234"); SessionManager* mgr = new SessionManager(store, _dict, factory, fake_chronos, _diameter_stack); SessionStore::Session* sess = NULL; Message* start_msg = new Message("CALL_ID_TWO", ORIGINATING, SCSCF, NULL, Rf::AccountingRecordType(2), 300, FAKE_TRAIL_ID); Message* stop_msg = new Message("CALL_ID_TWO", ORIGINATING, SCSCF, NULL, Rf::AccountingRecordType(4), 300, FAKE_TRAIL_ID); Message* start_msg_2 = new Message("CALL_ID_TWO", ORIGINATING, SCSCF, NULL, Rf::AccountingRecordType(2), 300, FAKE_TRAIL_ID); mgr->handle(start_msg); sess = store->get_session_data("CALL_ID_TWO", ORIGINATING, SCSCF, FAKE_TRAIL_ID); delete sess; mgr->handle(stop_msg); sess = store->get_session_data("CALL_ID_TWO", ORIGINATING, SCSCF, FAKE_TRAIL_ID); ASSERT_EQ(NULL, sess); mgr->handle(start_msg_2); // Re-using call-IDs should just work sess = store->get_session_data("CALL_ID_TWO", ORIGINATING, SCSCF, FAKE_TRAIL_ID); ASSERT_EQ(1u, sess->acct_record_number); delete sess; sess = NULL; delete mgr; delete factory; delete fake_chronos; delete store; delete memstore; }
Sender(const unsigned char* data, string ia, tpport_t port, uint32 tstamp, uint16 count) : packetsPerSecond(10) { Facade* facade = Facade::getInstance(); SessionManager* session = facade->createClientSession(ia, port, new RecordDevice, new PlaybackDevice, "/home/ivocalado/workspace/streamadapt/policies/instance1.xml", 0); TransportSession* sender = session->getTSession(); uint32 timestamp = tstamp ? tstamp : 0; // // // string s = sender->getSession()->retrievePluginInformation( "CurrentRTPClockRate"); istringstream s1(s); uint16 tstampInc = 0; s1 >> tstampInc; tstampInc /= packetsPerSecond; uint32 period = 1000 / packetsPerSecond; TimerPort::setTimer(period); for (int i = 0; i < count; i++) { uint32 tmp = timestamp + i * tstampInc; sender->getSession()->sendData(tmp, data, strlen((char *) data) + 1, &b); Thread::sleep(TimerPort::getTimer()); TimerPort::incTimer(period); } session->endSession(); }
void sessionmanager_5() { SessionManager sm; int tmp = -1; tmp = sm.verID(); // there's no "correct" value b/c it's monotonically increasing. }
extern "C" int IsConnected(int worldId) { int ret = 0; SessionManager* pMgr = g_SessionManagers.Get(worldId); if (NULL != pMgr) { ret = (NULL != pMgr->GetSession() ? 1 : 0); } return ret; }
void SessionEntry::doubleClickAction() { SessionManager* manager = getParentManager(); if ( manager != NULL ) { manager->sessionEntryAction( this ); } }
extern "C" int TargetHandle(int worldId, const char* name) { int handle = 0; if (NULL != name) { SessionManager* pMgr = g_SessionManagers.Get(worldId); if (NULL != pMgr) { handle = pMgr->TargetHandle(name); } } return handle; }
// Space API - Provide info for ObjectHost to communicate with spaces void ObjectHost::addServerIDMap(const SpaceID& space_id, ServerIDMap* sidmap) { SessionManager* smgr = new SessionManager( mContext, space_id, sidmap, std::tr1::bind(&ObjectHost::handleObjectConnected, this, _1, _2), std::tr1::bind(&ObjectHost::handleObjectMigrated, this, _1, _2, _3), std::tr1::bind(&ObjectHost::handleObjectMessage, this, _1, space_id, _2), std::tr1::bind(&ObjectHost::handleObjectDisconnected, this, _1, _2) ); mSessionManagers[space_id] = smgr; smgr->start(); }
void ObjectHost::stop() { for(SpaceSessionManagerMap::iterator it = mSessionManagers.begin(); it != mSessionManagers.end(); it++) { SessionManager* sm = it->second; sm->stop(); } for(InternalIDHostedObjectMap::const_iterator it = mHostedObjectsByID.begin(); it != mHostedObjectsByID.end(); it++) { HostedObjectPtr ho = it->second.lock(); if (ho) ho->stop(); } }
void sessionManager_4() { char *buf; int len; SessionManager sm; buf = sm.getShmContents(len); CPPUNIT_ASSERT(len > 0); CPPUNIT_ASSERT(buf != NULL); delete [] buf; }
void AllProjectsFilter::refreshInternally() { m_files.clear(); SessionManager *session = m_projectExplorer->session(); if (!session) return; foreach (Project *project, session->projects()) m_files += project->files(Project::AllFiles); qSort(m_files); generateFileNames(); }
TEST_F(SessionManagerTest, TimerIDTest) { LocalStore* memstore = new LocalStore(); SessionStore* store = new SessionStore(memstore); DummyPeerMessageSenderFactory* factory = new DummyPeerMessageSenderFactory(BILLING_REALM); MockChronosConnection* fake_chronos = new MockChronosConnection("http://localhost:1234"); SessionManager* mgr = new SessionManager(store, _dict, factory, fake_chronos, _diameter_stack); SessionStore::Session* sess = NULL; Message* start_msg = new Message("CALL_ID_ONE", ORIGINATING, SCSCF, NULL, Rf::AccountingRecordType(2), 300, FAKE_TRAIL_ID); start_msg->ccfs.push_back("10.0.0.1"); Message* interim_msg = new Message("CALL_ID_ONE", ORIGINATING, SCSCF, NULL, Rf::AccountingRecordType(3), 0, FAKE_TRAIL_ID); Message* stop_msg = new Message("CALL_ID_ONE", ORIGINATING, SCSCF, NULL, Rf::AccountingRecordType(4), 0, FAKE_TRAIL_ID); // START should put a session in the store mgr->handle(start_msg); sess = store->get_session_data("CALL_ID_ONE", ORIGINATING, SCSCF, FAKE_TRAIL_ID); ASSERT_NE((SessionStore::Session*)NULL, sess); EXPECT_EQ(1u, sess->acct_record_number); // Change the stored timer - this means that the chronos PUT will return a // clashing timer, triggering the session manager to update the stored timer ID sess->timer_id = "NEW_TIMER"; store->set_session_data("CALL_ID_ONE", ORIGINATING, SCSCF, sess, FAKE_TRAIL_ID); delete sess; sess = NULL; // INTERIM should keep that session in the store mgr->handle(interim_msg); sess = store->get_session_data("CALL_ID_ONE", ORIGINATING, SCSCF, FAKE_TRAIL_ID); ASSERT_NE((SessionStore::Session*)NULL, sess); EXPECT_EQ(2u, sess->acct_record_number); // The timer id should have been updated to match the id returned from the PUT. EXPECT_EQ("TIMER_ID", sess->timer_id); delete sess; sess = NULL; // STOP should remove the session from the store mgr->handle(stop_msg); sess = store->get_session_data("CALL_ID_ONE", ORIGINATING, SCSCF, FAKE_TRAIL_ID); ASSERT_EQ(NULL, sess); delete mgr; delete factory; delete fake_chronos; delete store; delete memstore; }
extern "C" int SendCommandByName(int worldId, const char* name, const char* command) { int ret = 0; if (NULL != name && NULL != command) { SessionManager* pMgr = g_SessionManagers.Get(worldId); if (NULL != pMgr) { int dest = pMgr->TargetHandle(name); ret = SendCommandByHandle(worldId, dest, command); } } return ret; }
void ChatTests::init() { /* User #1. */ SessionManager *sessionManager = SessionManager::getInstance(); QSignalSpy spy(sessionManager, SIGNAL(loginCompleted(QSharedPointer<Session>, bool, QString))); QVERIFY(spy.isValid()); QVERIFY(spy.isEmpty()); QSharedPointer<const LoginUser> u(new LoginUser(TEMP_SESSION_USER3, WORKING_DIR "public.pem", WORKING_DIR "private.pem")); sessionManager->login(SERVER_URL, CA_CERT, u, "password"); waitForResult(spy); QCOMPARE(spy.count(), 1); QList<QVariant> arguments = spy.takeFirst(); QVERIFY2(arguments.at(1) == true, arguments.at(2).toString().toStdString().c_str()); session = arguments.at(0).value<QSharedPointer<Session> >(); QSignalSpy spy2(session.data(), SIGNAL(initChatCompleted(QSharedPointer<Chat>, bool, QString))); QVERIFY(spy2.isValid()); QVERIFY(spy2.isEmpty()); session->initChat(); waitForResult(spy2); QCOMPARE(spy2.count(), 1); QList<QVariant> arguments2 = spy2.takeFirst(); QVERIFY2(arguments2.at(1) == true, arguments2.at(2).toString().toStdString().c_str()); chat = arguments2.at(0).value<QSharedPointer<Chat> >(); /* User #2. */ QSignalSpy spy3(sessionManager, SIGNAL(loginCompleted(QSharedPointer<Session>, bool, QString))); QVERIFY(spy3.isValid()); QVERIFY(spy3.isEmpty()); QSharedPointer<const LoginUser> u2(new LoginUser(TEMP_SESSION_USER2, WORKING_DIR "public.pem", WORKING_DIR "private.pem")); sessionManager->login(SERVER_URL, CA_CERT, u2, "password"); waitForResult(spy3); QCOMPARE(spy3.count(), 1); QList<QVariant> arguments3 = spy3.takeFirst(); QVERIFY2(arguments3.at(1) == true, arguments3.at(2).toString().toStdString().c_str()); session2 = arguments3.at(0).value<QSharedPointer<Session> >(); }
extern "C" int SendByName(int worldId, const char* name, const void* data, int len) { int ret = 0; if (NULL != name && NULL != data) { SessionManager* pMgr = g_SessionManagers.Get(worldId); if (NULL != pMgr) { int dest = pMgr->TargetHandle(name); ret = SendByHandle(worldId, dest, data, len); } } return ret; }
extern "C" void Tick(void) { if (NULL != g_pNetIoService && NULL != g_EventBase) { g_pNetIoService->Poll(); for (SessionManagers::Iterator it = g_SessionManagers.First(); !it.IsNull(); ++it) { SessionManager* pMgr = it->GetValue(); if (NULL != pMgr) { pMgr->Tick(); } } } }
CalpontSelectExecutionPlan* parseQuery(const string& query, const uint32_t sid) { //We're going to make parsing the query single-threaded for now. This makes it a lot // easier to interface with the parser and doesn;t materially affect overall query // performance (I think) mutex::scoped_lock lk(ParserMutex); boost::shared_ptr<CalpontSystemCatalog> csc = CalpontSystemCatalog::makeCalpontSystemCatalog(sid); CalpontSelectExecutionPlan* csep=0; csep = new CalpontSelectExecutionPlan(); //we use an auto_ptr here with some trepidation. We only want auto delete on an execption. //If the parseing and plan build succeed, we want the ptr to stay around. boost::scoped_ptr<> //doesn't have an API to release ownership, so we use auto_ptr... auto_ptr<CalpontSelectExecutionPlan> scsep(csep); yy_buffer_state* ybs=0; ybs = qfe_scan_string(query.c_str()); if (ybs != 0) { ParserCSEP = csep; ParserCSC = csc; if (qfeparse() != 0) throw runtime_error("syntax error"); qfe_delete_buffer(ybs); } else throw runtime_error("Internal parser memory error"); csep->data(query); SessionManager sm; TxnID txnID; txnID = sm.getTxnID(sid); if (!txnID.valid) { txnID.id = 0; txnID.valid = true; } QueryContext verID; verID = sm.verID(); csep->txnID(txnID.id); csep->verID(verID); csep->sessionID(sid); //cout << *csep << endl; scsep.release(); return csep; }
// Space API - Provide info for ObjectHost to communicate with spaces void ObjectHost::addServerIDMap(const SpaceID& space_id, ServerIDMap* sidmap) { SessionManager* smgr = new SessionManager( mContext, space_id, sidmap, std::tr1::bind(&ObjectHost::handleObjectConnected, this, _1, _2), std::tr1::bind(&ObjectHost::handleObjectMigrated, this, _1, _2, _3), std::tr1::bind(&ObjectHost::handleObjectMessage, this, _1, space_id, _2), std::tr1::bind(&ObjectHost::handleObjectDisconnected, this, _1, _2) ); smgr->registerDefaultOHDPHandler( std::tr1::bind(&ObjectHost::handleDefaultOHDPMessageHandler, this, _1, _2, _3) ); smgr->addListener(static_cast<SpaceNodeSessionListener*>(this)); mSessionManagers[space_id] = smgr; smgr->start(); }
extern "C" int TargetName(int worldId, int handle, char* buf, int len) { int ret = 0; if (NULL != buf) { SessionManager* pMgr = g_SessionManagers.Get(worldId); if (NULL != pMgr) { const char* name = pMgr->TargetName(handle); if (NULL != name) { tsnprintf(buf, len, "%s", name); ret = 1; } } } return ret; }
TEST_F(SessionManagerTest, CDFInterimFailureWithTimerIdChangeTest) { LocalStore* memstore = new LocalStore(); SessionStore* store = new SessionStore(memstore); DummyPeerMessageSenderFactory* factory = new DummyPeerMessageSenderFactory(BILLING_REALM); MockChronosConnection* fake_chronos = new MockChronosConnection("http://localhost:1234"); SessionManager* mgr = new SessionManager(store, _dict, factory, fake_chronos, _diameter_stack); DummyErrorPeerMessageSenderFactory* fail_factory = new DummyErrorPeerMessageSenderFactory(BILLING_REALM); SessionManager* fail_mgr = new SessionManager(store, _dict, fail_factory, fake_chronos, _diameter_stack); SessionStore::Session* sess = NULL; Message* start_msg = new Message("CALL_ID_FOUR", ORIGINATING, SCSCF, NULL, Rf::AccountingRecordType(2), 300, FAKE_TRAIL_ID); Message* interim_msg = new Message("CALL_ID_FOUR", ORIGINATING, SCSCF, NULL, Rf::AccountingRecordType(3), 300, FAKE_TRAIL_ID); mgr->handle(start_msg); sess = store->get_session_data("CALL_ID_FOUR", ORIGINATING, SCSCF, FAKE_TRAIL_ID); ASSERT_NE((SessionStore::Session*)NULL, sess); EXPECT_EQ(1u, sess->acct_record_number); // Change the stored timer - this means that the chronos PUT will return a // clashing timer, triggering the session manager to update the stored timer ID sess->timer_id = "NEW_TIMER"; store->set_session_data("CALL_ID_FOUR", ORIGINATING, SCSCF, sess, FAKE_TRAIL_ID); delete sess; sess = NULL; // When an INTERIM message fails with an error other than 5002 "Session unknown", we should still keep the session fail_mgr->handle(interim_msg); sess = store->get_session_data("CALL_ID_FOUR", ORIGINATING, SCSCF, FAKE_TRAIL_ID); ASSERT_NE((SessionStore::Session*)NULL, sess); EXPECT_EQ(2u, sess->acct_record_number); // The timer id should have been updated to match the id returned from the PUT. EXPECT_EQ("TIMER_ID", sess->timer_id); delete sess; sess = NULL; delete mgr; delete factory; delete fail_mgr; delete fail_factory; delete fake_chronos; delete store; delete memstore; }
Core::IFile *ProjectFileFactory::open(const QString &fileName) { Core::IFile *fIFace = 0; ProjectExplorerPlugin *pe = ProjectExplorerPlugin::instance(); if (!pe->openProject(fileName)) { Core::ICore::instance()->messageManager()->printToOutputPane(tr("Could not open the following project: '%1'").arg(fileName)); } else if (pe->session()) { SessionManager *session = pe->session(); if (session->projects().count() == 1) fIFace = session->projects().first()->file(); else if (session->projects().count() > 1) fIFace = session->file(); // TODO: Why return session file interface here ??? } return fIFace; }
static void registerUser(const QString &user) { SessionManager *sessionManager = SessionManager::getInstance(); QSignalSpy spy(sessionManager, SIGNAL(registerCompleted(bool, const QString &))); QVERIFY(spy.isValid()); QVERIFY(spy.isEmpty()); QSharedPointer<const User> u(new User(user, WORKING_DIR "public.pem")); sessionManager->registerUser(SERVER_URL, CA_CERT, u, "password"); waitForResult(spy); QCOMPARE(spy.count(), 1); /* Don't check results - we don't delete this user, so it will fail. */ }
void VideoSource::doubleClickAction() { if ( altAddress.compare( "" ) != 0 ) { SessionManager* manager = session->getParentManager(); if ( manager ) { manager->rotateTo( altAddress, false ); } } else { gravUtil::logVerbose( "VideoSource::doubleClickAction(): no alternate " "address to connect to\n" ); } }