(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.39 and 1.59

version 1.39, 2005/07/22 23:36:07 version 1.59, 2008/12/16 18:56:47
Line 1 
Line 1 
 //%2005////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development  // Licensed to The Open Group (TOG) under one or more contributor license
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;  // this work for additional information regarding copyright ownership.
 // IBM Corp.; EMC Corporation, The Open Group.  // Each contributor licenses this file to you under the OpenPegasus Open
 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;  // Source License; you may not use this file except in compliance with the
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.  // License.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;  //
 // EMC Corporation; VERITAS Software Corporation; The Open Group.  // Permission is hereby granted, free of charge, to any person obtaining a
 //  // copy of this software and associated documentation files (the "Software"),
 // Permission is hereby granted, free of charge, to any person obtaining a copy  // to deal in the Software without restriction, including without limitation
 // of this software and associated documentation files (the "Software"), to  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // deal in the Software without restriction, including without limitation the  // and/or sell copies of the Software, and to permit persons to whom the
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // Software is furnished to do so, subject to the following conditions:
 // sell copies of the Software, and to permit persons to whom the 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 ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  //
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //  //
 //==============================================================================  //////////////////////////////////////////////////////////////////////////
 //  
 // Author: Dong Xiang, EMC Corporation (xiang_dong@emc.com)  
 //  
 // Modified By:   Dan Gorey (djgorey@us.ibm.com)  
 //                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/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:
Line 66 
Line 58 
   ~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 86 
Line 80 
  
         /** Return true if the server has shutdown, false otherwise.         /** Return true if the server has shutdown, false otherwise.
         */         */
         Boolean terminated() const { return _dieNow; };      Boolean terminated() const
       {
           return _dieNow;
       };
  
         /** Call to resume the sever.         /** Call to resume the sever.
         */         */
Line 111 
Line 108 
          */          */
         Uint32 getPortNumber() const;         Uint32 getPortNumber() const;
  
         static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _listener_routine(void *param);      static ThreadReturnType PEGASUS_THREAD_CDECL
       _listener_routine(void *param);
  
 private: private:
         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)      Uint32 portNumber,
 ,_sslContext(sslContext)      SSLContext * sslContext)
 ,_monitor(NULL)      :
 ,_acceptor(NULL)      _portNumber(portNumber),
 ,_dieNow(false)      _sslContext(sslContext),
 ,_dispatcher(NULL)      _monitor(NULL),
 ,_responseEncoder(NULL)      _ip6Acceptor(NULL),
 ,_requestDecoder(NULL)      _ip4Acceptor(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)      _ip6Acceptor(NULL),
 ,_dieNow(svc._dieNow)      _ip4Acceptor(NULL),
 ,_dispatcher(NULL)      _dieNow(svc._dieNow),
 ,_responseEncoder(NULL)      _dispatcher(NULL),
 ,_requestDecoder(NULL)      _responseEncoder(NULL),
       _requestDecoder(NULL)
 { {
 } }
   
 CIMListenerService::~CIMListenerService() CIMListenerService::~CIMListenerService()
 { {
     // if port is alive, clean up the port  
     //delete _sslContext;  
   
     delete _responseEncoder;     delete _responseEncoder;
   
     delete _requestDecoder;     delete _requestDecoder;
       delete _ip6Acceptor;
     //delete _dispatcher;      delete _ip4Acceptor;
   
     delete _acceptor;  
   
     delete _monitor;     delete _monitor;
 } }
  
Line 171 
Line 167 
 { {
         PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::init");         PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::init");
  
   if(NULL == _monitor) _monitor = new Monitor();      if (NULL == _monitor)
           _monitor = new Monitor();
  
         //_dispatcher = new CIMListenerIndicationDispatcher();         //_dispatcher = new CIMListenerIndicationDispatcher();
  
   if(NULL == _responseEncoder) _responseEncoder = new CIMExportResponseEncoder();      if (NULL == _responseEncoder)
   if(NULL == _requestDecoder) _requestDecoder = new CIMExportRequestDecoder(          _responseEncoder = new CIMExportResponseEncoder();
                                       _dispatcher,_responseEncoder->getQueueId());  
   
   if(NULL == _acceptor) _acceptor = new HTTPAcceptor(  
                  _monitor,  
                  _requestDecoder,  
                  false,  
                  _portNumber,  
                  _sslContext,  
                  false);  
  
       if (NULL == _requestDecoder)
       {
           _requestDecoder = new CIMExportRequestDecoder(
               _dispatcher, _responseEncoder->getQueueId());
       }
   #ifdef PEGASUS_ENABLE_IPV6
       if (System::isIPv6StackActive())
       {
           if (NULL == _ip6Acceptor)
           {
               if (NULL == _sslContext)
               {
                   _ip6Acceptor = new HTTPAcceptor(
                           _monitor, _requestDecoder,
                           HTTPAcceptor::IPV6_CONNECTION,
                           _portNumber, 0, 0);
               }
               else
               {
                   _ip6Acceptor = new HTTPAcceptor(
                           _monitor, _requestDecoder,
                           HTTPAcceptor::IPV6_CONNECTION,
                           _portNumber, _sslContext, &_sslContextObjectLock);
               }
           }
       }
   #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);
           }
           else
           {
               _ip4Acceptor = new HTTPAcceptor(
                       _monitor, _requestDecoder,
                       HTTPAcceptor::IPV4_CONNECTION,
                       _portNumber, _sslContext, &_sslContextObjectLock);
           }
       }
   bind();   bind();
  
   PEG_METHOD_EXIT();   PEG_METHOD_EXIT();
