DDSParentServer Class Reference

#include <DDSParentServer.h>

List of all members.

Public Types
	kMaxChild = 10
enum	{ kMaxChild = 10 }
Public Member Functions
	DDSParentServer (UInt_t port=0, UInt_t maxchild=kMaxChild, Int_t logLevel=Msg::kInfo, Int_t maxinactive=21600, Int_t backlog=TServerSocket::kDefaultBacklog)
virtual	~DDSParentServer ()
bool	IsValid () const
std::ostream &	Print (std::ostream &ms) const
void	Run ()
Private Member Functions
bool	Authorize () const
UInt_t	CheckChildStatus ()
bool	IsLocalClient () const
DDS::EMessageType	SpawnChildServer ()
DDS::EMessageType	Shutdown ()
DDS::EMessageType	Status ()
Private Attributes
TServerSocket *	fTServerSocket
UInt_t	fMaxChild
Int_t	fLogLevel
Int_t	fMaxInactive
UInt_t	fNumChild
bool	fShutdown
TSocket *	fTSocket
TInetAddress	fServerAddress
TInetAddress	fClientAddress
TMessage *	fMessageIn
TMessage	fMessageOut
DDSPSStatus	fPSStatus

---

Detailed Description

Definition at line 26 of file DDSParentServer.h.

---

Member Enumeration Documentation

anonymous enum

Enumerator:

kMaxChild

Definition at line 31 of file DDSParentServer.h.

{ kMaxChild = 10 }; // max no. of child servers allowed at any one time 

---

Constructor & Destructor Documentation

DDSParentServer::DDSParentServer	(	UInt_t	port = 0,
		UInt_t	maxchild = kMaxChild,
		Int_t	logLevel = Msg::kInfo,
		Int_t	maxinactive = 21600,
		Int_t	backlog = TServerSocket::kDefaultBacklog
	)

Definition at line 134 of file DDSParentServer.cxx.

References fServerAddress, fShutdown, fTServerSocket, IsValid(), Msg::kWarning, and MSG.

                                                                  :
fTServerSocket(0),fMaxChild(maxchild),fLogLevel(logLevel),
fMaxInactive(maxInactive),fNumChild(0),fShutdown(false),fTSocket(0),
fMessageIn(0), fMessageOut(), fPSStatus() {
  // Purpose: Constructor.  This constructor creates a TServerSocket 
  //          attached to the specified port. A TServerSocket is created
  //          and bound to the specified port.
  // 
  // Arguments: port: port number assigned to server socket.  If port = 0
  //                  (default), the serversocket will be connected to the
  //                  named service "MinosDDS", which should be assigned to
  //                  a port in the /etc/services file.
  //            maxchild: maximum number of concurrent child servers allowed
  //                      (default = kMaxChild).
  //            logLevel: message verbose level
  //            maxInactive: max inactive time before connection shutdown
  //            backlog: maximum number of clients the kernel should queue
  //                     up on this port for pending connections (default is
  //                     TServerSocket::kDefaultBacklog).
  //
  // Return: n/a.
  //
  // Contact: S. Kasahara
  //
  // Notes: Use IsValid() to check if DDSParentServer was created successfully.
  //

  // Create server socket
  // The second argument kTRUE sets the SO_REUSEADDR socket option 
  // (kFALSE by default). When set true, reuse allows the listening server to 
  // start and bind its port even if previously established connections 
  // exist that use this port as their local port (such as if the parent
  // starts, spawns a child, dies, and needs to be restarted with the child
  // still serving from that port). 
  if (!port) {
    // User has not specified an alternative port.  server socket will be
    // bound to the port assigned to the named service "MinosDDS" 
    fTServerSocket = new TServerSocket("MinosDDS",kTRUE,backlog);
  }
  else {
    fTServerSocket = new TServerSocket(port,kTRUE,backlog);
  }

  // Check validity of socket
  if(!fTServerSocket || !fTServerSocket -> IsValid()) {
    // An error occured during the creation of the server socket

    if ( port ) {
      MSG("DDS",Msg::kWarning) 
        << "PS: Unable to create parent server socket connected to port " 
        << port << "." << endl;
    }
    else {
      MSG("DDS",Msg::kWarning) 
    << "PS: Unable to create parent server socket connected to named service " 
        << "MinosDDS." << endl;
    }
    if(fTServerSocket)delete fTServerSocket; fTServerSocket = 0;
    fShutdown = true;
  } 
  else {
    // Store local address of the server socket.
    fServerAddress = fTServerSocket -> GetLocalInetAddress();
  }

}

