master

分支 (1)

管理

管理

master

Tars
/
cpp
/
framework
/
NodeServer
/
NodeImp.cpp

/**
 * Tencent is pleased to support the open source community by making Tars available.
 *
 * Copyright (C) 2016THL A29 Limited, a Tencent company. All rights reserved.
 *
 * Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * https://opensource.org/licenses/BSD-3-Clause
 *
 * Unless required by applicable law or agreed to in writing, software distributed
 * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 */

#include "util/tc_clientsocket.h"
#include "BatchPatchThread.h"
#include "NodeImp.h"
#include "RegistryProxy.h"
#include "NodeServer.h"
#include "CommandStart.h"
#include "CommandNotify.h"
#include "CommandStop.h"
#include "CommandDestroy.h"
#include "CommandAddFile.h"
#include "CommandPatch.h"
#include "NodeRollLogger.h"
#include "AdminReg.h"
#include "util/tc_timeprovider.h"

extern BatchPatch * g_BatchPatchThread;

void NodeImp::initialize()
{
    try
    {
        TLOGDEBUG("initialize NodeImp" << endl);

        _nodeInfo      = _platformInfo.getNodeInfo();
        _downloadPath  = _platformInfo.getDownLoadDir();
    }
    catch ( exception& e )
    {
        TLOGERROR(FILE_FUN << e.what() << endl);
        exit( 0 );
    }
}

int NodeImp::destroyServer( const string& application, const string& serverName,string &result, TarsCurrentPtr current )
{
    int64_t startMs = TC_TimeProvider::getInstance()->getNowMs();

    int iRet = EM_TARS_SUCCESS;
    if ( g_app.isValid(current->getIp()) == false )
    {
        result += " erro:ip "+ current->getIp()+" is invalid";
        iRet    = EM_TARS_INVALID_IP_ERR;
        NODE_LOG("destroyServer")->error() << FILE_FUN << "access_log|" << iRet << "|" << (TC_TimeProvider::getInstance()->getNowMs() - startMs)
                << "|" << application << "." << serverName << "|" << result << endl;
        return iRet;
    }

    result = " ["+application + "." + serverName+"] ";
    NODE_LOG("destroyServer")->debug() << result << endl;
    ServerObjectPtr pServerObjectPtr = ServerFactory::getInstance()->getServer( application, serverName );
    if ( pServerObjectPtr )
    {
        string s;
        CommandDestroy command(pServerObjectPtr);
        iRet = command.doProcess(current, s, false);
        if ( iRet == 0 && ServerFactory::getInstance()->eraseServer(application, serverName) == 0)
        {
            pServerObjectPtr = NULL;
            result = result+"succ:" + s;
        }
        else
        {
            result = FILE_FUN_STR+"error:"+s;
        }
    }
    else
    {
        result += FILE_FUN_STR+"server is not exist";
        iRet = -2;
    }

    NODE_LOG("destroyServer")->error()  << FILE_FUN << "access_log|" << iRet << "|" << (TC_TimeProvider::getInstance()->getNowMs() - startMs)
                << "|" << application << "|" << serverName << "|" << result << endl;
    return iRet;
}