Line 194 
Line 229 
  
 void CIMListenerService::bind() void CIMListenerService::bind()
 { {
   if(_acceptor!=NULL)      if (_ip6Acceptor != NULL)
     { // Bind to the port      {
       _acceptor->bind();          _ip6Acceptor->bind();
   
       //listener.addAcceptor(false, portNumberHttp, false);          Logger::put(
       Logger::put(Logger::STANDARD_LOG, System::CIMLISTENER, Logger::INFORMATION,              Logger::STANDARD_LOG,
                         "Listening on HTTP port $0.", _portNumber);              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(500000))          _monitor->run(500000);
           static struct timeval lastIdleCleanupTime = {0, 0};
           struct timeval now;
           Time::gettimeofday(&now);
           if (now.tv_sec - lastIdleCleanupTime.tv_sec > 300)
         {         {
           modulator++;              lastIdleCleanupTime.tv_sec = now.tv_sec;
       try       try
       {       {
              //MessageQueueService::_check_idle_flag = 1;  
                  //MessageQueueService::_polling_sem.signal();  
                  MessageQueueService::get_thread_pool()->cleanupIdleThreads();                  MessageQueueService::get_thread_pool()->cleanupIdleThreads();
       }       }
           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;  
       }  
 */  
     }     }
 } }
  
