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.12 and 1.29

version 1.12, 2003/10/22 14:26:11

version 1.29, 2005/03/10 00:38:21

Line 1

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

//%2005////////////////////////////////////////////////////////////////////////

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

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

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// 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"), to

Line 25

Line 29

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

// Modified By:

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

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

Line 101

Line 107

private:

Uint32 _portNumber;

SSLContext* _sslContext;

Monitor* _monitor;

HTTPAcceptor* _acceptor;

Boolean _dieNow;

CIMListenerIndicationDispatcher* _dispatcher;

Line 162

Line 168

{

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

_monitor = new Monitor(true);

_monitor = new Monitor();

//_dispatcher = new CIMListenerIndicationDispatcher();

_responseEncoder = new CIMExportResponseEncoder();

Line 175

Line 182

_requestDecoder,

false,

_portNumber,

_sslContext);

_sslContext,

false);

bind();

Line 195

Line 203

}

void CIMListenerService::runForever()

{

static int modulator = 0;

if(!_dieNow)

{

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

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

{

modulator++;

if(!(modulator % 5000) )

{

try

{

//MessageQueueService::_check_idle_flag = 1;

//MessageQueueService::_polling_sem.signal();

_monitor->kill_idle_threads();

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

}

catch(...)

{

}

if (handleShutdownSignal)

{

Line 235

Line 241

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

_dieNow = true;

_monitor->tickle();

PEG_METHOD_EXIT();

}

Line 254

Line 261

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

// tell Monitor to stop listening for client connections

_monitor->stopListeningForConnections();

_monitor->stopListeningForConnections(true);

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

Line 266

Line 273

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

// are updated before closing the connection sockets.

pegasus_sleep(150);

// pegasus_sleep(150); Not needed now due to the semaphore in the Monitor

if(_acceptor!=NULL)

_acceptor->closeConnectionSocket();

Line 274

Line 281

PEG_METHOD_EXIT();

}

Uint32 CIMListenerService::getOutstandingRequestCount()

{

return _acceptor->getOutstandingRequestCount();

}

CIMListenerIndicationDispatcher* CIMListenerService::getIndicationDispatcher() const

{

Line 288

Line 299

{

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

svc->init();

//svc->init(); bug 1394

while(!svc->terminated())

{

#if defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)

pthread_testcancel();

#endif

svc->runForever();

}

delete svc;

return 0;

}

static struct timeval create_time = {0, 1};

static struct timeval destroy_time = {15, 0};

static struct timeval deadlock_time = {0, 0};

/////////////////////////////////////////////////////////////////////////////

// CIMListenerRep

Line 324

Line 338

Boolean removeConsumer(CIMIndicationConsumer* consumer);

private:

Boolean waitForPendingRequests(Uint32 shutdownTimeout);

Uint32 _portNumber;

SSLContext* _sslContext;

CIMListenerIndicationDispatcher* _dispatcher;

ThreadPool* _thread_pool;

CIMListenerService* _svc;

Semaphore *_listener_sem;

};

CIMListenerRep::CIMListenerRep(Uint32 portNumber, SSLContext* sslContext)

Line 336

Line 354

,_sslContext(sslContext)

,_dispatcher(new CIMListenerIndicationDispatcher())

,_thread_pool(NULL)

,_svc(NULL)

,_listener_sem(NULL)

{

}

CIMListenerRep::~CIMListenerRep()

{

// if port is alive, clean up the port

if (_thread_pool != NULL)

{

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

}

if(_sslContext!=NULL)

delete _sslContext;

Line 349

Line 381

if(_thread_pool!=NULL)

delete _thread_pool;

if(_listener_sem!=NULL)

delete _listener_sem;

// don't delete _svc, this is deleted by _listener_routine

}

Uint32 CIMListenerRep::getPortNumber() const

Line 372

Line 409

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

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->allocate_and_awaken(svc,CIMListenerService::_listener_routine);

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

create_time, destroy_time);

_listener_sem = new Semaphore(0);

_thread_pool->allocate_and_awaken(svc,

CIMListenerService::_listener_routine,

_listener_sem);

_svc = svc;

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

Logger::INFORMATION,

Line 391

Line 445

void CIMListenerRep::stop()

{

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.

try

{

_listener_sem->time_wait(3000);

}

catch (TimeOut &)

{

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

_thread_pool = NULL;

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

Logger::INFORMATION,

Line 415

Line 501

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)

pegasus_sleep(100);

else

return true;

}

return false;

}

/////////////////////////////////////////////////////////////////////////////

// CIMListener

/////////////////////////////////////////////////////////////////////////////

Legend:

Removed from v.1.12
changed lines
	Added in v.1.29

No CVS admin address has been configured