DDSParentServer::~DDSParentServer

(

)

[virtual]

Definition at line 203 of file DDSParentServer.cxx.

References fTServerSocket, fTSocket, and IsValid().

                                  {
  // Purpose: Destructor.  
  // 
  // Arguments: n/a.
  //
  // Return: n/a.
  //
  // Contact: S. Kasahara
  //
  
  if ( IsValid() ) {
    delete fTServerSocket; fTServerSocket = 0;
  }
  // fTSocket should always be deleted and cleared in DDSParentServer::Run() 
  if ( fTSocket ) delete fTSocket; fTSocket = 0;
    
}

---

Member Function Documentation

bool DDSParentServer::Authorize

(

)

const [private]

Definition at line 58 of file DDSParentServer.cxx.

Referenced by Run().

                                      {
  // Purpose: Authorize currently connected client to use dispatcher.
  //          Address of currently connected client must have been previously
  //          stored in fClientAddress.
  // 
  // Argument: none.
  //
  // Return: true if client is authorized, else false.
  //
  // Contact: S. Kasahara
  //
  // Notes: Currently a dummy routine, always returns true.
  //

  // perform check on client address, if ok then
  return true;
 
}

UInt_t DDSParentServer::CheckChildStatus

(

)

[private]

Definition at line 78 of file DDSParentServer.cxx.

References fNumChild, fPSStatus, Msg::kInfo, Msg::kWarning, MSG, and DDSPSStatus::RemoveClientId().

Referenced by Run(), SpawnChildServer(), and Status().

                                         {
  // Purpose: Check status of any exited child processes spawned by
  //          parent.  This has the important side benefit of clearing 
  //          "zombies" (child processes that have exited but have status
  //          values left to be read).  The fNumChild counter of currently
  //          active children is decremented for each newly exited child.
  // 
  // Argument: none.
  //
  // Return: Number of remaining active child processes.  
  //
  // Contact: S. Kasahara
  //
  // Notes: Another way to do this would be for the parent server to maintain
  //        a list of spawned child processes and inquire each child's status
  //        according to its process id.

  int childpid;  // pid number of exited child processes
  Int_t childstat; // exit status of child process

  bool newexit = false;
  while ((childpid = waitpid(-1, &childstat, WNOHANG)) > 0) {
    // This child has exited
    if ( !newexit ) {
      newexit = true; 
      MSG("DDS",Msg::kInfo) 
      << "PS: ParentServer reporting on status of exited children: " << endl;
    }

    fNumChild--;  // decrement number of active children

    if ( childstat != 0 ) {
      // the child process exited with an error status
      MSG("DDS",Msg::kWarning) << "PS: Child process " << childpid << 
        " has exited with error status " << WEXITSTATUS(childstat) 
        << "." << endl;
    }
    else {
      // if in info mode report all child exits
      MSG("DDS",Msg::kInfo) << "PS: Child process " << childpid <<
        " has exited successfully." << endl;
    }
    fPSStatus.RemoveClientId(childpid);
  } 

  if ( newexit ) {
    MSG("DDS",Msg::kInfo) << "PS: Number of children currently running = " 
                          << fNumChild << "." << endl;
  }

  return fNumChild;

}

bool DDSParentServer::IsLocalClient

(

)

const [private]

Definition at line 222 of file DDSParentServer.cxx.

References fClientAddress, and gSystem().

Referenced by Shutdown(), and SpawnChildServer().

                                          {
  // Purpose: Determine if currently connected client with address given
  //          in fClientAddress is local.
  // 
  // Arguments: none.
  //
  // Return: true if local.
  //
  // Contact: S. Kasahara
  //
  // Notes:  This method currently determines that a client is local only if it
  //         resides on the same host as the parent server. The definition
  //         of a local client will eventually be expanded to include other 
  //         hosts in the same local area network (once I know how to do that).
  //         Having local client status bestows special privileges on that
  //         client, such as:
  //         a) local client child servers are run at higher priority than 
  //            remote client child servers.
  //         b) only local clients may shutdown the parent server.
  //

  bool local = false;

  TString localhost(gSystem->GetHostByName(gSystem->HostName()).GetHostName());
  
  if(!localhost.CompareTo(fClientAddress.GetHostName(),TString::kIgnoreCase)){ 
    local = true;
  }

  return local;

}