int NodeImp::patchPro(const tars::PatchRequest & req, string & result, TarsCurrentPtr current)
{
    NODE_LOG("patchPro")->debug() << FILE_FUN
                 << req.appname + "." + req.servername + "_" + req.nodename << "|"
                 << req.groupname   << "|"
                 << req.version     << "|"
                 << req.user        << "|"
                 << req.servertype  << "|"
                 << req.patchobj    << "|"
                 << req.md5            << "|"
                 << req.ostype      << endl;

    if ( g_app.isValid(current->getIp()) == false )
    {
        result +=FILE_FUN_STR+ " erro:ip "+ current->getIp()+" is invalid";
        NODE_LOG("patchPro")->error()<<FILE_FUN << result << endl;
        return EM_TARS_INVALID_IP_ERR;
    }

    try
    {
         //加载服务信息
        string sError("");
        ServerObjectPtr server = ServerFactory::getInstance()->loadServer(req.appname, req.servername, true, sError);
        if (!server)
        {
            result =FILE_FUN_STR+ "load " + req.appname + "." + req.servername + "|" + sError;
            NODE_LOG("patchPro")->error() <<FILE_FUN<<req.appname + "." + req.servername + "_" + req.nodename << "|" << result << endl;
            if(sError.find("server state") != string::npos)
                return EM_TARS_SERVICE_STATE_ERR;
            else
                return EM_TARS_LOAD_SERVICE_DESC_ERR;
        }

        {
            TC_ThreadRecLock::Lock lock(*server);
            ServerObject::InternalServerState  eState = server->getInternalState();

            //去掉启动中不能发布的限制
            if (server->toStringState(eState).find("ing") != string::npos && eState != ServerObject::Activating)
            {
                result = FILE_FUN_STR+"cannot patch the server ,the server state is " + server->toStringState(eState);
                NODE_LOG("patchPro")->error() <<FILE_FUN<< req.appname + "." + req.servername << "|" << result << endl;
                return EM_TARS_SERVICE_STATE_ERR;
            }

            if(req.md5 == "")
            {
                result = FILE_FUN_STR+"parameter error, md5 not setted.";
                NODE_LOG("patchPro")->error() <<FILE_FUN<< req.appname + "." + req.servername << "|" << result << endl;
                return EM_TARS_PARAMETER_ERR;
            }

            if(CommandPatch::checkOsType())
            {
                string osType = CommandPatch::getOsType();
                if(req.ostype != "" && req.ostype != osType)
                {
                    result = FILE_FUN_STR+"parameter error, req.ostype=" + req.ostype + ", local osType:" + osType;
                    NODE_LOG("patchPro")->error() <<FILE_FUN<< req.appname + "." + req.servername << "|" << result << endl;
                    return EM_TARS_PARAMETER_ERR;
                }
            }

            //保存patching前的状态，patch完成后恢复
            NODE_LOG("patchPro")->debug() <<FILE_FUN<<req.appname + "." + req.servername + "_" + req.nodename << "|saved state:" << server->toStringState(eState) << endl;
            server->setLastState(eState);
            server->setState(ServerObject::BatchPatching);
            //将百分比初始化为0，防止上次patch结果影响本次patch进度
            server->setPatchPercent(0);

            NODE_LOG("patchPro")->debug()<<FILE_FUN << req.appname + "." + req.servername + "_" + req.nodename << "|" << req.groupname   << "|preset success" << endl;
        }

        g_BatchPatchThread->push_back(req,server);
    }
    catch (std::exception & ex)
    {
        NODE_LOG("patchPro")->error() <<FILE_FUN<< req.appname + "." + req.servername + "_" + req.nodename << "|Exception:" << ex.what() << endl;

        result = FILE_FUN_STR+ex.what();

        if(result.find("reduplicate") != string::npos)
        {
            return EM_TARS_REQ_ALREADY_ERR;
        }

        return EM_TARS_UNKNOWN_ERR;
    }
    catch (...)
    {
        NODE_LOG("patchPro")->error() <<FILE_FUN<< req.appname + "." + req.servername + "_" + req.nodename << "|Unknown Exception" << endl;
        result = FILE_FUN_STR+"Unknown Exception";
        return EM_TARS_UNKNOWN_ERR;
    }

    NODE_LOG("patchPro")->debug() <<FILE_FUN
             << req.appname + "." + req.servername + "_" + req.nodename << "|"
             << req.groupname   << "|"
             << req.version     << "|"
             << req.user        << "|"
             << req.servertype  << "|return success"<< endl;

    return EM_TARS_SUCCESS;
}

