pegasus/src/Pegasus/Listener/CIMListener.cpp - diff

Return to CIMListener.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Listener

Diff for /pegasus/src/Pegasus/Listener/CIMListener.cpp between version 1.4 and 1.19

version 1.4, 2002/06/03 19:32:35

version 1.19, 2004/05/21 20:57:00

Line 1

//%/////////////////////////////////////////////////////////////////////////////

//%2003////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Company, L. P., IBM Corp., The Open Group, Tivoli Systems.

// IBM Corp.; EMC 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"), to

Line 21

Line 23

//==============================================================================

// Author: Mike Brasher (mbrasher@bmc.com)

// Author: Dong Xiang, EMC Corporation (xiang_dong@emc.com)

// Modified By:

// Modified By: Dan Gorey (djgorey@us.ibm.com)

// 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 <cassert>

#include <Pegasus/Common/SSLContext.h>

#include <cstdio>

#include <Pegasus/Common/Monitor.h>

#include <cctype>

#include <ctime>

#include <Pegasus/Common/FileSystem.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/CIMExportRequestDecoder.h>

#include "CIMListener.h"

#include <Pegasus/Consumer/CIMIndicationConsumer.h>

#include <Pegasus/Listener/CIMListenerIndicationDispatcher.h>

#define DDD(X) // X

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;

#ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT

Monitor* _monitor;

HTTPAcceptor* _acceptor;

#else

monitor_2* _monitor;

pegasus_acceptor* _acceptor;

#endif

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)

{

}

PEGASUS_USING_STD;

CIMListenerService::CIMListenerService(CIMListenerService& svc)

:_portNumber(svc._portNumber)

,_sslContext(svc._sslContext)

,_monitor(NULL)

,_acceptor(NULL)

,_dieNow(svc._dieNow)

,_dispatcher(NULL)

,_responseEncoder(NULL)

,_requestDecoder(NULL)

{

}

CIMListenerService::~CIMListenerService()

{

// if port is alive, clean up the port

//if(_sslContext!=NULL)

// delete _sslContext;

PEGASUS_NAMESPACE_BEGIN

if(_responseEncoder!=NULL)

delete _responseEncoder;

if(_requestDecoder!=NULL)

delete _requestDecoder;

CIMListener::CIMListener(

//if(_dispatcher!=NULL)

Monitor* monitor,

// delete _dispatcher;

const String& rootPath,

Boolean dynamicReg,

if(_monitor!=NULL)

Boolean staticConsumers,

delete _monitor;

Boolean persistence)

: _dieNow(false), _rootPath(rootPath),

if(_acceptor!=NULL)

_dynamicReg(dynamicReg),

delete _acceptor;

_staticConsumers(staticConsumers),

}

_persistence(persistence)

void CIMListenerService::init()

{

PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::CIMListener()");

PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::init");

// -- Save the monitor or create a new one:

#ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT

_monitor = new Monitor(true);

#else

_monitor = new monitor_2();

#endif

//_dispatcher = new CIMListenerIndicationDispatcher();

_responseEncoder = new CIMExportResponseEncoder();

_requestDecoder = new CIMExportRequestDecoder(

_dispatcher,

_responseEncoder->getQueueId());

#ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT

_acceptor = new HTTPAcceptor(

_monitor,

_requestDecoder,

false,

_portNumber,

_sslContext,

false);

#else

_acceptor = new pegasus_acceptor(_monitor,

_requestDecoder,

false,

_portNumber,

_sslContext);

#endif

_monitor = monitor;

bind();

// -- Create a CIMListenerState object:

PEG_METHOD_EXIT();

}

void CIMListenerService::bind()

{

if(_acceptor!=NULL)

{ // Bind to the port

_acceptor->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);

_cimExportRequestDispatcher

}

= new CIMExportRequestDispatcher(dynamicReg, staticConsumers, persistence);

}

void CIMListenerService::runForever()

