ServerEntryPtr ServerCache::postUpdate(const ServerInfo& info, bool noRestart) { Lock sync(*this); ServerEntryPtr entry = getImpl(info.descriptor->id); assert(entry); ServerInfo oldInfo = entry->getInfo(); entry->update(info, noRestart); if(!noRestart) { _nodeCache.get(info.node, true)->addServer(entry); forEachCommunicator(AddCommunicator(*this, entry, info.application))(oldInfo.descriptor, info.descriptor); } if(_traceLevels && _traceLevels->server > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->serverCat); out << "updated server `" << info.descriptor->id << "' (`" << info.uuid << "', `" << info.revision << "')"; } return entry; }
ServerEntryPtr ServerCache::add(const ServerInfo& info) { Lock sync(*this); ServerEntryPtr entry = getImpl(info.descriptor->id); if(!entry) { entry = new ServerEntry(*this, info.descriptor->id); addImpl(info.descriptor->id, entry); } entry->update(info, false); _nodeCache.get(info.node, true)->addServer(entry); forEachCommunicator(AddCommunicator(*this, entry, info.application))(info.descriptor); if(_traceLevels && _traceLevels->server > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->serverCat); out << "added server `" << info.descriptor->id << "' (`" << info.uuid << "', `" << info.revision << "')"; } return entry; }
void ServerCache::preUpdate(const ServerInfo& newInfo, bool noRestart) { Lock sync(*this); const string& id = newInfo.descriptor->id; ServerEntryPtr entry = getImpl(id); assert(entry); if(!noRestart) { ServerInfo info = entry->getInfo(); forEachCommunicator(RemoveCommunicator(*this, entry))(info.descriptor, newInfo.descriptor); _nodeCache.get(info.node)->removeServer(entry); } if(_traceLevels && _traceLevels->server > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->serverCat); out << "updating server `" << id << "'"; if(noRestart) { out << " with no restart"; } } }
bool ServerCache::has(const string& id) const { Lock sync(*this); ServerEntryPtr entry = getImpl(id); return entry && !entry->isDestroyed(); }
void SceneClientManager::init(const std::vector<ServerEntryPtr>& scenesentry) { if (scenesentry.empty()) { LOG(INFO)<<("can't find scene entry"); return ; } else { LOG(INFO)<<"scene entry num="<<scenesentry.size(); } for (size_t i=0;i<scenesentry.size(); ++i) { ServerEntryPtr e = scenesentry[i]; connection_ptr conn(new connection(GatewayServer::instance().get_io_service(), std::string("sceneclient") + boost::lexical_cast<std::string>(i))); context_ptr client(new SceneClient(conn->get_io_service(), conn, e)); conn->set_context(client); conn->set_compressor(std::shared_ptr<loki::compressor>(new loki::compressor_zlib())); char key[32]= {'a', 'b', 'c'}; std::shared_ptr<loki::encryptor_aes> aes(new loki::encryptor_aes()); aes->setkey((const unsigned char*)key,256); conn->set_encryptor(aes); ///////////////////// conn->set_connected_handler(std::bind(&SceneClientManager::on_connected, this, std::placeholders::_1)); conn->set_error_handler(std::bind(&SceneClientManager::on_error, this, std::placeholders::_1)); //直接放入主逻辑线程处理 conn->set_msg_handler(std::bind(&GatewayServer::on_msg, GatewayServer::getSingletonPtr(), std::placeholders::_1)); conn->async_connect(e->ip(), e->port()); //start timer //timer_.expires_from_now(boost::posix_time::seconds(5)); //timer_.async_wait(boost::bind(&SceneClientManager::check_reconnect, SceneClientManager::instance_ptr(), _1, conn)); } }
void IceGrid::RegistryServerAdminRouter::ice_invoke_async(const AMD_Object_ice_invokePtr& cb, const std::pair<const Ice::Byte*, const Ice::Byte*>& inParams, const Current& current) { ObjectPrx target = 0; try { ServerEntryPtr server = _database->getServer(current.id.name); try { target = server->getAdminProxy(); } catch(const SynchronizationException&) { server->addSyncCallback(new SynchronizationCallbackI(this, cb, inParams, current)); return; // Wait for the server synchronization to complete and retry. } } catch(const ServerNotExistException&) { } catch(const NodeUnreachableException&) { } catch(const DeploymentException&) { } if(target == 0) { throw ObjectNotExistException(__FILE__, __LINE__); } target = target->ice_facet(current.facet); invokeOnTarget(target, cb, inParams, current); }
ServerEntryPtr ServerCache::remove(const string& id, bool noRestart) { Lock sync(*this); ServerEntryPtr entry = getImpl(id); assert(entry); ServerInfo info = entry->getInfo(); forEachCommunicator(RemoveCommunicator(*this, entry))(info.descriptor); _nodeCache.get(info.node)->removeServer(entry); entry->destroy(noRestart); // This must be done after otherwise some allocatable objects // might allocate a destroyed server. if(_traceLevels && _traceLevels->server > 0) { Ice::Trace out(_traceLevels->logger, _traceLevels->serverCat); out << "removed server `" << id << "'"; } return entry; }
void ServerCache::addCommunicator(const CommunicatorDescriptorPtr& oldDesc, const CommunicatorDescriptorPtr& newDesc, const ServerEntryPtr& server, const string& application) { if(!newDesc) { return; // Nothing to add } for(AdapterDescriptorSeq::const_iterator q = newDesc->adapters.begin() ; q != newDesc->adapters.end(); ++q) { AdapterDescriptor oldAdpt; if(oldDesc) { for(AdapterDescriptorSeq::const_iterator p = oldDesc->adapters.begin() ; p != oldDesc->adapters.end(); ++p) { if(p->id == q->id) { oldAdpt = *p; break; } } } assert(!q->id.empty()); _adapterCache.addServerAdapter(*q, server, application); for(ObjectDescriptorSeq::const_iterator r = q->objects.begin(); r != q->objects.end(); ++r) { _objectCache.add(toObjectInfo(_communicator, *r, q->id), application, server->getId()); } for(ObjectDescriptorSeq::const_iterator r = q->allocatables.begin(); r != q->allocatables.end(); ++r) { ObjectDescriptorSeq::const_iterator s; for(s = oldAdpt.allocatables.begin(); s != oldAdpt.allocatables.end() && s->id != r->id; ++s); if(s == oldAdpt.allocatables.end() || *s != *r) // Only add new or updated allocatables { _allocatableObjectCache.add(toObjectInfo(_communicator, *r, q->id), server); } } } }
void NodeEntry::removeServer(const ServerEntryPtr& entry) { Lock sync(*this); _servers.erase(entry->getId()); }
void NodeEntry::addServer(const ServerEntryPtr& entry) { Lock sync(*this); _servers.insert(make_pair(entry->getId(), entry)); }
DestroyCB(const TraceLevelsPtr& traceLevels, const ServerEntryPtr& server, const string& node) : _traceLevels(traceLevels), _server(server), _id(server->getId()), _node(node) { }
LoadCB(const TraceLevelsPtr& traceLevels, const ServerEntryPtr& server, const string& node, int timeout) : _traceLevels(traceLevels), _server(server), _id(server->getId()), _node(node), _timeout(timeout) { }
bool GatewayServer::start_server() { new LoginSessionManager(); new GatewayTaskManager(); new SceneClientManager(); notify_login_server(); //as client recordclient_.reset(new connection(pool_.get_io_service(),"recordclient")); recordclient_->set_msg_handler(std::bind(&GatewayServer::on_msg, this, std::placeholders::_1)); recordclient_->set_error_handler(std::bind(&GatewayServer::handle_stop, this)); //TODO: change another handler ServerEntryPtr recordEntry = serverlist_.getEntryByType(RECORDSERVER); if (!recordEntry) { LOG(ERROR)<<("can't find record entry"); return false; } if (!recordclient_->connect(recordEntry->ip(), recordEntry->port())) { LOG(ERROR)<<("can't find record entry"); return false; } else { Record::t_LoginRecord send; send.set_id(myentry_->id()); send.set_type(myentry_->type()); codec_.send(recordclient_, &send); } //as client sessionclient_.reset(new connection(pool_.get_io_service(), "sessionclient")); sessionclient_->set_msg_handler(std::bind(&GatewayServer::on_msg, this, std::placeholders::_1)); sessionclient_->set_error_handler(std::bind(&GatewayServer::handle_stop, this)); //TODO: change another handler ServerEntryPtr sessionEntry = serverlist_.getEntryByType(SESSIONSERVER); if (!sessionEntry) { LOG(INFO)<<("can't find session entry"); return false; } if (!sessionclient_->connect(sessionEntry->ip(), sessionEntry->port())) { LOG(INFO)<<("connect session error"); return false; } else { Session::t_LoginSession send; send.set_id(myentry_->id()); send.set_type(myentry_->type()); codec_.send(sessionclient_, &send); } //as client std::vector<ServerEntryPtr> scenesentry = serverlist_.getEntrysByType(SCENESERVER); if (scenesentry.empty()) { LOG(INFO)<<("can't find scene entry"); return false; } else { LOG(INFO)<<"scene entry num="<<scenesentry.size(); } SceneClientManager::instance().init(scenesentry); started_ = true; one_second_timer_.expires_from_now(boost::posix_time::seconds(1)); one_second_timer_.async_wait(boost::bind(&GatewayServer::one_second_callback, this, _1)); return true; }