MultiSRPC.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 22 14:19:09 EDT 2005 by irina.furman@intel.com 
//      modified on Wed Oct 29 16:13:25 EST 2003 by ken@xorian.net   
//      modified on Tue Feb  8 14:00:08 PST 2000 by mann   
//      modified on Mon Jun 16 11:07:42 PDT 1997 by heydon 
//      modified on Mon Jun 24 15:31:30 PDT 1996 by levin  

#include <Basics.H>

#include "SRPC.H"
#include "MultiSRPC.H"

const int DefaultConnections = 3;

#define LOCK(mu) (mu).lock(); try {
#define UNLOCK(mu) } catch (...) { (mu).unlock(); throw; } (mu).unlock()

MultiSRPC::Entry::~Entry() throw ()
{
    if (this->srpc != (SRPC *)NULL) {
        delete this->srpc;
        this->srpc = (SRPC *)NULL;
    }
}

MultiSRPC::MultiSRPC(const Text &interface)
  : intf(interface), next(0), num(DefaultConnections)
{
    this->tbl = NEW_ARRAY(MultiSRPC::EntryPtr, this->num);
    for (int i = 0; i < this->num; i++) {
        this->tbl[i] = (MultiSRPC::EntryPtr)NULL;
    }
}

MultiSRPC::~MultiSRPC()
{
    // free up table of connections
    LOCK(this->mu);
    if (this->tbl != (MultiSRPC::EntryPtr *)NULL) {
        for (int i = 0; i < this->next; i++) {
            delete this->tbl[i];
            this->tbl[i] = (MultiSRPC::EntryPtr)NULL;
        }
        delete[] this->tbl;
        this->tbl = (MultiSRPC::EntryPtr *)NULL;
    }
    UNLOCK(this->mu);
}

MultiSRPC::ConnId
MultiSRPC::Start(const Text &hostname, const Text &interface, SRPC*& srpc)
  throw(SRPC::failure)
{
    Text tIntf(this->intf);
    if (this->intf.Empty()) {
      if (interface.Empty())
        throw(SRPC::failure(SRPC::invalid_parameter,
                            "Interface not specified"));
      else tIntf = interface;
    } else if (!interface.Empty())
      throw(SRPC::failure(SRPC::invalid_parameter,
                          "Interface specified in constructor"));
    // assert: precisely one of intf and interface is Empty()
    // assert: tIntf != ""

    int res, availEntry = -1;

    // Search for existing connection not in use.
    this->mu.lock();
    try
      {
        for (res = 0; res < this->next; res++) {
          if (!(this->tbl[res]->inUse) &&
              (this->tbl[res]->srpc != (SRPC *)NULL) &&
              !(this->tbl[res]->srpc->alive())) {
            // Delete dead connection
            delete this->tbl[res]->srpc;
            this->tbl[res]->srpc = (SRPC *)NULL;
          }         
          if (!(this->tbl[res]->inUse) &&
              (this->tbl[res]->srpc != (SRPC *)NULL) &&
              (hostname == this->tbl[res]->hostname) &&
              (tIntf == this->tbl[res]->interface)) {
            // Found existing connection
            break;
          }
          if (!(this->tbl[res]->inUse) &&
              (this->tbl[res]->srpc == (SRPC *)NULL)) {
            // Remember available slot
            availEntry = res;
          }
        }
      }
    catch(...)
      {
        this->mu.unlock();
        throw;
      }

    // If we found an entry, note that it's in use and return it to
    // the caller.
    if(res < this->next)
      {
        this->tbl[res]->inUse = true;
        srpc = this->tbl[res]->srpc;
        this->mu.unlock();
        return res;
      }

    // no existing connection found -- create a new one
    if (availEntry >= 0) {
      // use an existing entry
      res = availEntry;
      tbl[res]->hostname = hostname;
      tbl[res]->interface = tIntf;
    } else {
      // use the next available entry in the array
      if (this->next >= this->num) {
        // no more space in table -- make it larger
        this->num *= 2;
        MultiSRPC::EntryPtr *newTbl = 
          NEW_ARRAY(MultiSRPC::EntryPtr, this->num);
        int i;
        for (i = 0; i < this->next; i++) {
          newTbl[i] = this->tbl[i]; // pointer copy
          this->tbl[i] = (MultiSRPC::EntryPtr)NULL;
        }
        while (i < this->num) newTbl[i++] = (MultiSRPC::EntryPtr)NULL;
        delete[] this->tbl;
        this->tbl = newTbl;
      }
      res = this->next++;
      this->tbl[res] = NEW(Entry);
      this->tbl[res]->hostname = hostname;
      this->tbl[res]->interface = tIntf;
    }
    // Note that this entry is in use.
    this->tbl[res]->inUse = true;
    // Release the lock on this object during connection establishment
    // (as it is potentially long-running).
    this->mu.unlock();

    // Create the new SRPC object.
    SRPC *new_srpc = 0;
    try
      {
        new_srpc = NEW_CONSTR(SRPC, (SRPC::caller, tIntf, hostname));
      }
    catch(...)
      {
        // If we fail to create the new SRPC object, mark this table
        // entry as not in use.
        this->mu.lock();
        this->tbl[res]->inUse = false;
        this->mu.unlock();
        throw;
      }

    // Re-acquire the lock, record the new SRPC object in the table,
    // and return it to the caller.
    this->mu.lock();
    srpc = this->tbl[res]->srpc = new_srpc;
    this->mu.unlock();
    return res;
}

void MultiSRPC::End(MultiSRPC::ConnId id) throw ()
{
    if (id >= 0) {
        LOCK(this->mu);
        this->tbl[id]->inUse = false;
        if (!(this->tbl[id]->srpc->alive())) {
            // A failure has occurred on this SRPC, so delete the SRPC resource
            // and set the "srpc" field to NULL to indicate that this entry is
            // available for re-use.
            delete this->tbl[id]->srpc;
            this->tbl[id]->srpc = (SRPC *)NULL;
        }
        UNLOCK(this->mu);
    }
}

void MultiSRPC::Discard(MultiSRPC::ConnId id) throw ()
{
    if (id >= 0) {
        LOCK(this->mu);
        this->tbl[id]->inUse = false;
        delete this->tbl[id]->srpc;
        this->tbl[id]->srpc = (SRPC *)NULL;
        UNLOCK(this->mu);
    }
}

void
MultiSRPC::Purge(const Text &hostname, const Text &interface) throw(SRPC::failure)
{
    Text tIntf(this->intf);
    if (this->intf.Empty()) {
      if (interface.Empty())
        throw(SRPC::failure(SRPC::invalid_parameter,
                            "Interface not specified"));
      else tIntf = interface;
    } else if (!interface.Empty())
      throw(SRPC::failure(SRPC::invalid_parameter,
                          "Interface specified in constructor"));
    // assert: precisely one of intf and interface is Empty()
    // assert: tIntf != ""

    int res, availEntry = -1;

    // search for existing connections not in use
    LOCK(this->mu);
    for (res = 0; res < this->next; res++) {
        if ((hostname == this->tbl[res]->hostname) &&
            (tIntf == this->tbl[res]->interface) &&
            !(this->tbl[res]->inUse)) {
            if ((this->tbl[res]->srpc != (SRPC *)NULL)) {
                delete this->tbl[res]->srpc;
                this->tbl[res]->srpc = (SRPC *)NULL;
            }
        }
    }
    UNLOCK(this->mu);
}

---