provisionserver.cxx

SIP（Session Initiation Protocol）是由IETF定义

        char timestamp[32];
        int charcnt = 0;
        int cnt = 0;

        for (map < string, TimeStamp > ::iterator itr = localMap.begin();
                itr != localMap.end(); itr++)
        {
            retData += (*itr).first;
            sprintf(timestamp, ",%lu", (*itr).second);
            retData += timestamp;
            charcnt += ((*itr).first).size();
            charcnt += string(timestamp).size();
            charcnt += 1;
            if (cnt == 1000)
            {
                retData += ",\n";
                cpLog(LOG_DEBUG, retData.c_str());
                tosend.push_back(retData);
                cnt = 0;
                retData = "";
            }
            else
            {
                retData += ",";
            }
            cnt++;
        }

        ///Finish any remaining in the list
        if (cnt)
        {
            retData += "\n";
            cpLog(LOG_DEBUG, retData.c_str());
            tosend.push_back(retData);
        }
        finalData = makeVPPHeader(vppOkGLBL, charcnt);
        list < string > ::iterator itr2 = tosend.begin();

        // no data, so send empty 200
        if (itr2 == tosend.end())
        {
            conn.writeData(finalData);
        }

        for (itr2 = tosend.begin(); itr2 != tosend.end(); itr2++)
        {
            finalData += (*itr2);
            conn.writeData(finalData);
            finalData = "";
        }

        setSyncFailTimer();
    }

    catch (VIoException& e)
    {
        //Failed to get the dir list
        string retData = makeVPPHeader(0, 0);
        cpLog(LOG_DEBUG, retData.c_str());
        conn.writeData(retData);
    }
}



void
ProvisionServer::handleSyncPutRequest(LockedConnection& conn,
                                      const string& group, const string &name)
{
    if (!_copy.inUse())
    {
        // We aren't syncing, so ignore this
        cpLog(LOG_ERR, "Sync request but not using sync");
        string retData = makeVPPHeader(vppFailGLBL, 0);
        conn.writeData(retData);
        return ;
    }

    char buf[MAXLINE];
    int nread = 0;
    int cntLength = 0;
    char cntStr[56];
    TimeStamp timestamp;
    int state;

    state = _copy.syncExchange();
    if (state == RedundancyManager::ERR)
    {
        // this is bad
        cpLog(LOG_ERR, "Server went into ERROR sync state.");
        string retData = makeVPPHeader(vppFailGLBL, 0);
        conn.writeData(retData);
        setSyncTimer();
        return ;
    }

    if (state == RedundancyManager::FAIL)
    {
        //Bad VPP header
        string retData = makeVPPHeader(vppFailGLBL, 0);
        cpLog(LOG_DEBUG, "Got a SYNCPUT when not expecting it.");
        conn.writeData(retData);
        setSyncTimer();
        return ;
    }

    // Read content length
    nread = 0;
    if (conn.readLine(buf, sizeof(buf), nread) < 0)
    {
        // Bad VPP header
        string retData = makeVPPHeader(vppFailGLBL, 0);
        cpLog(LOG_DEBUG, retData.c_str());
        conn.writeData(retData);
        return ;
    }
    sscanf(buf, "%s%lu", cntStr, &timestamp);

    // Read Timestamp
    if (conn.readLine(buf, sizeof(buf), nread) < 0)
    {
        // Bad VPP header
        string retData = makeVPPHeader(vppFailGLBL, 0);
        cpLog(LOG_DEBUG, retData.c_str());
        conn.writeData(retData);
        return ;
    }
    sscanf(buf, "%s%d", cntStr, &cntLength);

    //Read the contents
    char *c = new char[cntLength + 1];
    nread = 0;
    conn.readn(c, cntLength, nread);

    if (nread == -1)
    {
        cpLog (LOG_ALERT, "Read error on socket");
        delete c;
        return ;
    }

    else if (nread != cntLength)
    {
        cpLog(LOG_ALERT, "Content length mismatch, expected %d read %d",
              cntLength, nread);
        delete c;
        return ;
    }

    c[cntLength] = 0;
    cpLog(LOG_DEBUG, "Data for PUT request:%s", c);
    //Write data to the data store
    try
    {
        _dataStore->putItem(group, name, c, timestamp);

        // updates are sent in the PsProcess module, so no need to do it

        string retData = makeVPPHeader(vppOkGLBL, 0);
        try
        {
            conn.writeData(retData);
        }
        catch (VNetworkException& e)
        {
            cpLog(LOG_DEBUG, "Caught exception when writing data, reason %s",
                  e.getDescription().c_str());
        }
    }
    catch (VIoException& e)
    {
        string retData = makeVPPHeader(vppFailGLBL, 0);
        cpLog(LOG_ALERT, "Failed to write item (%s,%s), reason %s",
              group.c_str(), name.c_str(), strerror(errno));
        conn.writeData(retData);
    }

    delete c;
}



void
ProvisionServer::handleSyncStatRequest(LockedConnection& conn)
{
    string data;

    if (!_copy.inUse())
    {
        // We aren't syncing, so ignore this
        data += "This server is not using redundancy.\n";
    }
    else
    {

        cpLog(LOG_DEBUG, "Received SYNCSTAT Request");

        data += "Remote Connection Status : ";
        if (_copy.isAlive())
        {
            data += "Alive\n";
        }
        else
        {
            data += "Not Alive\n";
        }

        data += "Syncronization Status    : ";
        if (_copy.isSync())
        {
            data += "Synched\n";
        }
        else
        {
            data += "Not Synched\n";
        }

        data += "Mastering Status         : ";
        if (_copy.isMaster())
        {
            data += "Master\n";
        }
        else
        {
            data += "Not Master\n";
        }

        data += "Slave Status             : ";
        if (_copy.isSlave())
        {
            data += "Slave\n";
        }
        else
        {
            data += "Not Slave\n";
        }

    }

    string retData = makeVPPHeader(vppOkGLBL, data.size());
    retData += data;
    cpLog(LOG_DEBUG, retData.c_str());
    conn.writeData(retData);

    return ;
}


