void UserNameWriterAdapter::run()
{
while(true)
{
MyUtil::IntSeq ids;
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_mutex);
if(_idSet.empty())
{
_mutex.wait();
}
ids.insert(ids.end(), _idSet.begin(), _idSet.end());
_idSet.clear();
}
for(MyUtil::IntSeq::const_iterator it = ids.begin(); it != ids.end(); ++it)
{
UserNameWriterPrx prx = getUserNameWriter(*it);
if(prx)
{
try
{
prx->reload(*it);
}catch(Ice::Exception& e)
{
MCE_WARN("UserNameWriterAdapter::run reload Exception id = " << *it <<" " << e.what());
}
}
}
}
}
void MiniGroupWriterAdapter::run() {
while (true) {
MyUtil::IntSeq userIds;
MyUtil::LongSeq miniGroupIds;
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_mutex);
if (_userIdSet.empty() && _miniGroupIdSet.empty()) {
_mutex.wait();
}
userIds.insert(userIds.end(), _userIdSet.begin(), _userIdSet.end());
_userIdSet.clear();
miniGroupIds.insert(miniGroupIds.end(), _miniGroupIdSet.begin(), _miniGroupIdSet.end());
_miniGroupIdSet.clear();
}
if (!userIds.empty()) {
try {
getMiniGroupWriterPrx(0)->reloadUsers(userIds);
} catch(Ice::Exception& e) {
MCE_WARN("[MiniGroupWriterAdapter::run] reloadUsers size = " << userIds.size());
}
}
if (!miniGroupIds.empty()) {
try {
getMiniGroupWriterPrx(0)->reloadMiniGroups(miniGroupIds);
} catch(Ice::Exception& e) {
MCE_WARN("[MiniGroupWriterAdapter::run] reloadMiniGroups size = " << miniGroupIds.size());
}
}
}
}
void RoomManagerI::removeRoom(const RoomIdPtr& rid, const Ice::Current&) {
IceUtil::RWRecMutex::WLock lock(_mutex);
MCE_DEBUG("RoomManagerI::removeRoom --> remove room, "
<< roomIdToString(rid));
Ice::Long hashcode = StrUtil::hashcode(roomIdToString(rid));
RoomClusterPtr rc = ServiceI::instance().findObject<RoomClusterPtr>(ROOM_CLUSTER, hashcode);
if (!rc) {
return;
}
rc->remove(rid);
MemberListPtr ml = ServiceI::instance().locateObject<MemberListPtr>(MEMBER_LIST, hashcode);
if (!ml) {
return;
}
Int2IntSeqMap memMap = ml->getMemberList(rid);
/* for (Int2IntSeqMap::iterator it = memMap.begin(); it != memMap.end(); ++it) {
for (size_t i = 0; i < it->second.size(); ++i) {
RoomListPtr rl = ServiceI::instance().findObject<RoomListPtr>(ROOM_LIST, it->second.at(i));
if (rl) {
rl->removeRoom(rid);
}
}
}
*/
ml->remove(rid);
Statement sql;
sql << "delete from room where roomid='" << roomIdToString(rid) << "'";
Statement sql2;
sql2 << "delete from room_member where roomid='" << roomIdToString(rid)
<< "'";
try {
QueryRunner("im_groupchat", CDbWServer).store(sql);
QueryRunner("im_groupchat", CDbWServer).store(sql2);
} catch(Ice::Exception& e) {
MCE_WARN(e << " at " << __FILE__ << ":" << __LINE__);
} catch (std::exception& e) {
MCE_WARN(e.what() << " at " << __FILE__ << ":" << __LINE__);
} catch (...) {
MCE_WARN("Unkown exception at " << __FILE__ << ":" << __LINE__);
}
MyUtil::IntSeq userIds;
for (Int2IntSeqMap::iterator it = memMap.begin(); it != memMap.end(); ++it) {
if(it->first < Member){
continue;
}
userIds.insert(userIds.end(), it->second.begin(), it->second.end());
}
UserRoomAdapter::instance().removeRoomIds(userIds, rid);
}
//--------------------------------------------------------------------------------
void VertifyPipe::handle(const ObjectSeq& seq) {
//MCE_INFO("VertifyPipe::handle --> thread_id = " << pthread_self());
if (seq.empty()) {
return;
} else {
//MCE_DEBUG("VertifyPipe::handle --> objectseq size = " <<seq.size());
}
VerifySeq vSeq;
IntSeq needNotVerifyUsers;
for (size_t i = 0; i < seq.size(); ++i) {
MessagePtr m = MessagePtr::dynamicCast(seq.at(i));
//MCE_INFO("m->from = " << m->from->userId << " m->to = " << m->to->userId);
if( (m->type != MESSAGE && m->type != OFFLINE_MESSAGE) || (m->from->userId == 365734329 || m->to->userId == 365734329) ){//客服ID，不检查好友。
//MCE_INFO("VertifyPipe::handle --> m->from = " << m->from << " m->to = " << m->to);
needNotVerifyUsers.push_back(i);
continue;
}
VerifyPtr v = new Verify();
v->from = m->from->userId;
v->to = m->to->userId;
/*if(MESSAGE != m->type){
v->to = v->from;
}*/
v->type = m->type;
/* if (v->type == SYSTEM_MESSAGE) {
v->sysMsgType = m->from->endpoint;
}*/
v->index = i;
vSeq.push_back(v);
}
MyUtil::IntSeq indexSeq;
try{
indexSeq = TalkRightAdapter::instance().batchVerify(getIndex(), vSeq);
}catch(Ice::Exception& e){
MCE_WARN("VertifyPipe::handle-->TalkRightAdapter::batchVerify-->" << e);
}
indexSeq.insert(indexSeq.end(), needNotVerifyUsers.begin(), needNotVerifyUsers.end());
//MCE_DEBUG("VertifyPipe::handle -->indexSeq size:"<<indexSeq.size());
for (size_t i = 0; i < indexSeq.size(); ++i) {
MessagePtr m = MessagePtr::dynamicCast(seq.at(indexSeq.at(i)));
//MCE_DEBUG("VertifyPipe::handle --> "<<m->to->index);
if (m->to->index == 0 || m->to->index == 2 || m->to->index >1) {
//MCE_DEBUG("VertifyPipe::handle --> endpoint:"<<m->to->endpoint);
PipePool::instance().push(m->to->endpoint, 0, m);
}
}
}
MyUtil::IntSeq TalkRightAdapter::batchVerify(const VerifySeq& seq) {
map<int, VerifySeq> vMap;
for (size_t i = 0; i < seq.size(); ++i) {
vMap[abs(seq.at(i)->to) % getCluster()].push_back(seq.at(i));
}
MyUtil::IntSeq res;
for (map<int,VerifySeq>::iterator it = vMap.begin(); it != vMap.end(); ++it) {
try {
MyUtil::IntSeq tmp = getManager(it->first)->batchVerify(it->second);
res.insert(res.end(),tmp.begin(),tmp.end());
} catch(...) {
for(size_t i = 0; i < it->second.size(); ++i){
res.push_back(it->second.at(i)->index);
}
}
}
return res;
}
void xce::distcache::userapicache::DelayReloadThread::run()
{
while(true)
{
MyUtil::IntSeq ids;
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_mutex);
if(_idSet.empty())
{
_mutex.timedWait(IceUtil::Time::seconds(1));
}
if(_idSet.empty())
{
continue;
}
ids.insert(ids.end(),_idSet.begin(), _idSet.end());
_idSet.clear();
}
MyUtil::TaskManager::instance().execute(new ReloadTask(ids));
}
}