int NodeImp::addFile(const string &application,const string &serverName,const string &file, string &result, TarsCurrentPtr current)
{
    result = string(__FUNCTION__)+" server ["+application + "." + serverName+"] file:"+file;
    TLOGDEBUG(FILE_FUN << result  << endl);

    ServerObjectPtr pServerObjectPtr = ServerFactory::getInstance()->getServer( application, serverName );
    if ( pServerObjectPtr )
    {
        string s;
        CommandAddFile command(pServerObjectPtr,file);
        int iRet = command.doProcess(current,s);
        if ( iRet == 0)
        {
            result = result+"succ:" + s;
        }
        else
        {
            result = FILE_FUN_STR+"error:"+s;
        }
        return iRet;
    }

    result += FILE_FUN_STR+"server is  not exist";

    return -1;
}

string NodeImp::getName( TarsCurrentPtr current )
{
    TLOGDEBUG(FILE_FUN << endl);

    _nodeInfo = _platformInfo.getNodeInfo();

    return _nodeInfo.nodeName;
}

LoadInfo NodeImp::getLoad( TarsCurrentPtr current )
{
    TLOGDEBUG(FILE_FUN<< endl);

    return  _platformInfo.getLoadInfo();
}

int NodeImp::shutdown( string &result,TarsCurrentPtr current )
{
    try
    {
        result = FILE_FUN_STR;

        TLOGDEBUG( result << endl);
        if ( g_app.isValid(current->getIp()) == false )
        {
            result += "erro:ip "+ current->getIp()+" is invalid";
            TLOGERROR(FILE_FUN << result << endl);
            return -1;
        }
        Application::terminate();
        return 0;
    }
    catch ( exception& e )
    {
        TLOGERROR( "NodeImp::shutdown catch exception :" << e.what() << endl);
    }
    catch ( ... )
    {
        TLOGERROR( "NodeImp::shutdown catch unkown exception" << endl);
    }
    return -1;
}

int NodeImp::stopAllServers( string &result,TarsCurrentPtr current )
{
    try
    {
        if ( g_app.isValid(current->getIp()) == false )
        {
            result = FILE_FUN_STR+" erro:ip "+ current->getIp()+" is invalid";
            TLOGERROR( result << endl);
            return -1;
        }
        map<string, ServerGroup> mmServerList;
        mmServerList.clear();
        mmServerList = ServerFactory::getInstance()->getAllServers();
        for ( map<string, ServerGroup>::const_iterator it = mmServerList.begin(); it != mmServerList.end(); it++ )
        {
            for ( map<string, ServerObjectPtr>::const_iterator p = it->second.begin(); p != it->second.end(); p++ )
            {
                ServerObjectPtr pServerObjectPtr = p->second;
                if ( pServerObjectPtr )
                {
                    result =result+"stop server ["+it->first+"."+ p->first+"] ";
                    TLOGDEBUG(FILE_FUN << result << endl);

                    bool bByNode = true;
                    string s;
                    CommandStop command(pServerObjectPtr,true,bByNode);
                    int iRet = command.doProcess(s);
                    if (iRet == 0)
                    {
                        result = result+"succ:"+s+"\n";
                    }
                    else
                    {
                        result = result+"error:"+s+"\n";
                    }
                }
            }
        }
        return 0;
    }
    catch ( exception& e )
    {
        TLOGERROR( FILE_FUN<<" catch exception :" << e.what() << endl);
        result += e.what();
    }
    catch ( ... )
    {
        TLOGERROR( FILE_FUN<<" catch unkown exception" << endl);
        result += "catch unkown exception";
    }
    TLOGDEBUG("stop succ"<<endl);
    return -1;
}

