(file) Return to CIMListener.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Listener

Diff for /pegasus/src/Pegasus/Listener/CIMListener.cpp between version 1.13 and 1.19.2.1

version 1.13, 2003/11/05 06:29:37 version 1.19.2.1, 2004/08/09 10:18:43
Line 25 
Line 25 
 // //
 // Author: Dong Xiang, EMC Corporation (xiang_dong@emc.com) // Author: Dong Xiang, EMC Corporation (xiang_dong@emc.com)
 // //
 // Modified By:  // Modified By:   Dan Gorey (djgorey@us.ibm.com)
   //                Amit K Arora, IBM (amita@in.ibm.com) for PEP#183
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 101 
Line 102 
 private: private:
         Uint32                  _portNumber;         Uint32                  _portNumber;
         SSLContext* _sslContext;         SSLContext* _sslContext;
     #ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT
         Monitor*                                _monitor;         Monitor*                                _monitor;
   HTTPAcceptor*   _acceptor;   HTTPAcceptor*   _acceptor;
     #else
           monitor_2*                              _monitor;
     pegasus_acceptor*   _acceptor;
     #endif
   
         Boolean                                 _dieNow;         Boolean                                 _dieNow;
  
   CIMListenerIndicationDispatcher* _dispatcher;   CIMListenerIndicationDispatcher* _dispatcher;
Line 162 
Line 168 
 { {
         PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::init");         PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::init");
  
     #ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT
   _monitor = new Monitor(true);   _monitor = new Monitor(true);
     #else
     _monitor = new monitor_2();
     #endif
   
         //_dispatcher = new CIMListenerIndicationDispatcher();         //_dispatcher = new CIMListenerIndicationDispatcher();
  
         _responseEncoder = new CIMExportResponseEncoder();         _responseEncoder = new CIMExportResponseEncoder();
Line 170 
Line 181 
                 _dispatcher,                 _dispatcher,
                 _responseEncoder->getQueueId());                 _responseEncoder->getQueueId());
  
     #ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT
         _acceptor = new HTTPAcceptor(         _acceptor = new HTTPAcceptor(
                  _monitor,                  _monitor,
                  _requestDecoder,                  _requestDecoder,
                  false,                  false,
                  _portNumber,                  _portNumber,
                    _sslContext,
                    false);
     #else
     _acceptor = new pegasus_acceptor(_monitor,
                      _requestDecoder,
                      false,
                      _portNumber,
                  _sslContext);                  _sslContext);
     #endif
  
         bind();         bind();
  
Line 195 
Line 215 
  
         }         }
 } }
   
 void CIMListenerService::runForever() void CIMListenerService::runForever()
 { {
         static int modulator = 0;         static int modulator = 0;
  
         if(!_dieNow)         if(!_dieNow)
         {         {
                 if(false == _monitor->run(100))  #ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT
         if(false == _monitor->run(500000))
                 {                 {
                         modulator++;                         modulator++;
                         if(!(modulator % 5000) )  
                         {  
                                 try                                 try
                                 {                                 {
                                         //MessageQueueService::_check_idle_flag = 1;                                         //MessageQueueService::_check_idle_flag = 1;
Line 216 
Line 236 
                                 {                                 {
                                 }                                 }
                         }                         }
                 }  
 /* /*
                 if (handleShutdownSignal)                 if (handleShutdownSignal)
                 {                 {
Line 227 
Line 246 
                         handleShutdownSignal = false;                         handleShutdownSignal = false;
                 }                 }
 */ */
   #else
         _monitor->run();
   #endif
         }         }
 } }
  
Line 235 
Line 257 
     PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::shutdown()");     PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::shutdown()");
  
     _dieNow = true;     _dieNow = true;
   #ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT
       _monitor->tickle();
   #endif
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
Line 254 
Line 279 
     PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::stopClientConnection()");     PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::stopClientConnection()");
  
     // tell Monitor to stop listening for client connections     // tell Monitor to stop listening for client connections
       #ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT
     _monitor->stopListeningForConnections();     _monitor->stopListeningForConnections();
       #else
       _monitor->stop();
       #endif
  
     //     //
     // Wait 150 milliseconds to allow time for the Monitor to stop     // Wait 150 milliseconds to allow time for the Monitor to stop
Line 266 
Line 295 
     // for the wait here is to make sure that the Monitor entries     // for the wait here is to make sure that the Monitor entries
     // are updated before closing the connection sockets.     // are updated before closing the connection sockets.
     //     //
     pegasus_sleep(150);      // pegasus_sleep(150); Not needed now due to the semaphore in the Monitor
  
     if(_acceptor!=NULL)     if(_acceptor!=NULL)
     _acceptor->closeConnectionSocket();     _acceptor->closeConnectionSocket();
