(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.22 and 1.42

version 1.22, 2004/08/16 14:03:43 version 1.42, 2006/08/09 21:12:59
Line 1 
Line 1 
 //%2003////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
 // IBM Corp.; EMC Corporation, The Open Group. // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 27 
Line 33 
 // //
 // Modified By:   Dan Gorey (djgorey@us.ibm.com) // Modified By:   Dan Gorey (djgorey@us.ibm.com)
 //                Amit K Arora, IBM (amita@in.ibm.com) for PEP#183 //                Amit K Arora, IBM (amita@in.ibm.com) for PEP#183
   //                Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //                David Dillard, VERITAS Software Corp.
   //                    (david.dillard@veritas.com)
   //                Vijay Eli, IBM (vijay.eli@in.ibm.com) for bug#3425
   //                Aruran, IBM (ashanmug@in.ibm.com) for Bug# 3604
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "CIMListener.h" #include "CIMListener.h"
   
 #include <Pegasus/Common/Exception.h> #include <Pegasus/Common/Exception.h>
 #include <Pegasus/Common/SSLContext.h> #include <Pegasus/Common/SSLContext.h>
 #include <Pegasus/Common/Monitor.h> #include <Pegasus/Common/Monitor.h>
 #include <Pegasus/Common/HTTPAcceptor.h> #include <Pegasus/Common/HTTPAcceptor.h>
 #include <Pegasus/Common/PegasusVersion.h> #include <Pegasus/Common/PegasusVersion.h>
   #include <Pegasus/Common/MessageLoader.h>
 #include <Pegasus/ExportServer/CIMExportResponseEncoder.h> #include <Pegasus/ExportServer/CIMExportResponseEncoder.h>
 #include <Pegasus/ExportServer/CIMExportRequestDecoder.h> #include <Pegasus/ExportServer/CIMExportRequestDecoder.h>
   
 #include <Pegasus/Consumer/CIMIndicationConsumer.h> #include <Pegasus/Consumer/CIMIndicationConsumer.h>
 #include <Pegasus/Listener/CIMListenerIndicationDispatcher.h> #include <Pegasus/Listener/CIMListenerIndicationDispatcher.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
 /////////////////////////////////////////////////////////////////////////////  
   ////////////////////////////////////////////////////////////////////////////////
   //
 // CIMListenerService // CIMListenerService
 /////////////////////////////////////////////////////////////////////////////  //
   ////////////////////////////////////////////////////////////////////////////////
   
 class CIMListenerService class CIMListenerService
 { {
 public: public:
Line 56 
Line 69 
   ~CIMListenerService();   ~CIMListenerService();
  
         void                            init();         void                            init();
   
         /** bind to the port         /** bind to the port
         */         */
         void                            bind();         void                            bind();
   
         /** runForever Main runloop for the server.         /** runForever Main runloop for the server.
         */         */
         void runForever();         void runForever();
Line 76 
Line 91 
  
         /** Return true if the server has shutdown, false otherwise.         /** Return true if the server has shutdown, false otherwise.
         */         */
         Boolean terminated() { return _dieNow; };      Boolean terminated() const
       {
           return _dieNow;
       };
  
         /** Call to resume the sever.         /** Call to resume the sever.
         */         */
Line 97 
Line 115 
          */          */
         void setIndicationDispatcher(CIMListenerIndicationDispatcher* dispatcher);         void setIndicationDispatcher(CIMListenerIndicationDispatcher* dispatcher);
  
         static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _listener_routine(void *param);      /** Returns the port number being used.
       */
       Uint32 getPortNumber() const;
   
       static ThreadReturnType PEGASUS_THREAD_CDECL
       _listener_routine(void *param);
  
 private: private:
         Uint32                  _portNumber;         Uint32                  _portNumber;
         SSLContext* _sslContext;         SSLContext* _sslContext;
   #ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT  
         Monitor*                                _monitor;         Monitor*                                _monitor;
       Mutex _monitorMutex;
   HTTPAcceptor*   _acceptor;   HTTPAcceptor*   _acceptor;
   #else  
         monitor_2*                              _monitor;  
   pegasus_acceptor*   _acceptor;  
   #endif  
   
   Boolean                                       _dieNow;   Boolean                                       _dieNow;
   
   CIMListenerIndicationDispatcher* _dispatcher;   CIMListenerIndicationDispatcher* _dispatcher;
   
   CIMExportResponseEncoder* _responseEncoder;   CIMExportResponseEncoder* _responseEncoder;
   CIMExportRequestDecoder*  _requestDecoder;   CIMExportRequestDecoder*  _requestDecoder;
   
 }; };
  
 CIMListenerService::CIMListenerService(Uint32 portNumber, SSLContext* sslContext)  CIMListenerService::CIMListenerService(
 :_portNumber(portNumber)      Uint32 portNumber,
 ,_sslContext(sslContext)      SSLContext * sslContext)
 ,_monitor(NULL)      :
 ,_acceptor(NULL)      _portNumber(portNumber),
 ,_dieNow(false)      _sslContext(sslContext),
 ,_dispatcher(NULL)      _monitor(NULL),
 ,_responseEncoder(NULL)      _acceptor(NULL),
 ,_requestDecoder(NULL)      _dieNow(false),
       _dispatcher(NULL),
       _responseEncoder(NULL),
       _requestDecoder(NULL)
 { {
 } }
  
 CIMListenerService::CIMListenerService(CIMListenerService& svc)  CIMListenerService::CIMListenerService(CIMListenerService & svc) :
 :_portNumber(svc._portNumber)      _portNumber(svc._portNumber),
 ,_sslContext(svc._sslContext)      _sslContext(svc._sslContext),
 ,_monitor(NULL)      _monitor(NULL),
 ,_acceptor(NULL)      _acceptor(NULL),
 ,_dieNow(svc._dieNow)      _dieNow(svc._dieNow),
 ,_dispatcher(NULL)      _dispatcher(NULL),
 ,_responseEncoder(NULL)      _responseEncoder(NULL),
 ,_requestDecoder(NULL)      _requestDecoder(NULL)
 { {
 } }
   
 CIMListenerService::~CIMListenerService() CIMListenerService::~CIMListenerService()
 { {
         // if port is alive, clean up the port  
         //if(_sslContext!=NULL)  
         //      delete _sslContext;  
   
         if(_responseEncoder!=NULL)  
                 delete _responseEncoder;                 delete _responseEncoder;
   
         if(_requestDecoder!=NULL)  
                 delete _requestDecoder;                 delete _requestDecoder;
   
         //if(_dispatcher!=NULL)  
         //      delete _dispatcher;  
   
         if(_monitor!=NULL)  
                 delete _monitor;  
   
         if(_acceptor!=NULL)  
                 delete _acceptor;                 delete _acceptor;
       delete _monitor;
 } }
  
 void CIMListenerService::init() void CIMListenerService::init()
 { {
         PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::init");         PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::init");
  
   #ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT      if (NULL == _monitor)
   _monitor = new Monitor(true);          _monitor = new Monitor();
   #else  
   _monitor = new monitor_2();  
   #endif  
  
         //_dispatcher = new CIMListenerIndicationDispatcher();         //_dispatcher = new CIMListenerIndicationDispatcher();
  
       if (NULL == _responseEncoder)
   _responseEncoder = new CIMExportResponseEncoder();   _responseEncoder = new CIMExportResponseEncoder();
   
       if (NULL == _requestDecoder)
       {
   _requestDecoder = new CIMExportRequestDecoder(   _requestDecoder = new CIMExportRequestDecoder(
                 _dispatcher,              _dispatcher, _responseEncoder->getQueueId());
                 _responseEncoder->getQueueId());      }
  
   #ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT      if (NULL == _acceptor)
       {
   _acceptor = new HTTPAcceptor(   _acceptor = new HTTPAcceptor(
                  _monitor,              _monitor, _requestDecoder, false, _portNumber, _sslContext, false);
                  _requestDecoder,      }
                  false,  
                  _portNumber,  
                  _sslContext,  
                  false);  
   #else  
   _acceptor = new pegasus_acceptor(_monitor,  
                    _requestDecoder,  
                    false,  
                    _portNumber,  
                    _sslContext);  
   #endif  
  
   bind();   bind();
  
   PEG_METHOD_EXIT();   PEG_METHOD_EXIT();
 } }
   
 void CIMListenerService::bind() void CIMListenerService::bind()
 { {
   if(_acceptor!=NULL)   if(_acceptor!=NULL)
     { // Bind to the port      {
       _acceptor->bind();       _acceptor->bind();
  
       PEGASUS_STD(cout) << "Listening on HTTP port " << _portNumber << PEGASUS_STD(endl);          Logger::put(
               Logger::STANDARD_LOG,
       //listener.addAcceptor(false, portNumberHttp, false);              System::CIMLISTENER,
       Logger::put(Logger::STANDARD_LOG, System::CIMLISTENER, Logger::INFORMATION,              Logger::INFORMATION,
                         "Listening on HTTP port $0.", _portNumber);              "Listening on HTTP port $0.",
               _portNumber);
     }     }
 } }
  
