indicationservice.h

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

                                           Modify Instance)
        @param   indicationSubclasses  the indication subclasses for the
                                           subscription
        @param   userName              the userName for authentication
        @param   authType              the authentication type
     */
    void _sendAsyncDeleteRequests (
        const Array <ProviderClassList> & indicationProviders,
        const CIMNamespaceName & nameSpace,
        const CIMInstance & subscription,
        const AcceptLanguageList & acceptLangs,
        const ContentLanguageList & contentLangs,
        const CIMRequestMessage * origRequest,
        const Array <CIMName> & indicationSubclasses,
        const String & userName,
        const String & authType = String::EMPTY);

    /**
        Sends Delete subscription request for the specified subscription
        to each provider in the list.  The requests are sent using SendWait,
        so no callback methods are required.  Delete Subscription requests are
        sent to the indication providers using SendWait in the following case:
        (1) on notification of a provider registration change newly preventing
        the provider from serving the subscription.  In case (1), there is an
        original Notify Provider Registration request to which the Indication
        Service must respond.

        @param   indicationProviders   list of providers with associated classes
        @param   nameSpace             the nameSpace name of the resource being
                                           monitored, from the SourceNamespace
                                           property of the CIM_IndicationFilter
                                           instance for the specified
                                           subscription
        @param   subscription          the subscription to be modified
        @param   acceptLangs           the language of the response
        @param   contentLangs          the language of the subscription
        @param   userName              the userName for authentication
        @param   authType              the authentication type
     */
    void _sendWaitDeleteRequests (
        const Array <ProviderClassList> & indicationProviders,
        const CIMNamespaceName & nameSpace,
        const CIMInstance & subscription,
        const AcceptLanguageList & acceptLangs,
        const ContentLanguageList & contentLangs,
        const String & userName,
        const String & authType = String::EMPTY);

    /**
        Collects responses from providers for aggregation as they are received,
        and stores them in the IndicationOperationAggregate instance.  Calls
        _handleOperationResponseAggregation to process the responses, once all
        expected responses have been received.

        @param  operation            shared data structure that controls message
                                         processing
        @param  destination          target queue of completion callback
        @param  userParameter        user parameter for callback processing
     */
    static void _aggregationCallBack (
        AsyncOpNode * operation,
        MessageQueue * destination,
        void * userParameter);

    /**
        Calls the appropriate function to processes responses from providers,
        based on the type of request sent to providers, once all responses have
        been received.

        @param   operationAggregate    the operation aggregate instance
     */
    void _handleOperationResponseAggregation (
        IndicationOperationAggregate * operationAggregate);

    /**
        Processes create subscription responses from providers, once all have
        been received.  Takes the appropriate action, based on the type of the
        original request, if any, and the responses received.  Sends the
        response to the original request, if required.

        @param   operationAggregate    the operation aggregate instance
     */
    void _handleCreateResponseAggregation (
        IndicationOperationAggregate * operationAggregate);

    /**
        Processes modify subscription responses from providers, once all have
        been received.  Updates the subscription hash tables.

        @param   operationAggregate    the operation aggregate instance
     */
    void _handleModifyResponseAggregation (
        IndicationOperationAggregate * operationAggregate);

    /**
        Processes delete subscription responses from providers, once all have
        been received.  Updates the subscription hash tables appropriately,
        based on the type of the original request, if any.  Sends the response
        to the original request, if required.

        @param   operationAggregate    the operation aggregate instance
     */
    void _handleDeleteResponseAggregation (
        IndicationOperationAggregate * operationAggregate);

    /**
        Creates an alert instance of the specified class.

        @param   alertClassName        the alert class name
        @param   subscriptions         subscriptions for which alert is to be
                                           created

        @return  the created alert instance
     */
    CIMInstance _createAlertInstance (
        const CIMName & alertClassName,
        const Array <CIMInstance> & subscriptions);

#if 0
     /**
	  Asynchronous completion routine for _sendAlerts
      */

      static void _sendAlertsCallBack(AsyncOpNode *operation,
				      MessageQueue *callback_destination,
				      void *parameter);

    /**
        Sends specified alert to each unique handler instance for the
        specified subscriptions in the list.

        @param   subscriptions         subscriptions for which alert is to be
                                           sent
        @param   alertInstance         the alert to be sent
     */
    void _sendAlerts (
        const Array <CIMInstance> & subscriptions,
        /* const */ CIMInstance & alertInstance);
