void getDevicesToken(CImPdu* pPdu, uint32_t conn_uuid)
 {
     IM::Server::IMGetDeviceTokenReq msg;
     IM::Server::IMGetDeviceTokenRsp msgResp;
     if(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()))
     {
         CacheManager* pCacheManager = CacheManager::getInstance();
         CacheConn* pCacheConn = pCacheManager->GetCacheConn("token");
         CImPdu* pPduResp = new CImPdu;
         uint32_t nCnt = msg.user_id_size();
         if (pCacheConn)
         {
             vector<string> vecTokens;
             for (uint32_t i=0; i<nCnt; ++i) {
                 string strKey = "device_"+int2string(msg.user_id(i));
                 vecTokens.push_back(strKey);
             }
             map<string, string> mapTokens;
             bool bRet = pCacheConn->mget(vecTokens, mapTokens);
             pCacheManager->RelCacheConn(pCacheConn);
             
             if(bRet)
             {
                 for (auto it=mapTokens.begin(); it!=mapTokens.end(); ++it) {
                     string strKey = it->first;
                     size_t nPos = strKey.find("device_");
                     if( nPos != string::npos)
                     {
                         string strUserId = strKey.substr(nPos + strlen("device_"));
                         uint32_t nUserId = string2int(strUserId);
                         string strValue = it->second;
                         nPos = strValue.find(":");
                         if(nPos!=string::npos)
                         {
                             string strType = strValue.substr(0, nPos);
                             string strToken = strValue.substr(nPos + 1);
                             IM::BaseDefine::ClientType nClientType = IM::BaseDefine::ClientType(0);
                             if(strType == "ios")
                             {
                                 nClientType = IM::BaseDefine::CLIENT_TYPE_IOS;
                             }
                             else if(strType == "android")
                             {
                                 nClientType = IM::BaseDefine::CLIENT_TYPE_ANDROID;
                             }
                             if(IM::BaseDefine::ClientType_IsValid(nClientType))
                             {
                                 IM::BaseDefine::UserTokenInfo* pToken = msgResp.add_user_token_info();
                                 pToken->set_user_id(nUserId);
                                 pToken->set_token(strToken);
                                 pToken->set_user_type(nClientType);
                                 uint32_t nTotalCnt = 0;
                                 CMessageModel::getInstance()->getUnReadCntAll(nUserId, nTotalCnt);
                                 CGroupMessageModel::getInstance()->getUnReadCntAll(nUserId, nTotalCnt);
                                 pToken->set_push_count(nTotalCnt);
                                 pToken->set_push_type(1);
                             }
                             else
                             {
                                 log("invalid clientType.clientType=%u", nClientType);
                             }
                         }
                         else
                         {
                             log("invalid value. value=%s", strValue.c_str());
                         }
                         
                     }
                     else
                     {
                         log("invalid key.key=%s", strKey.c_str());
                     }
                 }
             }
             else
             {
                 log("mget failed!");
             }
         }
         else
         {
             log("no cache connection for token");
         }
         
         log("req devices token.reqCnt=%u, resCnt=%u", nCnt, msgResp.user_token_info_size());
         
         msgResp.set_attach_data(msg.attach_data());
         pPduResp->SetPBMsg(&msgResp);
         pPduResp->SetSeqNum(pPdu->GetSeqNum());
         pPduResp->SetServiceId(IM::BaseDefine::SID_OTHER);
         pPduResp->SetCommandId(IM::BaseDefine::CID_OTHER_GET_DEVICE_TOKEN_RSP);
         CProxyConn::AddResponsePdu(conn_uuid, pPduResp);
     }
     else
     {
         log("parse pb failed");
     }
 }