Line 222 
Line 219 
  
   if(!_dieNow)   if(!_dieNow)
     {     {
 #ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT  
       if(false == _monitor->run(500000))       if(false == _monitor->run(500000))
         {         {
           modulator++;           modulator++;
       try       try
       {       {
              //MessageQueueService::_check_idle_flag = 1;                  MessageQueueService::get_thread_pool()->cleanupIdleThreads();
                  //MessageQueueService::_polling_sem.signal();  
                  MessageQueueService::get_thread_pool()->kill_idle_threads();  
       }       }
           catch(...)           catch(...)
       {       {
                   // Ignore!
       }       }
         }         }
 /*  
       if (handleShutdownSignal)  
       {  
         Tracer::trace(TRC_SERVER, Tracer::LEVEL3,  
         "CIMServer::runForever - signal received.  Shutting down.");  
   
         ShutdownService::getInstance(this)->shutdown(true, 10, false);  
         handleShutdownSignal = false;  
       }  
 */  
 #else  
       _monitor->run();  
 #endif  
     }     }
 } }
  
Line 256 
Line 238 
 { {
     PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::shutdown()");     PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::shutdown()");
  
       // This logic signals the thread currently executing _listener_routine()
       // to exit. That function deletes this instance of CIMListenerService,
       // which deletes the _monitor member. We use a mutex to keep it from
       // deleting the monitor until after tickle has been called.
       {
           AutoMutex am(_monitorMutex);
     _dieNow = true;     _dieNow = true;
 #ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT  
     _monitor->tickle();     _monitor->tickle();
 #endif      }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
Line 276 
Line 263 
  
 void CIMListenerService::stopClientConnection() void CIMListenerService::stopClientConnection()
 { {
     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(true);     _monitor->stopListeningForConnections(true);
     #else  
     _monitor->stop();  
     #endif  
   
     //  
     // Wait 150 milliseconds to allow time for the Monitor to stop  
     // listening for client connections.  
     //  
     // This wait time is the timeout value for the select() call  
     // in the Monitor's run() method (currently set to 100  
     // milliseconds) plus a delta of 50 milliseconds.  The reason  
     // for the wait here is to make sure that the Monitor entries  
     // are updated before closing the connection sockets.  
     //  
     // pegasus_sleep(150); Not needed now due to the semaphore in the Monitor  
  
     if(_acceptor!=NULL)     if(_acceptor!=NULL)
     _acceptor->closeConnectionSocket();     _acceptor->closeConnectionSocket();
Line 303 
Line 276 
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
   Uint32 CIMListenerService::getOutstandingRequestCount()
   {
       return _acceptor->getOutstandingRequestCount();
   }
  
 CIMListenerIndicationDispatcher* CIMListenerService::getIndicationDispatcher() const  CIMListenerIndicationDispatcher*
   CIMListenerService::getIndicationDispatcher() const
 { {
         return _dispatcher;         return _dispatcher;
 } }
 void CIMListenerService::setIndicationDispatcher(CIMListenerIndicationDispatcher* dispatcher)  
   void CIMListenerService::setIndicationDispatcher(
       CIMListenerIndicationDispatcher* dispatcher)
 { {
         _dispatcher = dispatcher;         _dispatcher = dispatcher;
 } }
  
 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL CIMListenerService::_listener_routine(void *param)  Uint32 CIMListenerService::getPortNumber() const
   {
       Uint32 portNumber = _portNumber;
   
       if ((portNumber == 0) && (_acceptor != 0))
       {
           portNumber = _acceptor->getPortNumber();
       }
   
       return (portNumber);
   }
   
   ThreadReturnType PEGASUS_THREAD_CDECL
   CIMListenerService::_listener_routine(void *param)
 { {
   CIMListenerService *svc = reinterpret_cast<CIMListenerService *>(param);   CIMListenerService *svc = reinterpret_cast<CIMListenerService *>(param);
  
       try
       {
   //svc->init(); bug 1394   //svc->init(); bug 1394
   while(!svc->terminated())   while(!svc->terminated())
   {   {
Line 325 
Line 320 
 #endif #endif
     svc->runForever();     svc->runForever();
   }   }
       }
       catch(...)
       {
           Tracer::trace(TRC_SERVER, Tracer::LEVEL2,
                         "Unknown exception thrown in _listener_routine.");
       }
   
       // CAUTION: deleting the service also deletes the monitor whose tickle()
       // method may still be executing in another thread. This line of code was
       // most likely reached when the CIMListenerService::shutdown() method set
       // _dieNow to true and called Monitor::tickle(). We must wait until we
       // can obtain the _monitorMutex, indicating that we are no longer inside
       // Monitor::tickle().
       svc->_monitorMutex.lock();
       svc->_monitorMutex.unlock();
   delete svc;   delete svc;
  
   return 0;   return 0;
 } }
 static struct timeval create_time = {0, 1};  
 static struct timeval destroy_time = {15, 0};  
 static struct timeval deadlock_time = {0, 0};  
  
 /////////////////////////////////////////////////////////////////////////////  ////////////////////////////////////////////////////////////////////////////////
   //
 // CIMListenerRep // CIMListenerRep
 /////////////////////////////////////////////////////////////////////////////  //
   ////////////////////////////////////////////////////////////////////////////////
   
 class CIMListenerRep class CIMListenerRep
 { {
 public: public:
Line 356 
Line 366 
         Boolean removeConsumer(CIMIndicationConsumer* consumer);         Boolean removeConsumer(CIMIndicationConsumer* consumer);
  
 private: private:
       Boolean waitForPendingRequests(Uint32 shutdownTimeout);
   
         Uint32                  _portNumber;         Uint32                  _portNumber;
         SSLContext* _sslContext;         SSLContext* _sslContext;
  
Line 365 
Line 377 
   Semaphore *_listener_sem;   Semaphore *_listener_sem;
 }; };
  
 CIMListenerRep::CIMListenerRep(Uint32 portNumber, SSLContext* sslContext)  CIMListenerRep::CIMListenerRep(
 :_portNumber(portNumber)      Uint32 portNumber,
 ,_sslContext(sslContext)      SSLContext * sslContext)
 ,_dispatcher(new CIMListenerIndicationDispatcher())      :
 ,_thread_pool(NULL)      _portNumber(portNumber),
 ,_svc(NULL)      _sslContext(sslContext),
 ,_listener_sem(NULL)      _dispatcher(new CIMListenerIndicationDispatcher()),
       _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)      if (_thread_pool != 0)
   {   {
     // Block incoming export requests and unbind the port     // Block incoming export requests and unbind the port
     _svc->stopClientConnection();     _svc->stopClientConnection();
  
           // Wait until pending export requests in the server are done.
           waitForPendingRequests(10);
   
     // Shutdown the CIMListenerService     // Shutdown the CIMListenerService
     _svc->shutdown();     _svc->shutdown();
   }   }
  
   if(_sslContext!=NULL)  
     delete _sslContext;     delete _sslContext;
   
   if(_dispatcher!=NULL)  
     delete _dispatcher;     delete _dispatcher;
   
   if(_thread_pool!=NULL)  
     delete _thread_pool;     delete _thread_pool;
   
   if(_listener_sem!=NULL)  
     delete _listener_sem;     delete _listener_sem;
  
   // don't delete _svc, this is deleted by _listener_routine   // don't delete _svc, this is deleted by _listener_routine
Line 403 
Line 415 
  
 Uint32 CIMListenerRep::getPortNumber() const Uint32 CIMListenerRep::getPortNumber() const
 { {
         return _portNumber;      Uint32 portNumber;
   
       if (_svc == 0)
           portNumber = _portNumber;
       else
           portNumber = _svc->getPortNumber();
   
       return portNumber;
 } }
  
 SSLContext* CIMListenerRep::getSSLContext() const SSLContext* CIMListenerRep::getSSLContext() const
 { {
         return _sslContext;         return _sslContext;
 } }
   
 void CIMListenerRep::setSSLContext(SSLContext* sslContext) void CIMListenerRep::setSSLContext(SSLContext* sslContext)
 { {
         if(_sslContext!=NULL)  
                 delete _sslContext;                 delete _sslContext;
   
         _sslContext = sslContext;         _sslContext = sslContext;
 } }
   
 void CIMListenerRep::start() void CIMListenerRep::start()
 { {
   // spawn a thread to do this   // spawn a thread to do this
   if(_thread_pool==NULL)      if (_thread_pool == 0)
   {  
     CIMListenerService* svc = new CIMListenerService(_portNumber,_sslContext);  
     try  
     {     {
       // Try to initialize the service (bug 1394)          AutoPtr < CIMListenerService >
               svc(new CIMListenerService(_portNumber, _sslContext));
   
       svc->setIndicationDispatcher(_dispatcher);       svc->setIndicationDispatcher(_dispatcher);
       svc->init();       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,  
                                   create_time, destroy_time, deadlock_time);  
   
     _listener_sem = new Semaphore(0);  
     _thread_pool->allocate_and_awaken(svc,  
                                       CIMListenerService::_listener_routine,  
                                       _listener_sem);  
   
     _svc = svc;  
  
     Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER,          struct timeval deallocateWait = { 15, 0 };
           AutoPtr < ThreadPool >
               threadPool(new ThreadPool(0, "Listener", 0, 1, deallocateWait));
           AutoPtr < Semaphore > sem(new Semaphore(0));
   
           if (threadPool->allocate_and_awaken(
               svc.get(), CIMListenerService::_listener_routine, sem.get())
               != PEGASUS_THREAD_OK)
           {
               Logger::put(
                   Logger::STANDARD_LOG, System::CIMSERVER,
                   Logger::TRACE,
                   "Not enough threads to start CIMListernerService.");
   
               Tracer::trace(
                   TRC_SERVER,
                   Tracer::LEVEL2,
                   "Could not allocate thread for "
                   "CIMListenerService::_listener_routine.");
               throw
                   Exception(MessageLoaderParms(
                       "Listener.CIMListener.CANNOT_ALLOCATE_THREAD",
                       "Could not allocate thread."));
           }
   
           Logger::put(
               Logger::STANDARD_LOG,
               System::CIMLISTENER,
                 Logger::INFORMATION,                 Logger::INFORMATION,
                 "CIMListener started");                 "CIMListener started");
  
     PEGASUS_STD(cerr) << "CIMlistener started" << PEGASUS_STD(endl);          _svc = svc.release();
           _thread_pool = threadPool.release();
           _listener_sem = sem.release();
   }   }
 } }
  
Line 466 
Line 495 
     // Block incoming export requests and unbind the port     // Block incoming export requests and unbind the port
     _svc->stopClientConnection();     _svc->stopClientConnection();
  
           // Wait until pending export requests in the server are done.
           waitForPendingRequests(10);
   
     // Shutdown the CIMListenerService     // Shutdown the CIMListenerService
     _svc->shutdown();     _svc->shutdown();
  
Line 477 
Line 509 
     {     {
       _listener_sem->time_wait(3000);       _listener_sem->time_wait(3000);
     }     }
     catch (TimeOut &)          catch(const TimeOut &)
     {     {
       // No need to do anything, the thread pool will be deleted below       // No need to do anything, the thread pool will be deleted below
       // to cancel the _listener_routine thread if it is still running.       // to cancel the _listener_routine thread if it is still running.
Line 486 
Line 518 
     delete _listener_sem;     delete _listener_sem;
     _listener_sem = NULL;     _listener_sem = NULL;
  
     // Delete the thread pool.  This cancels the listener thread if it is still          // Delete the thread pool.  This cancels the listener thread if it is
           // still
     // running.     // running.
     delete _thread_pool;     delete _thread_pool;
     _thread_pool = NULL;     _thread_pool = NULL;
  
     Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER,          Logger::put(
                 Logger::INFORMATION,              Logger::STANDARD_LOG, System::CIMLISTENER,
                 "CIMListener stopped");              Logger::INFORMATION, "CIMListener stopped");
   }   }
 } }
  