#endif

    /**
        Sends a Subscription Init Complete request to the Provider
        Manager Service.
     */
    void _sendSubscriptionInitComplete ();

    /**
        Gets the value of the Creator property from the specified Subscription
        instance.  If this function returns False, the value of the creator
        parameter is unchanged.

        @param   instance              subscription instance
        @param   creator               value of Creator property if retrieved

        @return  True, if the value of the Creator property was retrieved;
                 False if Creator property was missing, null, or of an
                       incorrect type
     */
    Boolean _getCreator (
        const CIMInstance & instance,
        String & creator) const;

    /**
        Validates the specified SubscriptionState property value.

        @param   state                 SubscriptionState property value

        @return  True, if the SubscriptionState property value is valid;
                 False otherwise
     */
    Boolean _validateState (
        const Uint16 state) const;

    /**
        This function peforms an authorization test based on the
        value of the enableSubscriptionForNonprivilegedUsers.

        @param   userName                String

        @return  True, if authentication is not enabled or the
                       user is a privileged system user;
                 False, if authentication is enabled and the
                       user is not privileged
     */
    void _checkNonprivilegedAuthorization (
        const String & userName);

    /**
        Updates the propertyList, in preparation for calling the Repository.
        If the propertyList is not null, the Creator property must be added to
        the list.  Also, if the request is for the Subscription class, the
        value of the Time Remaining property need only be calculated if it is
        requested.  In that case, the Subscription Duration and Start Time
        properties must be added to the list if not already there.

        @param   className             class name for the request
        @param   propertyList          list of properties requested
        @param   setTimeRemaining      indicates whether Time Remaining property
                                       was requested
        @param   startTimeAdded        indicates whether Start Time property was
                                       added to the list
        @param   durationAdded         indicates whether Duration property was
                                       added to the list
     */
    void _updatePropertyList
        (CIMName & className,
         CIMPropertyList & propertyList,
         Boolean & setTimeRemaining,
         Boolean & startTimeAdded,
         Boolean & durationAdded);

    /**
        Gets a String containing the comma-separated Subscription Filter Name
        and Handler Name, for use in a log message to identify the subscription.

        @param   subscription          subscription instance

        @return  String containing the comma-separated Subscription Filter Name
                 and Handler Name
     */
    String _getSubscriptionLogString
        (CIMInstance & subscription);

    SubscriptionRepository* _subscriptionRepository;

    SubscriptionTable * _subscriptionTable;

    /**
        Handle to Provider Registration Manager
     */
    ProviderRegistrationManager * _providerRegManager;

    /**
        Pointer to CIMRepository, for use in building QueryExpression.
     */
    CIMRepository* _cimRepository;

    /**
        Integer representing queue ID for accessing Provider Manager Service
     */
    Uint32 _providerManager;

    /**
        Integer representing queue ID for accessing Handler Manager Service
     */
    Uint32 _handlerService;

    /**
        Boolean indicating that the CIM Server has been configured to
        allow non-privileged users read and write access to the
        Subscription classes.
     */
    Boolean _enableSubscriptionsForNonprivilegedUsers;

    /**
        Boolean indicating whether authentication is currently enabled in the
        CIM Server.
     */
    Boolean _authenticationEnabled;

    /**
	Gets the indication class specified by the subscription filter query.

	@param instance     the subscription instance

	@return CIMClass object for the indication class
    */
    CIMClass _getIndicationClass(
	const CIMInstance & instance);

    /**
        Arrays of valid and supported property values

        Notes:
        Valid values are defined by the CIM Event Schema MOF
        Supported values are a subset of the valid values
        Some valid values, as defined in the MOF, are not currently supported
            by the Pegasus IndicationService

        Supported Values
        SubscriptionState: Enabled, Disabled
        RepeatNotificationPolicy: Unknown, Other, None, Suppress, Delay
        OnFatalErrorPolicy: Ignore, Disable, Remove
        PersistenceType: Permanent, Transient
        SNMPVersion: SNMPv1 Trap, SNMPv2C Trap
     */
    Array <Uint16> _validStates;
    Array <Uint16> _validRepeatPolicies;
    Array <Uint16> _validErrorPolicies;
    Array <Uint16> _validPersistenceTypes;
    Array <Uint16> _validSNMPVersion;
    Array <Uint16> _supportedStates;
    Array <Uint16> _supportedRepeatPolicies;
    Array <Uint16> _supportedErrorPolicies;
    Array <Uint16> _supportedPersistenceTypes;
    Array <Uint16> _supportedSNMPVersion;

    /**
        Arrays of names of supported properties for each class
     */
    Array <CIMName> _supportedSubscriptionProperties;
    Array <CIMName> _supportedFormattedSubscriptionProperties;
    Array <CIMName> _supportedFilterProperties;
    Array <CIMName> _supportedCIMXMLHandlerProperties;
    Array <CIMName> _supportedCIMXMLListenerDestinationProperties;
    Array <CIMName> _supportedSNMPHandlerProperties;
    Array <CIMName> _supportedSyslogListenerDestinationProperties;
    Array <CIMName> _supportedEmailListenerDestinationProperties;
};

PEGASUS_NAMESPACE_END

#endif  /* Pegasus_IndicationService_h */