bool DDSParentServer::IsValid

(

)

const [inline]

Definition at line 40 of file DDSParentServer.h.

References fTServerSocket.

Referenced by DDSFileHandler::BuildFileIndex(), DDSParentServer(), main(), Print(), and ~DDSParentServer().

                        { 
                 return (fTServerSocket != (TServerSocket*)0) ? true : false; }

std::ostream & DDSParentServer::Print

(

std::ostream &

ms

)

const

Definition at line 256 of file DDSParentServer.cxx.

References fLogLevel, fMaxChild, fMaxInactive, fNumChild, fServerAddress, IsValid(), and Msg::LevelAsString().

Referenced by operator<<().

                                                       {
  // Purpose: Print DDSParentServer status on std::ostream.
  // 
  // Arguments: ms  std::ostream to print on.
  //
  // Return: std::ostream reference.
  //
  // Contact: S. Kasahara
  //

  if ( IsValid() ) {
    ms << "PS: local addr " 
    // Print the local host name, address, port number
       << fServerAddress.GetHostName() 
       << "(port " << fServerAddress.GetPort() << ")" 
       << ", maxchild " << fMaxChild 
       << ", loglvl " << Msg::LevelAsString(fLogLevel)
       << ", maxinactive(sec) " << fMaxInactive  
       << ", currentchild " << fNumChild << "." << endl; 
  }
  else {
    ms << "PS: socket is not connected." << endl; 
  }

  return ms;

}

void DDSParentServer::Run

(

)

Definition at line 285 of file DDSParentServer.cxx.