Line 506 
Line 539 
 { {
         return _dispatcher->addConsumer(consumer);         return _dispatcher->addConsumer(consumer);
 } }
   
 Boolean CIMListenerRep::removeConsumer(CIMIndicationConsumer* consumer) Boolean CIMListenerRep::removeConsumer(CIMIndicationConsumer* consumer)
 { {
         return _dispatcher->removeConsumer(consumer);         return _dispatcher->removeConsumer(consumer);
 } }
  
   Boolean CIMListenerRep::waitForPendingRequests(Uint32 shutdownTimeout)
   {
       // Wait for 10 sec max
       Uint32 reqCount;
       Uint32 countDown = shutdownTimeout * 10;
   
       for (; countDown > 0; countDown--)
       {
           reqCount = _svc->getOutstandingRequestCount();
           if (reqCount > 0)
               Threads::sleep(100);
           else
               return true;
       }
   
       return false;
   }
   
 ///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
   //
 // CIMListener // CIMListener
   //
 ///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
 CIMListener::CIMListener(Uint32 portNumber, SSLContext* sslContext)  
 :_rep(new CIMListenerRep(portNumber,sslContext))  CIMListener::CIMListener(
       Uint32 portNumber,
       SSLContext * sslContext)
       :
       _rep(new CIMListenerRep(portNumber, sslContext))
 { {
 } }
   
 CIMListener::~CIMListener() CIMListener::~CIMListener()
 { {
         if(_rep!=NULL)         if(_rep!=NULL)
Line 534 
Line 593 
 { {
         return static_cast<CIMListenerRep*>(_rep)->getSSLContext();         return static_cast<CIMListenerRep*>(_rep)->getSSLContext();
 } }
   
 void CIMListener::setSSLContext(SSLContext* sslContext) void CIMListener::setSSLContext(SSLContext* sslContext)
 { {
         static_cast<CIMListenerRep*>(_rep)->setSSLContext(sslContext);         static_cast<CIMListenerRep*>(_rep)->setSSLContext(sslContext);
 } }
   
 void CIMListener::start() void CIMListener::start()
 { {
         static_cast<CIMListenerRep*>(_rep)->start();         static_cast<CIMListenerRep*>(_rep)->start();
 } }
   
 void CIMListener::stop() void CIMListener::stop()
 { {
         static_cast<CIMListenerRep*>(_rep)->stop();         static_cast<CIMListenerRep*>(_rep)->stop();
 } }
  
 Boolean CIMListener::isAlive()  Boolean CIMListener::isAlive() const
 { {
         return static_cast<CIMListenerRep*>(_rep)->isAlive();         return static_cast<CIMListenerRep*>(_rep)->isAlive();
 } }
Line 556 
Line 618 
 { {
         return static_cast<CIMListenerRep*>(_rep)->addConsumer(consumer);         return static_cast<CIMListenerRep*>(_rep)->addConsumer(consumer);
 } }
   
 Boolean CIMListener::removeConsumer(CIMIndicationConsumer* consumer) Boolean CIMListener::removeConsumer(CIMIndicationConsumer* consumer)
 { {
         return static_cast<CIMListenerRep*>(_rep)->removeConsumer(consumer);         return static_cast<CIMListenerRep*>(_rep)->removeConsumer(consumer);

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