(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.30 and 1.40.2.1

version 1.30, 2005/04/01 17:26:54 version 1.40.2.1, 2006/09/19 18:29:19
Line 1 
Line 1 
 //%2005////////////////////////////////////////////////////////////////////////  //%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.
Line 8 
Line 8 
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 // EMC Corporation; VERITAS Software Corporation; The Open Group. // 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 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // 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)  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "CIMListener.h" #include "CIMListener.h"
Line 42 
Line 38 
 #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>
Line 81 
Line 78 
  
         /** 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 102 
Line 99 
          */          */
         void setIndicationDispatcher(CIMListenerIndicationDispatcher* dispatcher);         void setIndicationDispatcher(CIMListenerIndicationDispatcher* dispatcher);
  
           /** Returns the port number being used.
            */
           Uint32 getPortNumber() const;
   
         static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _listener_routine(void *param);         static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _listener_routine(void *param);
  
 private: private:
Line 145 
Line 146 
 CIMListenerService::~CIMListenerService() CIMListenerService::~CIMListenerService()
 { {
         // if port is alive, clean up the port         // if port is alive, clean up the port
         //if(_sslContext!=NULL)  
         //      delete _sslContext;         //      delete _sslContext;
  
         if(_responseEncoder!=NULL)  
                 delete _responseEncoder;                 delete _responseEncoder;
  
         if(_requestDecoder!=NULL)  
                 delete _requestDecoder;                 delete _requestDecoder;
  
         //if(_dispatcher!=NULL)  
         //      delete _dispatcher;         //      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");
  
   _monitor = new Monitor();    if(NULL == _monitor) _monitor = new Monitor();
  
         //_dispatcher = new CIMListenerIndicationDispatcher();         //_dispatcher = new CIMListenerIndicationDispatcher();
  
   _responseEncoder = new CIMExportResponseEncoder();    if(NULL == _responseEncoder) _responseEncoder = new CIMExportResponseEncoder();
   _requestDecoder = new CIMExportRequestDecoder(    if(NULL == _requestDecoder) _requestDecoder = new CIMExportRequestDecoder(
                 _dispatcher,                                        _dispatcher,_responseEncoder->getQueueId());
                 _responseEncoder->getQueueId());  
  
   _acceptor = new HTTPAcceptor(    if(NULL == _acceptor) _acceptor = new HTTPAcceptor(
                  _monitor,                  _monitor,
                  _requestDecoder,                  _requestDecoder,
                  false,                  false,
Line 189 
Line 183 
  
   PEG_METHOD_EXIT();   PEG_METHOD_EXIT();
 } }
   
 void CIMListenerService::bind() void CIMListenerService::bind()
 { {
   if(_acceptor!=NULL)   if(_acceptor!=NULL)
     { // Bind to the port     { // Bind to the port
       _acceptor->bind();       _acceptor->bind();
  
       PEGASUS_STD(cout) << "Listening on HTTP port " << _portNumber << PEGASUS_STD(endl);  
   
       //listener.addAcceptor(false, portNumberHttp, false);       //listener.addAcceptor(false, portNumberHttp, false);
       Logger::put(Logger::STANDARD_LOG, System::CIMLISTENER, Logger::INFORMATION,       Logger::put(Logger::STANDARD_LOG, System::CIMLISTENER, Logger::INFORMATION,
                         "Listening on HTTP port $0.", _portNumber);                         "Listening on HTTP port $0.", _portNumber);
Line 206 
Line 199 
  
 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;
           gettimeofday(&now, 0);
           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 290 
Line 274 
 { {
         return _dispatcher;         return _dispatcher;
 } }
   
 void CIMListenerService::setIndicationDispatcher(CIMListenerIndicationDispatcher* dispatcher) void CIMListenerService::setIndicationDispatcher(CIMListenerIndicationDispatcher* dispatcher)
 { {
         _dispatcher = dispatcher;         _dispatcher = dispatcher;
 } }
  
   Uint32 CIMListenerService::getPortNumber() const
   {
   
       Uint32 portNumber = _portNumber;
   
       if (( portNumber == 0 ) && ( _acceptor != 0 ))
       {
           portNumber = _acceptor->getPortNumber();
       }
   
       return(portNumber);
   }
   
 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL CIMListenerService::_listener_routine(void *param) PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL CIMListenerService::_listener_routine(void *param)
 { {
   CIMListenerService *svc = reinterpret_cast<CIMListenerService *>(param);    try {
       AutoPtr<CIMListenerService> svc(reinterpret_cast<CIMListenerService *>(param));
  
   //svc->init(); bug 1394   //svc->init(); bug 1394
   while(!svc->terminated())   while(!svc->terminated())
Line 307 
Line 306 
 #endif #endif
     svc->runForever();     svc->runForever();
   }   }
     } catch (...)
   delete svc;    {
           Tracer::trace(TRC_SERVER, Tracer::LEVEL2,
                           "Unknown exception thrown in _listener_routine.");
     }
   return 0;   return 0;
 } }
  
Line 356 
Line 357 
 ,_listener_sem(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();
Line 371 
Line 373 
     _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 388 
Line 383 
  
 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);          AutoPtr<CIMListenerService> svc(new CIMListenerService(_portNumber,_sslContext));
     try  
     {  
       // Try to initialize the service (bug 1394)  
       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;  
     }  
  
     struct timeval deallocateWait = {15, 0};     struct timeval deallocateWait = {15, 0};
     _thread_pool = new ThreadPool(0, "Listener", 0, 1, deallocateWait);          AutoPtr<ThreadPool> threadPool(new ThreadPool(0, "Listener", 0, 1, deallocateWait));
           AutoPtr<Semaphore> sem(new Semaphore(0));
     _listener_sem = new Semaphore(0);          if (threadPool->allocate_and_awaken(svc.get(), CIMListenerService::_listener_routine, sem.get()) != PEGASUS_THREAD_OK)
     _thread_pool->allocate_and_awaken(svc,          {
                                       CIMListenerService::_listener_routine,              Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
                                       _listener_sem);                          "Not enough threads to start CIMListernerService.");
   
     _svc = svc;              Tracer::trace(TRC_SERVER, Tracer::LEVEL2,
                           "Could not allocate thread for CIMListenerService::_listener_routine.");
     Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER,              throw Exception(MessageLoaderParms("Listener.CIMListener.CANNOT_ALLOCATE_THREAD",
                 Logger::INFORMATION,                                  "Could not allocate thread."));
           }
           Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER, 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 465 
Line 462 
     {     {
       _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 552 
Line 549 
         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();
 } }

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