References Authorize(), CheckChildStatus(), fClientAddress, fMessageIn, fMessageOut, fShutdown, fTServerSocket, fTSocket, DDS::kData, Msg::kInfo, DDS::kMessageUnknown, DDS::kPermissionDenied, DDS::kShutdown, DDS::kSocketError, DDS::kStatus, Msg::kWarning, MSG, Shutdown(), SpawnChildServer(), and Status().

                          {
  // Purpose: This is the main method of the DDSParentServer.  It
  //          listens for connections from new dispatcher clients.
  //          When a new connection with a client is established,
  //          the parent server will receive, process and respond to
  //          one and only one service request from the client before
  //          before disconnecting from that client.  This allows
  //          the parent server to remain open for listening to new connection
  //          requests. Each request received (of type DDS::EMessageType) 
  //          is responded to in return with a single message of type 
  //          DDS::EMessageType sent to the client upon completion of 
  //          servicing the request.  In this way the client can remain in 
  //          sync with the parent server's processing of its request. 
  //
  //          The services which the client can currently request are:
  //          DDS::kData  == Request for data.  This request spawns a separate
  //                         child server to handle the client.
  //          DDS::kShutdown    == Request to shutdown parent server.
  //                               Note that client must be local to
  //                               have authorization to shutdown parent
  //                               server.
  //          DDS:kStatus = Request for parent server status.  Returns 
  //                        kOk if alive.
  // 
  //          The return status with which the parent server can respond
  //          to the client may be one of the following:
  //          DDS::kPermissionDenied == Unauthorized client access denied.
  //          DDS::kMessageUnknown == Unrecognized message from client.
  //          DDS::kSystemError == Error occured in system call
  //                             (e.g. fork failed when spawning child server).
  //          DDS::kSocketError == An error return was received on the
  //                               socket receipt of the client's message.
  //          DDS::kSaturated == Maximum number of child servers reached.
  //          DDS::kOk == Parent server status ok or service completed ok.
  //
  // Arguments: none.
  //
  // Return: none.
  //
  // Contact: S. Kasahara
  //
  // Notes: The DDSParentServer will remain in the Run method until it 
  //        receives the DDS::kShutdown message from a local
  //        client.  
  //

   while ( !fShutdown ) {
    // Wait for new connection to parent server
    fTSocket = fTServerSocket -> Accept();
    if ( !fTSocket ) {
      MSG("DDS",Msg::kWarning) 
      << "PS: An error occured in TServerSocket::Accept while attempting to\n"
      << "accept a new client connection." << endl;
      continue; // loop and try again  
    }

    fClientAddress = fTSocket -> GetInetAddress();


    // Handle connected socket request
    if( ( fTSocket -> Recv(fMessageIn) ) > 0 ) {
      if ( fMessageIn -> What() != DDS::kStatus ) {
        MSG("DDS",Msg::kInfo) <<  "PS: Connected to new client at " 
                          << fClientAddress.GetHostName() << "/" 
                          << fClientAddress.GetHostAddress() 
                          << "(port " << fClientAddress.GetPort() << ")"
                          << endl;
      }
      fMessageOut.Reset();
      
      if ( !Authorize() ) {
        // Client is not authorized to access parent server
        fMessageOut.Reset(DDS::kPermissionDenied);
      }
      else {
        
        switch ( fMessageIn -> What()) {

        case DDS::kStatus:
          // Request for parentserver status
          Status();
          break;

        case DDS::kData:
          // Request for data
          fMessageOut.Reset(SpawnChildServer());
          break;

        case DDS::kShutdown:
          // Request to shutdown parent server
          fMessageOut.Reset(Shutdown());
          break;

        default:
          MSG("DDS",Msg::kWarning) << "PS: Unknown client message: " 
                               << fMessageIn->What() << " received.\n" 
                               <<"Unable to process client request." << endl;
          fMessageOut.Reset(DDS::kMessageUnknown);
          break;
        } // end of switch block

      } // end of fMessageIn processing

      delete fMessageIn; fMessageIn = 0;
    }
    else {
      MSG("DDS",Msg::kInfo) <<  "PS: Connected to new client at " 
                          << fClientAddress.GetHostName() << "/" 
                          << fClientAddress.GetHostAddress() 
                          << "(port " << fClientAddress.GetPort() << ")"
                          << endl;
      // Error return on TSocket::Recv call
      MSG("DDS",Msg::kWarning) 
      << "PS: Error returned from TSocket::Recv of client message.\n" << endl;
      fMessageOut.Reset(DDS::kSocketError);
    } // end of socket received fMessageIn block

    fTSocket -> Send(fMessageOut); // send return status to client
    // Client only allowed one chance to send valid message to parent server
    // to avoid backlog waiting for one client to get it right; child server
    // is more tolerant
    delete fTSocket; fTSocket=0;  // close and delete TSocket object 
    CheckChildStatus();   // check status of any exited children 
   
  } // while server processing block

}

DDS::EMessageType DDSParentServer::Shutdown

(

)

[private]

Definition at line 414 of file DDSParentServer.cxx.

References fClientAddress, fShutdown, gSystem(), IsLocalClient(), DDS::kOk, DDS::kPermissionDenied, Msg::kWarning, and MSG.

Referenced by Run().

                                          {
  // Purpose: This Service shuts down the parent server.  This routine is 
  //          activated when the DDS::kShutdown message is received in
  //          DDSParentServer::Run().
  // 
  // Arguments: none.
  //
  // Return: DDS::EMessageType containing the return status of this service.
  //                           This service can return one of 2 messages:
  //                           DDS::kOk  (service provided ok)
  //                           DDS::kPermissionDenied (client doesn't have
  //                                permission to request shutdown)
  //
  // Contact: S. Kasahara
  //
  // Notes:  Client must be local (as determined by IsLocalClient()) to have 
  //         authority to shutdown parent server.

  DDS::EMessageType msgrc = DDS::kOk; // default return value

  if ( IsLocalClient() ) { 
    fShutdown = true;   // stops processing loop in Run
  }
  else {
    MSG("DDS",Msg::kWarning)
      << "PS: Nonlocal client at address:\n" << fClientAddress.GetHostName() 
      << "/" << fClientAddress.GetHostAddress() << "(port " 
      << fClientAddress.GetPort() << ")\n" 
      << "has requested shutdown of parent server on host "
      << gSystem->GetHostByName(gSystem->HostName()).GetHostName() 
      << ".\nPermission denied."<< endl;
    msgrc = DDS::kPermissionDenied; 
  }

  return msgrc;

}