int NodeImp::loadServer( const string& application, const string& serverName,string &result, TarsCurrentPtr current )
{
    try
    {
        result = string(__FUNCTION__)+" ["+application + "." + serverName+"] ";
        TLOGDEBUG("NodeImp::loadServer"<<result<<endl);
        if ( g_app.isValid(current->getIp()) == false )
        {
            result += " erro:ip "+ current->getIp()+" is invalid";
            TLOGERROR(FILE_FUN << result << endl);
            return -1;
        }

        string s;

        ServerObjectPtr pServerObjectPtr = ServerFactory::getInstance()->loadServer(application,serverName,false,s);
        if (!pServerObjectPtr)
        {
            result =result+" error::cannot load server description.\n"+s;
            return EM_TARS_LOAD_SERVICE_DESC_ERR;
        }
        result = result + " succ" + s;
        return 0;
    }
    catch ( exception& e )
    {
        TLOGERROR( FILE_FUN<<" catch exception :" << e.what() << endl);
        result += e.what();
    }
    catch ( ... )
    {
        TLOGERROR( FILE_FUN<<" catch unkown exception" << endl);
        result += "catch unkown exception";
    }
    return -1;
}

int NodeImp::startServer( const string& application, const string& serverName,string &result, TarsCurrentPtr current )
{
    int iRet = EM_TARS_UNKNOWN_ERR;
    try
    {
        result = string(__FUNCTION__)+ " ["+application + "." + serverName+"] from "+ current->getIp()+" ";
        NODE_LOG("startServer")->debug()<<FILE_FUN << result << endl;
        if ( g_app.isValid(current->getIp()) == false )
        {
            result += " erro:ip "+ current->getIp()+" is invalid";
            NODE_LOG("startServer")->error()<<FILE_FUN << result << endl;
            return EM_TARS_INVALID_IP_ERR;
        }

        NODE_LOG("startServer")->debug()<<FILE_FUN<<result <<"|load begin"<< endl;

        string s;

        ServerObjectPtr pServerObjectPtr = ServerFactory::getInstance()->loadServer( application, serverName,true,s);
        NODE_LOG("startServer")->debug()<<FILE_FUN<<result<<"|load"<< endl;

        if ( pServerObjectPtr )
        {
            bool bByNode = true;
            CommandStart command(pServerObjectPtr,bByNode);
            iRet = command.doProcess(s);
            if (iRet == 0 )
            {
                result = result+":server is activating, please wait ...|"+s;
            }
            else
            {
                result = result+"error:"+s;
            }
            NODE_LOG("startServer")->debug()<<FILE_FUN <<result << endl;
            return iRet;
        }

        //设置服务状态enable
        pServerObjectPtr = ServerFactory::getInstance()->getServer( application, serverName );
        if (pServerObjectPtr)
        {
            pServerObjectPtr->setEnabled(true);
        }

        result += "error::cannot load server description from regisrty.\n" + s;
        iRet = EM_TARS_LOAD_SERVICE_DESC_ERR;
    }
    catch ( exception& e )
    {
        NODE_LOG("startServer")->error() << FILE_FUN << " catch exception:" << e.what() << endl;
        result += e.what();
    }
    catch ( ... )
    {
        NODE_LOG("startServer")->error() << FILE_FUN <<" catch unkown exception" << endl;
        result += "catch unkown exception";
    }
    return iRet;
}

int NodeImp::stopServer( const string& application, const string& serverName,string &result, TarsCurrentPtr current )
{
    int iRet = EM_TARS_UNKNOWN_ERR;
    try
    {
        result = string(__FUNCTION__)+" ["+application + "." + serverName+"] from "+ current->getIp()+" ";

        NODE_LOG("stopServer")->debug() <<FILE_FUN<<result << endl;

        ServerObjectPtr pServerObjectPtr = ServerFactory::getInstance()->getServer( application, serverName );
        if ( pServerObjectPtr )
        {
            string s;
            bool bByNode = true;
            CommandStop command(pServerObjectPtr,true, bByNode);
            iRet = command.doProcess(current,s);
            if (iRet == 0 )
            {
                result = result+"succ:"+s;
            }
            else
            {
                result = result+"error:"+s;
            }
            NODE_LOG("stopServer")->debug()<<FILE_FUN <<result << endl;
        }
        else
        {
            result += "server is  not exist";
            iRet = EM_TARS_LOAD_SERVICE_DESC_ERR;
        }

        return iRet;
    }
    catch ( exception& e )
    {
        NODE_LOG("stopServer")->error() << FILE_FUN<<" catch exception :" << e.what() << endl;
        result += e.what();
    }
    catch ( ... )
    {
        NODE_LOG("stopServer")->error() << FILE_FUN<<" catch unkown exception" << endl;
        result += "catch unkown exception";
    }
    return EM_TARS_UNKNOWN_ERR;
}

