pegasus/src/Pegasus/Common/MessageQueueService.cpp - diff

Return to MessageQueueService.cpp CVS log

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

Diff for /pegasus/src/Pegasus/Common/MessageQueueService.cpp between version 1.79 and 1.88.2.2

version 1.79, 2003/10/15 13:59:35

version 1.88.2.2, 2005/04/14 21:12:01

Line 1

//%////-*-c++-*-////////////////////////////////////////////////////////////////

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

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

Line 30

// Author: Mike Day (mdday@us.ibm.com)

// Modified By:

// Amit K Arora, IBM (amita@in.ibm.com) for Bug#1090

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

Line 54

Line 61

return _thread_pool;

}

void unload_idle_providers(void);

PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL MessageQueueService::kill_idle_threads(void *parm)

{

Line 75

Line 80

}

exit_thread((PEGASUS_THREAD_RETURN)dead_threads);

return (PEGASUS_THREAD_RETURN)dead_threads;

#ifdef PEGASUS_POINTER_64BIT

return (PEGASUS_THREAD_RETURN)(Uint64)dead_threads;

#elif PEGASUS_PLATFORM_AIX_RS_IBMCXX

return (PEGASUS_THREAD_RETURN)(unsigned long)dead_threads;

#else

return (PEGASUS_THREAD_RETURN)(Uint32)dead_threads;

#endif

}

Line 159

Line 170

if(_check_idle_flag.value() != 0 )

{

_check_idle_flag = 0;

Thread th(kill_idle_threads, 0, true);

th.run();

// If there are insufficent resources to run

// kill_idle_threads, then just return.

_thread_pool->allocate_and_awaken(service, kill_idle_threads);

}

myself->exit_self( (PEGASUS_THREAD_RETURN) 1 );

Line 195

Line 208

_default_op_timeout.tv_sec = 30;

_default_op_timeout.tv_usec = 100;

_meta_dispatcher_mutex.lock(pegasus_thread_self());

AutoMutex autoMut(_meta_dispatcher_mutex);

if( _meta_dispatcher == 0 )

{

_stop_polling = 0;

PEGASUS_ASSERT( _service_count.value() == 0 );

_meta_dispatcher = new cimom();

if (_meta_dispatcher == NULL )

{

_meta_dispatcher_mutex.unlock();

throw NullPointer();

}

_thread_pool = new ThreadPool(0, "MessageQueueService", 0, 0,

Line 212

Line 225

_polling_thread = new Thread(polling_routine,

reinterpret_cast<void *>(&_polling_list),

false);

_polling_thread->run();

while (!_polling_thread->run())

{

pegasus_yield();

}

_service_count++;

if( false == register_service(name, _capabilities, _mask) )

{

_meta_dispatcher_mutex.unlock();

//l10n

//throw BindFailedException("MessageQueueService Base Unable to register with Meta Dispatcher");

MessageLoaderParms parms("Common.MessageQueueService.UNABLE_TO_REGISTER",

Line 229

Line 244

_polling_list.insert_last(this);

_meta_dispatcher_mutex.unlock();

// _meta_dispatcher_mutex.unlock(); //Bug#1090

// _callback_thread.run();

// _req_thread.run();

Line 246

Line 261

}

_callback_ready.signal();

_meta_dispatcher_mutex.lock(pegasus_thread_self());

{

AutoMutex autoMut(_meta_dispatcher_mutex);

_service_count--;

if (_service_count.value() == 0 )

{

Line 263

Line 279

delete _thread_pool;

_thread_pool = 0;

}

_meta_dispatcher_mutex.unlock();

} // mutex unlocks here

_polling_list.remove(this);

// Clean up in case there are extra stuff on the queue.

while (_incoming.count())

Line 302

Line 318

void MessageQueueService::enqueue(Message *msg) throw(IPCException)

void MessageQueueService::enqueue(Message *msg)

{

PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE, "MessageQueueService::enqueue()");

Line 678

Line 694

{

MessageQueueService *service = static_cast<MessageQueueService *>(req->op->_service_ptr);

PEGASUS_STD(cout) << service->getQueueName() << " Received AsyncIoctl::IO_CLOSE " << PEGASUS_STD(endl);

#ifdef MESSAGEQUEUESERVICE_DEBUG

PEGASUS_STD(cout) << service->getQueueName() << " Received AsyncIoctl::IO_CLOSE " << PEGASUS_STD(endl);

#endif

// respond to this message. this is fire and forget, so we don't need to delete anything.

// this takes care of two problems that were being found

Line 727

Line 745

void MessageQueueService::handle_CimServiceStart(CimServiceStart *req)

{

#ifdef MESSAGEQUEUESERVICE_DEBUG

PEGASUS_STD(cout) << getQueueName() << "received START" << PEGASUS_STD(endl);

#endif

// clear the stoped bit and update

_capabilities &= (~(module_capabilities::stopped));

Line 738

Line 758

}

void MessageQueueService::handle_CimServiceStop(CimServiceStop *req)

{

#ifdef MESSAGEQUEUESERVICE_DEBUG

PEGASUS_STD(cout) << getQueueName() << "received STOP" << PEGASUS_STD(endl);

#endif

// set the stopeed bit and update

_capabilities |= module_capabilities::stopped;

_make_response(req, async_results::CIM_STOPPED);

Line 964

Line 986

Boolean destroy_op = false;

if (request->op == false)

if (request->op == 0)

{

request->op = get_op();

request->op->_request.insert_first(request);

Line 1163

Line 1185

{

static Mutex _monitor;

Uint32 value;

_monitor.lock(pegasus_thread_self());

AutoMutex autoMut(_monitor);

_xid++;

value = _xid.value();

_monitor.unlock();

return value;

}

Legend:

Removed from v.1.79
changed lines
	Added in v.1.88.2.2

No CVS admin address has been configured