cimoperationrequestdispatcher.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

        response->setComplete(isComplete);

        Uint32 dest = poA->_dest;
        response->dest = dest;
        poA->resequenceResponse(*response);

        // now get the completion status of the response after it has been
        // resequenced. This will reset the completion status of the entire
        // message, not just this one thread coming through here.

        isComplete = response->isComplete();

        // can the destination service queue handle async responses ?
        // (i.e multiple responses from one request). Certain known ones
        // cannot handle it. Most notably, the internal client.

        MessageQueue* q = lookup(dest);
        const char* name = q ? q->getQueueName() : 0;
        Boolean isDestinationQueueAsync = !(name &&
            (strcmp(name, PEGASUS_QUEUENAME_BINARY_HANDLER) == 0 ||
             strcmp(name, PEGASUS_QUEUENAME_INTERNALCLIENT) == 0));

        // for non-async queues, we'll just keep appending until all responses
        // have come in

        if (isDestinationQueueAsync == false)
        {
            if (isComplete == false)
            {
                poA->appendResponse(response);
                return isComplete;
            }

            // need to reset the first response to complete if the
            // last one that came in was complete

            response->setComplete(true);
            response->setIndex(0);
        }

        if (isComplete)
        {
            _logOperation(poA->getRequest(), response);
        }

        // send it syncronously so that multiple responses will show up in the
        // receiving queue according to the order that we have set the response
        // index. If this was a single complete response, we could in theory
        // send it async (i.e SendForget), however, there is no need to make a
        // condition point based off this.

        if (q)
            q->enqueue(response);
        else throw UninitializedObjectException();
    }
    catch (...)
    {
        static const char failMsg[] =
            "Failed to resequence/aggregate/forward response";
        PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
            Logger::TRACE, String(func) + String(failMsg)));

        if (response->cimException.getCode() != CIM_ERR_SUCCESS)
            response->cimException =
                CIMException(CIM_ERR_FAILED, String(failMsg));
    }

    // after sending, the response has been deleted externally
    response = 0;

    return isComplete;
}

void CIMOperationRequestDispatcher::_handle_async_request(AsyncRequest* req)
{
    PEG_METHOD_ENTER(TRC_DISPATCHER,
        "CIMOperationRequestDispatcher::_handle_async_request");

    // pass legacy operations to handleEnqueue
    if (req->getType() == async_messages::ASYNC_LEGACY_OP_START)
    {
        req->op->processing();

        Message* message =
            static_cast<AsyncLegacyOperationStart*>(req)->get_action();

        handleEnqueue(message);

        PEG_METHOD_EXIT();
        return;
    }

    // pass all other operations to the default handler
    Base::_handle_async_request(req);
    PEG_METHOD_EXIT();
}

Boolean CIMOperationRequestDispatcher::_lookupInternalProvider(
    const CIMNamespaceName& nameSpace,
    const CIMName& className,
    String& service,
    String& provider)
{
    static AtomicInt _initialized(0);
    static Mutex _monitor;

    PEG_METHOD_ENTER(TRC_DISPATCHER,
        "CIMOperationRequestDispatcher::_lookupInternalProvider");
    // Clear the strings since used as test later. Poor code but true now

    service = String::EMPTY;
    provider = String::EMPTY;
    CIMNamespaceName _wild;
    if (_initialized.get() == 0)
    {
        AutoMutex autoMut(_monitor);
        if (_initialized.get() == 0)
        {
            _routing_table.insert_record(
                PEGASUS_CLASSNAME_CONFIGSETTING,
                PEGASUS_NAMESPACENAME_CONFIG,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_CONFIGPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME_AUTHORIZATION,
                PEGASUS_NAMESPACENAME_AUTHORIZATION,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_USERAUTHPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME_USER,
                PEGASUS_NAMESPACENAME_USER,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_USERAUTHPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME_SHUTDOWN,
                PEGASUS_NAMESPACENAME_SHUTDOWN,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_SHUTDOWNPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME___NAMESPACE,
                _wild,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_NAMESPACEPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

#ifdef PEGASUS_HAS_SSL
            _routing_table.insert_record(
                PEGASUS_CLASSNAME_CERTIFICATE,
                PEGASUS_NAMESPACENAME_CERTIFICATE,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_CERTIFICATEPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME_CRL,
                PEGASUS_NAMESPACENAME_CERTIFICATE,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_CERTIFICATEPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);
#endif

#ifndef PEGASUS_DISABLE_PERFINST
            _routing_table.insert_record(
                PEGASUS_CLASSNAME_CIMOMSTATDATA,
                PEGASUS_NAMESPACENAME_CIMOMSTATDATA,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_CIMOMSTATDATAPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);
#endif

#ifndef PEGASUS_DISABLE_CQL
            _routing_table.insert_record(
                PEGASUS_CLASSNAME_CIMQUERYCAPABILITIES,
                //PEGASUS_NAMESPACENAME_CIMQUERYCAPABILITIES,
                _wild,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_CIMQUERYCAPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);
#endif

#if !defined(PEGASUS_DISABLE_PERFINST) || defined(PEGASUS_ENABLE_SLP)
            // InteropProvider ObjectManager Class
            _routing_table.insert_record(
                PEGASUS_CLASSNAME_PG_OBJECTMANAGER,
                PEGASUS_NAMESPACENAME_INTEROP,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            // CIM_Namespace - Implemented to assure that it does not
            // access the repository and to allow  access to
            // common class CIM_Namespace for namespace creation.
            _routing_table.insert_record(
                PEGASUS_CLASSNAME_CIMNAMESPACE,
                _wild,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            // PG_NAMESPACE - Implements subclass of CIM_Namespace managed by
            // InteropProvider.
            _routing_table.insert_record(
                PEGASUS_CLASSNAME_PGNAMESPACE,
                _wild,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);
#endif

#ifdef PEGASUS_ENABLE_SLP
            _routing_table.insert_record(
                PEGASUS_CLASSNAME_PG_CIMXMLCOMMUNICATIONMECHANISM,
                PEGASUS_NAMESPACENAME_INTEROP,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME_PG_COMMMECHANISMFORMANAGER,
                PEGASUS_NAMESPACENAME_INTEROP,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME_PG_COMPUTERSYSTEM,
                PEGASUS_NAMESPACENAME_INTEROP,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME_PG_HOSTEDOBJECTMANAGER,
                PEGASUS_NAMESPACENAME_INTEROP,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME_PG_HOSTEDACCESSPOINT,
                PEGASUS_NAMESPACENAME_INTEROP,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME_PG_NAMESPACEINMANAGER,
                PEGASUS_NAMESPACENAME_INTEROP,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE,
                PEGASUS_NAMESPACENAME_INTEROP,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME_PG_REGISTEREDSUBPROFILE,
                PEGASUS_NAMESPACENAME_INTEROP,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME_PG_REFERENCEDPROFILE,
                PEGASUS_NAMESPACENAME_INTEROP,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                PEGASUS_CLASSNAME_PG_REGISTEREDSUBPROFILE,
                PEGASUS_NAMESPACENAME_INTEROP,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,
                PEGASUS_QUEUENAME_CONTROLSERVICE);

            _routing_table.insert_record(
                 PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE,
                _wild,
                DynamicRoutingTable::INTERNAL,
                0,
                static_cast<MessageQueueService*>(
                    MessageQueue::lookup(PEGASUS_QUEUENAME_CONTROLSERVICE)),
                PEGASUS_MODULENAME_INTEROPPROVIDER,