int NodeImp::notifyServer( const string& application, const string& serverName, const string &sMsg, string &result, TarsCurrentPtr current )
{
    try
    {
        result = string(__FUNCTION__)+" ["+application + "." + serverName+"] '" + sMsg + "' ";
        TLOGDEBUG(result<<endl);
        if ( g_app.isValid(current->getIp()) == false )
        {
            result += " erro:ip "+ current->getIp()+" is invalid";
            TLOGERROR("NodeImp::notifyServer " << result << endl);
            return EM_TARS_INVALID_IP_ERR;
        }

        if ( application == "tars" && serverName == "tarsnode" )
        {
            AdminFPrx pAdminPrx;    //服务管理代理
            pAdminPrx = Application::getCommunicator()->stringToProxy<AdminFPrx>("AdminObj@"+ServerConfig::Local);
            result = pAdminPrx->notify(sMsg);
            return 0;
        }

        ServerObjectPtr pServerObjectPtr = ServerFactory::getInstance()->getServer( application, serverName );
        if ( pServerObjectPtr )
        {
            string s;
            CommandNotify command(pServerObjectPtr,sMsg);
            int iRet = command.doProcess(s);
            if (iRet == 0 )
            {
                result = result + "succ:" + s;
            }
            else
            {
                result = result + "error:" + s;
            }
            return iRet;
        }

        result += "server is not exist";
    }
    catch ( exception& e )
    {
        TLOGERROR( "NodeImp::notifyServer catch exception :" << e.what() << endl);
        result += e.what();
    }
    catch ( ... )
    {
        TLOGERROR( "NodeImp::notifyServer catch unkown exception" << endl);
        result += "catch unkown exception";
    }
    return -1;
}

int NodeImp::getServerPid( const string& application, const string& serverName,string &result,TarsCurrentPtr current )
{
    result = string(__FUNCTION__)+" ["+application + "." + serverName+"] ";
    TLOGDEBUG("NodeImp::getServerPid " <<result  << endl);
    ServerObjectPtr pServerObjectPtr = ServerFactory::getInstance()->getServer( application, serverName );
    if ( pServerObjectPtr )
    {
        result += "succ";
        return pServerObjectPtr->getPid();
    }
    result += "server not exist";
    return -1;
}

ServerState NodeImp::getSettingState( const string& application, const string& serverName,string &result, TarsCurrentPtr current )
{
    result = string(__FUNCTION__)+" ["+application + "." + serverName+"] ";
    ServerObjectPtr pServerObjectPtr = ServerFactory::getInstance()->getServer( application, serverName );
    if ( pServerObjectPtr )
    {
        result += "succ";
        return pServerObjectPtr->isEnabled()==true?tars::Active:tars::Inactive;
    }
    result += "server not exist";
    TLOGERROR( "NodeImp::getServerPid" <<" "<<result<< endl);
    return tars::Inactive;
}

