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.

00031 { 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.

00135                                                                   :
00136 fTServerSocket(0),fMaxChild(maxchild),fLogLevel(logLevel),
00137 fMaxInactive(maxInactive),fNumChild(0),fShutdown(false),fTSocket(0),
00138 fMessageIn(0), fMessageOut(), fPSStatus() {
00139   // Purpose: Constructor.  This constructor creates a TServerSocket 
00140   //          attached to the specified port. A TServerSocket is created
00141   //          and bound to the specified port.
00142   // 
00143   // Arguments: port: port number assigned to server socket.  If port = 0
00144   //                  (default), the serversocket will be connected to the
00145   //                  named service "MinosDDS", which should be assigned to
00146   //                  a port in the /etc/services file.
00147   //            maxchild: maximum number of concurrent child servers allowed
00148   //                      (default = kMaxChild).
00149   //            logLevel: message verbose level
00150   //            maxInactive: max inactive time before connection shutdown
00151   //            backlog: maximum number of clients the kernel should queue
00152   //                     up on this port for pending connections (default is
00153   //                     TServerSocket::kDefaultBacklog).
00154   //
00155   // Return: n/a.
00156   //
00157   // Contact: S. Kasahara
00158   //
00159   // Notes: Use IsValid() to check if DDSParentServer was created successfully.
00160   //
00161 
00162   // Create server socket
00163   // The second argument kTRUE sets the SO_REUSEADDR socket option 
00164   // (kFALSE by default). When set true, reuse allows the listening server to 
00165   // start and bind its port even if previously established connections 
00166   // exist that use this port as their local port (such as if the parent
00167   // starts, spawns a child, dies, and needs to be restarted with the child
00168   // still serving from that port). 
00169   if (!port) {
00170     // User has not specified an alternative port.  server socket will be
00171     // bound to the port assigned to the named service "MinosDDS" 
00172     fTServerSocket = new TServerSocket("MinosDDS",kTRUE,backlog);
00173   }
00174   else {
00175     fTServerSocket = new TServerSocket(port,kTRUE,backlog);
00176   }
00177 
00178   // Check validity of socket
00179   if(!fTServerSocket || !fTServerSocket -> IsValid()) {
00180     // An error occured during the creation of the server socket
00181 
00182     if ( port ) {
00183       MSG("DDS",Msg::kWarning) 
00184         << "PS: Unable to create parent server socket connected to port " 
00185         << port << "." << endl;
00186     }
00187     else {
00188       MSG("DDS",Msg::kWarning) 
00189     << "PS: Unable to create parent server socket connected to named service " 
00190         << "MinosDDS." << endl;
00191     }
00192     if(fTServerSocket)delete fTServerSocket; fTServerSocket = 0;
00193     fShutdown = true;
00194   } 
00195   else {
00196     // Store local address of the server socket.
00197     fServerAddress = fTServerSocket -> GetLocalInetAddress();
00198   }
00199 
00200 }

DDSParentServer::~DDSParentServer (  )  [virtual]

Definition at line 203 of file DDSParentServer.cxx.

References fTServerSocket, fTSocket, and IsValid().

00203                                   {
00204   // Purpose: Destructor.  
00205   // 
00206   // Arguments: n/a.
00207   //
00208   // Return: n/a.
00209   //
00210   // Contact: S. Kasahara
00211   //
00212   
00213   if ( IsValid() ) {
00214     delete fTServerSocket; fTServerSocket = 0;
00215   }
00216   // fTSocket should always be deleted and cleared in DDSParentServer::Run() 
00217   if ( fTSocket ) delete fTSocket; fTSocket = 0;
00218     
00219 }


Member Function Documentation

bool DDSParentServer::Authorize (  )  const [private]

Definition at line 58 of file DDSParentServer.cxx.

Referenced by Run().

00058                                       {
00059   // Purpose: Authorize currently connected client to use dispatcher.
00060   //          Address of currently connected client must have been previously
00061   //          stored in fClientAddress.
00062   // 
00063   // Argument: none.
00064   //
00065   // Return: true if client is authorized, else false.
00066   //
00067   // Contact: S. Kasahara
00068   //
00069   // Notes: Currently a dummy routine, always returns true.
00070   //
00071 
00072   // perform check on client address, if ok then
00073   return true;
00074  
00075 }

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().

00078                                          {
00079   // Purpose: Check status of any exited child processes spawned by
00080   //          parent.  This has the important side benefit of clearing 
00081   //          "zombies" (child processes that have exited but have status
00082   //          values left to be read).  The fNumChild counter of currently
00083   //          active children is decremented for each newly exited child.
00084   // 
00085   // Argument: none.
00086   //
00087   // Return: Number of remaining active child processes.  
00088   //
00089   // Contact: S. Kasahara
00090   //
00091   // Notes: Another way to do this would be for the parent server to maintain
00092   //        a list of spawned child processes and inquire each child's status
00093   //        according to its process id.
00094 
00095   int childpid;  // pid number of exited child processes
00096   Int_t childstat; // exit status of child process
00097 
00098   bool newexit = false;
00099   while ((childpid = waitpid(-1, &childstat, WNOHANG)) > 0) {
00100     // This child has exited
00101     if ( !newexit ) {
00102       newexit = true; 
00103       MSG("DDS",Msg::kInfo) 
00104       << "PS: ParentServer reporting on status of exited children: " << endl;
00105     }
00106 
00107     fNumChild--;  // decrement number of active children
00108 
00109     if ( childstat != 0 ) {
00110       // the child process exited with an error status
00111       MSG("DDS",Msg::kWarning) << "PS: Child process " << childpid << 
00112         " has exited with error status " << WEXITSTATUS(childstat) 
00113         << "." << endl;
00114     }
00115     else {
00116       // if in info mode report all child exits
00117       MSG("DDS",Msg::kInfo) << "PS: Child process " << childpid <<
00118         " has exited successfully." << endl;
00119     }
00120     fPSStatus.RemoveClientId(childpid);
00121   } 
00122 
00123   if ( newexit ) {
00124     MSG("DDS",Msg::kInfo) << "PS: Number of children currently running = " 
00125                           << fNumChild << "." << endl;
00126   }
00127 
00128   return fNumChild;
00129 
00130 }

bool DDSParentServer::IsLocalClient (  )  const [private]

Definition at line 222 of file DDSParentServer.cxx.

References fClientAddress, and gSystem().

Referenced by Shutdown(), and SpawnChildServer().

00222                                           {
00223   // Purpose: Determine if currently connected client with address given
00224   //          in fClientAddress is local.
00225   // 
00226   // Arguments: none.
00227   //
00228   // Return: true if local.
00229   //
00230   // Contact: S. Kasahara
00231   //
00232   // Notes:  This method currently determines that a client is local only if it
00233   //         resides on the same host as the parent server. The definition
00234   //         of a local client will eventually be expanded to include other 
00235   //         hosts in the same local area network (once I know how to do that).
00236   //         Having local client status bestows special privileges on that
00237   //         client, such as:
00238   //         a) local client child servers are run at higher priority than 
00239   //            remote client child servers.
00240   //         b) only local clients may shutdown the parent server.
00241   //
00242 
00243   bool local = false;
00244 
00245   TString localhost(gSystem->GetHostByName(gSystem->HostName()).GetHostName());
00246   
00247   if(!localhost.CompareTo(fClientAddress.GetHostName(),TString::kIgnoreCase)){ 
00248     local = true;
00249   }
00250 
00251   return local;
00252 
00253 }

bool DDSParentServer::IsValid (  )  const [inline]

Definition at line 40 of file DDSParentServer.h.

References fTServerSocket.

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

00040                         { 
00041                  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<<().

00256                                                        {
00257   // Purpose: Print DDSParentServer status on std::ostream.
00258   // 
00259   // Arguments: ms  std::ostream to print on.
00260   //
00261   // Return: std::ostream reference.
00262   //
00263   // Contact: S. Kasahara
00264   //
00265 
00266   if ( IsValid() ) {
00267     ms << "PS: local addr " 
00268     // Print the local host name, address, port number
00269        << fServerAddress.GetHostName() 
00270        << "(port " << fServerAddress.GetPort() << ")" 
00271        << ", maxchild " << fMaxChild 
00272        << ", loglvl " << Msg::LevelAsString(fLogLevel)
00273        << ", maxinactive(sec) " << fMaxInactive  
00274        << ", currentchild " << fNumChild << "." << endl; 
00275   }
00276   else {
00277     ms << "PS: socket is not connected." << endl; 
00278   }
00279 
00280   return ms;
00281 
00282 }

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().

00285                           {
00286   // Purpose: This is the main method of the DDSParentServer.  It
00287   //          listens for connections from new dispatcher clients.
00288   //          When a new connection with a client is established,
00289   //          the parent server will receive, process and respond to
00290   //          one and only one service request from the client before
00291   //          before disconnecting from that client.  This allows
00292   //          the parent server to remain open for listening to new connection
00293   //          requests. Each request received (of type DDS::EMessageType) 
00294   //          is responded to in return with a single message of type 
00295   //          DDS::EMessageType sent to the client upon completion of 
00296   //          servicing the request.  In this way the client can remain in 
00297   //          sync with the parent server's processing of its request. 
00298   //
00299   //          The services which the client can currently request are:
00300   //          DDS::kData  == Request for data.  This request spawns a separate
00301   //                         child server to handle the client.
00302   //          DDS::kShutdown    == Request to shutdown parent server.
00303   //                               Note that client must be local to
00304   //                               have authorization to shutdown parent
00305   //                               server.
00306   //          DDS:kStatus = Request for parent server status.  Returns 
00307   //                        kOk if alive.
00308   // 
00309   //          The return status with which the parent server can respond
00310   //          to the client may be one of the following:
00311   //          DDS::kPermissionDenied == Unauthorized client access denied.
00312   //          DDS::kMessageUnknown == Unrecognized message from client.
00313   //          DDS::kSystemError == Error occured in system call
00314   //                             (e.g. fork failed when spawning child server).
00315   //          DDS::kSocketError == An error return was received on the
00316   //                               socket receipt of the client's message.
00317   //          DDS::kSaturated == Maximum number of child servers reached.
00318   //          DDS::kOk == Parent server status ok or service completed ok.
00319   //
00320   // Arguments: none.
00321   //
00322   // Return: none.
00323   //
00324   // Contact: S. Kasahara
00325   //
00326   // Notes: The DDSParentServer will remain in the Run method until it 
00327   //        receives the DDS::kShutdown message from a local
00328   //        client.  
00329   //
00330 
00331    while ( !fShutdown ) {
00332     // Wait for new connection to parent server
00333     fTSocket = fTServerSocket -> Accept();
00334     if ( !fTSocket ) {
00335       MSG("DDS",Msg::kWarning) 
00336       << "PS: An error occured in TServerSocket::Accept while attempting to\n"
00337       << "accept a new client connection." << endl;
00338       continue; // loop and try again  
00339     }
00340 
00341     fClientAddress = fTSocket -> GetInetAddress();
00342 
00343 
00344     // Handle connected socket request
00345     if( ( fTSocket -> Recv(fMessageIn) ) > 0 ) {
00346       if ( fMessageIn -> What() != DDS::kStatus ) {
00347         MSG("DDS",Msg::kInfo) <<  "PS: Connected to new client at " 
00348                           << fClientAddress.GetHostName() << "/" 
00349                           << fClientAddress.GetHostAddress() 
00350                           << "(port " << fClientAddress.GetPort() << ")"
00351                           << endl;
00352       }
00353       fMessageOut.Reset();
00354       
00355       if ( !Authorize() ) {
00356         // Client is not authorized to access parent server
00357         fMessageOut.Reset(DDS::kPermissionDenied);
00358       }
00359       else {
00360         
00361         switch ( fMessageIn -> What()) {
00362 
00363         case DDS::kStatus:
00364           // Request for parentserver status
00365           Status();
00366           break;
00367 
00368         case DDS::kData:
00369           // Request for data
00370           fMessageOut.Reset(SpawnChildServer());
00371           break;
00372 
00373         case DDS::kShutdown:
00374           // Request to shutdown parent server
00375           fMessageOut.Reset(Shutdown());
00376           break;
00377 
00378         default:
00379           MSG("DDS",Msg::kWarning) << "PS: Unknown client message: " 
00380                                << fMessageIn->What() << " received.\n" 
00381                                <<"Unable to process client request." << endl;
00382           fMessageOut.Reset(DDS::kMessageUnknown);
00383           break;
00384         } // end of switch block
00385 
00386       } // end of fMessageIn processing
00387 
00388       delete fMessageIn; fMessageIn = 0;
00389     }
00390     else {
00391       MSG("DDS",Msg::kInfo) <<  "PS: Connected to new client at " 
00392                           << fClientAddress.GetHostName() << "/" 
00393                           << fClientAddress.GetHostAddress() 
00394                           << "(port " << fClientAddress.GetPort() << ")"
00395                           << endl;
00396       // Error return on TSocket::Recv call
00397       MSG("DDS",Msg::kWarning) 
00398       << "PS: Error returned from TSocket::Recv of client message.\n" << endl;
00399       fMessageOut.Reset(DDS::kSocketError);
00400     } // end of socket received fMessageIn block
00401 
00402     fTSocket -> Send(fMessageOut); // send return status to client
00403     // Client only allowed one chance to send valid message to parent server
00404     // to avoid backlog waiting for one client to get it right; child server
00405     // is more tolerant
00406     delete fTSocket; fTSocket=0;  // close and delete TSocket object 
00407     CheckChildStatus();   // check status of any exited children 
00408    
00409   } // while server processing block
00410 
00411 }

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().

00414                                           {
00415   // Purpose: This Service shuts down the parent server.  This routine is 
00416   //          activated when the DDS::kShutdown message is received in
00417   //          DDSParentServer::Run().
00418   // 
00419   // Arguments: none.
00420   //
00421   // Return: DDS::EMessageType containing the return status of this service.
00422   //                           This service can return one of 2 messages:
00423   //                           DDS::kOk  (service provided ok)
00424   //                           DDS::kPermissionDenied (client doesn't have
00425   //                                permission to request shutdown)
00426   //
00427   // Contact: S. Kasahara
00428   //
00429   // Notes:  Client must be local (as determined by IsLocalClient()) to have 
00430   //         authority to shutdown parent server.
00431 
00432   DDS::EMessageType msgrc = DDS::kOk; // default return value
00433 
00434   if ( IsLocalClient() ) { 
00435     fShutdown = true;   // stops processing loop in Run
00436   }
00437   else {
00438     MSG("DDS",Msg::kWarning)
00439       << "PS: Nonlocal client at address:\n" << fClientAddress.GetHostName() 
00440       << "/" << fClientAddress.GetHostAddress() << "(port " 
00441       << fClientAddress.GetPort() << ")\n" 
00442       << "has requested shutdown of parent server on host "
00443       << gSystem->GetHostByName(gSystem->HostName()).GetHostName() 
00444       << ".\nPermission denied."<< endl;
00445     msgrc = DDS::kPermissionDenied; 
00446   }
00447 
00448   return msgrc;
00449 
00450 }

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().

00482                                                   {
00483   // Purpose: This Service spawns a child server to handle client request 
00484   //          for near-online data. This routine is activated when the 
00485   //          DDS:kData message is received in DDSParentServer::Run(). 
00486   // 
00487   // Arguments: none.
00488   //
00489   // Return: DDS::EMessageType containing the return status of this 
00490   //                           service.  This service can return one of
00491   //                           3 messages: 
00492   //                           DDS::kOk (service provided ok)
00493   //                           DDS::kSaturated (max no. of children reached)
00494   //                           DDS::kSystemError (fork or exec failed)
00495   //
00496   // Contact: S. Kasahara
00497   //
00498   // Notes: Local client child servers are executed at a higher priority 
00499   //        than remote clients.  A successfully spawned child increments 
00500   //        the fNumChild counter by 1.
00501   //        
00502   
00503   DDS::EMessageType msgrc = DDS::kOk; // default return value 
00504 
00505   DDSClientId* ddsId = dynamic_cast<DDSClientId*>
00506                       (fMessageIn -> ReadObject(fMessageIn->GetClass()));
00507   
00508   if ( !ddsId ) {
00509      MSG("DDS",Msg::kWarning) 
00510      << "PS: SpawnChildServer failed to received DDSClientId from client."
00511      << "\nClient sw likely out-of-date. Refuse to spawn childserver." << endl;
00512      msgrc = DDS::kError;
00513      return msgrc;
00514   }
00515 
00516   // First check to see if parent has reached the saturation level with
00517   // the number of supported children.
00518   CheckChildStatus();  // first check for any newly returned children
00519   if( fNumChild == fMaxChild ) {
00520     MSG("DDS",Msg::kWarning) << "PS: Unable to spawn new child per request\n"
00521     << "because number of child servers running (" << fNumChild 
00522     << ") is maximum allowed." << endl;
00523     msgrc = DDS::kSaturated;
00524   }
00525   else {
00526     // Fork a child process to handle the new client
00527     int pid;
00528     if( (pid = fork()) < 0) {
00529       // Error in fork, unable to spawn child
00530       MSG("DDS",Msg::kError) 
00531       << "PS: Unable to spawn child.  Fork failed with error "
00532       << strerror(errno) << endl;
00533       msgrc = DDS::kSystemError;
00534     }
00535     else if ( pid > 0 ) {
00536       // Successful fork, report new child process id
00537       MSG("DDS",Msg::kInfo) << "PS: Spawned child with process id " << pid 
00538                             << " to handle client request." << endl;
00539       fNumChild++;
00540 
00541       // However, wait one second to check to see if execlp failed to start
00542       // ChildServer properly. This is done so that the correct status can be
00543       // reported back to the client if the execlp failed.
00544       gSystem -> Sleep(1000);
00545       int childpid;  // pid number of exited child processes
00546       Int_t childstat; // exit status of child process
00547       childpid = waitpid(pid, &childstat, WNOHANG);
00548       if (childpid > 0) {
00549         // Spawned child process exited prematurely
00550         fNumChild--; 
00551         msgrc = DDS::kSystemError;
00552       }
00553       else {
00554         // Successfully spawned child. Enter pid in ClientId
00555         ddsId -> Connected(pid);
00556         fPSStatus.SetClientId(pid,ddsId);
00557         MSG("DDS",Msg::kInfo) << fPSStatus << endl;
00558       }
00559     }
00560 
00561     if (pid == 0) {
00562       // In the child process.
00563       // Must Close serversocket in child because reference count of
00564       // serversocket is incremented by 1 when child is created. Close
00565       // just decrements reference count of serversocket by 1 (child won't
00566       // use server socket).  
00567       fTServerSocket -> Close();
00568       Int_t sockfd = fTSocket->GetDescriptor(); //connected socket descriptor
00569       char csockfd[20];
00570       sprintf(csockfd,"%i",sockfd); // convert to character string
00571       // Determine the priority level at which the child server will run.
00572       // Local clients are served at a priority level higher than remote 
00573       // clients. 
00574       Int_t niceincr = (IsLocalClient()) ? 0 : 5;
00575       char cniceincr[20];
00576       sprintf(cniceincr,"%i",niceincr); // convert to character string
00577       char cloglevel[20];
00578       sprintf(cloglevel,"%i",fLogLevel); // convert loglevel to char string
00579       char cmaxinactive[20];
00580       sprintf(cmaxinactive,"%i",fMaxInactive); // maxinactive to char string
00581       // Pass the program which handles the child the connected socket 
00582       // descriptor
00583       execlp("ddschildserver","ddschildserver", csockfd, cniceincr,cloglevel,
00584              cmaxinactive,(char *)0);
00585       // Only reach this point if execlp fails
00586       MSG("DDS",Msg::kError) << "PS: execlp of ChildServer\n" 
00587        << "failed with error: " << strerror(errno) << ".  Please check that\n"
00588    <<"the location of the ChildServer is in the calling process search PATH.\n"
00589      << endl;
00590       exit(1);
00591     } // end of child processing
00592 
00593   } 
00594 
00595   return msgrc;
00596 
00597 }

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().

00453                                         {
00454   // Purpose: This Service returns the parent server status.  This routine is 
00455   //          activated when the DDS::kStatus message is received in
00456   //          DDSParentServer::Run().
00457   // 
00458   // Arguments: none.
00459   //
00460   // Return: DDS::EMessageType containing the return status of this service.
00461   //                           This service can return one  message:
00462   //                           DDS::kOk  (service provided ok)
00463   //
00464   // Contact: S. Kasahara
00465   //
00466   // Notes: Eventually could send status object back to client. Currently
00467   //        always returns okay (e.g. this server is up and listening).
00468 
00469   DDS::EMessageType msgrc = DDS::kOk; // default return value
00470   CheckChildStatus();  // first check for any newly returned children
00471   if( fNumChild >= fMaxChild ) {
00472     msgrc = DDS::kSaturated;
00473   }
00474   fMessageOut.Reset(msgrc);
00475   fMessageOut.WriteObject(&fPSStatus);
00476   
00477   return msgrc;
00478 
00479 }


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:
Generated on Mon Nov 10 00:55:24 2014 for loon by  doxygen 1.4.7