DDS::EMessageType DDSParentServer::SpawnChildServer

(

)

[private]

Definition at line 482 of file DDSParentServer.cxx.

References CheckChildStatus(), fLogLevel, fMaxChild, fMaxInactive, fMessageIn, fNumChild, fPSStatus, fTServerSocket, fTSocket, gSystem(), IsLocalClient(), Msg::kError, DDS::kError, Msg::kInfo, DDS::kOk, DDS::kSaturated, DDS::kSystemError, Msg::kWarning, MSG, and DDSPSStatus::SetClientId().

Referenced by Run().

                                                  {
  // Purpose: This Service spawns a child server to handle client request 
  //          for near-online data. This routine is activated when the 
  //          DDS:kData message is received in DDSParentServer::Run(). 
  // 
  // Arguments: none.
  //
  // Return: DDS::EMessageType containing the return status of this 
  //                           service.  This service can return one of
  //                           3 messages: 
  //                           DDS::kOk (service provided ok)
  //                           DDS::kSaturated (max no. of children reached)
  //                           DDS::kSystemError (fork or exec failed)
  //
  // Contact: S. Kasahara
  //
  // Notes: Local client child servers are executed at a higher priority 
  //        than remote clients.  A successfully spawned child increments 
  //        the fNumChild counter by 1.
  //        
  
  DDS::EMessageType msgrc = DDS::kOk; // default return value 

  DDSClientId* ddsId = dynamic_cast<DDSClientId*>
                      (fMessageIn -> ReadObject(fMessageIn->GetClass()));
  
  if ( !ddsId ) {
     MSG("DDS",Msg::kWarning) 
     << "PS: SpawnChildServer failed to received DDSClientId from client."
     << "\nClient sw likely out-of-date. Refuse to spawn childserver." << endl;
     msgrc = DDS::kError;
     return msgrc;
  }

  // First check to see if parent has reached the saturation level with
  // the number of supported children.
  CheckChildStatus();  // first check for any newly returned children
  if( fNumChild == fMaxChild ) {
    MSG("DDS",Msg::kWarning) << "PS: Unable to spawn new child per request\n"
    << "because number of child servers running (" << fNumChild 
    << ") is maximum allowed." << endl;
    msgrc = DDS::kSaturated;
  }
  else {
    // Fork a child process to handle the new client
    int pid;
    if( (pid = fork()) < 0) {
      // Error in fork, unable to spawn child
      MSG("DDS",Msg::kError) 
      << "PS: Unable to spawn child.  Fork failed with error "
      << strerror(errno) << endl;
      msgrc = DDS::kSystemError;
    }
    else if ( pid > 0 ) {
      // Successful fork, report new child process id
      MSG("DDS",Msg::kInfo) << "PS: Spawned child with process id " << pid 
                            << " to handle client request." << endl;
      fNumChild++;

      // However, wait one second to check to see if execlp failed to start
      // ChildServer properly. This is done so that the correct status can be
      // reported back to the client if the execlp failed.
      gSystem -> Sleep(1000);
      int childpid;  // pid number of exited child processes
      Int_t childstat; // exit status of child process
      childpid = waitpid(pid, &childstat, WNOHANG);
      if (childpid > 0) {
        // Spawned child process exited prematurely
        fNumChild--; 
        msgrc = DDS::kSystemError;
      }
      else {
        // Successfully spawned child. Enter pid in ClientId
        ddsId -> Connected(pid);
        fPSStatus.SetClientId(pid,ddsId);
        MSG("DDS",Msg::kInfo) << fPSStatus << endl;
      }
    }

    if (pid == 0) {
      // In the child process.
      // Must Close serversocket in child because reference count of
      // serversocket is incremented by 1 when child is created. Close
      // just decrements reference count of serversocket by 1 (child won't
      // use server socket).  
      fTServerSocket -> Close();
      Int_t sockfd = fTSocket->GetDescriptor(); //connected socket descriptor
      char csockfd[20];
      sprintf(csockfd,"%i",sockfd); // convert to character string
      // Determine the priority level at which the child server will run.
      // Local clients are served at a priority level higher than remote 
      // clients. 
      Int_t niceincr = (IsLocalClient()) ? 0 : 5;
      char cniceincr[20];
      sprintf(cniceincr,"%i",niceincr); // convert to character string
      char cloglevel[20];
      sprintf(cloglevel,"%i",fLogLevel); // convert loglevel to char string
      char cmaxinactive[20];
      sprintf(cmaxinactive,"%i",fMaxInactive); // maxinactive to char string
      // Pass the program which handles the child the connected socket 
      // descriptor
      execlp("ddschildserver","ddschildserver", csockfd, cniceincr,cloglevel,
             cmaxinactive,(char *)0);
      // Only reach this point if execlp fails
      MSG("DDS",Msg::kError) << "PS: execlp of ChildServer\n" 
       << "failed with error: " << strerror(errno) << ".  Please check that\n"
   <<"the location of the ChildServer is in the calling process search PATH.\n"
     << endl;
      exit(1);
    } // end of child processing

  } 

  return msgrc;

}

