cimoperationrequestdispatcher.h

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

        CIMCreateInstanceRequestMessage* request);

    void handleModifyClassRequest(
        CIMModifyClassRequestMessage* request);

    void handleModifyInstanceRequest(
        CIMModifyInstanceRequestMessage* request);

    void handleEnumerateClassesRequest(
        CIMEnumerateClassesRequestMessage* request);

    void handleEnumerateClassNamesRequest(
        CIMEnumerateClassNamesRequestMessage* request);

    void handleEnumerateInstancesRequest(
        CIMEnumerateInstancesRequestMessage* request);

    void handleEnumerateInstanceNamesRequest(
        CIMEnumerateInstanceNamesRequestMessage* request);

    void handleAssociatorsRequest(
        CIMAssociatorsRequestMessage* request);

    void handleAssociatorNamesRequest(
        CIMAssociatorNamesRequestMessage* request);

    void handleReferencesRequest(
        CIMReferencesRequestMessage* request);

    void handleReferenceNamesRequest(
        CIMReferenceNamesRequestMessage* request);

    void handleGetPropertyRequest(
        CIMGetPropertyRequestMessage* request);

    void handleSetPropertyRequest(
        CIMSetPropertyRequestMessage* request);

    void handleGetQualifierRequest(
        CIMGetQualifierRequestMessage* request);

    void handleSetQualifierRequest(
        CIMSetQualifierRequestMessage* request);

    void handleDeleteQualifierRequest(
        CIMDeleteQualifierRequestMessage* request);

    void handleEnumerateQualifiersRequest(
        CIMEnumerateQualifiersRequestMessage* request);

    void handleExecQueryRequest(
        CIMExecQueryRequestMessage* request);

    void handleInvokeMethodRequest(
        CIMInvokeMethodRequestMessage* request);

    static void _forwardForAggregationCallback(
        AsyncOpNode*,
        MessageQueue*,
        void*);

    static void _forwardRequestCallback(
        AsyncOpNode*,
        MessageQueue*,
        void*);

    // Response Handler functions

    void handleOperationResponseAggregation(OperationAggregate* poA);

    void handleReferencesResponseAggregation(OperationAggregate* poA);

    void handleReferenceNamesResponseAggregation(OperationAggregate* poA);

    void handleAssociatorsResponseAggregation(OperationAggregate* poA);

    void handleAssociatorNamesResponseAggregation(OperationAggregate* poA);

    void handleEnumerateInstancesResponseAggregation(OperationAggregate* poA);

    void handleEnumerateInstanceNamesResponseAggregation(
        OperationAggregate* poA);

    void handleExecQueryResponseAggregation(OperationAggregate* poA);

