(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.8 and 1.60

version 1.8, 2003/08/15 14:10:29 version 1.60, 2015/06/10 12:36:02
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Licensed to The Open Group (TOG) under one or more contributor license
 // The Open Group, Tivoli Systems  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
   // this work for additional information regarding copyright ownership.
   // Each contributor licenses this file to you under the OpenPegasus Open
   // Source License; you may not use this file except in compliance with the
   // License.
 // //
 // 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
 // of this software and associated documentation files (the "Software"), to  // copy of this software and associated documentation files (the "Software"),
 // deal in the Software without restriction, including without limitation the  // to deal in the Software without restriction, including without limitation
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // sell copies of the Software, and to permit persons to whom the Software is  // and/or sell copies of the Software, and to permit persons to whom the
 // furnished to do so, subject to the following conditions:  // Software is furnished to do so, subject to the following conditions:
 //  
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
 // //
 //==============================================================================  // The above copyright notice and this permission notice shall be included
   // in all copies or substantial portions of the Software.
 // //
 // Author: Dong Xiang, EMC Corporation (xiang_dong@emc.com)  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 // Modified By:  //////////////////////////////////////////////////////////////////////////
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #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/HostAddress.h>
   #include <Pegasus/Common/PegasusVersion.h>
   #include <Pegasus/Common/MessageLoader.h>
   #include <Pegasus/Common/Time.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:
       CIMListenerService(
           const String &listenAddress,
           Uint32 portNumber,
           SSLContext * sslContext = NULL);
         CIMListenerService(Uint32 portNumber, SSLContext* sslContext=NULL);         CIMListenerService(Uint32 portNumber, SSLContext* sslContext=NULL);
         CIMListenerService(CIMListenerService& svc);         CIMListenerService(CIMListenerService& svc);
   ~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 72 
Line 85 
  
         /** 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 93 
Line 109 
          */          */
         void setIndicationDispatcher(CIMListenerIndicationDispatcher* dispatcher);         void setIndicationDispatcher(CIMListenerIndicationDispatcher* dispatcher);
  
         static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _listener_routine(void *param);      /** Returns the bind address.
       */
       String getListenAddress() const;
   
       /** Returns the port number being used.
       */
       Uint32 getPortNumber() const;
   
       static ThreadReturnType PEGASUS_THREAD_CDECL
       _listener_routine(void *param);
  
 private: private:
       String _listenAddress;
         Uint32                  _portNumber;         Uint32                  _portNumber;
         SSLContext* _sslContext;         SSLContext* _sslContext;
       ReadWriteSem _sslContextObjectLock;
         Monitor*                                _monitor;         Monitor*                                _monitor;
   HTTPAcceptor*   _acceptor;      Mutex _monitorMutex;
       HTTPAcceptor *_ip6Acceptor;
       HTTPAcceptor *_ip4Acceptor;
         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)      const String &listenAddress,
 ,_sslContext(sslContext)      Uint32 portNumber,
 ,_monitor(NULL)      SSLContext * sslContext)
 ,_acceptor(NULL)      :
 ,_dieNow(false)      _listenAddress(listenAddress),
 ,_dispatcher(NULL)      _portNumber(portNumber),
 ,_responseEncoder(NULL)      _sslContext(sslContext),
 ,_requestDecoder(NULL)      _monitor(NULL),
       _ip6Acceptor(NULL),
       _ip4Acceptor(NULL),
       _dieNow(false),
       _dispatcher(NULL),
       _responseEncoder(NULL),
       _requestDecoder(NULL)
 { {
 } }
  
 CIMListenerService::CIMListenerService(CIMListenerService& svc)  CIMListenerService::CIMListenerService(
 :_portNumber(svc._portNumber)      Uint32 portNumber,
 ,_sslContext(svc._sslContext)      SSLContext * sslContext)
 ,_monitor(NULL)      :
 ,_acceptor(NULL)      _listenAddress(),
 ,_dieNow(svc._dieNow)      _portNumber(portNumber),
 ,_dispatcher(NULL)      _sslContext(sslContext),
 ,_responseEncoder(NULL)      _monitor(NULL),
 ,_requestDecoder(NULL)      _ip6Acceptor(NULL),
       _ip4Acceptor(NULL),
       _dieNow(false),
       _dispatcher(NULL),
       _responseEncoder(NULL),
       _requestDecoder(NULL)
 { {
 } }
 CIMListenerService::~CIMListenerService()  
   CIMListenerService::CIMListenerService(CIMListenerService & svc) :
       _listenAddress(svc._listenAddress),
       _portNumber(svc._portNumber),
       _sslContext(svc._sslContext),
       _monitor(NULL),
       _ip6Acceptor(NULL),
       _ip4Acceptor(NULL),
       _dieNow(svc._dieNow),
       _dispatcher(NULL),
       _responseEncoder(NULL),
       _requestDecoder(NULL)
 { {
         // if port is alive, clean up the port  }
         //if(_sslContext!=NULL)  
         //      delete _sslContext;  
  
         if(_responseEncoder!=NULL)  CIMListenerService::~CIMListenerService()
   {
                 delete _responseEncoder;                 delete _responseEncoder;
   
         if(_requestDecoder!=NULL)  
                 delete _requestDecoder;                 delete _requestDecoder;
       delete _ip6Acceptor;
         //if(_dispatcher!=NULL)      delete _ip4Acceptor;
         //      delete _dispatcher;  
   
         if(_monitor!=NULL)  
                 delete _monitor;                 delete _monitor;
   
         if(_acceptor!=NULL)  
                 delete _acceptor;  
 } }
  
 void CIMListenerService::init() void CIMListenerService::init()
 { {
         PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::init");         PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::init");
  
   _monitor = new Monitor(true);      if (NULL == _monitor)
           _monitor = new Monitor();
   
         //_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());      }
  
         _acceptor = new HTTPAcceptor(      HostAddress listenAddress;
                  _monitor,      Boolean listenAddressEmpty = _listenAddress == String::EMPTY;
                  _requestDecoder,      if (!listenAddressEmpty)
                  false,          listenAddress.setHostAddress(_listenAddress);
                  _portNumber,  
                  _sslContext);  
  
   #ifdef PEGASUS_ENABLE_IPV6
       if (System::isIPv6StackActive() &&
          (listenAddressEmpty ||
          (listenAddress.isValid() &&
           listenAddress.getAddressType() == HostAddress::AT_IPV6)))
       {
           if (NULL == _ip6Acceptor)
           {
               if (NULL == _sslContext)
               {
                   _ip6Acceptor = new HTTPAcceptor(
                           _monitor, _requestDecoder,
                           HTTPAcceptor::IPV6_CONNECTION,
                           _portNumber, 0, 0,
                           listenAddressEmpty ? 0 : &listenAddress);
               }
               else
               {
                   _ip6Acceptor = new HTTPAcceptor(
                           _monitor, _requestDecoder,
                           HTTPAcceptor::IPV6_CONNECTION,
                           _portNumber, _sslContext, &_sslContextObjectLock,
                           listenAddressEmpty ? 0 : &listenAddress);
               }
           }
       }
   #ifndef PEGASUS_OS_TYPE_WINDOWS
       else
   #endif
   #endif
       if (NULL == _ip4Acceptor)
       {
           if (NULL == _sslContext)
           {
               _ip4Acceptor = new HTTPAcceptor(
                       _monitor, _requestDecoder,
                       HTTPAcceptor::IPV4_CONNECTION,
                       _portNumber, 0, 0,
                       listenAddressEmpty ? 0 : &listenAddress);
           }
           else
           {
               _ip4Acceptor = new HTTPAcceptor(
                       _monitor, _requestDecoder,
                       HTTPAcceptor::IPV4_CONNECTION,
                       _portNumber, _sslContext, &_sslContextObjectLock,
                       listenAddressEmpty ? 0 : &listenAddress);
           }
       }
         bind();         bind();
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
   
 void CIMListenerService::bind() void CIMListenerService::bind()
 { {
         if(_acceptor!=NULL)      if (_ip6Acceptor != NULL)
         { // Bind to the port      {
                 _acceptor->bind();          _ip6Acceptor->bind();
   
                 PEGASUS_STD(cout) << "Listening on HTTP port " << _portNumber << PEGASUS_STD(endl);  
   
                 //listener.addAcceptor(false, portNumberHttp, false);  
     Logger::put(Logger::STANDARD_LOG, System::CIMLISTENER, Logger::INFORMATION,  
                         "Listening on HTTP port $0.", _portNumber);  
  
           Logger::put(
               Logger::STANDARD_LOG,
               System::CIMLISTENER,
               Logger::INFORMATION,
               "IPV6, Listening on HTTP port $0.",
               _portNumber);
         }         }
       if (_ip4Acceptor != NULL)
       {
           _ip4Acceptor->bind();
   
           Logger::put(
               Logger::STANDARD_LOG,
               System::CIMLISTENER,
               Logger::INFORMATION,
               "IPV4, Listening on HTTP for port $0.",
               _portNumber);
 } }
   }
   
 void CIMListenerService::runForever() void CIMListenerService::runForever()
 { {
         static int modulator = 0;  
   
         if(!_dieNow)         if(!_dieNow)
         {         {
                 if(false == _monitor->run(100))          _monitor->run(500000);
                 {          static struct timeval lastIdleCleanupTime = {0, 0};
                         modulator++;          struct timeval now;
                         if(!(modulator % 5000) )          Time::gettimeofday(&now);
           if (now.tv_sec - lastIdleCleanupTime.tv_sec > 300)
                         {                         {
               lastIdleCleanupTime.tv_sec = now.tv_sec;
                                 try                                 try
                                 {                                 {
                                         //MessageQueueService::_check_idle_flag = 1;                  MessageQueueService::get_thread_pool()->cleanupIdleThreads();
                                         //MessageQueueService::_polling_sem.signal();  
                                         _monitor->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;  
                 }  
 */  
         }  
 } }
  
 void CIMListenerService::shutdown() void CIMListenerService::shutdown()
 { {
     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;
           _monitor->tickle();
       }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
Line 239 
Line 339 
 void CIMListenerService::resume() void CIMListenerService::resume()
 { {
     PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::resume()");     PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::resume()");
       if (_ip6Acceptor != NULL)
       {
           _ip6Acceptor->reopenConnectionSocket();
       }
       if (_ip4Acceptor != NULL)
       {
           _ip4Acceptor->reopenConnectionSocket();
       }
       PEG_METHOD_EXIT();
   }
  
     if(_acceptor!=NULL)  void CIMListenerService::stopClientConnection()
         _acceptor->reopenConnectionSocket();  {
       PEG_METHOD_ENTER(
           TRC_LISTENER,
           "CIMListenerService::stopClientConnection()");
  
       // tell Monitor to stop listening for client connections
       _monitor->stopListeningForConnections(true);
       if (_ip6Acceptor != NULL)
       {
           _ip6Acceptor->closeConnectionSocket();
       }
       if (_ip4Acceptor != NULL)
       {
           _ip4Acceptor->closeConnectionSocket();
       }
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 void CIMListenerService::stopClientConnection()  Uint32 CIMListenerService::getOutstandingRequestCount()
 { {
     PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::stopClientConnection()");      Uint32 cnt = 0;
  
     if(_acceptor!=NULL)      if (_ip6Acceptor)
     _acceptor->closeConnectionSocket();      {
           cnt = _ip6Acceptor->getOutstandingRequestCount();
       }
  
     PEG_METHOD_EXIT();      if (_ip4Acceptor)
       {
           cnt += _ip4Acceptor->getOutstandingRequestCount();
 } }
  
       return cnt;
   }
  
 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)  String CIMListenerService::getListenAddress() const
   {
       bool listenAddressEmpty = _listenAddress == String::EMPTY;
   
       if (listenAddressEmpty && _ip6Acceptor != 0)
           return _ip6Acceptor->getListenAddress();
       else if (listenAddressEmpty && _ip4Acceptor != 0)
           return _ip4Acceptor->getListenAddress();
   
       return _listenAddress;
   }
   
   Uint32 CIMListenerService::getPortNumber() const
   {
       Uint32 portNumber = _portNumber;
   
       if ((portNumber == 0) && (_ip6Acceptor != 0))
       {
           portNumber = _ip6Acceptor->getPortNumber();
       }
       else if ((portNumber == 0) && (_ip4Acceptor != 0))
       {
           portNumber = _ip4Acceptor->getPortNumber();
       }
   
       return (portNumber);
   }
   
   ThreadReturnType PEGASUS_THREAD_CDECL
   CIMListenerService::_listener_routine(void *param)
 { {
   CIMListenerService *svc = reinterpret_cast<CIMListenerService *>(param);   CIMListenerService *svc = reinterpret_cast<CIMListenerService *>(param);
  
         svc->init();      try
       {
           // svc->init(); bug 1394
         while(!svc->terminated())         while(!svc->terminated())
         {         {
   #if defined(PEGASUS_OS_DARWIN)
               pthread_testcancel();
   #endif
           svc->runForever();           svc->runForever();
 } }
       }
       catch(...)
       {
           PEG_TRACE_CSTRING(TRC_SERVER, Tracer::LEVEL1,
                         "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:
       CIMListenerRep(
           const String &listenAddress,
           Uint32 portNumber,
           SSLContext* sslContext = NULL);
         CIMListenerRep(Uint32 portNumber, SSLContext* sslContext=NULL);         CIMListenerRep(Uint32 portNumber, SSLContext* sslContext=NULL);
   ~CIMListenerRep();   ~CIMListenerRep();
  
       String getListenAddress() const;
         Uint32 getPortNumber() const;         Uint32 getPortNumber() const;
  
         SSLContext* getSSLContext() const;         SSLContext* getSSLContext() const;
Line 306 
Line 492 
         Boolean removeConsumer(CIMIndicationConsumer* consumer);         Boolean removeConsumer(CIMIndicationConsumer* consumer);
  
 private: private:
       Boolean waitForPendingRequests(Uint32 shutdownTimeout);
   
       String _listenAddress;
         Uint32                  _portNumber;         Uint32                  _portNumber;
         SSLContext* _sslContext;         SSLContext* _sslContext;
  
   CIMListenerIndicationDispatcher* _dispatcher;   CIMListenerIndicationDispatcher* _dispatcher;
         ThreadPool* _thread_pool;         ThreadPool* _thread_pool;
       CIMListenerService *_svc;
       Semaphore *_listener_sem;
 }; };
  
 CIMListenerRep::CIMListenerRep(Uint32 portNumber, SSLContext* sslContext)  CIMListenerRep::CIMListenerRep(
 :_portNumber(portNumber)      const String &listenAddress,
 ,_sslContext(sslContext)      Uint32 portNumber,
 ,_dispatcher(new CIMListenerIndicationDispatcher())      SSLContext * sslContext)
 ,_thread_pool(NULL)      :
       _listenAddress(listenAddress),
       _portNumber(portNumber),
       _sslContext(sslContext),
       _dispatcher(new CIMListenerIndicationDispatcher()),
       _thread_pool(NULL),
       _svc(NULL),
       _listener_sem(NULL)
 { {
 } }
   
   CIMListenerRep::CIMListenerRep(
       Uint32 portNumber,
       SSLContext * sslContext)
       :
       _listenAddress(),
       _portNumber(portNumber),
       _sslContext(sslContext),
       _dispatcher(new CIMListenerIndicationDispatcher()),
       _thread_pool(NULL),
       _svc(NULL),
       _listener_sem(NULL)
   {
   }
   
 CIMListenerRep::~CIMListenerRep() CIMListenerRep::~CIMListenerRep()
 { {
         // if port is alive, clean up the port      stop();
         if(_sslContext!=NULL)  
                 delete _sslContext;  
  
         if(_dispatcher!=NULL)      delete _sslContext;
                 delete _dispatcher;                 delete _dispatcher;
   
         if(_thread_pool!=NULL)  
                 delete _thread_pool;                 delete _thread_pool;
       delete _listener_sem;
   
       // don't delete _svc, this is deleted by _listener_routine
   }
   
   String CIMListenerRep::getListenAddress() const
   {
       return !_svc ? _listenAddress : _svc->getListenAddress();
 } }
  
 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)
         {         {
                 _thread_pool = new ThreadPool(0, "Listener", 0, 1,          AutoPtr < CIMListenerService >
                         create_time, destroy_time, deadlock_time);              svc(new CIMListenerService(_listenAddress, _portNumber,
                       _sslContext));
  
                 CIMListenerService* svc = new CIMListenerService(_portNumber,_sslContext);  
                 svc->setIndicationDispatcher(_dispatcher);                 svc->setIndicationDispatcher(_dispatcher);
           svc->init();
  
                 _thread_pool->allocate_and_awaken(svc,CIMListenerService::_listener_routine);          struct timeval deallocateWait = { 15, 0 };
           AutoPtr < ThreadPool >
                 Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER,              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)
           {
               PEG_TRACE_CSTRING(
                   TRC_SERVER,
                   Tracer::LEVEL1,
                   "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();
         }         }
 } }
  
 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();
   
           // Wait until pending export requests in the server are done.
           waitForPendingRequests(10);
   
           // 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.
           if (!_listener_sem->time_wait(3000))
           {
               // 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::INFORMATION,              Logger::STANDARD_LOG, System::CIMLISTENER,
                                               "CIMListener stopped");              Logger::INFORMATION, "CIMListener stopped");
         }         }
 } }
  
Line 392 
Line 668 
 { {
         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(
       const String &listenAddress,
       Uint32 portNumber,
       SSLContext* sslContext)
       :
       _rep(new CIMListenerRep(listenAddress, portNumber, sslContext))
   {
   }
   
   CIMListener::CIMListener(
       Uint32 portNumber,
       SSLContext * sslContext)
       :
       _rep(new CIMListenerRep(portNumber, sslContext))
 { {
 } }
   
 CIMListener::~CIMListener() CIMListener::~CIMListener()
 { {
         if(_rep!=NULL)         if(_rep!=NULL)
                 delete _rep;          delete static_cast < CIMListenerRep * >(_rep);
         _rep=NULL;         _rep=NULL;
 } }
  
   String CIMListener::getListenAddress() const
   {
       return static_cast < CIMListenerRep * >(_rep)->getListenAddress();
   }
   
 Uint32 CIMListener::getPortNumber() const Uint32 CIMListener::getPortNumber() const
 { {
         return static_cast<CIMListenerRep*>(_rep)->getPortNumber();         return static_cast<CIMListenerRep*>(_rep)->getPortNumber();
Line 420 
Line 736 
 { {
         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 442 
Line 761 
 { {
         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.8  
changed lines
  Added in v.1.60
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2