DDS::EMessageType DDSParentServer::Status

(

)

[private]

Definition at line 453 of file DDSParentServer.cxx.

References CheckChildStatus(), fMaxChild, fMessageOut, fNumChild, fPSStatus, DDS::kOk, and DDS::kSaturated.

Referenced by Run().

                                        {
  // Purpose: This Service returns the parent server status.  This routine is 
  //          activated when the DDS::kStatus message is received in
  //          DDSParentServer::Run().
  // 
  // Arguments: none.
  //
  // Return: DDS::EMessageType containing the return status of this service.
  //                           This service can return one  message:
  //                           DDS::kOk  (service provided ok)
  //
  // Contact: S. Kasahara
  //
  // Notes: Eventually could send status object back to client. Currently
  //        always returns okay (e.g. this server is up and listening).

  DDS::EMessageType msgrc = DDS::kOk; // default return value
  CheckChildStatus();  // first check for any newly returned children
  if( fNumChild >= fMaxChild ) {
    msgrc = DDS::kSaturated;
  }
  fMessageOut.Reset(msgrc);
  fMessageOut.WriteObject(&fPSStatus);
  
  return msgrc;

}

---

Member Data Documentation

TInetAddress DDSParentServer::fClientAddress [private]

Definition at line 66 of file DDSParentServer.h.

Referenced by IsLocalClient(), Run(), and Shutdown().

Int_t DDSParentServer::fLogLevel [private]

Definition at line 60 of file DDSParentServer.h.

Referenced by Print(), and SpawnChildServer().

UInt_t DDSParentServer::fMaxChild [private]

Definition at line 59 of file DDSParentServer.h.

Referenced by Print(), SpawnChildServer(), and Status().

Int_t DDSParentServer::fMaxInactive [private]

Definition at line 61 of file DDSParentServer.h.

Referenced by Print(), and SpawnChildServer().

TMessage* DDSParentServer::fMessageIn [private]

Definition at line 67 of file DDSParentServer.h.

Referenced by Run(), and SpawnChildServer().

TMessage DDSParentServer::fMessageOut [private]

Definition at line 68 of file DDSParentServer.h.

Referenced by Run(), and Status().

UInt_t DDSParentServer::fNumChild [private]

Definition at line 62 of file DDSParentServer.h.

Referenced by CheckChildStatus(), Print(), SpawnChildServer(), and Status().

DDSPSStatus DDSParentServer::fPSStatus [private]

Definition at line 69 of file DDSParentServer.h.

Referenced by CheckChildStatus(), SpawnChildServer(), and Status().

TInetAddress DDSParentServer::fServerAddress [private]

Definition at line 65 of file DDSParentServer.h.

Referenced by DDSParentServer(), and Print().

bool DDSParentServer::fShutdown [private]

Definition at line 63 of file DDSParentServer.h.

Referenced by DDSParentServer(), Run(), and Shutdown().

TServerSocket* DDSParentServer::fTServerSocket [private]

Definition at line 58 of file DDSParentServer.h.

Referenced by DDSParentServer(), IsValid(), Run(), SpawnChildServer(), and ~DDSParentServer().

TSocket* DDSParentServer::fTSocket [private]

Definition at line 64 of file DDSParentServer.h.

Referenced by Run(), SpawnChildServer(), and ~DDSParentServer().

---

The documentation for this class was generated from the following files:

• DDSParentServer.h
• DDSParentServer.cxx

---