{

static int modulator = 0;

_cimExportResponseEncoder

if(!_dieNow)

= new CIMExportResponseEncoder;

{

#ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT

if(false == _monitor->run(100))

{

modulator++;

if(!(modulator % 5000) )

{

try

{

//MessageQueueService::_check_idle_flag = 1;

//MessageQueueService::_polling_sem.signal();

MessageQueueService::get_thread_pool()->kill_idle_threads();

}

catch(...)

{

}

if (handleShutdownSignal)

{

Tracer::trace(TRC_SERVER, Tracer::LEVEL3,

"CIMServer::runForever - signal received. Shutting down.");

_cimExportRequestDecoder = new CIMExportRequestDecoder(

ShutdownService::getInstance(this)->shutdown(true, 10, false);

_cimExportRequestDispatcher,

handleShutdownSignal = false;

_cimExportResponseEncoder->getQueueId());

}

#else

_monitor->run();

#endif

}

SSLContext * sslcontext = NULL;

void CIMListenerService::shutdown()

{

PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::shutdown()");

_acceptor = new HTTPAcceptor(_monitor, _cimExportRequestDecoder, sslcontext);

_dieNow = true;

PEG_METHOD_EXIT();

}

CIMListener::~CIMListener()

void CIMListenerService::resume()

{

PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::~CIMListener()");

PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::resume()");

// Note: do not delete the acceptor because it belongs to the Monitor

if(_acceptor!=NULL)

// which takes care of disposing of it.

_acceptor->reopenConnectionSocket();

PEG_METHOD_EXIT();

}

void CIMListener::bind(Uint32 port)

void CIMListenerService::stopClientConnection()

{

PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::bind()");

PEG_METHOD_ENTER(TRC_LISTENER, "CIMListenerService::stopClientConnection()");

// not the best place to build the service url, but it works for now

// tell Monitor to stop listening for client connections

// because the address string is accessible mdday

#ifdef PEGASUS_USE_23HTTPMONITOR_CLIENT

_monitor->stopListeningForConnections();

#else

_monitor->stop();

#endif

_acceptor->bind(port);

// Wait 150 milliseconds to allow time for the Monitor to stop

// listening for client connections.

// This wait time is the timeout value for the select() call

// in the Monitor's run() method (currently set to 100

// milliseconds) plus a delta of 50 milliseconds. The reason

// for the wait here is to make sure that the Monitor entries

// are updated before closing the connection sockets.

pegasus_sleep(150);

if(_acceptor!=NULL)

_acceptor->closeConnectionSocket();

PEG_METHOD_EXIT();

}

void CIMListener::runForever()

CIMListenerIndicationDispatcher* CIMListenerService::getIndicationDispatcher() const

{

//ATTN: Do not add Trace code in this method.

return _dispatcher;

if(!_dieNow)

}

_monitor->run(100);

void CIMListenerService::setIndicationDispatcher(CIMListenerIndicationDispatcher* dispatcher)

{

_dispatcher = dispatcher;

}

void CIMListener::stopClientConnection()

PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL CIMListenerService::_listener_routine(void *param)

{

PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::stopClientConnection()");

CIMListenerService *svc = reinterpret_cast<CIMListenerService *>(param);

_acceptor->closeConnectionSocket();

// svc->init(); bug 1394

while(!svc->terminated())

{

#if defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)

pthread_testcancel();

#endif

svc->runForever();

}

delete svc;

PEG_METHOD_EXIT();

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

{

public:

CIMListenerRep(Uint32 portNumber, SSLContext* sslContext=NULL);

~CIMListenerRep();

Uint32 getPortNumber() const;

SSLContext* getSSLContext() const;

void setSSLContext(SSLContext* sslContext);

void start();

void stop();

Boolean isAlive();

void CIMListener::shutdown()

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()

{

PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::shutdown()");

// if port is alive, clean up the port

if(_sslContext!=NULL)

delete _sslContext;

_dieNow = true;

if(_dispatcher!=NULL)

delete _dispatcher;

PEG_METHOD_EXIT();

if(_thread_pool!=NULL)

delete _thread_pool;

}

void CIMListener::resume()

Uint32 CIMListenerRep::getPortNumber() const

{

PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::resume()");

return _portNumber;

}

_acceptor->reopenConnectionSocket();

SSLContext* CIMListenerRep::getSSLContext() const

{

return _sslContext;

}

void CIMListenerRep::setSSLContext(SSLContext* sslContext)

{

if(_sslContext!=NULL)

delete _sslContext;

PEG_METHOD_EXIT();

_sslContext = sslContext;

}

void CIMListenerRep::start()

{

// spawn a thread to do this

if(_thread_pool==NULL)

{

CIMListenerService* svc = new CIMListenerService(_portNumber,_sslContext);

try

{

// Try to initialize the service (bug 1394)

svc->setIndicationDispatcher(_dispatcher);

svc->init();

}

catch(...)

{

// Error. Exit without creating the ThreadPool, so that this listener

// is not 'alive'

delete svc;

throw;

}

_thread_pool = new ThreadPool(0, "Listener", 0, 1,

create_time, destroy_time, deadlock_time);

_thread_pool->allocate_and_awaken(svc,CIMListenerService::_listener_routine);

Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER,

Logger::INFORMATION,

"CIMListener started");

CIMExportRequestDispatcher* CIMListener::getDispatcher()

PEGASUS_STD(cerr) << "CIMlistener started" << PEGASUS_STD(endl);

}

void CIMListenerRep::stop()

{

PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::getDispatcher()");

if(_thread_pool!=NULL)

{ // stop the thread

PEG_METHOD_EXIT();

delete _thread_pool;

_thread_pool = NULL;

return _cimExportRequestDispatcher;

Logger::put(Logger::STANDARD_LOG,System::CIMLISTENER,

Logger::INFORMATION,

"CIMListener stopped");

}

Uint32 CIMListener::getOutstandingRequestCount()

Boolean CIMListenerRep::isAlive()

{

PEG_METHOD_ENTER(TRC_SERVER, "CIMListener::getOutstandingRequestCount()");

return (_thread_pool!=NULL)?true:false;

}

PEG_METHOD_EXIT();

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 static_cast<CIMListenerRep*>(_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();

}

return (_acceptor->getOutstandingRequestCount());

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

Legend:

Removed from v.1.4
changed lines
	Added in v.1.19

No CVS admin address has been configured