Line 241 
Line 280 
 { {
     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();     _monitor->tickle();
       }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
Line 250 
Line 296 
 void CIMListenerService::resume() void CIMListenerService::resume()
 { {
     PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::resume()");     PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::resume()");
       if (_ip6Acceptor != NULL)
     if(_acceptor!=NULL)      {
         _acceptor->reopenConnectionSocket();          _ip6Acceptor->reopenConnectionSocket();
       }
       if (_ip4Acceptor != NULL)
       {
           _ip4Acceptor->reopenConnectionSocket();
       }
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 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
     _monitor->stopListeningForConnections(true);     _monitor->stopListeningForConnections(true);
       if (_ip6Acceptor != NULL)
     //      {
     // Wait 150 milliseconds to allow time for the Monitor to stop          _ip6Acceptor->closeConnectionSocket();
     // listening for client connections.      }
     //      if (_ip4Acceptor != NULL)
     // This wait time is the timeout value for the select() call      {
     // in the Monitor's run() method (currently set to 100          _ip4Acceptor->closeConnectionSocket();
     // 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)  
     _acceptor->closeConnectionSocket();  
   
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 Uint32 CIMListenerService::getOutstandingRequestCount() Uint32 CIMListenerService::getOutstandingRequestCount()
 { {
     return _acceptor->getOutstandingRequestCount();      Uint32 cnt = 0;
   
       if (_ip6Acceptor)
       {
           cnt = _ip6Acceptor->getOutstandingRequestCount();
       }
   
       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;
 } }
  
 Uint32 CIMListenerService::getPortNumber() const Uint32 CIMListenerService::getPortNumber() const
 { {
   
     Uint32 portNumber = _portNumber;     Uint32 portNumber = _portNumber;
  
     if (( portNumber == 0 ) && ( _acceptor != 0 ))      if ((portNumber == 0) && (_ip6Acceptor != 0))
       {
           portNumber = _ip6Acceptor->getPortNumber();
       }
       else if ((portNumber == 0) && (_ip4Acceptor != 0))
     {     {
         portNumber = _acceptor->getPortNumber();          portNumber = _ip4Acceptor->getPortNumber();
     }     }
  
     return(portNumber);     return(portNumber);
 } }
  
 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL CIMListenerService::_listener_routine(void *param)  ThreadReturnType PEGASUS_THREAD_CDECL
   CIMListenerService::_listener_routine(void *param)
 { {
   try {      CIMListenerService *svc = reinterpret_cast < CIMListenerService * >(param);
     AutoPtr<CIMListenerService> svc(reinterpret_cast<CIMListenerService *>(param));  
  
       try
       {
     //svc->init(); bug 1394     //svc->init(); bug 1394
     while(!svc->terminated())     while(!svc->terminated())
     {     {
 #if defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)  #if defined(PEGASUS_OS_DARWIN)
         pthread_testcancel();         pthread_testcancel();
 #endif #endif
         svc->runForever();         svc->runForever();
     }     }
   } catch (...)      }
       catch(...)
   {   {
         Tracer::trace(TRC_SERVER, Tracer::LEVEL2,          PEG_TRACE_CSTRING(TRC_SERVER, Tracer::LEVEL1,
                         "Unknown exception thrown in _listener_routine.");                         "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;
   
     return 0;     return 0;
 } }
  
 /////////////////////////////////////////////////////////////////////////////  ////////////////////////////////////////////////////////////////////////////////
   //
 // CIMListenerRep // CIMListenerRep
 /////////////////////////////////////////////////////////////////////////////  //
   ////////////////////////////////////////////////////////////////////////////////
   
 class CIMListenerRep class CIMListenerRep
 { {
 public: public:
Line 365 
Line 443 
   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      stop();
     if (_thread_pool != 0)  
     {  
         // 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();  
     }  
  
     delete _sslContext;     delete _sslContext;
     delete _dispatcher;     delete _dispatcher;
Line 403 
Line 473 
     Uint32 portNumber;     Uint32 portNumber;
  
     if ( _svc == 0 )     if ( _svc == 0 )
     {  
         portNumber = _portNumber;         portNumber = _portNumber;
     }      else
     else portNumber = _svc->getPortNumber();          portNumber = _svc->getPortNumber();
  
     return portNumber;     return portNumber;
 } }
Line 427 
Line 496 
     // spawn a thread to do this     // spawn a thread to do this
     if(_thread_pool==0)     if(_thread_pool==0)
     {     {
         AutoPtr<CIMListenerService> svc(new CIMListenerService(_portNumber,_sslContext));          AutoPtr < CIMListenerService >
               svc(new CIMListenerService(_portNumber, _sslContext));
  
         svc->setIndicationDispatcher(_dispatcher);         svc->setIndicationDispatcher(_dispatcher);
         svc->init();         svc->init();
  
         struct timeval deallocateWait = {15, 0};         struct timeval deallocateWait = {15, 0};
         AutoPtr<ThreadPool> threadPool(new ThreadPool(0, "Listener", 0, 1, deallocateWait));          AutoPtr < ThreadPool >
               threadPool(new ThreadPool(0, "Listener", 0, 1, deallocateWait));
         AutoPtr<Semaphore> sem(new Semaphore(0));         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,          if (threadPool->allocate_and_awaken(
                         "Could not allocate thread for CIMListenerService::_listener_routine.");              svc.get(), CIMListenerService::_listener_routine, sem.get())
             throw Exception(MessageLoaderParms("Listener.CIMListener.CANNOT_ALLOCATE_THREAD",              != 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."));                                 "Could not allocate thread."));
         }         }
         Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER, Logger::INFORMATION,  
           Logger::put(
               Logger::STANDARD_LOG,
               System::CIMLISTENER,
               Logger::INFORMATION,
                         "CIMListener started");                         "CIMListener started");
  
         _svc = svc.release();         _svc = svc.release();
Line 475 
Line 555 
     // The thread could be delivering an export, so give it 3sec.     // The thread could be delivering an export, so give it 3sec.
     // Note that _listener_routine deletes the CIMListenerService,     // Note that _listener_routine deletes the CIMListenerService,
     // so no need to delete _svc.     // so no need to delete _svc.
     try          if (!_listener_sem->time_wait(3000))
     {  
       _listener_sem->time_wait(3000);  
     }  
     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 488 
Line 564 
     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 508 
Line 585 
 { {
         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);
Line 518 
Line 596 
   // Wait for 10 sec max   // Wait for 10 sec max
   Uint32 reqCount;   Uint32 reqCount;
   Uint32 countDown = shutdownTimeout * 10;   Uint32 countDown = shutdownTimeout * 10;
   
   for (; countDown > 0; countDown--)   for (; countDown > 0; countDown--)
   {   {
     reqCount = _svc->getOutstandingRequestCount();     reqCount = _svc->getOutstandingRequestCount();
     if (reqCount > 0)     if (reqCount > 0)
       pegasus_sleep(100);              Threads::sleep(100);
     else     else
       return true;       return true;
   }   }
Line 531 
Line 610 
 } }
  
 ///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
   //
 // 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 553 
Line 639 
 { {
         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();
Line 575 
Line 664 
 { {
         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.39  
changed lines
  Added in v.1.59
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2