Line 288 
Line 317 
 { {
   CIMListenerService *svc = reinterpret_cast<CIMListenerService *>(param);   CIMListenerService *svc = reinterpret_cast<CIMListenerService *>(param);
  
         svc->init();    //svc->init(); bug 1394
         while(!svc->terminated())         while(!svc->terminated())
         {         {
   #if defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
       pthread_testcancel();
   #endif
           svc->runForever();           svc->runForever();
 } }
         delete svc;         delete svc;
Line 329 
Line 361 
  
   CIMListenerIndicationDispatcher* _dispatcher;   CIMListenerIndicationDispatcher* _dispatcher;
         ThreadPool* _thread_pool;         ThreadPool* _thread_pool;
     CIMListenerService* _svc;
     Semaphore *_listener_sem;
 }; };
  
 CIMListenerRep::CIMListenerRep(Uint32 portNumber, SSLContext* sslContext) CIMListenerRep::CIMListenerRep(Uint32 portNumber, SSLContext* sslContext)
Line 336 
Line 370 
 ,_sslContext(sslContext) ,_sslContext(sslContext)
 ,_dispatcher(new CIMListenerIndicationDispatcher()) ,_dispatcher(new CIMListenerIndicationDispatcher())
 ,_thread_pool(NULL) ,_thread_pool(NULL)
   ,_svc(NULL)
   ,_listener_sem(NULL)
 { {
 } }
 CIMListenerRep::~CIMListenerRep() CIMListenerRep::~CIMListenerRep()
 { {
         // if port is alive, clean up the port         // if port is alive, clean up the port
     if (_thread_pool != NULL)
     {
       // Block incoming export requests and unbind the port
       _svc->stopClientConnection();
   
       // Shutdown the CIMListenerService
       _svc->shutdown();
     }
   
         if(_sslContext!=NULL)         if(_sslContext!=NULL)
                 delete _sslContext;                 delete _sslContext;
  
Line 349 
Line 394 
  
         if(_thread_pool!=NULL)         if(_thread_pool!=NULL)
                 delete _thread_pool;                 delete _thread_pool;
   
     if(_listener_sem!=NULL)
       delete _listener_sem;
   
     // don't delete _svc, this is deleted by _listener_routine
 } }
  
 Uint32 CIMListenerRep::getPortNumber() const Uint32 CIMListenerRep::getPortNumber() const
Line 372 
Line 422 
         // spawn a thread to do this         // spawn a thread to do this
         if(_thread_pool==NULL)         if(_thread_pool==NULL)
         {         {
       CIMListenerService* svc = new CIMListenerService(_portNumber,_sslContext);
       try
       {
         // Try to initialize the service (bug 1394)
         svc->setIndicationDispatcher(_dispatcher);
         svc->init();
       }
       catch(...)
       {
         // Error. Exit without creating the ThreadPool, so that this listener
         // is not 'alive'
         delete svc;
         throw;
       }
   
                 _thread_pool = new ThreadPool(0, "Listener", 0, 1,                 _thread_pool = new ThreadPool(0, "Listener", 0, 1,
                         create_time, destroy_time, deadlock_time);                         create_time, destroy_time, deadlock_time);
  
                 CIMListenerService* svc = new CIMListenerService(_portNumber,_sslContext);      _listener_sem = new Semaphore(0);
                 svc->setIndicationDispatcher(_dispatcher);      _thread_pool->allocate_and_awaken(svc,
                                         CIMListenerService::_listener_routine,
                                         _listener_sem);
  
                 _thread_pool->allocate_and_awaken(svc,CIMListenerService::_listener_routine);      _svc = svc;
  
                 Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER,                 Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER,
                                               Logger::INFORMATION,                                               Logger::INFORMATION,
Line 391 
Line 458 
 void CIMListenerRep::stop() void CIMListenerRep::stop()
 { {
         if(_thread_pool!=NULL)         if(_thread_pool!=NULL)
         { // stop the thread    {
       //
       // Graceful shutdown of the listener service
       //
   
       // Block incoming export requests and unbind the port
       _svc->stopClientConnection();
   
       // Shutdown the CIMListenerService
       _svc->shutdown();
   
       // Wait for the _listener_routine thread to exit.
       // The thread could be delivering an export, so give it 3sec.
       // Note that _listener_routine deletes the CIMListenerService,
       // so no need to delete _svc.
       try
       {
         _listener_sem->time_wait(3000);
       }
       catch (TimeOut &)
       {
         // No need to do anything, the thread pool will be deleted below
         // to cancel the _listener_routine thread if it is still running.
       }
   
       delete _listener_sem;
       _listener_sem = NULL;
  
       // Delete the thread pool.  This cancels the listener thread if it is still
       // running.
                 delete _thread_pool;                 delete _thread_pool;
       _thread_pool = NULL;
  
                 Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER,                 Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER,
                                                     Logger::INFORMATION,                                                     Logger::INFORMATION,

Legend:
Removed from v.1.13  
changed lines
  Added in v.1.19.2.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2