ServerState NodeImp::getState( const string& application, const string& serverName, string &result, TarsCurrentPtr current )
{
    result = string(__FUNCTION__)+" ["+application + "." + serverName+"] ";
    ServerObjectPtr pServerObjectPtr = ServerFactory::getInstance()->getServer( application, serverName );
    if ( pServerObjectPtr )
    {
        result += "succ";
        return pServerObjectPtr->getState();
    }
    result += "server not exist";
    TLOGERROR("NodeImp::getState " << result << endl);
    return tars::Inactive;
}

tars::Int32 NodeImp::getStateInfo(const std::string & application,const std::string & serverName,tars::ServerStateInfo &info,std::string &result,tars::TarsCurrentPtr current)
{
    result = string(__FUNCTION__)+" ["+application + "." + serverName+"] ";
    ServerObjectPtr pServerObjectPtr = ServerFactory::getInstance()->getServer( application, serverName );
    if ( pServerObjectPtr )
    {
        result += "succ";

        info.serverState = pServerObjectPtr->getState();
        info.processId = pServerObjectPtr->getPid();
        info.settingState = pServerObjectPtr->isEnabled()==true?tars::Active:tars::Inactive;

        TLOGDEBUG("NodeImp::getStateInfo " <<result  << endl);

        return EM_TARS_SUCCESS;
    }

    result += "server not exist";
    TLOGERROR("NodeImp::getStateInfo " << result << endl);

    info.serverState = tars::Inactive;
    info.processId = -1;
    info.settingState = tars::Inactive;

    return EM_TARS_UNKNOWN_ERR;
}

int NodeImp::synState( const string& application, const string& serverName, string &result, TarsCurrentPtr current )
{
    try
    {
        result = string(__FUNCTION__)+" ["+application + "." + serverName+"] ";
        ServerObjectPtr pServerObjectPtr = ServerFactory::getInstance()->getServer( application, serverName );
        if ( pServerObjectPtr )
        {
            result += "succ";
            pServerObjectPtr->synState();
            return  0;
        }
        result += "server not exist";
        TLOGERROR("NodeImp::synState "<<result<< endl);
    }
    catch ( exception& e )
    {
        TLOGERROR( "NodeImp::synState catch exception :" << e.what() << endl);
        result += e.what();
    }
    catch ( ... )
    {
        TLOGERROR( "NodeImp::synState catch unkown exception" << endl);
        result += "catch unkown exception";
    }
    return -1;
}

int NodeImp::getPatchPercent( const string& application, const string& serverName,PatchInfo &tPatchInfo, TarsCurrentPtr current)
{
    string &result =  tPatchInfo.sResult;
    try
    {
        result = string(__FUNCTION__)+" ["+application + "." + serverName+"] ";

        ServerObjectPtr pServerObjectPtr = ServerFactory::getInstance()->getServer( application, serverName );
        if ( pServerObjectPtr )
        {
            result += "succ";
            NODE_LOG("getPatchPercent")->debug()<<FILE_FUN << result << "|get ServerObj" << endl;
            return pServerObjectPtr->getPatchPercent(tPatchInfo);
        }

        result += "server not exist";
        NODE_LOG("getPatchPercent")->error() << FILE_FUN <<" "<< result<< endl;
        return EM_TARS_LOAD_SERVICE_DESC_ERR;
    }
    catch ( exception& e )
    {
        NODE_LOG("getPatchPercent")->error() << FILE_FUN << " catch exception :" << e.what() << endl;
        result += e.what();
    }
    catch ( ... )
    {
        NODE_LOG("getPatchPercent")->error() << FILE_FUN <<" catch unkown exception" << endl;
        result += "catch unkown exception";
    }

    return EM_TARS_UNKNOWN_ERR;

}

