VCache.C

Go to the documentation of this file.

// Copyright (C) 2001, Compaq Computer Corporation
// 
// This file is part of Vesta.
// 
// Vesta is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// Vesta is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with Vesta; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

// Last modified on Fri Apr 29 00:22:52 EDT 2005 by ken@xorian.net  
//      modified on Sat Feb 12 13:25:49 PST 2000 by mann  
//      modified on Wed Sep  2 13:30:05 PDT 1998 by heydon

// The Vesta-2 cache server

#include <Basics.H>
#include <CacheArgs.H>
#include <CacheConfig.H>
#include <Debug.H>
#include <ReadConfig.H>
#include <CacheConfigServer.H>

#include "VCacheVersion.H"
#include "CacheS.H"
#include "ExpCache.H"

using std::cout;
using std::cerr;
using std::endl;

static void ExitServer() throw ()
{
    cerr << "Syntax: VCache [ -debug <level> ] [ -noHits ]" << endl;
    cerr << "The allowed values for <level> are:";
    for (int i = 0, lineCnt = 0; i <= CacheIntf::All; i++, lineCnt++) {
        if (i == CacheIntf::WeederScans) continue;
        if (i > 0) cerr << ", ";
        if (lineCnt % 5 == 0) cerr << endl << "  ";
        cerr << CacheIntf::DebugName(i);
    }
    cerr << endl;
    exit(1);
}

static void HandleFailure(SRPC *srpc, const SRPC::failure &f, void *arg)
  throw ()
{
    ExpCache::CallArg *args = (ExpCache::CallArg *)arg;

    if (f.r != SRPC::partner_went_away ||
        args->cacheS->DebugLevel() >= CacheIntf::StatusMsgs) {
        Debug::Lock();
        cout << Debug::Timestamp();
        if (f.r == SRPC::partner_went_away) {
            // remote end disconnected
            cout << f.msg << " (continuing...)" << endl;
        } else {
            cout << "Cache Server Failure:" << endl;
            cout << "  SRPC failure (code " << f.r << ')' << endl;
            cout << "  " << f.msg << endl;
            cout << ((f.r == SRPC::transport_failure) ?"Exiting":"Continuing");
        }
        cout << endl;
        Debug::Unlock();
    }
}

static void Server(int argc, char *argv[]) throw ()
{
    CacheIntf::DebugLevel debug = CacheIntf::None;
    bool noHits = false;
    int arg = 1;

    // parse arguments
    while (arg < argc && argv[arg][0] == '-') {
        if (CacheArgs::StartsWith(argv[arg], "-debug")) {
            if (argc <= ++arg) {
                cerr << "Error: expecting level" << endl;
                ExitServer();
            }
            if (sscanf(argv[arg], "%d", &debug) != 1) {
                int i;
                for (i = 0; i <= CacheIntf::All; i++) {
                    if (strcmp(argv[arg], CacheIntf::DebugName(i)) == 0) break;
                }
                debug = (CacheIntf::DebugLevel)i;
            }
            if (debug < CacheIntf::None || debug > CacheIntf::All) {
                cerr << "Error: unrecognized debug-level '"
                    << argv[arg] << "'" << endl;
                ExitServer();
            }
            arg++;
        } else if (CacheArgs::StartsWith(argv[arg], "-noHits")) {
            noHits = true;
            arg++;
        } else if (CacheArgs::StartsWith(argv[arg], "-help")
                   || CacheArgs::StartsWith(argv[arg], "-?")) {
            ExitServer();
        } else {
            cerr << "Error: Unrecognized switch '" << argv[arg] << "'" << endl;
            ExitServer();
        }
    }
    if (arg < argc) {
        cerr << "Error: Too many arguments" << endl;
        ExitServer();
    }
    
    // start server
    CacheS *cs = NEW_CONSTR(CacheS, (debug, noHits));
    if (debug >= CacheIntf::StatusMsgs) {
        Debug::Lock();
        cout << Debug::Timestamp() << "Starting server:" << endl;
        cout << "  Version = " << VCacheVersion << endl;
        cout << "  Interface version = " << CacheIntf::Version << endl;
        cout << "  Config file = " << ReadConfig::Location() << endl;
        cout << "  Cache root = " << Config_CacheMDPath << endl;
        cout << "  Debug level = " << CacheIntf::DebugName(debug) << endl;
        cout << "  Disable cache hits = " << BoolName[noHits] << endl;
        cout << "  Maximum running threads = " << Config_MaxRunning << endl;
        cout << "  Maximum blocked threads = " << Config_MaxBlocked << endl;
        cout << endl;
        Debug::Unlock();
    }
    ExpCache *exp =
      NEW_CONSTR(ExpCache,
                 (cs, Config_MaxRunning, Config_MaxBlocked, HandleFailure));

    // Run the cache server
    while (true) {
        try {
            exp->Run();
        }
        catch (SRPC::failure f) {
            ExpCache::CallArg ca(NULL, cs);
            HandleFailure((SRPC *)NULL, f, (void *)(&ca));
            // exit immediately if another server is already running
            if (f.r == SRPC::transport_failure) break;
        }
    }
}

int main(int argc, char *argv[])
{
    // rename any existing core file so it won't be overwritten
    system("if [ -e core ] ; then mv core core.`date +%m-%d-%y.%T` ; fi");

    // start the server
    Server(argc, argv);
    return(0);
}

---