QVariant SessionModel::data(const QModelIndex &index, int role) const { if (index.row() < 0 || index.row() >= d->sessions.count()) return QVariant(); // get session Session *session = d->sessions[index.row()]; // return correct value switch (role) { case DirectoryRole: return session->directory().absolutePath(); case FileRole: return session->fileName(); case TypeRole: return session->type(); case NameRole: return session->displayName(); case ExecRole: return session->exec(); case CommentRole: return session->comment(); default: break; } // return empty value return QVariant(); }
void Command::emitResponses() { if ( state() == Retired ) return; Session * s = imap()->session(); if ( s && !s->initialised() ) return; imap()->emitResponses(); if ( !d->untagged.isEmpty() ) return; setState( Retired ); // we don't have a tag if we're an implicit Fetch or Store used by // ImapSession. if ( d->tag.isEmpty() ) return; EString t = tag(); if ( !d->error ) { t.append( " OK " ); } else if ( d->errorCode == Bad ) { imap()->recordSyntaxError(); t.append( " BAD " ); } else { t.append( " NO " ); } if ( !d->respTextCode.isEmpty() ) { t.append( "[" ); t.append( d->respTextCode ); t.append( "] " ); } if ( d->error ) { t.append( d->errorText ); } else { t.append( "done" ); } log( t ); t.append( "\r\n" ); imap()->enqueue( t ); }
//====================================================================================================================== void SocketWriteThread::run() { Session* session; // Call our internal _startup method _startup(); // Main loop while(!mExit) { //if((!this->mServerService) && sessionCount) { //DLOG(info) << "SocketWriteThread::run() START"; //DLOG(info) << "servicing : " << sessionCount << " Sessions"; //DLOG(info) << "NO ACTIVE OBJECT"; //} uint32 packetsSend = 0; while(mSessionQueue.pop(session)) { uint32 packetCount = 0; // Process our session active_.Send( [=] { session->ProcessWriteThread(); mAsyncSessionQueue.push(session); } ); } while(mAsyncSessionQueue.pop(session)) { _send(session); } //if((!this->mServerService) && sessionCount) { //DLOG(info) << "SocketWriteThread::run() END"; //DLOG(info) << "sending : " << packetsSend << "Packets"; //} boost::this_thread::sleep(boost::posix_time::milliseconds(1)); } // Shutdown internally _shutdown(); }
void WServer::HandlePlayerLoginResult(WorldPacket & pck) { uint32 guid, sessionid; uint8 result; pck >> guid >> sessionid >> result; if(result) { Log.Success("WServer", "Worldserver %u reports successful login of player %u", m_id, guid); Session * s = sClientMgr.GetSession(sessionid); if(s) { /* update server */ s->SetNextServer(); /* pack together a player info packet and distribute it to all the other servers */ ASSERT(s->GetPlayer()); WorldPacket data(ISMSG_PLAYER_INFO, 100); s->GetPlayer()->Pack(data); sClusterMgr.DistributePacketToAll(&data, this); } } else { Log.Error("WServer", "Worldserver %u reports failed login of player %u", m_id, guid); Session * s = sClientMgr.GetSession(sessionid); if(s) { s->ClearCurrentPlayer(); s->ClearServers(); } sClientMgr.DestroyRPlayerInfo(guid); } }
bool_t NetworkTask::DispatchMsg() { bool_t ret = FALSE; Buffer *buffer = network_q_->Pop(); if(!buffer) { return FALSE; } Session *sess = 0; PacketHeader pkt_header; ret = buffer->GetBinary((char_t*)&pkt_header, sizeof(pkt_header)); if(!ret) { ECILA_TRACE(); goto _ERROR; } //network task 는 비동기, dispatch task 는 동기이므로 세션이 먼저 close 될수 있다. //그러므로 활성 세션을 찻지 못했을경우는 스킵한다. sess = act_sess_pool_->ACTSession(pkt_header.uidx_); if(!sess) { goto _ABORT; } if(pkt_header.cmd_ & PKT_CMD_SEND) { ret = sess->Send(buffer->GetOutPtr(), pkt_header.size_); if(!ret) { ECILA_TRACE(); goto _ERROR; } } if(pkt_header.cmd_ & PKT_CMD_CLOSE) { ret = sess->Close(TRUE); if(!ret) { ECILA_TRACE(); goto _ERROR; } } _ABORT: ret = buff_pool_->Release(buffer); if(!ret) { ECILA_TRACE(); return FALSE; } return TRUE; _ERROR: ret = buff_pool_->Release(buffer); if(!ret) { ECILA_TRACE(); return FALSE; } return FALSE; }
osg::Node* FeatureModelSource::createNodeImplementation(const Map* map, ProgressCallback* progress ) { // trivial bailout. if (!getStatus().isOK()) return 0L; // user must provide a valid map. if ( !map ) { OE_WARN << LC << "NULL Map is illegal when building feature data." << std::endl; return 0L; } // make sure the feature source initialized properly: if ( !_features.valid() || !_features->getFeatureProfile() ) { return 0L; } // create a feature node factory: FeatureNodeFactory* factory = createFeatureNodeFactory(); if ( !factory ) { OE_WARN << LC << "Unable to create a feature node factory!" << std::endl; setStatus(Status::Error(Status::ServiceUnavailable, "Failed to create a feature node factory")); return 0L; } // Session holds data that's shared across the life of the FMG Session* session = new Session( map, _options.styles().get(), _features.get(), _readOptions.get() ); // Name the session (for debugging purposes) session->setName( this->getName() ); // Graph that will render feature models. May included paged data. FeatureModelGraph* graph = new FeatureModelGraph(session, _options, factory, getSceneGraphCallbacks()); return graph; }
void Display::startAuth(const QString &user, const QString &password, const Session &session) { m_passPhrase = password; // sanity check if (!session.isValid()) { qCritical() << "Invalid session" << session.fileName(); return; } if (session.xdgSessionType().isEmpty()) { qCritical() << "Failed to find XDG session type for session" << session.fileName(); return; } if (session.exec().isEmpty()) { qCritical() << "Failed to find command for session" << session.fileName(); return; } m_reuseSessionId = QString(); if (Logind::isAvailable() && mainConfig.Users.ReuseSession.get()) { OrgFreedesktopLogin1ManagerInterface manager(Logind::serviceName(), Logind::managerPath(), QDBusConnection::systemBus()); auto reply = manager.ListSessions(); reply.waitForFinished(); foreach(const SessionInfo &s, reply.value()) { if (s.userName == user) { OrgFreedesktopLogin1SessionInterface session(Logind::serviceName(), s.sessionPath.path(), QDBusConnection::systemBus()); if (session.service() == QLatin1String("sddm")) { m_reuseSessionId = s.sessionId; break; } } } }
void ServerManager::Manage(Packet * packet) { Session *session; Packet_v1 *packet_v1; packet_v1 = static_cast<Packet_v1 *>(packet); field_t componentId = packet_v1->getComponentId(), requestId = packet_v1->getRequestId(); session = _sessionManager->FindSession(packet_v1); #ifdef _DEBUG COLOR_BLUE;COLOR_INTENSITY; std::cout << std::endl; std::cout << "< RECV > "; packet_v1->Print("", this); COLOR_DEFAULT; #endif if (session) { session->setTimeOutTest(); session->CancelTimeOutOccurred(); if (IsRegisteredComponent(componentId)) { if (IsRegisteredRequest(componentId, requestId)) { getBindRecv(componentId, requestId).Receive(packet_v1, session); Request const & r = getRegisteredRequest(componentId, requestId); if (r.IsResponseTo()) session->CancelAutoRetry(componentId, r.getResponseTo()); } else std::cout << "UNREGISTERED REQUEST ID" << std::endl; } else std::cout << "UNREGISTERED COMPONENT ID" << std::endl; } else if (componentId == SESSION_COMPONENTID && requestId == SESSION_AUTHREQUEST) _sessionManager->Recv_AuthRequest(packet_v1, 0); else { //_sessionManager->PrintSession(packet); std::cout << "auth required" << std::endl; // send apropriate information } }
void WidgetIrcMain::connectToImpl(const ConnectionInfo& connection) { Session* session = Session::fromConnection(connection, this); session->setEncoding(Application::encoding()); if (session->userName().isEmpty()) session->setUserName("quazaa"); if (!session->hasQuit() && session->ensureNetwork()) session->open(); tabWidget->addSession(session); connect(session, SIGNAL(activeChanged(bool)), this, SLOT(updateSession())); connect(session, SIGNAL(connectedChanged(bool)), this, SLOT(updateSession())); updateSession(session); SessionTabWidget* tab = tabWidget->sessionWidget(session); connect(tab, SIGNAL(viewAdded(WidgetIrcMessageView*)), this, SLOT(viewAdded(WidgetIrcMessageView*))); connect(tab, SIGNAL(viewRemoved(WidgetIrcMessageView*)), this, SLOT(viewRemoved(WidgetIrcMessageView*))); connect(tab, SIGNAL(viewRenamed(WidgetIrcMessageView*)), this, SLOT(viewRenamed(WidgetIrcMessageView*))); connect(tab, SIGNAL(viewActivated(WidgetIrcMessageView*)), this, SLOT(viewActivated(WidgetIrcMessageView*))); connect(tab, SIGNAL(editSession(Session*)), this, SLOT(editSession(Session*))); if (WidgetIrcMessageView* view = tab->viewAt(0)) { treeWidget->addView(view); treeWidget->setCurrentView(view); treeWidget->parentWidget()->show(); view->applySettings(); } if (!quazaaSettings.WinMain.ChatUserListSplitter.isEmpty()) tab->restoreSplitter(quazaaSettings.WinMain.ChatUserListSplitter); }
int LuaNetwork::CloseSession(lua_State* L) { int sn; Lua::argParse(L, "i", &sn); Net *pNet = ServerApp::get()->getNet(); if (!pNet) { luaL_error(L, "Net have'nt been created!"); return 0; } Session *s = pNet->getSession(sn); if (s) { s->close(); LOG("Close connection %d sn by script interface", sn); } return 0; }
void Node::receiveNodeNameSet(void* user, VNodeID ID, const char* name) { Session* session = Session::getCurrent(); Node* node = session->getNodeByID(ID); if (!node) return; if (node->mName != name) { const Node::ObserverList& observers = node->getObservers(); for (Node::ObserverList::const_iterator i = observers.begin(); i != observers.end(); i++) (*i)->onSetName(*node, name); node->mName = name; node->updateDataVersion(); } }
ClassificationObjectPtr DatabaseSubsystem::getClassificationObject(int clObjID) { RWLock::ScopedLock lock(_dbLock); ClassificationObjectPtr result; Session session = getSession(); session.begin(); session << "SELECT * FROM classification_object WHERE object_id = ?", use(clObjID), into(result), now; if (!result.isNull()) { getClassificationObjectDescrIDs(session, result); getClassificationObjectLabelIDs(session, result); } session.commit(); return result; }
void DatabaseSubsystem::createProcess(ProcessPtr process) { RWLock::ScopedLock lock(_dbLock, true); Session session = getSession(); session.begin(); session << "INSERT INTO process (process_name, input_file, start_time, sample_freq) " "VALUES (?, ?, ?, ?)", use(process->name), use(process->inputFile), use(process->startTime), use(process->sampleFreq), now; process->processID = lastInsertID(session); insertProcessParams(session, process); session.commit(); }
ResponsePtr DatabaseSubsystem::getResponse(int responseID) { RWLock::ScopedLock lock(_dbLock); ResponsePtr result; Session session = getSession(); session.begin(); session << "SELECT * FROM response WHERE response_id = ?", use(responseID), into(result), now; if (!result.isNull()) { getResponseLabels(session, result); } session.commit(); return result; }
//////////////////////////////////////////////////////////// // Delete Process data::ENSessionState BasicHandler::OnDBSvrDelete(Session& session) { // check db process index if (session.db_process_index() >= (size_t)session.db_handles_size()) return data::SESSION_STATE_FINISH; // get db query auto& db_handle = session.db_handles(session.db_process_index()); // construct request msg::SS message; message.set_msg_type(msg::SS_TYPE_DELETE_DATA_REQ); message.mutable_proxy_head()->set_session_id(session.session_id()); auto& request = *message.mutable_delete_data_req(); request.set_type(db_handle.type()); request.set_id(db_handle.id()); ConnectServerMsgTransferService::Instance()->TransferMessageByHash(conf::SERVER_TYPE_DATA_SERVER, db_handle.id(), message); return data::SESSION_STATE_DBSVR_DELETE_WAIT; }
void SessionInitialiser::recordExpunges() { if ( !d->expunges ) return; Row * r = 0; IntegerSet uids; while ( (r=d->expunges->nextRow()) != 0 ) uids.add( r->getInt( "uid" ) ); if ( uids.isEmpty() ) return; List<Session>::Iterator i( d->sessions ); while ( i ) { Session * s = i; ++i; s->expunge( uids ); } }
AuthHostInstance::AuthHostInstance(Session &session, AuthHostType host) : mHostType(host) { secdebug("authhost", "authhost born (%p)", this); referent(session); session.addReference(*this); if (host == securityAgent) pthread_once(&agent_cred_init, initialize_agent_creds); }
virtual void List(Session& ses) const { ServerInstanceInfo srv(ses); bool serverIsUp = GameModules[GAME_NAME]->IsUp(srv.Id); ses.NewElem(); if (serverIsUp) { ses.AddChildNode("name", "server_online"); ses.AddChildNode("status", "on"); } else { ses.AddChildNode("name", "server_offline"); ses.AddChildNode("status", "off"); } AddRow(ses, "ip", srv.GetIp()); AddRow(ses, "port", str::Str(srv.GetPort())); AddRow(ses, "players_online", serverIsUp?str::Str(GameModules[GAME_NAME]->PlayersOnline(srv.Id)):"-"); }
void VirtualScrollback::Sync() { if (this->owner == NULL) throw new NullPointerException("this->owner", BOOST_CURRENT_FUNCTION); // Let's get all sessions who need to be informed about creation of this scrollback Session *session = this->owner->GetAnyGPSession(); if (!session) return; QHash<QString, QVariant> parameters; parameters.insert("name", this->GetTarget()); if (this->parentSx) parameters.insert("parent_sid", QVariant(this->parentSx->GetOriginalID())); if (this->GetSession() && this->GetSession()->GetType() == SessionType_IRC) parameters.insert("network_id", QVariant(((IRCSession*)this->GetSession())->GetSID())); parameters.insert("scrollback", QVariant(this->ToHash())); session->SendToEverySession(GP_CMD_SCROLLBACK_RESYNC, parameters); }
int Game::SspCalculateFrame() { // clear old state m_cur_state.clear(); //pick the newest state of each client for(auto session_iter = m_player_list->begin(); session_iter != m_player_list->end(); ++session_iter) { Session *s = (*session_iter); std::string state; if(s->PopState(state) == 0) { m_cur_state += state; } } return 0; }
void MemcachedSessionManager::delete_session(Session &session) { memcached_return rc; std::string const &sessionid = session.sessionid(); rc = memcached_delete(memcached_conn, sessionid.data(), sessionid.length(), 0); if (rc != MEMCACHED_SUCCESS) throw MemcacheError(memcached_conn, rc); }
int LuaNetwork::SetSessionUserData(lua_State* L) { int sn; char *ud; Lua::argParse(L, "is", &sn, &ud); Net *pNet = ServerApp::get()->getNet(); if (!pNet) { luaL_error(L, "Net have'nt been created!"); return 0; } Session *s = pNet->getSession(sn); if (s) s->setUserData(ud); else luaL_error(L, "Can't find session %d", sn); return 0; }
TEST(DeleteTests, SessionDeleteUnallowedAfterPostTest) { Session session; { auto url = Url{base + "/url_post.html"}; auto payload = Payload{{"x", "5"}}; session.SetUrl(url); auto response = session.Post(); } auto url = Url{base + "/delete_unallowed.html"}; session.SetUrl(url); auto response = session.Delete(); auto expected_text = std::string{"Method unallowed"}; EXPECT_EQ(expected_text, response.text); EXPECT_EQ(url, response.url); EXPECT_EQ(std::string{"text/html"}, response.header["content-type"]); EXPECT_EQ(405, response.status_code); EXPECT_EQ(ErrorCode::OK, response.error.code); }
void DatabaseSubsystem::updateResponse(ResponsePtr response) { RWLock::ScopedLock lock(_dbLock, true); Session session = getSession(); session.begin(); session << "UPDATE response SET name = ?, description = ? WHERE response_id = ?", use(response->name), use(response->description), use(response->responseID), now; session << "DELETE FROM response_label WHERE response_id = ?", use(response->responseID), now; insertResponseLabels(session, response); session.commit(); }
void RTMFPServer::onReadable(Socket& socket) { // Running on the thread of manager socket AutoPtr<RTMFPReceiving> pRTMFPReceiving(new RTMFPReceiving(*this,(DatagramSocket&)socket)); if(!pRTMFPReceiving->pPacket) return; if(pRTMFPReceiving->id==0) { _handshake.decode(pRTMFPReceiving); return; } ScopedLock<Mutex> lock(_sessions.mutex); Session* pSession = _sessions.find(pRTMFPReceiving->id); if(!pSession) { WARN("Unknown session %u",pRTMFPReceiving->id); return; } pSession->decode(pRTMFPReceiving); }
virtual void run() { try { // Create a ConnectionFactory auto_ptr<ConnectionFactory> connectionFactory( ConnectionFactory::createCMSConnectionFactory( (const char*)brokerURI ) ); // Create a Connection connection = connectionFactory->createConnection(); connection->start(); // Create a Session if( this->sessionTransacted ) { session = connection->createSession( Session::SESSION_TRANSACTED ); } else { session = connection->createSession( Session::AUTO_ACKNOWLEDGE ); } destination = session->createQueue((const char*)queue); //destination = session->createQueue("/asev/queue"); // Create a MessageProducer from the Session to the Topic or Queue producer = session->createProducer( destination ); producer->setDeliveryMode( DeliveryMode::PERSISTENT ); //cout<<"message:"<<message<<"\n"; TextMessage* sendmessage = session->createTextMessage( (char*)message ); //cout<<"producer:"<<sendmessage->getText()<<"\n"; // Tell the producer to send the message //printf( "Sent message #%d from thread %s\n", ix+1, threadIdStr.c_str() ); producer->send( sendmessage ); if(this->sessionTransacted) session->commit(); delete sendmessage; }catch ( CMSException& e ) { e.printStackTrace(); } }
int main( int argc, char * argv[] ) { Process process; Session session; // Internal process object not initialized try { session.Init(); // Should never come here cerr << "Test failed - line " << __LINE__ << endl; return 1; } catch( pso::Exception exc ) { if ( exc.ErrorCode() != PSO_PROCESS_NOT_INITIALIZED ) { cerr << "Test failed - line " << __LINE__ << ", error = " << exc.Message() << endl; return 1; } } try { if ( argc > 1 ) { process.Init( argv[1], argv[0] ); } else { process.Init( "10701", argv[0] ); } } catch( pso::Exception exc ) { cerr << "Test failed in init phase, error = " << exc.Message() << endl; cerr << "Is the server running?" << endl; return 1; } try { session.Init(); } catch( pso::Exception exc ) { cerr << "Test failed - line " << __LINE__ << ", error = " << exc.Message() << endl; return 1; } return 0; }
/** * @brief Returns the userId of the currently logged in user. * Throws std::invalid_argument if no user with that cookie found. * * @param cookie the cookie that the client browser gave us * @param touch If true, updates the session time out * * @return userId of the currently logged in user */ int MemorySessionStore::userId(const string& cookie, bool touch) { ReadOnlyLock lock(_lock); Session* session = findSession(lock, cookie); if (session != 0) { if (session->age() < _timeout) { if (touch) { ReadWriteLock touchLock(_lock); // Session is still good, update its timeout on our end session->updateLoginTime(); } return session->userId(); } else { // Cookie is expired - delete its session and return empty ReadWriteLock eraseLock(_lock); sessions.erase(cookie); } } throw invalid_argument("No user with cookie " + cookie + " found"); }
static Session * start_session(team_id team, dev_t device, ino_t node, const char *name, int32 seconds = 30) { RecursiveLocker locker(&sLock); Session *session = new Session(team, name, device, node, seconds); if (session == NULL) return NULL; if (session->InitCheck() != B_OK || session->StartWatchingTeam() != B_OK) { delete session; return NULL; } // let's see if there is a prefetch session for this session Session *prefetchSession; if (session->IsMainSession()) { // search for session by name for (prefetchSession = sMainPrefetchSessions; prefetchSession != NULL; prefetchSession = prefetchSession->Next()) { if (!strcmp(prefetchSession->Name(), name)) { // found session! break; } } } else { // ToDo: search for session by device/node ID prefetchSession = NULL; } if (prefetchSession != NULL) { TRACE(("found prefetch session %s\n", prefetchSession->Name())); prefetchSession->Prefetch(); } if (team >= B_OK) hash_insert(sTeamHash, session); session->Lock(); return session; }
void OkcoinApp::submitMarketOrder(const char *symbol, OrderSide side, double amount, const char *userId) { int ts = timestamp(); FIX44::NewOrderSingle message; message.set(Account(_publicKey + "," + _privateKey)); if (userId) message.set(ClOrdID(userId)); else message.set(ClOrdID("OkcoinOrder")); message.set(Price(amount)); message.set(OrderQty(amount)); message.set(OrdType(OrdType_MARKET)); message.set(Symbol(symbol)); message.set(Side(side == OrderBuy ? Side_BUY : Side_SELL)); message.set(TransactTime()); Session *session = Session::lookupSession(_sessionID); if (session) session->send(message); }