protected:

    /** _getSubClassNames - Gets the names of all subclasses of the defined
        class (including the class) and returns it in an array of strings. Uses
        a similar function in the repository class to get the names.
        @param namespace
        @param className
        @return Array of strings with class names.  Note that there should be
        at least one classname in the array (the input name)
        Note that there is a special exception to this function, the __namespace
        class which does not have any representation in the class repository.
        @exception CIMException(CIM_ERR_INVALID_CLASS)
    */
    Array<CIMName> _getSubClassNames(
        const CIMNamespaceName& nameSpace,
        const CIMName& className);

    Boolean _lookupInternalProvider(
        const CIMNamespaceName& nameSpace,
        const CIMName& className,
        String& service,
        String& provider);

    /* Boolean _lookupNewQueryProvider(
        const CIMNamespaceName& nameSpace,
        const CIMName& className,
        String& serviceName,
        String& controlProviderName,
        Boolean* notQueryProvider); */

    ProviderInfo _lookupNewInstanceProvider(
        const CIMNamespaceName& nameSpace,
        const CIMName& className);

    /* String _lookupQueryProvider(
        const CIMNamespaceName& nameSpace,
        const CIMName& className,
        Boolean* notQueryProvider); */

    ProviderInfo _lookupInstanceProvider(
        const CIMNamespaceName& nameSpace,
        const CIMName& className);

    /* Array<ProviderInfo> _lookupAllQueryProviders(
        const CIMNamespaceName& nameSpace,
        const CIMName& className,
        Uint32& providerCount); */

    // @exception CIMException
    Array<ProviderInfo> _lookupAllInstanceProviders(
        const CIMNamespaceName& nameSpace,
        const CIMName& className,
        Uint32& providerCount);

    Array<ProviderInfo> _lookupAllAssociationProviders(
        const CIMNamespaceName& nameSpace,
        const CIMObjectPath& objectName,
        const CIMName& assocClass,
        const String& role,
        Uint32& providerCount);

    Boolean _lookupNewAssociationProvider(
        const CIMNamespaceName& nameSpace,
        const CIMName& assocClass,
        String& serviceName,
        String& controlProviderName,
        ProviderIdContainer** container);

    Array<String> _lookupAssociationProvider(
        const CIMNamespaceName& nameSpace,
        const CIMName& assocClass,
        ProviderIdContainer** container);

    String _lookupMethodProvider(
        const CIMNamespaceName& nameSpace,
        const CIMName& className,
        const CIMName& methodName,
        ProviderIdContainer** providerIdContainer);

    void _forwardRequestToService(
        const String& serviceName,
        CIMRequestMessage* request,
        CIMRequestMessage* requestCopy);

    void _forwardRequestForAggregation(
        const String& serviceName,
        const String& controlProviderName,
        CIMRequestMessage* request,
        OperationAggregate* poA,
        CIMResponseMessage* response = 0);

    void _forwardRequestToProviderManager(
        const CIMName& className,
        const String& serviceName,
        const String& controlProviderName,
        CIMRequestMessage* request,
        CIMRequestMessage* requestCopy);

    void _getProviderName(
          const OperationContext& context,
          String& moduleName,
          String& providerName);

    void _logOperation(
        const CIMRequestMessage* request,
        const CIMResponseMessage* response);

    Boolean _enqueueResponse(
        OperationAggregate*& poA,
        CIMResponseMessage*& response);

    void _enqueueResponse(
        CIMRequestMessage* request,
        CIMResponseMessage* response);

    CIMValue _convertValueType(const CIMValue& value, CIMType type);

    void _fixInvokeMethodParameterTypes(CIMInvokeMethodRequestMessage* request);

    void _fixSetPropertyValueType(CIMSetPropertyRequestMessage* request);

    void _checkExistenceOfClass(
        const CIMNamespaceName& nameSpace,
        const CIMName& className,
        CIMException& cimException);

    CIMClass _getClass(
        const CIMNamespaceName& nameSpace,
        const CIMName& className,
        CIMException& cimException);

    CIMRepository* _repository;

    ProviderRegistrationManager* _providerRegistrationManager;

    Boolean _enableAssociationTraversal;
    Boolean _enableIndicationService;
    Uint32 _maximumEnumerateBreadth;
    static Uint64 cimOperationAggregationSN;

#ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
    Boolean _enableNormalization;
    Array<String> _excludeModulesFromNormalization;
#endif

    // << Tue Feb 12 08:48:09 2002 mdd >> meta dispatcher integration
    virtual void _handle_async_request(AsyncRequest* req);

    // the following two methods enable specific query language implementations

    /* void handleQueryRequest(
        CIMExecQueryRequestMessage* request);

    void handleQueryResponseAggregation(
        OperationAggregate* poA);

    void applyQueryToEnumeration(CIMResponseMessage* msg,
        QueryExpressionRep* query);
    */

private:
    static void _handle_enqueue_callback(AsyncOpNode*, MessageQueue*, void*);

};

PEGASUS_NAMESPACE_END

#endif /* PegasusDispatcher_Dispatcher_h */