tars::Int32 NodeImp::delCache(const  string &sFullCacheName, const std::string &sBackupPath, const std::string & sKey, std :: string &result, TarsCurrentPtr current)
{
    try
    {
        TLOGDEBUG("NodeImp::delCache "<<sFullCacheName << "|" << sBackupPath << "|" << sKey << endl);
        if (sFullCacheName.empty())
        {
            result = "cache server name is empty";
            throw runtime_error(result);
        }

        string sBasePath = "/usr/local/app/tars/tarsnode/data/"+sFullCacheName+"/bin/";
        if (!TC_File::isFileExistEx(sBasePath, S_IFDIR))
        {
            result = "no such directory:" + sBasePath;
            return 0;
        }

        key_t key;
        if (sKey.empty())
        {
            key = ftok(sBasePath.c_str(), 'D');
        }
        else
        {
            key = TC_Common::strto<key_t>(sKey);
        }
        TLOGDEBUG("NodeImp::delCache|key=" << key << endl);

        int shmid = shmget(key, 0, 0666);
        if (shmid == -1)
        {
            result = "failed to shmget " + sBasePath + "|key=" + TC_Common::tostr(key);
            //如果获取失败则认为共享内存已经删除,直接返回成功
            TLOGDEBUG("NodeImp::delCache"<< "|"  << sFullCacheName << "|" << result << endl);
            return 0;
        }

        shmid_ds *pShmInfo= new shmid_ds;
        int iRet = shmctl(shmid, IPC_STAT, pShmInfo);
        if (iRet != 0)
        {
            result = "failed to shmctl " + sBasePath + "|key=" + TC_Common::tostr(key) + "|ret=" + TC_Common::tostr(iRet);
            delete pShmInfo;
            pShmInfo = NULL;
            throw runtime_error(result);
        }

        if (pShmInfo->shm_nattch>=1)
        {
            result = "current attach count >= 1,please check it |" + sBasePath + "|key=" +TC_Common::tostr(key)+"|attch_count=" + TC_Common::tostr(pShmInfo->shm_nattch);
            delete pShmInfo;
            pShmInfo = NULL;
            throw runtime_error(result);
        };

        delete pShmInfo;
        pShmInfo = NULL;

        int ret =shmctl(shmid, IPC_RMID, NULL);
        if (ret !=0)
        {
            result = "failed to rm share memory|key=" + TC_Common::tostr(key) + "|shmid=" + TC_Common::tostr(shmid) + "|ret=" + TC_Common::tostr(ret);
            throw runtime_error(result);
        }

        TLOGDEBUG("NodeImp::delCache success delete cache:" << sFullCacheName <<", no need backup it"<< endl);

        return 0;
    }
    catch ( exception& e )
    {
        result = TC_Common::tostr(__FILE__)+":"+TC_Common::tostr(__FUNCTION__) + ":"+ TC_Common::tostr(__LINE__)  + "|" + e.what();
        TLOGERROR("NodeImp::delCache " << result << endl);
        TARS_NOTIFY_ERROR(result);
    }

    return -1;
}

tars::Int32 NodeImp::getUnusedShmKeys(tars::Int32 count,vector<tars::Int32> &shm_keys,tars::TarsCurrentPtr current) {
    int ret = 0;
    for(size_t i = 0; i < 256 && shm_keys.size() < (size_t)count; i++)
    {
        key_t key = ftok(ServerConfig::BasePath.c_str(), i);
        if(key == -1)
        {
            TLOGDEBUG("NodeImp::getUnusedShmKeys create an key failed, i=" << i << endl);
        }
        else
        {
            int shmid = shmget(key, 0, 0666);
            if(shmid == -1)
            {
                TLOGDEBUG("NodeImp::getUnusedShmKeys find an key:" << key << " 0x" << keyToStr(key) << endl);
                shm_keys.push_back(key);
            }
            else
            {
                TLOGDEBUG("NodeImp::getUnusedShmKeys key: " << key << " 0x" << keyToStr(key) << " is busy"<< endl);
            }
        }
    }

    return ret;
}

string NodeImp::keyToStr(key_t key_value)
{
    char buf[32];
    snprintf(buf, 32, "%08x", key_value);
    string s(buf);
    return s;
}
/*********************************************************************/