(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.7 and 1.8

version 1.7, 2003/03/11 21:26:54 version 1.8, 2003/08/15 14:10:29
Line 21 
Line 21 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  // Author: Dong Xiang, EMC Corporation (xiang_dong@emc.com)
 // //
 // Modified By: // Modified By:
 //         Mike Day (mdday@us.ibm.com)s  
 //         Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)  
 //         Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)  
 //         Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)  
 //         Jenny Yu, Hewlett-Packard Company (jenny_yu@hp.com)  
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <Pegasus/Common/Config.h>  #include "CIMListener.h"
  
 #include <iostream>  #include <Pegasus/Common/Exception.h>
 #include <cstdio>  #include <Pegasus/Common/SSLContext.h>
 #include <cctype>  #include <Pegasus/Common/Monitor.h>
 #include <ctime>  
 #include <Pegasus/Common/FileSystem.h>  
 #include <Pegasus/Common/HTTPAcceptor.h> #include <Pegasus/Common/HTTPAcceptor.h>
 #include <Pegasus/Common/Tracer.h>  
 #include <Pegasus/Common/PegasusVersion.h>  
  
 #include <Pegasus/Repository/CIMRepository.h>  
 #include <Pegasus/ExportServer/CIMExportRequestDispatcher.h>  
 #include <Pegasus/ExportServer/CIMExportResponseEncoder.h> #include <Pegasus/ExportServer/CIMExportResponseEncoder.h>
 #include <Pegasus/ExportServer/CIMExportRequestDecoder.h> #include <Pegasus/ExportServer/CIMExportRequestDecoder.h>
  
 #include "CIMListener.h"  #include <Pegasus/Consumer/CIMIndicationConsumer.h>
   #include <Pegasus/Listener/CIMListenerIndicationDispatcher.h>
 #define DDD(X) // X  
   
 PEGASUS_USING_STD;  
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
   /////////////////////////////////////////////////////////////////////////////
   // CIMListenerService
   /////////////////////////////////////////////////////////////////////////////
   class CIMListenerService
   {
   public:
           CIMListenerService(Uint32 portNumber, SSLContext* sslContext=NULL);
           CIMListenerService(CIMListenerService& svc);
     ~CIMListenerService();
   
           void                            init();
           /** bind to the port
           */
           void                            bind();
           /** runForever Main runloop for the server.
           */
           void runForever();
   
           /** Call to gracefully shutdown the server.  The server connection socket
           will be closed to disable new connections from clients.
           */
           void stopClientConnection();
   
           /** Call to gracefully shutdown the server.  It is called when the server
           has been stopped and is ready to be shutdown.  Next time runForever()
           is called, the server shuts down.
           */
           void shutdown();
   
           /** Return true if the server has shutdown, false otherwise.
           */
           Boolean terminated() { return _dieNow; };
   
           /** Call to resume the sever.
           */
           void resume();
   
           /** Call to set the CIMServer state.  Also inform the appropriate
           message queues about the current state of the CIMServer.
           */
           void setState(Uint32 state);
   
           Uint32 getOutstandingRequestCount();
   
           /** Returns the indication listener dispatcher
            */
           CIMListenerIndicationDispatcher* getIndicationDispatcher() const;
   
     /** Returns the indication listener dispatcher
            */
           void setIndicationDispatcher(CIMListenerIndicationDispatcher* dispatcher);
   
           static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _listener_routine(void *param);
   
   private:
           Uint32                  _portNumber;
           SSLContext* _sslContext;
   
           Monitor*                                _monitor;
     HTTPAcceptor*   _acceptor;
           Boolean                                 _dieNow;
   
     CIMListenerIndicationDispatcher* _dispatcher;
   
     CIMExportResponseEncoder* _responseEncoder;
     CIMExportRequestDecoder*  _requestDecoder;
   
   };
   
   CIMListenerService::CIMListenerService(Uint32 portNumber, SSLContext* sslContext)
   :_portNumber(portNumber)
   ,_sslContext(sslContext)
   ,_monitor(NULL)
   ,_acceptor(NULL)
   ,_dieNow(false)
   ,_dispatcher(NULL)
   ,_responseEncoder(NULL)
   ,_requestDecoder(NULL)
   {
   }
  
 CIMListener::CIMListener(  CIMListenerService::CIMListenerService(CIMListenerService& svc)
     Monitor* monitor,  :_portNumber(svc._portNumber)
     const String& rootPath,  ,_sslContext(svc._sslContext)
     Boolean dynamicReg,  ,_monitor(NULL)
     Boolean staticConsumers,  ,_acceptor(NULL)
     Boolean persistence,  ,_dieNow(svc._dieNow)
     Uint32 portNumber)  ,_dispatcher(NULL)
     : _dieNow(false), _rootPath(rootPath),  ,_responseEncoder(NULL)
     _dynamicReg(dynamicReg),  ,_requestDecoder(NULL)
     _staticConsumers(staticConsumers),  
     _persistence(persistence),  
     _portNumber(portNumber)  
 { {
     PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::CIMListener()");  }
   CIMListenerService::~CIMListenerService()
   {
           // if port is alive, clean up the port
           //if(_sslContext!=NULL)
           //      delete _sslContext;
   
           if(_responseEncoder!=NULL)
                   delete _responseEncoder;
  
     // -- Save the monitor or create a new one:          if(_requestDecoder!=NULL)
                   delete _requestDecoder;
  
     _monitor = monitor;          //if(_dispatcher!=NULL)
           //      delete _dispatcher;
  
     // -- Create a CIMListenerState object:          if(_monitor!=NULL)
                   delete _monitor;
  
     _cimExportRequestDispatcher          if(_acceptor!=NULL)
         = new CIMExportRequestDispatcher(dynamicReg, staticConsumers, persistence);                  delete _acceptor;
   }
  
     _cimExportResponseEncoder  void CIMListenerService::init()
         = new CIMExportResponseEncoder;  {
           PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::init");
  
     _cimExportRequestDecoder = new CIMExportRequestDecoder(    _monitor = new Monitor(true);
         _cimExportRequestDispatcher,          //_dispatcher = new CIMListenerIndicationDispatcher();
         _cimExportResponseEncoder->getQueueId());  
  
     SSLContext * sslcontext = NULL;          _responseEncoder = new CIMExportResponseEncoder();
     _requestDecoder = new CIMExportRequestDecoder(
                   _dispatcher,
                   _responseEncoder->getQueueId());
   
           _acceptor = new HTTPAcceptor(
                    _monitor,
                    _requestDecoder,
                    false,
                    _portNumber,
                    _sslContext);
  
     _acceptor = new HTTPAcceptor(_monitor, _cimExportRequestDecoder, false, portNumber, sslcontext);          bind();
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
   void CIMListenerService::bind()
   {
           if(_acceptor!=NULL)
           { // Bind to the port
                   _acceptor->bind();
  
 CIMListener::~CIMListener()                  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);
   
           }
   }
   void CIMListenerService::runForever()
 { {
     PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::~CIMListener()");          static int modulator = 0;
  
     // Note: do not delete the acceptor because it belongs to the Monitor          if(!_dieNow)
     // which takes care of disposing of it.          {
                   if(false == _monitor->run(100))
                   {
                           modulator++;
                           if(!(modulator % 5000) )
                           {
                                   try
                                   {
                                           //MessageQueueService::_check_idle_flag = 1;
                                           //MessageQueueService::_polling_sem.signal();
                                           _monitor->kill_idle_threads();
                                   }
                                   catch(...)
                                   {
                                   }
                           }
                   }
   /*
                   if (handleShutdownSignal)
                   {
                           Tracer::trace(TRC_SERVER, Tracer::LEVEL3,
                                   "CIMServer::runForever - signal received.  Shutting down.");
  
     PEG_METHOD_EXIT();                          ShutdownService::getInstance(this)->shutdown(true, 10, false);
                           handleShutdownSignal = false;
                   }
   */
           }
 } }
  
 void CIMListener::bind()  void CIMListenerService::shutdown()
 { {
     PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::bind()");      PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::shutdown()");
  
     _acceptor->bind();      _dieNow = true;
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 void CIMListener::runForever()  void CIMListenerService::resume()
 { {
     //ATTN: Do not add Trace code in this method.      PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::resume()");
     if(!_dieNow)  
         _monitor->run(100);      if(_acceptor!=NULL)
           _acceptor->reopenConnectionSocket();
   
       PEG_METHOD_EXIT();
 } }
  
 void CIMListener::stopClientConnection()  void CIMListenerService::stopClientConnection()
 { {
     PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::stopClientConnection()");      PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::stopClientConnection()");
  
       if(_acceptor!=NULL)
     _acceptor->closeConnectionSocket();     _acceptor->closeConnectionSocket();
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 void CIMListener::shutdown()  
   CIMListenerIndicationDispatcher* CIMListenerService::getIndicationDispatcher() const
 { {
     PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::shutdown()");          return _dispatcher;
   }
   void CIMListenerService::setIndicationDispatcher(CIMListenerIndicationDispatcher* dispatcher)
   {
           _dispatcher = dispatcher;
   }
  
     _dieNow = true;  PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL CIMListenerService::_listener_routine(void *param)
   {
     CIMListenerService *svc = reinterpret_cast<CIMListenerService *>(param);
  
     PEG_METHOD_EXIT();          svc->init();
           while(!svc->terminated())
           {
             svc->runForever();
 } }
           delete svc;
  
 void CIMListener::resume()          return 0;
   }
   static struct timeval create_time = {0, 1};
   static struct timeval destroy_time = {15, 0};
   static struct timeval deadlock_time = {0, 0};
   
   /////////////////////////////////////////////////////////////////////////////
   // CIMListenerRep
   /////////////////////////////////////////////////////////////////////////////
   class CIMListenerRep
 { {
     PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::resume()");  public:
           CIMListenerRep(Uint32 portNumber, SSLContext* sslContext=NULL);
     ~CIMListenerRep();
  
     _acceptor->reopenConnectionSocket();          Uint32 getPortNumber() const;
  
     PEG_METHOD_EXIT();          SSLContext* getSSLContext() const;
           void setSSLContext(SSLContext* sslContext);
   
           void start();
           void stop();
   
           Boolean isAlive();
   
           Boolean addConsumer(CIMIndicationConsumer* consumer);
           Boolean removeConsumer(CIMIndicationConsumer* consumer);
   
   private:
           Uint32                  _portNumber;
           SSLContext* _sslContext;
   
     CIMListenerIndicationDispatcher* _dispatcher;
           ThreadPool* _thread_pool;
   };
   
   CIMListenerRep::CIMListenerRep(Uint32 portNumber, SSLContext* sslContext)
   :_portNumber(portNumber)
   ,_sslContext(sslContext)
   ,_dispatcher(new CIMListenerIndicationDispatcher())
   ,_thread_pool(NULL)
   {
   }
   CIMListenerRep::~CIMListenerRep()
   {
           // if port is alive, clean up the port
           if(_sslContext!=NULL)
                   delete _sslContext;
   
           if(_dispatcher!=NULL)
                   delete _dispatcher;
   
           if(_thread_pool!=NULL)
                   delete _thread_pool;
 } }
  
 Uint32 CIMListener::getOutstandingRequestCount()  Uint32 CIMListenerRep::getPortNumber() const
 { {
     PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::getOutstandingRequestCount()");          return _portNumber;
   }
  
     PEG_METHOD_EXIT();  SSLContext* CIMListenerRep::getSSLContext() const
   {
           return _sslContext;
   }
   void CIMListenerRep::setSSLContext(SSLContext* sslContext)
   {
           if(_sslContext!=NULL)
                   delete _sslContext;
   
           _sslContext = sslContext;
   }
   void CIMListenerRep::start()
   {
           // spawn a thread to do this
           if(_thread_pool==NULL)
           {
                   _thread_pool = new ThreadPool(0, "Listener", 0, 1,
                           create_time, destroy_time, deadlock_time);
   
                   CIMListenerService* svc = new CIMListenerService(_portNumber,_sslContext);
                   svc->setIndicationDispatcher(_dispatcher);
   
                   _thread_pool->allocate_and_awaken(svc,CIMListenerService::_listener_routine);
  
     return (_acceptor->getOutstandingRequestCount());                  Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER,
                                                 Logger::INFORMATION,
                                           "CIMListener started");
   
                   PEGASUS_STD(cerr) << "CIMlistener started" << PEGASUS_STD(endl);
           }
   }
   
   void CIMListenerRep::stop()
   {
           if(_thread_pool!=NULL)
           { // stop the thread
   
                   delete _thread_pool;
   
                   Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER,
                                                       Logger::INFORMATION,
                                                 "CIMListener stopped");
           }
   }
   
   Boolean CIMListenerRep::isAlive()
   {
           return (_thread_pool!=NULL)?true:false;
   }
   
   Boolean CIMListenerRep::addConsumer(CIMIndicationConsumer* consumer)
   {
           return _dispatcher->addConsumer(consumer);
   }
   Boolean CIMListenerRep::removeConsumer(CIMIndicationConsumer* consumer)
   {
           return _dispatcher->removeConsumer(consumer);
   }
   
   /////////////////////////////////////////////////////////////////////////////
   // CIMListener
   /////////////////////////////////////////////////////////////////////////////
   CIMListener::CIMListener(Uint32 portNumber, SSLContext* sslContext)
   :_rep(new CIMListenerRep(portNumber,sslContext))
   {
   }
   CIMListener::~CIMListener()
   {
           if(_rep!=NULL)
                   delete _rep;
           _rep=NULL;
   }
   
   Uint32 CIMListener::getPortNumber() const
   {
           return static_cast<CIMListenerRep*>(_rep)->getPortNumber();
   }
   
   SSLContext* CIMListener::getSSLContext() const
   {
           return static_cast<CIMListenerRep*>(_rep)->getSSLContext();
   }
   void CIMListener::setSSLContext(SSLContext* sslContext)
   {
           static_cast<CIMListenerRep*>(_rep)->setSSLContext(sslContext);
   }
   void CIMListener::start()
   {
           static_cast<CIMListenerRep*>(_rep)->start();
   }
   void CIMListener::stop()
   {
           static_cast<CIMListenerRep*>(_rep)->stop();
   }
   
   Boolean CIMListener::isAlive()
   {
           return static_cast<CIMListenerRep*>(_rep)->isAlive();
   }
   
   Boolean CIMListener::addConsumer(CIMIndicationConsumer* consumer)
   {
           return static_cast<CIMListenerRep*>(_rep)->addConsumer(consumer);
   }
   Boolean CIMListener::removeConsumer(CIMIndicationConsumer* consumer)
   {
           return static_cast<CIMListenerRep*>(_rep)->removeConsumer(consumer);
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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