void
ProvisionServer::handleSyncGoodRequest(LockedConnection& conn)
{
    if (!_copy.inUse())
    {
        // We aren't syncing, so ignore this
        cpLog(LOG_ERR, "Sync request but not using sync");
        string retData = makeVPPHeader(vppFailGLBL, 0);
        conn.writeData(retData);
        return ;
    }

    cpLog(LOG_DEBUG, "Received SYNCGOOD");

    int state;

    state = _copy.syncGood();
    if (state == RedundancyManager::ERR)
    {
        // this is bad
        cpLog(LOG_ERR, "Server went into ERROR sync state.");
        string retData = makeVPPHeader(vppFailGLBL, 0);
        conn.writeData(retData);
        setSyncTimer();
        return ;
    }
    if (state == RedundancyManager::FAIL)
    {
        //Bad VPP header
        string retData = makeVPPHeader(vppFailGLBL, 0);
        cpLog(LOG_DEBUG, "Got a SYNCGOOD when not expecting it.");
        conn.writeData(retData);
        setSyncTimer();
        return ;
    }

    string retData = makeVPPHeader(vppOkGLBL, 0);
    conn.writeData(retData);

    cpLog(LOG_DEBUG, "Synchronization complete and succeeded!");

    return ;
}


string
ProvisionServer::makeVPPHeader(int success, 
                               int contLength, 
                               TimeStamp timestamp)
{
    string retData;
    char buf[256];
    char buf2[256];

    if (success)
    {
        retData += "200 OK\n";
    }
    else
    {
        retData += "400 FAILED\n";
    }

    // if they gave us a timestamp, use it.
    if (timestamp != 0)
    {
        sprintf(buf2, "Timestamp: %lu\n", timestamp);
//        retData += buf;
        contLength += strlen(buf2);
    }

    // add the content length
    sprintf(buf, "%s %d\n", CONT_LENGTH, contLength);
    retData += buf;

    if(timestamp != 0)
    {
        retData += buf2;
    }



    return (retData);
}


void
ProvisionServer::handleSyncRegisterItemRequest(const string& group,
        const string &name,
        const string &host)
{
    _registerManager.registerItem(group, name, host);
}


void
ProvisionServer::handleSyncRegisterGroupRequest(const string& group,
        const string &host)
{
    _registerManager.registerGroup(group, host);
}


void
ProvisionServer::handleSyncUnregisterItemRequest(const string& group,
        const string &name,
        const string &host)
{
    _registerManager.unregisterItem(group, name, host);
}


void
ProvisionServer::handleSyncUnregisterGroupRequest(const string& group,
        const string &host)
{
    _registerManager.unregisterGroup(group, host);
}




int
ProvisionServer::getLocalMap(map < string, TimeStamp > &local)
{
    local.clear();

    cpLog(LOG_DEBUG, "ProvisionServer::generating local map for sync");

    try
    {
        StringList listOfGroups = _dataStore->listGroups();

        if (listOfGroups.size() == 0)
        {
            return 0;
        }

        StringList::iterator itr;

        // get just the items, and just their names. Make sure
        // we exclude CVS
        for (itr = listOfGroups.begin(); itr != listOfGroups.end(); itr++)
        {

            StringList listOfItems = _dataStore->listItems(*itr);

            StringList::iterator itr2;

            for (itr2 = listOfItems.begin(); itr2 != listOfItems.end(); itr2++)
            {
                char hashkey[256];
                sprintf(hashkey, "%s|%s", (*itr).c_str(), (*itr2).c_str());
                local[hashkey] = _dataStore->getItemTimeStamp((*itr), (*itr2));
            }
        }
    }

    catch (VIoException& e)
    {
        //Failed to get the dir list
        return -1;
        cpLog(LOG_DEBUG, "Failed to generate localmap.");
    }

    return 0;
}


void ProvisionServer::gotBeat()
{
    int val = _copy.heartBeat();
    if (val == RedundancyManager::OK)
    {
        setSyncTimer();
    }
}


int
ProvisionServer::parseMapItem(const string &input, string &group, string &name)
{
    size_t loc = input.find("|");

    if (loc == string::npos)
    {
        return -1;
    }

    group = input.substr(0, loc);
    name = input.substr(loc + 1, input.size());

    return 0;
}


string
ProvisionServer::getRoot()
{
    // if we have asked before, return the result, else generate first time
    if (_root.size())
    {
        return _root;
    }

    string retStr(VEnvVar::VPS_FILESYSTEM.value());

    // ensure root ends in a slash and strip any extra (double, triple etc.)
    if (retStr.size() && retStr[retStr.size() - 1] != '/')
    {
        retStr += "/";
    }
    while (retStr.find("//") != string::npos)
    {
        retStr.replace(retStr.find("//"), 2, "/");
    }

    _root = retStr;
    return _root;
}


void
ProvisionServer::handleSyncDelRequest(LockedConnection& conn,
                                      const string &group, const string &name)
{
    cpLog(LOG_DEBUG, "ProvisionServer::handleRemoveRequest for (%s,%s)",
          group.c_str(), name.c_str());
    string gData;

    try
    {
        _dataStore->removeItem(group, name);
        cpLog(LOG_DEBUG, "Removed item (%s,%s)", group.c_str