pegasus/src/Pegasus/IndicationService/IndicationService.cpp - diff

Return to IndicationService.cpp CVS log

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

Diff for /pegasus/src/Pegasus/IndicationService/IndicationService.cpp between version 1.217 and 1.218

version 1.217, 2007/05/25 20:48:47

version 1.218, 2007/06/19 17:58:03

Line 49

#include <Pegasus/Common/ContentLanguageList.h>

#include <Pegasus/Common/LanguageParser.h>

#include <Pegasus/Common/OperationContextInternal.h>

// l10n

#include <Pegasus/Common/MessageLoader.h>

#include <Pegasus/Common/String.h>

#include <Pegasus/Common/IndicationFormatter.h>

// NOCHKSRC

#include <Pegasus/Server/ProviderRegistrationManager/ProviderRegistrationManager.h>

// DOCHKSRC

#include <Pegasus/Query/QueryExpression/QueryExpression.h>

#include <Pegasus/Query/QueryCommon/QueryException.h>

#include <Pegasus/Repository/RepositoryQueryContext.h>

Line 88

Line 89

IndicationService::IndicationService (

CIMRepository * repository,

ProviderRegistrationManager * providerRegManager)

: MessageQueueService (PEGASUS_QUEUENAME_INDICATIONSERVICE,

: MessageQueueService(

MessageQueue::getNextQueueId ()),

PEGASUS_QUEUENAME_INDICATIONSERVICE, MessageQueue::getNextQueueId()),

_providerRegManager (providerRegManager),

_cimRepository(repository)

{

Line 125

Line 126

// default to false (i.e., the more restrictive security

// setting.

PEG_TRACE_CSTRING(TRC_INDICATION_SERVICE, Tracer::LEVEL4,

"Failure attempting to read configuration parameters during initialization.");

"Failure attempting to read configuration parameters during "

"initialization.");

}

PEG_TRACE((TRC_INDICATION_SERVICE, Tracer::LEVEL4,

Line 155

Line 157

}

IndicationService::~IndicationService (void)

IndicationService::~IndicationService()

{

delete _subscriptionTable;

delete _subscriptionRepository;

Line 186

Line 188

{

req->op->processing();

Message *legacy =

(static_cast<AsyncLegacyOperationStart *>(req)->get_action());

static_cast<AsyncLegacyOperationStart *>(req)->get_action();

legacy->put_async(req);

handleEnqueue(legacy);

Line 194

Line 196

catch(Exception & )

{

PEG_TRACE_CSTRING(TRC_INDICATION_SERVICE, Tracer::LEVEL3,

"Caught Exception in IndicationService while handling a wrapped legacy message ");

"Caught Exception in IndicationService while handling a "

"wrapped legacy message ");

_make_response(req, async_results::CIM_NAK );

}

Line 212

Line 215

stopWatch.start();

#endif

// l10n

// Set the client's requested language into this service thread.

// This will allow functions in this service to return messages

// in the correct language.

Line 221

Line 223

{

if (msg->thread_changed())

{

AcceptLanguageList *langs = new AcceptLanguageList

AcceptLanguageList *langs = new AcceptLanguageList(

(((AcceptLanguageListContainer)msg->operationContext.get

((AcceptLanguageListContainer)msg->operationContext.get(

(AcceptLanguageListContainer::NAME)).getLanguages());

AcceptLanguageListContainer::NAME)).getLanguages());

Thread::setLanguages(langs);

}

Line 323

Line 325

stopWatch.stop();

PEG_TRACE((TRC_INDICATION_SERVICE_INTERNAL, Tracer::LEVEL2,

"%s: %.3f seconds", MessageTypeToString(message->getType()), stopWatch.getElapsed()));

"%s: %.3f seconds",

MessageTypeToString(message->getType()),

stopWatch.getElapsed()));

#endif

delete message;

}

void IndicationService::handleEnqueue(void)

void IndicationService::handleEnqueue()

{

Message * message = dequeue();

Line 337

Line 341

handleEnqueue(message);

}

void IndicationService::_initialize (void)

void IndicationService::_initialize()

{

PEG_METHOD_ENTER (TRC_INDICATION_SERVICE, "IndicationService::_initialize");

Line 425

Line 429

_supportedSubscriptionProperties.append (PEGASUS_PROPERTYNAME_HANDLER);

_supportedSubscriptionProperties.append (_PROPERTY_ONFATALERRORPOLICY);

_supportedSubscriptionProperties.append (_PROPERTY_OTHERONFATALERRORPOLICY);

_supportedSubscriptionProperties.append

_supportedSubscriptionProperties.append(

(_PROPERTY_FAILURETRIGGERTIMEINTERVAL);

_PROPERTY_FAILURETRIGGERTIMEINTERVAL);

_supportedSubscriptionProperties.append (PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE);

_supportedSubscriptionProperties.append(

PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE);

_supportedSubscriptionProperties.append (_PROPERTY_OTHERSTATE);

_supportedSubscriptionProperties.append (_PROPERTY_LASTCHANGE);

_supportedSubscriptionProperties.append (_PROPERTY_DURATION);

_supportedSubscriptionProperties.append (_PROPERTY_STARTTIME);

_supportedSubscriptionProperties.append (_PROPERTY_TIMEREMAINING);

_supportedSubscriptionProperties.append

_supportedSubscriptionProperties.append(_PROPERTY_REPEATNOTIFICATIONPOLICY);

(_PROPERTY_REPEATNOTIFICATIONPOLICY);

_supportedSubscriptionProperties.append(

_supportedSubscriptionProperties.append

_PROPERTY_OTHERREPEATNOTIFICATIONPOLICY);

(_PROPERTY_OTHERREPEATNOTIFICATIONPOLICY);

_supportedSubscriptionProperties.append(

_supportedSubscriptionProperties.append

_PROPERTY_REPEATNOTIFICATIONINTERVAL);

(_PROPERTY_REPEATNOTIFICATIONINTERVAL);

_supportedSubscriptionProperties.append (_PROPERTY_REPEATNOTIFICATIONGAP);

_supportedSubscriptionProperties.append (_PROPERTY_REPEATNOTIFICATIONCOUNT);

_supportedFormattedSubscriptionProperties =

_supportedSubscriptionProperties;

_supportedFormattedSubscriptionProperties.append

_supportedFormattedSubscriptionProperties.append(

(_PROPERTY_TEXTFORMATOWNINGENTITY);

_PROPERTY_TEXTFORMATOWNINGENTITY);

_supportedFormattedSubscriptionProperties.append

_supportedFormattedSubscriptionProperties.append(

(_PROPERTY_TEXTFORMATID);

_PROPERTY_TEXTFORMATID);

_supportedFormattedSubscriptionProperties.append

_supportedFormattedSubscriptionProperties.append(

(_PROPERTY_TEXTFORMAT);

_PROPERTY_TEXTFORMAT);

_supportedFormattedSubscriptionProperties.append

_supportedFormattedSubscriptionProperties.append(

(_PROPERTY_TEXTFORMATPARAMETERS);

_PROPERTY_TEXTFORMATPARAMETERS);

_supportedFilterProperties.append (_PROPERTY_CAPTION);

_supportedFilterProperties.append (_PROPERTY_DESCRIPTION);

Line 468

Line 472

commonListenerDestinationProperties.append (_PROPERTY_CAPTION);

commonListenerDestinationProperties.append (_PROPERTY_DESCRIPTION);

commonListenerDestinationProperties.append (_PROPERTY_ELEMENTNAME);

commonListenerDestinationProperties.append

commonListenerDestinationProperties.append(

(_PROPERTY_SYSTEMCREATIONCLASSNAME);

_PROPERTY_SYSTEMCREATIONCLASSNAME);

commonListenerDestinationProperties.append (_PROPERTY_SYSTEMNAME);

commonListenerDestinationProperties.append (PEGASUS_PROPERTYNAME_CREATIONCLASSNAME);

commonListenerDestinationProperties.append(

PEGASUS_PROPERTYNAME_CREATIONCLASSNAME);

commonListenerDestinationProperties.append (PEGASUS_PROPERTYNAME_NAME);

commonListenerDestinationProperties.append (PEGASUS_PROPERTYNAME_PERSISTENCETYPE);

commonListenerDestinationProperties.append(

PEGASUS_PROPERTYNAME_PERSISTENCETYPE);

commonListenerDestinationProperties.append (_PROPERTY_OTHERPERSISTENCETYPE);

_supportedCIMXMLHandlerProperties = commonListenerDestinationProperties;

_supportedCIMXMLHandlerProperties.append (_PROPERTY_OWNER);

_supportedCIMXMLHandlerProperties.append

_supportedCIMXMLHandlerProperties.append(

(PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION);

PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION);

_supportedCIMXMLListenerDestinationProperties =

commonListenerDestinationProperties;

_supportedCIMXMLListenerDestinationProperties.append

_supportedCIMXMLListenerDestinationProperties.append(

(PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION);

PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION);

_supportedSNMPHandlerProperties = commonListenerDestinationProperties;

_supportedSNMPHandlerProperties.append (_PROPERTY_OWNER);

_supportedSNMPHandlerProperties.append

_supportedSNMPHandlerProperties.append(

(PEGASUS_PROPERTYNAME_LSTNRDST_TARGETHOST);

PEGASUS_PROPERTYNAME_LSTNRDST_TARGETHOST);

_supportedSNMPHandlerProperties.append (_PROPERTY_TARGETHOSTFORMAT);

_supportedSNMPHandlerProperties.append (_PROPERTY_OTHERTARGETHOSTFORMAT);

_supportedSNMPHandlerProperties.append (_PROPERTY_PORTNUMBER);

Line 502

Line 508

_supportedEmailListenerDestinationProperties =

commonListenerDestinationProperties;

_supportedEmailListenerDestinationProperties.append

_supportedEmailListenerDestinationProperties.append(

(PEGASUS_PROPERTYNAME_LSTNRDST_MAILTO);

PEGASUS_PROPERTYNAME_LSTNRDST_MAILTO);

_supportedEmailListenerDestinationProperties.append

_supportedEmailListenerDestinationProperties.append(

(PEGASUS_PROPERTYNAME_LSTNRDST_MAILCC);

PEGASUS_PROPERTYNAME_LSTNRDST_MAILCC);

_supportedEmailListenerDestinationProperties.append

_supportedEmailListenerDestinationProperties.append(

(PEGASUS_PROPERTYNAME_LSTNRDST_MAILSUBJECT);

PEGASUS_PROPERTYNAME_LSTNRDST_MAILSUBJECT);

// Get existing active subscriptions from each namespace in the repository

invalidInstance = _subscriptionRepository->getActiveSubscriptions

invalidInstance = _subscriptionRepository->getActiveSubscriptions(

(activeSubscriptions);

activeSubscriptions);

noProviderSubscriptions.clear ();

PEG_TRACE((TRC_INDICATION_SERVICE, Tracer::LEVEL4,

Line 580

Line 586

// Append this subscription to no provider list and

// Insert entries into the subscription hash tables

if (!_subscriptionRepository->reconcileFatalError

if (!_subscriptionRepository->reconcileFatalError(

(activeSubscriptions [i]))

activeSubscriptions[i]))

{

noProviderSubscriptions.append (activeSubscriptions [i]);

Line 610

Line 616

continue;

}

//l10n start

// Get the language tags that were saved with the subscription instance

AcceptLanguageList acceptLangs;

Uint32 propIndex = instance.findProperty

Uint32 propIndex = instance.findProperty(

(PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS);

PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS);

if (propIndex != PEG_NOT_FOUND)

{

String acceptLangsString;

Line 626

Line 631

}

ContentLanguageList contentLangs;

propIndex = instance.findProperty

propIndex = instance.findProperty(

(PEGASUS_PROPERTYNAME_INDSUB_CONTENTLANGS);

PEGASUS_PROPERTYNAME_INDSUB_CONTENTLANGS);

if (propIndex != PEG_NOT_FOUND)

{

String contentLangsString;

Line 638

Line 643

contentLangsString);

}

// l10n end

// Send Create request message to each provider

Line 652

Line 656

// significant performance issue.

Array <ProviderClassList> acceptedProviders;

acceptedProviders = _sendWaitCreateRequests

acceptedProviders = _sendWaitCreateRequests(

(indicationProviders, sourceNameSpace,

indicationProviders, sourceNameSpace,

propertyList, condition, query, queryLanguage,

activeSubscriptions [i],

acceptLangs,

Line 673

Line 677

// If subscription is not disabled or removed, send alert and

// Insert entries into the subscription hash tables

if (!_subscriptionRepository->reconcileFatalError

if (!_subscriptionRepository->reconcileFatalError(

(activeSubscriptions [i]))

activeSubscriptions[i]))

{

// Insert entries into the subscription hash tables

_subscriptionTable->insertSubscription

_subscriptionTable->insertSubscription(

(activeSubscriptions [i],

activeSubscriptions[i],

acceptedProviders,

indicationSubclasses,

sourceNameSpace);

Line 695

Line 699

Array <CIMInstance> subscriptions;

subscriptions.append (activeSubscriptions [i]);

CIMInstance indicationInstance = _createAlertInstance

CIMInstance indicationInstance = _createAlertInstance(

(_CLASS_NO_PROVIDER_ALERT, subscriptions);

_CLASS_NO_PROVIDER_ALERT, subscriptions);

PEG_TRACE((TRC_INDICATION_SERVICE, Tracer::LEVEL4,

"Sending NoProvider Alert for %u subscriptions",

Line 707

Line 711

// Get Subscription Filter Name and Handler Name

String logString = _getSubscriptionLogString

String logString = _getSubscriptionLogString(

(activeSubscriptions [i]);

activeSubscriptions[i]);

// Log a message for the subscription

Line 716

Line 720

Logger::put_l (Logger::STANDARD_LOG, System::CIMSERVER,

Logger::WARNING, _MSG_NO_PROVIDER_KEY, _MSG_NO_PROVIDER,

logString,

activeSubscriptions[i].getPath().getNameSpace().getString());

activeSubscriptions[i].getPath().getNameSpace().

getString());

}

else

Line 725

Line 730

// At least one provider accepted the subscription

// Insert entries into the subscription hash tables

_subscriptionTable->insertSubscription

_subscriptionTable->insertSubscription(

(activeSubscriptions [i],

activeSubscriptions[i],

acceptedProviders,

indicationSubclasses,

sourceNameSpace);

Line 753

Line 758

// Send NoProviderAlertIndication to handler instances

// ATTN: NoProviderAlertIndication must be defined

CIMInstance indicationInstance = _createAlertInstance

CIMInstance indicationInstance = _createAlertInstance(

(_CLASS_NO_PROVIDER_ALERT, noProviderSubscriptions);

_CLASS_NO_PROVIDER_ALERT, noProviderSubscriptions);

PEG_TRACE((TRC_INDICATION_SERVICE, Tracer::LEVEL4,

"Sending NoProvider Alert for %u subscriptions",

Line 769

Line 774

// Get Subscription Filter Name and Handler Name

String logString = _getSubscriptionLogString

String logString =

(noProviderSubscriptions [i]);

_getSubscriptionLogString(noProviderSubscriptions[i]);

Logger::put_l (Logger::STANDARD_LOG, System::CIMSERVER,

Logger::put_l(

Logger::WARNING, _MSG_NO_PROVIDER_KEY, _MSG_NO_PROVIDER,

Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,

_MSG_NO_PROVIDER_KEY,

_MSG_NO_PROVIDER,

logString,

noProviderSubscriptions[i].getPath().getNameSpace().getString());

noProviderSubscriptions[i].getPath().getNameSpace().

getString());

}

Line 796

Line 804

PEG_METHOD_EXIT ();

}

void IndicationService::_terminate (void)

void IndicationService::_terminate()

{

PEG_METHOD_ENTER (TRC_INDICATION_SERVICE, "IndicationService::_terminate");

Line 819

Line 827

// Create CimomShutdownAlertIndication instance

// ATTN: CimomShutdownAlertIndication must be defined

indicationInstance = _createAlertInstance (_CLASS_CIMOM_SHUTDOWN_ALERT,

indicationInstance = _createAlertInstance(

activeSubscriptions);

_CLASS_CIMOM_SHUTDOWN_ALERT, activeSubscriptions);

// Send CimomShutdownAlertIndication to each unique handler instance

Line 863

Line 871

else

{

PEG_TRACE_STRING (TRC_INDICATION_SERVICE, Tracer::LEVEL4,

"_checkNonprivilegedAuthorization - checking whether user is privileged"

"_checkNonprivilegedAuthorization - checking whether user is "

"privileged"

+ userName);

if (!System::isPrivilegedUser(userName))

{

Line 902

Line 911

try

{

String userName = ((IdentityContainer)request->operationContext.get

String userName = ((IdentityContainer)request->operationContext.get(

(IdentityContainer :: NAME)).getUserName();

IdentityContainer::NAME)).getUserName();

_checkNonprivilegedAuthorization(userName);

AcceptLanguageList acceptLangs =

((AcceptLanguageListContainer)request->operationContext.get

((AcceptLanguageListContainer)request->operationContext.get(

(AcceptLanguageListContainer::NAME)).getLanguages();

AcceptLanguageListContainer::NAME)).getLanguages();

ContentLanguageList contentLangs =

((ContentLanguageListContainer)request->operationContext.get

((ContentLanguageListContainer)request->operationContext.get(

(ContentLanguageListContainer::NAME)).getLanguages();

ContentLanguageListContainer::NAME)).getLanguages();

if (_canCreate (instance, request->nameSpace))

{

Line 930

Line 939

Array <CIMName> indicationSubclasses;

Array <ProviderClassList> indicationProviders;

if ((instance.getClassName ().equal

if ((instance.getClassName().equal(

(PEGASUS_CLASSNAME_INDSUBSCRIPTION)) ||

PEGASUS_CLASSNAME_INDSUBSCRIPTION)) ||

(instance.getClassName ().equal

(instance.getClassName().equal(

(PEGASUS_CLASSNAME_FORMATTEDINDSUBSCRIPTION)))

PEGASUS_CLASSNAME_FORMATTEDINDSUBSCRIPTION)))

{

// Get subscription state

Line 944

Line 953

// the default value; if invalid, an exception was thrown

CIMValue subscriptionStateValue;

subscriptionStateValue = instance.getProperty

subscriptionStateValue = instance.getProperty(

(instance.findProperty (PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE)).getValue ();

instance.findProperty(

PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE)).getValue();

subscriptionStateValue.get (subscriptionState);

if ((subscriptionState == STATE_ENABLED) ||

Line 963

Line 973

PEG_METHOD_EXIT ();

// l10n

// throw PEGASUS_CIM_EXCEPTION (CIM_ERR_NOT_SUPPORTED,

// _MSG_NO_PROVIDERS);

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_NOT_SUPPORTED,

MessageLoaderParms(_MSG_NO_PROVIDERS_KEY,

_MSG_NO_PROVIDERS));

Line 975

Line 981

// Send Create request message to each provider

// l10n

_sendAsyncCreateRequests (indicationProviders,

sourceNameSpace, requiredProperties, condition,

query, queryLanguage, instance,

Line 995

Line 1000

// Create instance for disabled subscription

instanceRef = _subscriptionRepository->createInstance

instanceRef = _subscriptionRepository->createInstance(

(instance, request->nameSpace, userName,

instance, request->nameSpace, userName,

acceptLangs, contentLangs,

acceptLangs, contentLangs, false);

false);

}

else

Line 1006

Line 1010

// Create instance for filter or handler

instanceRef = _subscriptionRepository->createInstance

instanceRef = _subscriptionRepository->createInstance(

(instance, request->nameSpace, userName,

instance, request->nameSpace, userName,

acceptLangs, contentLangs,

acceptLangs, contentLangs, false);

false);

}

Line 1057

Line 1060

try

{

String userName = ((IdentityContainer)request->operationContext.get

String userName = ((IdentityContainer)request->operationContext.get(

(IdentityContainer :: NAME)).getUserName();

IdentityContainer::NAME)).getUserName();

_checkNonprivilegedAuthorization(userName );

Line 1077

Line 1080

// Get instance from repository

instance = _subscriptionRepository->getInstance

instance = _subscriptionRepository->getInstance(

(request->nameSpace, request->instanceName, request->localOnly,

request->nameSpace, request->instanceName, request->localOnly,

request->includeQualifiers, request->includeClassOrigin,

propertyList);

Line 1093

Line 1096

// L10N TODO DONE -- new throw of exception

PEG_METHOD_EXIT ();

//throw PEGASUS_CIM_EXCEPTION (CIM_ERR_FAILED,

//_MSG_INVALID_INSTANCES);

MessageLoaderParms parms(_MSG_INVALID_INSTANCES_KEY,

_MSG_INVALID_INSTANCES);

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);

}

instance.removeProperty (instance.findProperty

instance.removeProperty(instance.findProperty(

(PEGASUS_PROPERTYNAME_INDSUB_CREATOR));

PEGASUS_PROPERTYNAME_INDSUB_CREATOR));

// l10n start

// Remove the language properties from instance before returning

Uint32 propIndex = instance.findProperty

Uint32 propIndex = instance.findProperty(

(PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS);

PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS);

if (propIndex != PEG_NOT_FOUND)

{

instance.removeProperty (propIndex);

}

propIndex = instance.findProperty

propIndex = instance.findProperty(

(PEGASUS_PROPERTYNAME_INDSUB_CONTENTLANGS);

PEGASUS_PROPERTYNAME_INDSUB_CONTENTLANGS);

if (propIndex != PEG_NOT_FOUND)

{

// Get the content languages to be sent in the Content-Language header

// Get the content languages to be sent in the Content-Language

// header

instance.getProperty(propIndex).getValue().get(contentLangsString);

instance.removeProperty (propIndex);

}

// l10n end

// If a subscription with a duration, calculate subscription time

Line 1143

}

if (startTimeAdded)

{

instance.removeProperty (instance.findProperty

instance.removeProperty(instance.findProperty(

(_PROPERTY_STARTTIME));

_PROPERTY_STARTTIME));

}

if (durationAdded)

{

instance.removeProperty (instance.findProperty

instance.removeProperty(instance.findProperty(

(_PROPERTY_DURATION));

_PROPERTY_DURATION));

}

Line 1159

}

catch (Exception& exception)

{

cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

cimException =

exception.getMessage());

PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());

}

CIMGetInstanceResponseMessage * response = dynamic_cast

CIMGetInstanceResponseMessage * response =

<CIMGetInstanceResponseMessage *> (request->buildResponse ());

dynamic_cast<CIMGetInstanceResponseMessage *>(request->buildResponse());

response->cimException = cimException;

if (contentLangsString.size())

{

Line 1197

try

{

String userName = ((IdentityContainer)request->operationContext.get

String userName = ((IdentityContainer)request->operationContext.get(

(IdentityContainer :: NAME)).getUserName();

IdentityContainer::NAME)).getUserName();

_checkNonprivilegedAuthorization(userName);

Line 1218

request->includeQualifiers, request->includeClassOrigin,

propertyList);

// l10n

// Vars used to aggregate the content languages of the subscription

// instances.

Boolean langMismatch = false;

Line 1239

Line 1238

continue;

}

enumInstances [i].removeProperty

enumInstances[i].removeProperty(

(enumInstances [i].findProperty

enumInstances[i].findProperty(

(PEGASUS_PROPERTYNAME_INDSUB_CREATOR));

PEGASUS_PROPERTYNAME_INDSUB_CREATOR));

// l10n start

propIndex = enumInstances[i].findProperty(

propIndex = enumInstances [i].findProperty

PEGASUS_PROPERTYNAME_INDSUB_CONTENTLANGS);

(PEGASUS_PROPERTYNAME_INDSUB_CONTENTLANGS);

String contentLangs;

if (propIndex != PEG_NOT_FOUND)

{

enumInstances [i].getProperty(propIndex).getValue().get

enumInstances[i].getProperty(propIndex).getValue().get(

(contentLangs);

contentLangs);

enumInstances [i].removeProperty(propIndex);

}

propIndex = enumInstances [i].findProperty

propIndex = enumInstances[i].findProperty(

(PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS);

PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS);

if (propIndex != PEG_NOT_FOUND)

{

enumInstances [i].removeProperty(propIndex);

}

// Determine what to set into the Content-Language header back to the client

// Determine what to set into the Content-Language header back to

// the client

if (!langMismatch)

{

if (contentLangs == String::EMPTY)

Line 1282

Line 1281

}

// l10n end

// If a subscription with a duration, calculate subscription time

Line 1293

Line 1291

try

{

_setTimeRemaining (enumInstances [i]);

} catch (DateTimeOutOfRangeException &)

}

catch (DateTimeOutOfRangeException&)

{

// This instance from the repository is invalid

Line 1303

Line 1302

}

if (startTimeAdded)

{

enumInstances [i].removeProperty

enumInstances[i].removeProperty(

(enumInstances [i].findProperty (_PROPERTY_STARTTIME));

enumInstances[i].findProperty(_PROPERTY_STARTTIME));

}

if (durationAdded)

{

enumInstances [i].removeProperty

enumInstances[i].removeProperty(

(enumInstances [i].findProperty (_PROPERTY_DURATION));

enumInstances[i].findProperty(_PROPERTY_DURATION));

}

Line 1344

Line 1343

PEG_METHOD_EXIT ();

}

void IndicationService::_handleEnumerateInstanceNamesRequest

void IndicationService::_handleEnumerateInstanceNamesRequest(

(const Message* message)

const Message* message)

{

PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,

"IndicationService::_handleEnumerateInstanceNamesRequest");

Line 1359

Line 1358

try

{

String userName = ((IdentityContainer)request->operationContext.get

String userName = ((IdentityContainer)request->operationContext.get(

(IdentityContainer :: NAME)).getUserName();

IdentityContainer::NAME)).getUserName();

_checkNonprivilegedAuthorization(userName);

enumInstanceNames =

_subscriptionRepository->enumerateInstanceNamesForClass

_subscriptionRepository->enumerateInstanceNamesForClass(

(request->nameSpace, request->className);

request->nameSpace, request->className);

}

catch (CIMException& exception)

{

Line 1401

Line 1400

try

{

String userName = ((IdentityContainer)request->operationContext.get

String userName = ((IdentityContainer)request->operationContext.get(

(IdentityContainer :: NAME)).getUserName();

IdentityContainer::NAME)).getUserName();

_checkNonprivilegedAuthorization(userName);

// Get the instance name

CIMObjectPath instanceReference =

CIMObjectPath instanceReference = request->modifiedInstance.getPath();

request->modifiedInstance.getPath ();

// Get instance from repository

CIMInstance instance;

instance = _subscriptionRepository->getInstance

instance = _subscriptionRepository->getInstance(

(request->nameSpace, instanceReference);

request->nameSpace, instanceReference);

CIMInstance modifiedInstance = request->modifiedInstance;

if (_canModify (request, instanceReference, instance, modifiedInstance))

Line 1442

Line 1440

PEG_METHOD_EXIT ();

// l10n

// String exceptionStr = _MSG_EXPIRED;

// throw PEGASUS_CIM_EXCEPTION (CIM_ERR_FAILED, exceptionStr);

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms(_MSG_EXPIRED_KEY, _MSG_EXPIRED));

}

} catch (DateTimeOutOfRangeException &)

}

catch (DateTimeOutOfRangeException&)

{

// This instance from the repository is invalid

Line 1483

Line 1477

// L10N TODO DONE -- new throw of exception

PEG_METHOD_EXIT ();

//throw PEGASUS_CIM_EXCEPTION (CIM_ERR_FAILED,

//_MSG_INVALID_INSTANCES);

MessageLoaderParms parms (_MSG_INVALID_INSTANCES_KEY,

_MSG_INVALID_INSTANCES);

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, parms);

Line 1499

Line 1491

// the default value; if invalid, an exception was thrown

Uint16 newState;

modifiedInstance.getProperty (modifiedInstance.findProperty

modifiedInstance.getProperty(modifiedInstance.findProperty(

(PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE)).getValue ().get (newState);

PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE)).getValue().get(

newState);

// If Subscription State has changed,

Line 1513

Line 1506

if (modifiedInstance.findProperty (_PROPERTY_LASTCHANGE) !=

PEG_NOT_FOUND)

{

CIMProperty lastChange = modifiedInstance.getProperty

CIMProperty lastChange = modifiedInstance.getProperty(

(modifiedInstance.findProperty

modifiedInstance.findProperty(

(_PROPERTY_LASTCHANGE));

_PROPERTY_LASTCHANGE));

lastChange.setValue (CIMValue (currentDateTime));

}

else

{

modifiedInstance.addProperty (CIMProperty

modifiedInstance.addProperty(CIMProperty(

(_PROPERTY_LASTCHANGE, CIMValue (currentDateTime)));

_PROPERTY_LASTCHANGE, CIMValue(currentDateTime)));

}

Array <CIMName> properties =

propertyList.getPropertyNameArray ();

Line 1541

Line 1534

// to the current date time

CIMDateTime startTime;

CIMProperty startTimeProperty = instance.getProperty

CIMProperty startTimeProperty = instance.getProperty(

(instance.findProperty (_PROPERTY_STARTTIME));

instance.findProperty(_PROPERTY_STARTTIME));

CIMValue startTimeValue = instance.getProperty

CIMValue startTimeValue = instance.getProperty(

(instance.findProperty

instance.findProperty(_PROPERTY_STARTTIME)).getValue();

(_PROPERTY_STARTTIME)).getValue ();

Boolean setStart = false;

if (startTimeValue.isNull ())

{

Line 1557

Line 1549

if (startTime.isInterval())

{

if (startTime.equal

if (startTime.equal(

(CIMDateTime (_ZERO_INTERVAL_STRING)))

CIMDateTime(_ZERO_INTERVAL_STRING)))

{

setStart = true;

}

Line 1570

Line 1562

if (modifiedInstance.findProperty (_PROPERTY_STARTTIME)

!= PEG_NOT_FOUND)

{

CIMProperty startTime = modifiedInstance.getProperty

CIMProperty startTime =

(modifiedInstance.findProperty

modifiedInstance.getProperty(

(_PROPERTY_STARTTIME));

modifiedInstance.findProperty(

_PROPERTY_STARTTIME));

startTime.setValue (CIMValue (currentDateTime));

}

else

{

modifiedInstance.addProperty (CIMProperty

modifiedInstance.addProperty(CIMProperty(

(_PROPERTY_STARTTIME,

_PROPERTY_STARTTIME,

CIMValue (currentDateTime)));

}

Line 1589

Line 1582

}

// l10n

// Add the language properties to the modified instance.

// Note: These came from the Accept-Language and Content-Language

// Note: These came from the Accept-Language and

// headers in the HTTP messages, and may be empty.

// Content-Language headers in the HTTP messages, and may be

// empty.

AcceptLanguageList acceptLangs =

((AcceptLanguageListContainer)request->operationContext.get

((AcceptLanguageListContainer)request->operationContext.get(

(AcceptLanguageListContainer::NAME)).getLanguages();

AcceptLanguageListContainer::NAME)).getLanguages();

modifiedInstance.addProperty (CIMProperty

modifiedInstance.addProperty(CIMProperty(

(PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS,

PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS,

LanguageParser::buildAcceptLanguageHeader(acceptLangs)));

ContentLanguageList contentLangs =

Line 1611

Line 1604

properties.append (PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS);

properties.append (PEGASUS_PROPERTYNAME_INDSUB_CONTENTLANGS);

propertyList.set (properties);

// l10n -end

// If subscription is to be enabled, determine if there are

Line 1648

Line 1640

_subscriptionRepository->reconcileFatalError (instance);

PEG_METHOD_EXIT ();

// l10n

// throw PEGASUS_CIM_EXCEPTION (CIM_ERR_NOT_SUPPORTED,

// _MSG_NO_PROVIDERS);

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_NOT_SUPPORTED,

MessageLoaderParms (_MSG_NO_PROVIDERS_KEY,

_MSG_NO_PROVIDERS));

Line 1664

Line 1652

try

{

modifiedInstance.setPath (instanceReference);

_subscriptionRepository->modifyInstance

_subscriptionRepository->modifyInstance(

(request->nameSpace, modifiedInstance,

request->nameSpace, modifiedInstance,

request->includeQualifiers, propertyList);

Logger::put (Logger::STANDARD_LOG, System::CIMSERVER,

Logger::TRACE,

"IndicationService::_handleModifyInstanceRequest - Name Space: $0 Instance name: $1",

"IndicationService::_handleModifyInstanceRequest - "

"Name Space: $0 Instance name: $1",

request->nameSpace.getString (),

modifiedInstance.getClassName ().getString ());

}

Line 1705

Line 1694

{

instanceReference.setNameSpace (request->nameSpace);

instance.setPath (instanceReference);

// l10n

_sendAsyncCreateRequests (indicationProviders,

_sendAsyncCreateRequests(

sourceNameSpace, requiredProperties, condition,

indicationProviders,

sourceNameSpace,

requiredProperties,

condition,

query,

queryLanguage,

instance,

Line 1715

Line 1707

contentLangs,

request,

indicationSubclasses,

userName, request->authType);

userName,

request->authType);

// Response is sent from _handleCreateResponseAggregation

Line 1739

Line 1732

// Send Delete requests

//l10n

if (indicationProviders.size () > 0)

{

_sendAsyncDeleteRequests (indicationProviders,

_sendAsyncDeleteRequests(

indicationProviders,

sourceNameSpace,

instance,

acceptLangs,

contentLangs,

request,

indicationSubclasses,

userName, request->authType);

userName,

request->authType);

// Response is sent from

Line 1767

Line 1761

}

catch (Exception& exception)

{

cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

cimException =

exception.getMessage());

PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());

}

Line 1778

Line 1772

if (!responseSent)

{

// l10n

// Note: don't need to set content-language in the response.

CIMResponseMessage * response = request->buildResponse ();

response->cimException = cimException;

Line 1801

Line 1794

try

{

String userName = ((IdentityContainer)request->operationContext.get

String userName = ((IdentityContainer)request->operationContext.get(

(IdentityContainer :: NAME)).getUserName();

IdentityContainer::NAME)).getUserName();

_checkNonprivilegedAuthorization(userName);

// Check if instance may be deleted -- a filter or handler instance

// referenced by a subscription instance may not be deleted

if (_canDelete (request->instanceName, request->nameSpace,

if (_canDelete(request->instanceName, request->nameSpace, userName))

userName))

{

// If a subscription, get the instance from the repository

CIMInstance subscriptionInstance;

if (request->instanceName.getClassName ().equal

if (request->instanceName.getClassName().equal(

(PEGASUS_CLASSNAME_INDSUBSCRIPTION) ||

PEGASUS_CLASSNAME_INDSUBSCRIPTION) ||

request->instanceName.getClassName ().equal

request->instanceName.getClassName ().equal(

(PEGASUS_CLASSNAME_FORMATTEDINDSUBSCRIPTION))

PEGASUS_CLASSNAME_FORMATTEDINDSUBSCRIPTION))

{

subscriptionInstance =

_subscriptionRepository->getInstance

_subscriptionRepository->getInstance(

(request->nameSpace, request->instanceName);

request->nameSpace, request->instanceName);

}

Line 1831

Line 1823

try

{

_subscriptionRepository->deleteInstance

_subscriptionRepository->deleteInstance(

(request->nameSpace, request->instanceName);

request->nameSpace, request->instanceName);

Logger::put (Logger::STANDARD_LOG, System::CIMSERVER,

Logger::TRACE,

"IndicationService::_handleDeleteInstanceRequest - Name Space: $0 Instance name: $1",

"IndicationService::_handleDeleteInstanceRequest - "

"Name Space: $0 Instance name: $1",

request->nameSpace.getString (),

request->instanceName.getClassName ().getString ());

}

Line 1860

Line 1853

return;

}

if (request->instanceName.getClassName ().equal

if (request->instanceName.getClassName().equal(

(PEGASUS_CLASSNAME_INDSUBSCRIPTION) ||

PEGASUS_CLASSNAME_INDSUBSCRIPTION) ||

request->instanceName.getClassName ().equal

request->instanceName.getClassName ().equal(

(PEGASUS_CLASSNAME_FORMATTEDINDSUBSCRIPTION))

PEGASUS_CLASSNAME_FORMATTEDINDSUBSCRIPTION))

{

// If subscription is active, send delete requests to providers

Line 1871

Line 1864

Uint16 subscriptionState;

CIMValue subscriptionStateValue;

subscriptionStateValue = subscriptionInstance.getProperty

subscriptionStateValue = subscriptionInstance.getProperty(

(subscriptionInstance.findProperty

subscriptionInstance.findProperty(

(PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE)).getValue ();

PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE)).getValue();

subscriptionStateValue.get (subscriptionState);

if ((subscriptionState == STATE_ENABLED) ||

Line 1886

Line 1879

instanceReference.setNameSpace (request->nameSpace);

subscriptionInstance.setPath (instanceReference);

indicationProviders = _getDeleteParams

indicationProviders = _getDeleteParams(

(subscriptionInstance, indicationSubclasses,

subscriptionInstance,

indicationSubclasses,

sourceNamespaceName);

if (indicationProviders.size () > 0)

Line 1895

Line 1889

// Send Delete requests

// l10n

_sendAsyncDeleteRequests(

_sendAsyncDeleteRequests (indicationProviders,

indicationProviders,

sourceNamespaceName, subscriptionInstance,

sourceNamespaceName,

subscriptionInstance,

((AcceptLanguageListContainer)

request->operationContext.get

request->operationContext.get(

(AcceptLanguageListContainer::NAME)).getLanguages(),

AcceptLanguageListContainer::NAME)).

getLanguages(),

((ContentLanguageListContainer)

request->operationContext.get

request->operationContext.get(

(ContentLanguageListContainer::NAME)).getLanguages(),

ContentLanguageListContainer::NAME)).

getLanguages(),

request,

indicationSubclasses,

userName, request->authType);

userName,

request->authType);

// Response is sent from

Line 1920

Line 1918

// Subscription was enabled, but had no providers

// Remove entries from the subscription hash tables

_subscriptionTable->removeSubscription

_subscriptionTable->removeSubscription(

(subscriptionInstance,

subscriptionInstance,

indicationSubclasses, sourceNamespaceName,

indicationSubclasses,

sourceNamespaceName,

indicationProviders);

}

Line 1935

Line 1934

}

catch (Exception& exception)

{

cimException = PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

cimException =

exception.getMessage());

PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, exception.getMessage());

}

Line 1953

Line 1952

PEG_METHOD_EXIT ();

}

// l10n TODO - might need to globalize another flow and another consumer interface

// l10n TODO - might need to globalize another flow and another consumer

// (ie. mdd's) if we can't agree on one export flow and consumer interface

// interface (ie. mdd's) if we can't agree on one export flow and consumer

// (see PEP67)

// interface (see PEP67)

void IndicationService::_handleProcessIndicationRequest (const Message* message)

{

Line 2139

Line 2138

getClassName().getString().getCString())));

continue;

}

} catch (DateTimeOutOfRangeException &)

}

catch (DateTimeOutOfRangeException&)

{

// This instance from the repository is invalid

Line 2158

queryLanguage,

filterName);

QueryExpression queryExpr = _getQueryExpression(filterQuery,

QueryExpression queryExpr = _getQueryExpression(

queryLanguage,

filterQuery, queryLanguage, request->nameSpace);

request->nameSpace);

#ifdef PEGASUS_INDICATION_PERFINST

stopWatch.reset();

Line 2194

Line 2193

// This is a two part process:

// 1) Call QueryExpression::applyProjection to remove properties

// 1) Call QueryExpression::applyProjection to remove

// not listed in the SELECT clause. Note: for CQL, this will handle

// properties not listed in the SELECT clause. Note: for CQL,

// properties on embedded objects.

// this will handle properties on embedded objects.

// QueryExpression::applyProjection throws an exception if

// the indication is missing a required property in the SELECT

// clause. Although _getMatchingSubscriptions checked for

// the indication missing required properties, it would have

// not detected missing required embedded object properties for CQL.

// not detected missing required embedded object properties for

// So, we need to catch the missing property exception here.

// CQL. So, we need to catch the missing property exception

// here.

// 2) Remove any properties that may be left on the indication

// that are not in the indication class. These are properties

Line 2212

// SELECT clause happens to have a property name not on the

// indication class, and the indication has that same property.

// Note: If SELECT includes all properties ("*"), it's still

// necessary to check, in case the provider added properties not in

// necessary to check, in case the provider added properties

// the indication class.

// not in the indication class.

try

{

Line 2223

{

// The indication was missing a required property.

// The call to _getMatchingSubscriptions above checked for

// missing required properties on the base indication object

// missing required properties on the base indication

// so this can only happen for CQL when an embedded object

// object so this can only happen for CQL when an embedded

// property is missing.

// object property is missing.

// Since this is the same as the indication

// Since this is the same as the indication not matching

// not matching the subscription, just swallow the exception,

// the subscription, just swallow the exception,

// and skip this subscription.

PEG_TRACE_STRING (TRC_INDICATION_SERVICE, Tracer::LEVEL4,

"Apply Projection error: " + re.getMessage());

Line 2240

for (Uint32 j = 0; j < propertyNames.size(); j++)

{

Uint32 rmIndex = formattedIndication.findProperty(propertyNames[j]);

Uint32 rmIndex =

formattedIndication.findProperty(propertyNames[j]);

if (rmIndex != PEG_NOT_FOUND &&

!ContainsCIMName (indicationClassProperties,

!ContainsCIMName(

propertyNames[j]))

indicationClassProperties, propertyNames[j]))

{

formattedIndication.removeProperty(rmIndex);

}

handlerNamedInstance = _subscriptionRepository->getHandler

handlerNamedInstance = _subscriptionRepository->getHandler(

(matchedSubscriptions[i]);

matchedSubscriptions[i]);

PEG_TRACE ((TRC_INDICATION_GENERATION, Tracer::LEVEL3,

"Handler %s:%s.%s found for %s Indication %s",

(const char*)(request->nameSpace.getString().getCString()),

Line 2366

Line 2367

AsyncReply * asyncReply =

static_cast<AsyncReply *>(operation->removeResponse());

CIMHandleIndicationResponseMessage * handlerResponse =

reinterpret_cast <CIMHandleIndicationResponseMessage *>

reinterpret_cast<CIMHandleIndicationResponseMessage *>(

((static_cast <AsyncLegacyOperationResult *>

(static_cast<AsyncLegacyOperationResult *>(

(asyncReply))->get_result ());

asyncReply))->get_result());

PEGASUS_ASSERT (handlerResponse != 0);

if (handlerResponse->cimException.getCode () != CIM_ERR_SUCCESS)

Line 2564

Line 2565

// Send Modify requests

// l10n

_sendWaitModifyRequests (indicationProviders,

sourceNameSpace,

requiredProperties, condition, query, queryLanguage,

Line 2578

// Send Create requests

// l10n

Array <ProviderClassList> acceptedProviders;

acceptedProviders = _sendWaitCreateRequests

(indicationProviders,

Line 2666

Line 2665

CIMInstance instance = formerSubscriptions [i];

String creator = instance.getProperty (instance.findProperty

(PEGASUS_PROPERTYNAME_INDSUB_CREATOR)).getValue ().toString ();

// l10n start

AcceptLanguageList acceptLangs;

Uint32 propIndex = instance.findProperty

(PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS);

Line 2695

Line 2693

contentLangsString);

}

// l10n end

// Look up the subscription in the active subscriptions table

Line 2723

Line 2720

if ((tableValue.providers [providerIndex].classList.size ()

== 1) &&

(tableValue.providers [providerIndex].classList

(tableValue.providers[providerIndex].classList[0].equal(

[0].equal (className)))

className)))

{

// l10n

_sendWaitDeleteRequests (indicationProviders,

sourceNameSpace,

formerSubscriptions [i],

Line 2753

Line 2749

// Send Modify requests

// l10n

_sendWaitModifyRequests (indicationProviders,

sourceNameSpace,

requiredProperties, condition,

Line 2870

Line 2865

// On Fatal Error policy, if necessary

providerSubscriptions.clear ();

providerSubscriptions = _subscriptionTable->reflectProviderDisable

providerSubscriptions = _subscriptionTable->reflectProviderDisable(

(providers [i]);

providers[i]);

if (providerSubscriptions.size () > 0)

{

Line 2902

Line 2897

// Log a message for each subscription

CIMClass providerClass = _subscriptionRepository->getClass

CIMClass providerClass = _subscriptionRepository->getClass(

(PEGASUS_NAMESPACENAME_INTEROP, PEGASUS_CLASSNAME_PROVIDER,

PEGASUS_NAMESPACENAME_INTEROP, PEGASUS_CLASSNAME_PROVIDER,

true, true, false, CIMPropertyList ());

CIMInstance providerCopy = providers [i].clone ();

CIMObjectPath path = providerCopy.buildPath (providerClass);

Line 2920

Line 2915

Logger::put_l (Logger::STANDARD_LOG, System::CIMSERVER,

Logger::WARNING, _MSG_PROVIDER_NO_LONGER_SERVING_KEY,

_MSG_PROVIDER_NO_LONGER_SERVING, logString1, logString2,

providerSubscriptions[j].getPath().getNameSpace().getString());

providerSubscriptions[j].getPath().getNameSpace().

getString());

}

Line 3217

Line 3213

System::CIMSERVER, Logger::WARNING,

_MSG_PROVIDER_NOW_SERVING_KEY,

_MSG_PROVIDER_NOW_SERVING, logString1, logString2,

subscriptions[s].getPath().getNameSpace().getString());

subscriptions[s].getPath().getNameSpace().

getString());

}

} // if any provider accepted the create subscription request

Line 3305

Line 3302

// Filter and Handler are key properties for Subscription

// No other properties are required

_checkRequiredProperty (instance, PEGASUS_PROPERTYNAME_FILTER, CIMTYPE_REFERENCE,

_checkRequiredProperty(

instance,

PEGASUS_PROPERTYNAME_FILTER,

CIMTYPE_REFERENCE,

_MSG_KEY_PROPERTY);

_checkRequiredProperty (instance, PEGASUS_PROPERTYNAME_HANDLER, CIMTYPE_REFERENCE,

_checkRequiredProperty(

instance,

PEGASUS_PROPERTYNAME_HANDLER,

CIMTYPE_REFERENCE,

_MSG_KEY_PROPERTY);

Line 3352

Line 3355

exceptionStr.append ("$1");

PEG_METHOD_EXIT ();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_INVALID_PARAMETER,

throw PEGASUS_CIM_EXCEPTION_L(

MessageLoaderParms (_MSG_INVALID_VALUE_FOR_PROPERTY_KEY,

CIM_ERR_INVALID_PARAMETER,

MessageLoaderParms(

_MSG_INVALID_VALUE_FOR_PROPERTY_KEY,

exceptionStr,

origFilterPath.toString(), PEGASUS_PROPERTYNAME_FILTER.getString()));

origFilterPath.toString(),

PEGASUS_PROPERTYNAME_FILTER.getString()));

}

Line 3373

Line 3379

exceptionStr.append ("$1");

PEG_METHOD_EXIT ();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_INVALID_PARAMETER,

throw PEGASUS_CIM_EXCEPTION_L(

MessageLoaderParms (_MSG_INVALID_VALUE_FOR_PROPERTY_KEY,

CIM_ERR_INVALID_PARAMETER,

MessageLoaderParms(

_MSG_INVALID_VALUE_FOR_PROPERTY_KEY,

exceptionStr,

origHandlerPath.toString(), PEGASUS_PROPERTYNAME_HANDLER.getString()));

origHandlerPath.toString(),

PEGASUS_PROPERTYNAME_HANDLER.getString()));

}

Line 3430

Line 3439

// Policy properties each has a default value, a corresponding

// Other___ property, and a set of valid values

_checkPropertyWithOther (instance, PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE,

_checkPropertyWithOther(

_PROPERTY_OTHERSTATE, (Uint16) STATE_ENABLED,

instance,

(Uint16) STATE_OTHER, _validStates, _supportedStates);

PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE,

_PROPERTY_OTHERSTATE,

_checkPropertyWithOther (instance, _PROPERTY_REPEATNOTIFICATIONPOLICY,

(Uint16) STATE_ENABLED,

_PROPERTY_OTHERREPEATNOTIFICATIONPOLICY, (Uint16) _POLICY_NONE,

(Uint16) STATE_OTHER,

(Uint16) _POLICY_OTHER, _validRepeatPolicies,

_validStates,

_supportedStates);

_checkPropertyWithOther(

instance,

_PROPERTY_REPEATNOTIFICATIONPOLICY,

_PROPERTY_OTHERREPEATNOTIFICATIONPOLICY,

(Uint16) _POLICY_NONE,

(Uint16) _POLICY_OTHER,

_validRepeatPolicies,

_supportedRepeatPolicies);

_checkPropertyWithOther (instance, _PROPERTY_ONFATALERRORPOLICY,

_checkPropertyWithOther(

_PROPERTY_OTHERONFATALERRORPOLICY, (Uint16) _ERRORPOLICY_IGNORE,

instance,

(Uint16) _ERRORPOLICY_OTHER, _validErrorPolicies,

_PROPERTY_ONFATALERRORPOLICY,

_PROPERTY_OTHERONFATALERRORPOLICY,

(Uint16) _ERRORPOLICY_IGNORE,

(Uint16) _ERRORPOLICY_OTHER,

_validErrorPolicies,

_supportedErrorPolicies);

Line 3548

Line 3570

// If they exist but are NULL, set value to the default

// If they exist and are not NULL, validate the value

_checkRequiredProperty (instance, PEGASUS_PROPERTYNAME_NAME, CIMTYPE_STRING,

_checkRequiredProperty(

instance,

PEGASUS_PROPERTYNAME_NAME,

CIMTYPE_STRING,

_MSG_KEY_PROPERTY);

_initOrValidateStringProperty (instance,PEGASUS_PROPERTYNAME_CREATIONCLASSNAME,

_initOrValidateStringProperty(

instance,

PEGASUS_PROPERTYNAME_CREATIONCLASSNAME,

instance.getClassName ().getString ());

_initOrValidateStringProperty (instance, _PROPERTY_SYSTEMNAME,

_initOrValidateStringProperty(

instance,

_PROPERTY_SYSTEMNAME,

System::getFullyQualifiedHostName ());

_initOrValidateStringProperty (instance,

_initOrValidateStringProperty(

instance,

_PROPERTY_SYSTEMCREATIONCLASSNAME,

System::getSystemCreationClassName ());

Line 3566

Line 3596

// Query and QueryLanguage properties are required for Filter

_checkRequiredProperty (instance, PEGASUS_PROPERTYNAME_QUERY, CIMTYPE_STRING,

_checkRequiredProperty(

instance,

PEGASUS_PROPERTYNAME_QUERY,

CIMTYPE_STRING,

_MSG_PROPERTY);

_checkRequiredProperty(

instance,

PEGASUS_PROPERTYNAME_QUERYLANGUAGE,

CIMTYPE_STRING,

_MSG_PROPERTY);

_checkRequiredProperty (instance, PEGASUS_PROPERTYNAME_QUERYLANGUAGE,

CIMTYPE_STRING, _MSG_PROPERTY);

// Validate the query language is supported

String queryLanguage;

instance.getProperty (instance.findProperty

instance.getProperty(

(PEGASUS_PROPERTYNAME_QUERYLANGUAGE)).getValue ().get (queryLanguage);

instance.findProperty(PEGASUS_PROPERTYNAME_QUERYLANGUAGE)).

getValue().get(queryLanguage);

#ifdef PEGASUS_DISABLE_CQL

// Special code to block CQL, if CQL is disabled

Line 3584

Line 3621

{

// CQL is not allowed in this case

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

throw PEGASUS_CIM_EXCEPTION(

queryLanguage);

CIM_ERR_NOT_SUPPORTED, queryLanguage);

}

#endif

Line 3593

Line 3630

// Default value for Source Namespace is the namespace of the

// Filter registration

CIMNamespaceName sourceNameSpace = CIMNamespaceName

CIMNamespaceName sourceNameSpace = CIMNamespaceName(

(_checkPropertyWithDefault (instance, _PROPERTY_SOURCENAMESPACE,

_checkPropertyWithDefault(

instance,

_PROPERTY_SOURCENAMESPACE,

nameSpace.getString()));

Line 3608

Line 3647

QueryExpression queryExpression;

try

{

queryExpression =

queryExpression = _getQueryExpression(

_getQueryExpression (filterQuery, queryLanguage, sourceNameSpace);

filterQuery, queryLanguage, sourceNameSpace);

}

catch (QueryLanguageInvalidException&)

{

// The filter query had an invalid language name.

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

throw PEGASUS_CIM_EXCEPTION(

queryLanguage);

CIM_ERR_NOT_SUPPORTED, queryLanguage);

}

CIMName indicationClassName = _getIndicationClassName

Line 3703

Line 3742

_MSG_CLASS_NOT_SERVED));

}

#endif

_checkPropertyWithOther (instance, PEGASUS_PROPERTYNAME_PERSISTENCETYPE,

_checkPropertyWithOther(

_PROPERTY_OTHERPERSISTENCETYPE, (Uint16) PERSISTENCE_PERMANENT,

instance,

(Uint16) PERSISTENCE_OTHER, _validPersistenceTypes,

PEGASUS_PROPERTYNAME_PERSISTENCETYPE,

_PROPERTY_OTHERPERSISTENCETYPE,

(Uint16) PERSISTENCE_PERMANENT,

(Uint16) PERSISTENCE_OTHER,

_validPersistenceTypes,

_supportedPersistenceTypes);

Line 3714

Line 3757

_checkProperty (instance, _PROPERTY_OWNER, CIMTYPE_STRING);

if (instance.getClassName ().equal

if (instance.getClassName().equal(

(PEGASUS_CLASSNAME_INDHANDLER_CIMXML) ||

PEGASUS_CLASSNAME_INDHANDLER_CIMXML) ||

instance.getClassName ().equal

instance.getClassName().equal(

(PEGASUS_CLASSNAME_LSTNRDST_CIMXML))

PEGASUS_CLASSNAME_LSTNRDST_CIMXML))

{

// Destination property is required for CIMXML

// Handler subclass

_checkRequiredProperty (instance,

_checkRequiredProperty(

instance,

PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION,

CIMTYPE_STRING, _MSG_PROPERTY);

CIMTYPE_STRING,

_MSG_PROPERTY);

}

if (instance.getClassName ().equal

Line 3735

Line 3780

// TargetHost property is required for SNMP

// Handler subclass

_checkRequiredProperty (instance,

_checkRequiredProperty(

instance,

PEGASUS_PROPERTYNAME_LSTNRDST_TARGETHOST,

CIMTYPE_STRING, _MSG_PROPERTY);

CIMTYPE_STRING,

_MSG_PROPERTY);

// TargetHostFormat property is required for SNMP

// Handler subclass

_checkRequiredProperty (instance, _PROPERTY_TARGETHOSTFORMAT,

_checkRequiredProperty(

CIMTYPE_UINT16, _MSG_PROPERTY);

instance,

_PROPERTY_TARGETHOSTFORMAT,

CIMTYPE_UINT16,

_MSG_PROPERTY);

// SNMPVersion property is required for SNMP Handler

_checkRequiredProperty (instance, PEGASUS_PROPERTYNAME_SNMPVERSION,

_checkRequiredProperty(

CIMTYPE_UINT16, _MSG_PROPERTY);

instance,

PEGASUS_PROPERTYNAME_SNMPVERSION,

CIMTYPE_UINT16,

_MSG_PROPERTY);

// Currently, only SNMPv1 trap and SNMPv2C trap are supported,

// verify if the value of SNMPVersion is one of them

_checkValue(instance, PEGASUS_PROPERTYNAME_SNMPVERSION,

_checkValue(

_validSNMPVersion, _supportedSNMPVersion);

instance,

PEGASUS_PROPERTYNAME_SNMPVERSION,

_validSNMPVersion,

_supportedSNMPVersion);

// For each remaining property, verify that if the property

Line 3776

Line 3832

// MailTo property is required for Email

// Handler subclass

_checkRequiredProperty (instance,

_checkRequiredProperty(

instance,

PEGASUS_PROPERTYNAME_LSTNRDST_MAILTO,

CIMTYPE_STRING, _MSG_PROPERTY, true);

CIMTYPE_STRING,

_MSG_PROPERTY,

true);

// get MailTo from handler instance

Array<String> mailTo;

instance.getProperty(instance.findProperty(

PEGASUS_PROPERTYNAME_LSTNRDST_MAILTO)).getValue().get(mailTo);

PEGASUS_PROPERTYNAME_LSTNRDST_MAILTO)).getValue().get(

mailTo);

// Build mail address string

String mailAddrStr;

Line 3806

Line 3866

if (mailAddrStr == String::EMPTY)

{

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

throw PEGASUS_CIM_EXCEPTION_L(

MessageLoaderParms("IndicationService.IndicationService._MSG_DO_NOT_HAVE_EMAIL_ADDRESS",

CIM_ERR_FAILED,

MessageLoaderParms(

"IndicationService.IndicationService."

"_MSG_DO_NOT_HAVE_EMAIL_ADDRESS",

"Do not have an e-mail address."));

}

Line 3815

Line 3878

// MailSubject property is required for Email

// Handler subclass

_checkRequiredProperty (instance,

_checkRequiredProperty(

instance,

PEGASUS_PROPERTYNAME_LSTNRDST_MAILSUBJECT,

CIMTYPE_STRING, _MSG_PROPERTY);

CIMTYPE_STRING,

_MSG_PROPERTY);

// For MailCc property, verify that if the property

// exists in the instance it is of the correct type

_checkProperty (instance,

_checkProperty(

instance,

PEGASUS_PROPERTYNAME_LSTNRDST_MAILCC,

CIMTYPE_STRING, true);

CIMTYPE_STRING,

true);

}

Line 3836

Line 3903

PEG_METHOD_EXIT ();

// l10n

throw PEGASUS_CIM_EXCEPTION_L(

CIM_ERR_NOT_SUPPORTED,

// throw PEGASUS_CIM_EXCEPTION (CIM_ERR_NOT_SUPPORTED,

MessageLoaderParms(

// _MSG_CLASS_NOT_SERVED);

_MSG_CLASS_NOT_SERVED_KEY,

_MSG_CLASS_NOT_SERVED));

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_NOT_SUPPORTED,

MessageLoaderParms(_MSG_CLASS_NOT_SERVED_KEY, _MSG_CLASS_NOT_SERVED));

}

Line 4008

Line 4073

if (theValue.isArray ())

{

MessageLoaderParms parms(

"IndicationService.IndicationService._MSG_INVALID_TYPE_ARRAY_OF_FOR_PROPERTY",

"IndicationService.IndicationService."

"_MSG_INVALID_TYPE_ARRAY_OF_FOR_PROPERTY",

"Invalid type array of $0 for property $1",

cimTypeToString(theValue.getType()),

propertyName.getString());

Line 4018

Line 4084

else

{

MessageLoaderParms parms(

"IndicationService.IndicationService._MSG_INVALID_TYPE_FOR_PROPERTY",

"IndicationService.IndicationService."

"_MSG_INVALID_TYPE_FOR_PROPERTY",

"Invalid type $0 for property $1",

cimTypeToString(theValue.getType()),

propertyName.getString());

Line 4048

Line 4115

if (!Contains (validValues, result))

{

// l10n

String exceptionStr = _MSG_INVALID_VALUE;

// exceptionStr.append (theValue.toString ());

exceptionStr.append ("$0");

exceptionStr.append (_MSG_FOR_PROPERTY);

// exceptionStr.append (propertyName.getString());

exceptionStr.append ("$1");

PEG_METHOD_EXIT ();

// throw PEGASUS_CIM_EXCEPTION (CIM_ERR_INVALID_PARAMETER,

// exceptionStr);

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_INVALID_PARAMETER,

MessageLoaderParms(_MSG_INVALID_VALUE_FOR_PROPERTY_KEY,

exceptionStr,

Line 4084

Line 4144

PEG_METHOD_EXIT ();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_NOT_SUPPORTED,

throw PEGASUS_CIM_EXCEPTION_L(

MessageLoaderParms (_MSG_UNSUPPORTED_VALUE_FOR_PROPERTY_KEY,

CIM_ERR_NOT_SUPPORTED,

MessageLoaderParms(

_MSG_UNSUPPORTED_VALUE_FOR_PROPERTY_KEY,

exceptionStr,

theValue.toString (), propertyName.getString ()));

theValue.toString(),

propertyName.getString()));

}

Line 4099

Line 4162

{

if (instance.findProperty (otherPropertyName) == PEG_NOT_FOUND)

{

// l10n

String exceptionStr = _MSG_MISSING_REQUIRED;

// exceptionStr.append (otherPropertyName.getString());

exceptionStr.append ("$0");

exceptionStr.append (_MSG_PROPERTY);

PEG_METHOD_EXIT ();

// l10n

throw PEGASUS_CIM_EXCEPTION_L(

CIM_ERR_INVALID_PARAMETER,

// throw PEGASUS_CIM_EXCEPTION (CIM_ERR_INVALID_PARAMETER,

MessageLoaderParms(

// exceptionStr);

_MSG_PROPERTY_KEY,

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_INVALID_PARAMETER,

MessageLoaderParms(_MSG_PROPERTY_KEY,

exceptionStr,

otherPropertyName.getString()));

}

Line 4125

Line 4182

CIMValue theOtherValue = otherProperty.getValue ();

if (theOtherValue.isNull ())

{

// l10n

String exceptionStr = _MSG_MISSING_REQUIRED;

// exceptionStr.append (otherPropertyName.getString());

exceptionStr.append ("$0");

exceptionStr.append (_MSG_PROPERTY);

PEG_METHOD_EXIT ();

// l10n

throw PEGASUS_CIM_EXCEPTION_L(

// throw PEGASUS_CIM_EXCEPTION (CIM_ERR_INVALID_PARAMETER,

CIM_ERR_INVALID_PARAMETER,

// exceptionStr);

MessageLoaderParms(

_MSG_PROPERTY_KEY,

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_INVALID_PARAMETER,

MessageLoaderParms(_MSG_PROPERTY_KEY,

exceptionStr,

otherPropertyName.getString()));

}

Line 4155

Line 4207

exceptionStr.append ("$1");

PEG_METHOD_EXIT ();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_INVALID_PARAMETER,

throw PEGASUS_CIM_EXCEPTION_L(

MessageLoaderParms

CIM_ERR_INVALID_PARAMETER,

(_MSG_INVALID_TYPE_FOR_PROPERTY_KEY,

MessageLoaderParms(

_MSG_INVALID_TYPE_FOR_PROPERTY_KEY,

exceptionStr,

cimTypeToString (theOtherValue.getType ()),

otherPropertyName.getString ()));

Line 4171

Line 4224

else if (instance.findProperty (otherPropertyName) != PEG_NOT_FOUND)

{

CIMProperty otherProperty = instance.getProperty

CIMProperty otherProperty = instance.getProperty(

(instance.findProperty (otherPropertyName));

instance.findProperty(otherPropertyName));

CIMValue theOtherValue = otherProperty.getValue ();

if (!theOtherValue.isNull ())

{

// l10n

// String exceptionStr = otherPropertyName.getString();

String exceptionStr ("$0");

exceptionStr.append (_MSG_PROPERTY_PRESENT);

// exceptionStr.append (propertyName.getString());

exceptionStr.append ("$1");

exceptionStr.append (_MSG_VALUE_NOT);

// exceptionStr.append (CIMValue (otherValue).toString ());

exceptionStr.append ("$2");

PEG_METHOD_EXIT ();

// l10n

throw PEGASUS_CIM_EXCEPTION_L(

CIM_ERR_INVALID_PARAMETER,

// throw PEGASUS_CIM_EXCEPTION (CIM_ERR_INVALID_PARAMETER,

MessageLoaderParms(

// exceptionStr);

_MSG_PROPERTY_PRESENT_BUT_VALUE_NOT_KEY,

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_INVALID_PARAMETER,

MessageLoaderParms(_MSG_PROPERTY_PRESENT_BUT_VALUE_NOT_KEY,

exceptionStr,

otherPropertyName.getString(),

propertyName.getString(),

Line 4523

Line 4568

exceptionStr,

theValue,

propertyName.getString()));

}

PEG_METHOD_EXIT ();

Line 4583

Line 4626

// If one property specified, it must be Subscription State property

else if ((request->propertyList.size () == 1) &&

(!request->propertyList[0].equal (PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE)))

(!request->propertyList[0].equal(

PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE)))

{

PEG_METHOD_EXIT ();

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);

Line 4592

Line 4636

// Check the SubscriptionState property in the modified instance

_checkPropertyWithOther (modifiedInstance, PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE,

_checkPropertyWithOther(

_PROPERTY_OTHERSTATE, (Uint16) STATE_ENABLED, (Uint16) STATE_OTHER,

modifiedInstance,

_validStates, _supportedStates);

PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE,

_PROPERTY_OTHERSTATE,

(Uint16) STATE_ENABLED,

(Uint16) STATE_OTHER,

_validStates,

_supportedStates);

// Get creator from instance

Line 4607

Line 4656

// L10N TODO DONE -- new throw of exception

PEG_METHOD_EXIT ();

//throw PEGASUS_CIM_EXCEPTION (CIM_ERR_FAILED,

//_MSG_INVALID_INSTANCES);

MessageLoaderParms parms(_MSG_INVALID_INSTANCES_KEY,

_MSG_INVALID_INSTANCES);

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);

Line 4842

Line 4889

(subscriptions [i], filterQuery, sourceNameSpace,

queryLanguage, filterName);

QueryExpression queryExpr = _getQueryExpression(filterQuery,

QueryExpression queryExpr = _getQueryExpression(

queryLanguage,

filterQuery, queryLanguage, sourceNameSpace);

sourceNameSpace);

// Get indication class name from filter query

Line 4996

Line 5042

_subscriptionRepository->getFilterProperties (newList [n], filterQuery,

sourceNameSpace, queryLanguage, filterName);

QueryExpression queryExpression = _getQueryExpression(filterQuery,

QueryExpression queryExpression = _getQueryExpression(

queryLanguage,

filterQuery, queryLanguage, sourceNameSpace);

sourceNameSpace);

// Get indication class name from filter query (FROM clause)

Line 5057

Line 5102

_subscriptionRepository->getFilterProperties (bothList [b], filterQuery,

sourceNameSpace, queryLanguage, filterName);

QueryExpression queryExpression = _getQueryExpression(filterQuery,

QueryExpression queryExpression = _getQueryExpression(

queryLanguage,

filterQuery, queryLanguage, sourceNameSpace);

sourceNameSpace);

// Get indication class name from filter query (FROM clause)

Line 5153

Line 5197

return true;

}

QueryExpression IndicationService::_getQueryExpression (const String& filterQuery,

QueryExpression IndicationService::_getQueryExpression(

const String& filterQuery,

const String& queryLanguage,

const CIMNamespaceName ns) const

const CIMNamespaceName& ns) const

{

PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,

"IndicationService::_getQueryExpression");

Line 5339

Line 5384

provider.classList.append (indicationSubclasses [i]);

#ifdef PEGASUS_ENABLE_REMOTE_CMPI

String remoteInformation;

Boolean isRemote = _cimRepository->isRemoteNameSpace(nameSpace,remoteInformation);

Boolean isRemote = _cimRepository->isRemoteNameSpace(

nameSpace, remoteInformation);

provider.isRemoteNameSpace = isRemote;

provider.remoteInfo = remoteInformation;

#endif

Line 5353

Line 5399

return indicationProviders;

}

CIMPropertyList IndicationService::_getPropertyList

CIMPropertyList IndicationService::_getPropertyList(

(const QueryExpression & queryExpression,

const QueryExpression& queryExpression,

const CIMNamespaceName & nameSpaceName,

const CIMName & indicationClassName) const

{

Line 5407

Line 5453

}

CIMPropertyList IndicationService::_checkPropertyList

CIMPropertyList IndicationService::_checkPropertyList(

(const Array <CIMName> & propertyList,

const Array<CIMName>& propertyList,

const CIMNamespaceName & nameSpaceName,

const CIMName & indicationClassName,

Array <CIMName> & indicationClassProperties) const

Line 5427

Line 5473

// Specify localOnly=false because superclass properties are needed

// Specify includeQualifiers=false because qualifiers are not needed

indicationClass = _subscriptionRepository->getClass

indicationClass = _subscriptionRepository->getClass(

(nameSpaceName, indicationClassName, false, false, false,

nameSpaceName, indicationClassName, false, false, false,

CIMPropertyList ());

Boolean allProperties = true;

for (Uint32 i = 0; i < indicationClass.getPropertyCount (); i++)

{

indicationClassProperties.append

indicationClassProperties.append(

(indicationClass.getProperty (i).getName ());

indicationClass.getProperty(i).getName());

if (!ContainsCIMName (propertyList,

indicationClass.getProperty (i).getName ()))

{

Line 5458

Line 5504

}

String IndicationService::_getCondition

String IndicationService::_getCondition(

(const String & filterQuery) const

const String& filterQuery) const

{

PEG_METHOD_ENTER (TRC_INDICATION_SERVICE,

"IndicationService::_getCondition");

Line 5471

Line 5517

if (filterQuery.find (_QUERY_WHERE) != PEG_NOT_FOUND)

{

condition = filterQuery.subString (filterQuery.find

condition = filterQuery.subString(filterQuery.find(_QUERY_WHERE) + 6);

(_QUERY_WHERE) + 6);

}

PEG_METHOD_EXIT ();

Line 5493

Line 5538

// Delete referencing subscriptions from the repository

deletedSubscriptions =

_subscriptionRepository->deleteReferencingSubscriptions

_subscriptionRepository->deleteReferencingSubscriptions(

(nameSpace, referenceProperty, handler);

nameSpace, referenceProperty, handler);

// Send delete request to each provider for each deleted subscription

Line 5522

Line 5567

// l10n start

AcceptLanguageList acceptLangs;

Uint32 propIndex = instance.findProperty

Uint32 propIndex = instance.findProperty(

(PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS);

PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS);

if (propIndex != PEG_NOT_FOUND)

{

String acceptLangsString;

Line 5536

Line 5581

}

ContentLanguageList contentLangs;

propIndex = instance.findProperty

propIndex = instance.findProperty(

(PEGASUS_PROPERTYNAME_INDSUB_CONTENTLANGS);

PEGASUS_PROPERTYNAME_INDSUB_CONTENTLANGS);

if (propIndex != PEG_NOT_FOUND)

{

String contentLangsString;

Line 5551

Line 5596

}

// l10n end

// l10n

_sendAsyncDeleteRequests(

_sendAsyncDeleteRequests (indicationProviders, sourceNamespaceName,

indicationProviders,

sourceNamespaceName,

deletedSubscriptions [i],

acceptLangs,

contentLangs,

Line 5605

Line 5651

// Delete instance from repository

subscriptionInstance = _subscriptionRepository->deleteSubscription

subscriptionInstance =

(subscription);

_subscriptionRepository->deleteSubscription(subscription);

// If a valid instance object was returned, the subscription was

Line 5620

Line 5666

Uint16 subscriptionState;

CIMValue subscriptionStateValue;

subscriptionStateValue = subscriptionInstance.getProperty

subscriptionStateValue = subscriptionInstance.getProperty(

(subscriptionInstance.findProperty

subscriptionInstance.findProperty(

(PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE)).getValue ();

PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE)).getValue();

subscriptionStateValue.get (subscriptionState);

if ((subscriptionState == STATE_ENABLED) ||

Line 5653

Line 5699

// instance

AcceptLanguageList acceptLangs;

Uint32 propIndex = subscriptionInstance.findProperty

Uint32 propIndex = subscriptionInstance.findProperty(

(PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS);

PEGASUS_PROPERTYNAME_INDSUB_ACCEPTLANGS);

if (propIndex != PEG_NOT_FOUND)

{

String acceptLangsString;

Line 5667

Line 5713

}

ContentLanguageList contentLangs;

propIndex = subscriptionInstance.findProperty

propIndex = subscriptionInstance.findProperty(

(PEGASUS_PROPERTYNAME_INDSUB_CONTENTLANGS);

PEGASUS_PROPERTYNAME_INDSUB_CONTENTLANGS);

if (propIndex != PEG_NOT_FOUND)

{

String contentLangsString;

Line 5681

Line 5727

}

// l10n

subscriptionInstance.setPath (subscription);

_sendAsyncDeleteRequests (indicationProviders,

sourceNamespaceName, subscriptionInstance,

Line 5784

Line 5829

Sint64 difference;

try

{

difference = CIMDateTime::getDifference

difference = CIMDateTime::getDifference(

(startTime, currentDateTime);

startTime, currentDateTime);

}

// Check if the date time is out of range.

Line 5826

Line 5871

if (instance.findProperty (_PROPERTY_TIMEREMAINING) == PEG_NOT_FOUND)

{

instance.addProperty (CIMProperty

instance.addProperty(

(_PROPERTY_TIMEREMAINING, timeRemaining));

CIMProperty(_PROPERTY_TIMEREMAINING, timeRemaining));

}

else

{

CIMProperty remaining = instance.getProperty

CIMProperty remaining = instance.getProperty(

(instance.findProperty (_PROPERTY_TIMEREMAINING));

instance.findProperty(_PROPERTY_TIMEREMAINING));

remaining.setValue (CIMValue (timeRemaining));

}

Line 5881

Line 5926

// Get list of subclass names for indication class

indicationSubclasses = _subscriptionRepository->getIndicationSubclasses

indicationSubclasses = _subscriptionRepository->getIndicationSubclasses(

(sourceNameSpace, indicationClassName);

sourceNameSpace, indicationClassName);

Line 5924

Line 5969

_subscriptionRepository->getFilterProperties (subscriptionInstance, query,

sourceNameSpace, queryLanguage, filterName);

QueryExpression queryExpression = _getQueryExpression(query,

QueryExpression queryExpression = _getQueryExpression(

query,

queryLanguage,

sourceNameSpace);

// Get indication class name from filter query (FROM clause)

CIMName indicationClassName = _getIndicationClassName (queryExpression,

CIMName indicationClassName =

sourceNameSpace);

_getIndicationClassName(queryExpression, sourceNameSpace);

// Get required property list from filter query (WHERE clause)

Line 5947

Line 5994

// Get list of subclass names for indication class

indicationSubclasses = _subscriptionRepository->getIndicationSubclasses

indicationSubclasses = _subscriptionRepository->getIndicationSubclasses(

(sourceNameSpace, indicationClassName);

sourceNameSpace, indicationClassName);

PEG_METHOD_EXIT ();

}

Line 5972

Line 6019

_subscriptionRepository->getFilterProperties (subscriptionInstance,

filterQuery, sourceNameSpace, queryLanguage, filterName);

QueryExpression queryExpression = _getQueryExpression(filterQuery,

QueryExpression queryExpression =

queryLanguage,

_getQueryExpression(filterQuery, queryLanguage, sourceNameSpace);

sourceNameSpace);

// Get indication class name from filter query (FROM clause)

indicationClassName = _getIndicationClassName (queryExpression,

indicationClassName =

sourceNameSpace);

_getIndicationClassName(queryExpression, sourceNameSpace);

// Get list of subclass names for indication class

indicationSubclasses = _subscriptionRepository->getIndicationSubclasses

indicationSubclasses = _subscriptionRepository->getIndicationSubclasses(

(sourceNameSpace, indicationClassName);

sourceNameSpace, indicationClassName);

// Get indication provider class lists from Active Subscriptions table

ActiveSubscriptionsTableEntry tableValue;

if (_subscriptionTable->getSubscriptionEntry

if (_subscriptionTable->getSubscriptionEntry(

(subscriptionInstance.getPath (), tableValue))

subscriptionInstance.getPath(), tableValue))

{

indicationProviders = tableValue.providers;

}

Line 6008

Line 6054

return indicationProviders;

}

// l10n

void IndicationService::_sendAsyncCreateRequests(

void IndicationService::_sendAsyncCreateRequests

const Array<ProviderClassList>& indicationProviders,

(const Array <ProviderClassList> & indicationProviders,

const CIMNamespaceName & nameSpace,

const CIMPropertyList & propertyList,

const String & condition,

Line 6040

Line 6085

// Get repeat notification policy value from subscription instance

propValue = subscription.getProperty

propValue = subscription.getProperty(

(subscription.findProperty

subscription.findProperty(

(_PROPERTY_REPEATNOTIFICATIONPOLICY)).getValue ();

_PROPERTY_REPEATNOTIFICATIONPOLICY)).getValue();

propValue.get (repeatNotificationPolicy);

CIMRequestMessage * aggRequest=0;

Line 6108

Line 6153

// Create the create subscription request

// l10n

CIMCreateSubscriptionRequestMessage * request =

new CIMCreateSubscriptionRequestMessage

new CIMCreateSubscriptionRequestMessage(

(XmlWriter::getNextMessageId (),

XmlWriter::getNextMessageId(),

nameSpace,

subscription,

indicationProviders [i].classList,

Line 6127

Line 6171

CIMCreateSubscriptionRequestMessage * requestCopy =

new CIMCreateSubscriptionRequestMessage (* request);

requestCopy->operationContext.insert(ProviderIdContainer

requestCopy->operationContext.insert(ProviderIdContainer(

(indicationProviders [i].providerModule

indicationProviders[i].providerModule

,indicationProviders [i].provider

#ifdef PEGASUS_ENABLE_REMOTE_CMPI

,indicationProviders [i].isRemoteNameSpace

Line 6136

Line 6180

#endif

));

operationAggregate->appendRequest (requestCopy);

request->operationContext.insert(ProviderIdContainer

request->operationContext.insert(ProviderIdContainer(

(indicationProviders [i].providerModule

indicationProviders[i].providerModule

,indicationProviders [i].provider

#ifdef PEGASUS_ENABLE_REMOTE_CMPI

,indicationProviders [i].isRemoteNameSpace

,indicationProviders [i].remoteInfo

#endif

));

request->operationContext.insert(SubscriptionInstanceContainer

request->operationContext.insert(

(subscription));

SubscriptionInstanceContainer(subscription));

request->operationContext.insert(SubscriptionFilterConditionContainer

request->operationContext.insert(

(condition,queryLanguage));

SubscriptionFilterConditionContainer(condition,queryLanguage));

request->operationContext.insert(SubscriptionFilterQueryContainer

request->operationContext.insert(

(query,queryLanguage,nameSpace));

SubscriptionFilterQueryContainer(query,queryLanguage,nameSpace));

request->operationContext.insert(IdentityContainer(userName));

request->operationContext.set(ContentLanguageListContainer

request->operationContext.set(

(contentLangs));

ContentLanguageListContainer(contentLangs));

request->operationContext.set(AcceptLanguageListContainer(acceptLangs));

AsyncOpNode * op = this->get_op ();

Line 6164

Line 6208

request,

_queueId);

SendAsync

SendAsync(

(op,

op,

_providerManager,

IndicationService::_aggregationCallBack,

this,

Line 6175

Line 6219

PEG_METHOD_EXIT ();

}

Array <ProviderClassList> IndicationService::_sendWaitCreateRequests

Array<ProviderClassList> IndicationService::_sendWaitCreateRequests(

(const Array <ProviderClassList> & indicationProviders,

const Array<ProviderClassList>& indicationProviders,

const CIMNamespaceName & nameSpace,

const CIMPropertyList & propertyList,

const String & condition,

Line 6206

Line 6250

// Get repeat notification policy value from subscription instance

propValue = subscription.getProperty

propValue = subscription.getProperty(

(subscription.findProperty

subscription.findProperty(

(_PROPERTY_REPEATNOTIFICATIONPOLICY)).getValue ();

_PROPERTY_REPEATNOTIFICATIONPOLICY)).getValue();

propValue.get (repeatNotificationPolicy);

Line 6220

Line 6264

// Create the create subscription request

CIMCreateSubscriptionRequestMessage * request =

new CIMCreateSubscriptionRequestMessage

new CIMCreateSubscriptionRequestMessage(

(XmlWriter::getNextMessageId (),

XmlWriter::getNextMessageId(),

nameSpace,

subscription,

indicationProviders [i].classList,

Line 6235

Line 6279

// Set operation context

request->operationContext.insert(ProviderIdContainer

request->operationContext.insert(ProviderIdContainer(

(indicationProviders [i].providerModule

indicationProviders[i].providerModule

,indicationProviders [i].provider

#ifdef PEGASUS_ENABLE_REMOTE_CMPI

,indicationProviders [i].isRemoteNameSpace

,indicationProviders [i].remoteInfo

#endif

));

request->operationContext.insert(SubscriptionInstanceContainer

request->operationContext.insert(

(subscription));

SubscriptionInstanceContainer(subscription));

request->operationContext.insert(SubscriptionFilterConditionContainer

request->operationContext.insert(

(condition,queryLanguage));

SubscriptionFilterConditionContainer(condition,queryLanguage));

request->operationContext.insert(SubscriptionFilterQueryContainer

request->operationContext.insert(

(query,queryLanguage,nameSpace));

SubscriptionFilterQueryContainer(query,queryLanguage,nameSpace));

request->operationContext.insert(IdentityContainer(userName));

request->operationContext.set(ContentLanguageListContainer

request->operationContext.set(

(contentLangs));

ContentLanguageListContainer(contentLangs));

request->operationContext.set(AcceptLanguageListContainer(acceptLangs));

AsyncLegacyOperationStart * asyncRequest =

Line 6264

Line 6308

AsyncReply * asyncReply = SendWait (asyncRequest);

CIMCreateSubscriptionResponseMessage * response =

reinterpret_cast <CIMCreateSubscriptionResponseMessage *>

reinterpret_cast<CIMCreateSubscriptionResponseMessage *>(

((static_cast <AsyncLegacyOperationResult *>

(static_cast<AsyncLegacyOperationResult *>(

(asyncReply))->get_result ());

asyncReply))->get_result());

if (response->cimException.getCode () == CIM_ERR_SUCCESS)

{

Line 6293

Line 6337

return acceptedProviders;

}

// l10n

void IndicationService::_sendWaitModifyRequests(

void IndicationService::_sendWaitModifyRequests

const Array<ProviderClassList>& indicationProviders,

(const Array <ProviderClassList> & indicationProviders,

const CIMNamespaceName & nameSpace,

const CIMPropertyList & propertyList,

const String & condition,

Line 6323

Line 6366

// Get repeat notification policy value from subscription instance

propValue = subscription.getProperty

propValue = subscription.getProperty(

(subscription.findProperty

subscription.findProperty(

(_PROPERTY_REPEATNOTIFICATIONPOLICY)).getValue ();

_PROPERTY_REPEATNOTIFICATIONPOLICY)).getValue();

propValue.get (repeatNotificationPolicy);

Line 6333

Line 6376

for (Uint32 i = 0; i < indicationProviders.size (); i++)

{

// l10n

CIMModifySubscriptionRequestMessage * request =

new CIMModifySubscriptionRequestMessage

new CIMModifySubscriptionRequestMessage(

(XmlWriter::getNextMessageId (),

XmlWriter::getNextMessageId(),

nameSpace,

subscription,

indicationProviders [i].classList,

Line 6350

Line 6392

// Set operation context

request->operationContext.insert(ProviderIdContainer

request->operationContext.insert(ProviderIdContainer(

(indicationProviders [i].providerModule

indicationProviders[i].providerModule

,indicationProviders [i].provider

#ifdef PEGASUS_ENABLE_REMOTE_CMPI

,indicationProviders [i].isRemoteNameSpace

,indicationProviders [i].remoteInfo

#endif

));

request->operationContext.insert(SubscriptionInstanceContainer

request->operationContext.insert(

(subscription));

SubscriptionInstanceContainer(subscription));

request->operationContext.insert(SubscriptionFilterConditionContainer

request->operationContext.insert(

(condition,queryLanguage));

SubscriptionFilterConditionContainer(condition,queryLanguage));

request->operationContext.insert(SubscriptionFilterQueryContainer

request->operationContext.insert(

(query,queryLanguage,nameSpace));

SubscriptionFilterQueryContainer(query,queryLanguage,nameSpace));

request->operationContext.insert(IdentityContainer(userName));

request->operationContext.set(ContentLanguageListContainer

request->operationContext.set(

(contentLangs));

ContentLanguageListContainer(contentLangs));

request->operationContext.set(AcceptLanguageListContainer(acceptLangs));

AsyncLegacyOperationStart * asyncRequest =

Line 6379

Line 6421

AsyncReply * asyncReply = SendWait (asyncRequest);

CIMModifySubscriptionResponseMessage * response =

reinterpret_cast <CIMModifySubscriptionResponseMessage *>

reinterpret_cast<CIMModifySubscriptionResponseMessage *>(

((static_cast <AsyncLegacyOperationResult *>

(static_cast<AsyncLegacyOperationResult *>(

(asyncReply))->get_result ());

asyncReply))->get_result());

if (!(response->cimException.getCode () == CIM_ERR_SUCCESS))

{

Line 6403

Line 6445

PEG_METHOD_EXIT ();

}

// l10n

void IndicationService::_sendAsyncDeleteRequests(

void IndicationService::_sendAsyncDeleteRequests

const Array<ProviderClassList>& indicationProviders,

(const Array <ProviderClassList> & indicationProviders,

const CIMNamespaceName & nameSpace,

const CIMInstance & subscription,

const AcceptLanguageList & acceptLangs,

Line 6428

Line 6469

// Update subscription hash tables

_subscriptionTable->removeSubscription

_subscriptionTable->removeSubscription(

(subscription,

subscription,

indicationSubclasses,

nameSpace,

indicationProviders);

Line 6495

Line 6536

for (Uint32 i = 0; i < indicationProviders.size (); i++)

{

// l10n

CIMDeleteSubscriptionRequestMessage * request =

new CIMDeleteSubscriptionRequestMessage

new CIMDeleteSubscriptionRequestMessage(

(XmlWriter::getNextMessageId (),

XmlWriter::getNextMessageId(),

nameSpace,

subscription,

indicationProviders [i].classList,

Line 6511

Line 6551

CIMDeleteSubscriptionRequestMessage * requestCopy =

new CIMDeleteSubscriptionRequestMessage (* request);

requestCopy->operationContext.insert(ProviderIdContainer

requestCopy->operationContext.insert(ProviderIdContainer(

(indicationProviders [i].providerModule

indicationProviders[i].providerModule

,indicationProviders [i].provider

#ifdef PEGASUS_ENABLE_REMOTE_CMPI

,indicationProviders [i].isRemoteNameSpace

Line 6520

Line 6560

#endif

));

operationAggregate->appendRequest (requestCopy);

request->operationContext.insert(ProviderIdContainer

request->operationContext.insert(ProviderIdContainer(

(indicationProviders [i].providerModule

indicationProviders[i].providerModule

,indicationProviders [i].provider

#ifdef PEGASUS_ENABLE_REMOTE_CMPI

,indicationProviders [i].isRemoteNameSpace

Line 6529

Line 6569

#endif

));

request->operationContext.insert(SubscriptionInstanceContainer

request->operationContext.insert(

(subscription));

SubscriptionInstanceContainer(subscription));

request->operationContext.insert(IdentityContainer(userName));

request->operationContext.set(ContentLanguageListContainer

request->operationContext.set(

(contentLangs));

ContentLanguageListContainer(contentLangs));

request->operationContext.set(AcceptLanguageListContainer(acceptLangs));

AsyncOpNode * op = this->get_op ();

Line 6545

Line 6585

request,

_queueId);

SendAsync

SendAsync(

(op,

op,

_providerManager,

IndicationService::_aggregationCallBack,

this,

Line 6556

Line 6596

PEG_METHOD_EXIT ();

}

void IndicationService::_sendWaitDeleteRequests

void IndicationService::_sendWaitDeleteRequests(

(const Array <ProviderClassList> & indicationProviders,

const Array<ProviderClassList>& indicationProviders,

const CIMNamespaceName & nameSpace,

const CIMInstance & subscription,

const AcceptLanguageList & acceptLangs,

Line 6581

Line 6621

for (Uint32 i = 0; i < indicationProviders.size (); i++)

{

CIMDeleteSubscriptionRequestMessage * request =

new CIMDeleteSubscriptionRequestMessage

new CIMDeleteSubscriptionRequestMessage(

(XmlWriter::getNextMessageId (),

XmlWriter::getNextMessageId(),

nameSpace,

subscription,

indicationProviders [i].classList,

Line 6593

Line 6633

// Set operation context

request->operationContext.insert(ProviderIdContainer

request->operationContext.insert(ProviderIdContainer(

(indicationProviders [i].providerModule

indicationProviders[i].providerModule

,indicationProviders [i].provider

#ifdef PEGASUS_ENABLE_REMOTE_CMPI

,indicationProviders [i].isRemoteNameSpace

,indicationProviders [i].remoteInfo

#endif

));

request->operationContext.insert(SubscriptionInstanceContainer

request->operationContext.insert(

(subscription));

SubscriptionInstanceContainer(subscription));

request->operationContext.insert(IdentityContainer(userName));

request->operationContext.set(ContentLanguageListContainer

request->operationContext.set(

(contentLangs));

ContentLanguageListContainer(contentLangs));

request->operationContext.set(AcceptLanguageListContainer(acceptLangs));

AsyncLegacyOperationStart * asyncRequest =

Line 6618

Line 6658

AsyncReply * asyncReply = SendWait (asyncRequest);

CIMDeleteSubscriptionResponseMessage * response =

reinterpret_cast <CIMDeleteSubscriptionResponseMessage *>

reinterpret_cast<CIMDeleteSubscriptionResponseMessage *>(

((static_cast <AsyncLegacyOperationResult *>

(static_cast<AsyncLegacyOperationResult *>(

(asyncReply))->get_result ());

asyncReply))->get_result());

if (!(response->cimException.getCode () == CIM_ERR_SUCCESS))

{

Line 6667

Line 6707

if (msgType == async_messages::ASYNC_LEGACY_OP_RESULT)

{

response = reinterpret_cast <CIMResponseMessage *>

response = reinterpret_cast<CIMResponseMessage *>(

((static_cast <AsyncLegacyOperationResult *>

(static_cast<AsyncLegacyOperationResult *>(

(asyncReply))->get_result ());

asyncReply))->get_result());

}

else if (msgType == async_messages::ASYNC_MODULE_OP_RESULT)

{

response = reinterpret_cast <CIMResponseMessage *>

response = reinterpret_cast<CIMResponseMessage *>(

((static_cast <AsyncModuleOperationResult *>

(static_cast<AsyncModuleOperationResult *>(

(asyncReply))->get_result ());

asyncReply))->get_result());

}

PEGASUS_ASSERT (response != 0);

Line 6717

Line 6757

default:

{

PEG_TRACE_STRING (TRC_INDICATION_SERVICE_INTERNAL, Tracer::LEVEL2,

"Unexpected request type " + String (MessageTypeToString

"Unexpected request type " + String(MessageTypeToString(

(operationAggregate->getRequest (0)->getType ())) +

operationAggregate->getRequest(0)->getType())) +

" in _handleOperationResponseAggregation");

PEGASUS_ASSERT (false);

break;

Line 6753

Line 6793

// Find provider from which response was sent

CIMResponseMessage * response = operationAggregate->getResponse (i);

ProviderClassList provider = operationAggregate->findProvider

ProviderClassList provider = operationAggregate->findProvider(

(response->messageId);

response->messageId);

if (response->cimException.getCode () == CIM_ERR_SUCCESS)

{

Line 6810

Line 6850

CIMInstance instance = request->subscriptionInstance;

try

{

instanceRef = _subscriptionRepository->createInstance

instanceRef = _subscriptionRepository->createInstance(

(request->subscriptionInstance, origRequest->nameSpace,

request->subscriptionInstance, origRequest->nameSpace,

((IdentityContainer)origRequest->operationContext.get

(IdentityContainer::NAME)).getUserName(),

((AcceptLanguageListContainer)request->operationContext.get

Line 6819

Line 6859

((ContentLanguageListContainer)request->operationContext.get

(ContentLanguageListContainer::NAME)).getLanguages(),

true);

instanceRef.setNameSpace

instanceRef.setNameSpace(

(request->subscriptionInstance.getPath().getNameSpace());

request->subscriptionInstance.getPath().getNameSpace());

instance.setPath (instanceRef);

}

catch (CIMException & exception)

Line 6829

Line 6869

}

catch (Exception & exception)

{

cimException = PEGASUS_CIM_EXCEPTION

cimException = PEGASUS_CIM_EXCEPTION(

(CIM_ERR_FAILED, exception.getMessage ());

CIM_ERR_FAILED, exception.getMessage());

}

if (cimException.getCode () == CIM_ERR_SUCCESS)

Line 6838

Line 6878

// Insert entries into the subscription hash tables

_subscriptionTable->insertSubscription

_subscriptionTable->insertSubscription(

(instance,

instance,

acceptedProviders,

operationAggregate->getIndicationSubclasses (),

request->nameSpace);

Line 6854

Line 6894

// Insert entries into the subscription hash tables

_subscriptionTable->insertSubscription

_subscriptionTable->insertSubscription(

(request->subscriptionInstance,

request->subscriptionInstance,

acceptedProviders,

operationAggregate->getIndicationSubclasses (),

request->nameSpace);

Line 6915

Line 6955

// Find provider from which response was sent and add to list

CIMResponseMessage * response = operationAggregate->getResponse (i);

ProviderClassList provider = operationAggregate->findProvider

ProviderClassList provider = operationAggregate->findProvider(

(response->messageId);

response->messageId);

checkProviders.append (provider);

Line 6977

Line 7017

// Add property values for all required properties of CIM_AlertIndication

indicationInstance.addProperty

indicationInstance.addProperty(

(CIMProperty (_PROPERTY_ALERTTYPE, CIMValue ((Uint16) _TYPE_OTHER)));

CIMProperty(_PROPERTY_ALERTTYPE, CIMValue((Uint16) _TYPE_OTHER)));

// ATTN: what should Other Alert Type value be??

// Currently using Alert class name

indicationInstance.addProperty

indicationInstance.addProperty(

(CIMProperty (_PROPERTY_OTHERALERTTYPE, alertClassName.getString()));

CIMProperty(_PROPERTY_OTHERALERTTYPE, alertClassName.getString()));

indicationInstance.addProperty

indicationInstance.addProperty(

(CIMProperty (_PROPERTY_PERCEIVEDSEVERITY,

CIMProperty(_PROPERTY_PERCEIVEDSEVERITY,

CIMValue ((Uint16) _SEVERITY_WARNING)));

// ATTN: what should Probable Cause value be??

// Currently using Unknown

indicationInstance.addProperty

indicationInstance.addProperty(

(CIMProperty (_PROPERTY_PROBABLECAUSE,

CIMProperty(_PROPERTY_PROBABLECAUSE,

CIMValue ((Uint16) _CAUSE_UNKNOWN)));

Line 7034

Line 7074

AsyncRequest *asyncRequest = static_cast<AsyncRequest *>(op->get_request());

AsyncReply *asyncReply = static_cast<AsyncReply *>(op->get_response());

CIMRequestMessage *request = reinterpret_cast<CIMRequestMessage *>

CIMRequestMessage *request = reinterpret_cast<CIMRequestMessage *>(

((static_cast<AsyncLegacyOperationStart *>(asyncRequest))->get_action());

(static_cast<AsyncLegacyOperationStart *>(asyncRequest))->get_action());

CIMHandleIndicationResponseMessage* response =

reinterpret_cast<CIMHandleIndicationResponseMessage *>

reinterpret_cast<CIMHandleIndicationResponseMessage *>(

((static_cast<AsyncLegacyOperationResult *>

(static_cast<AsyncLegacyOperationResult *>(

(asyncReply))->get_result());

asyncReply))->get_result());

PEGASUS_ASSERT(response != 0);

if (response->cimException.getCode() == CIM_ERR_SUCCESS)

Line 7056

Line 7096

// again

// << Mon Jul 15 09:59:16 2002 mdd >> handler is allocated as an element in an array,

// << Mon Jul 15 09:59:16 2002 mdd >> handler is allocated as an element in

// don't delete here.

// an array, don't delete here.

// delete _handler;

delete request;

delete response;

Line 7139

Line 7179

// Create the Subscription Init Complete request

CIMSubscriptionInitCompleteRequestMessage * request =

new CIMSubscriptionInitCompleteRequestMessage

new CIMSubscriptionInitCompleteRequestMessage(

(XmlWriter::getNextMessageId (),

XmlWriter::getNextMessageId(),

QueueIdStack (_providerManager, getQueueId ()));

Line 7168

Line 7208

{

PEG_METHOD_ENTER (TRC_INDICATION_SERVICE, "IndicationService::_getCreator");

Uint32 creatorIndex = instance.findProperty

Uint32 creatorIndex = instance.findProperty(

(PEGASUS_PROPERTYNAME_INDSUB_CREATOR);

PEGASUS_PROPERTYNAME_INDSUB_CREATOR);

if (creatorIndex != PEG_NOT_FOUND)

{

CIMValue creatorValue = instance.getProperty

CIMValue creatorValue = instance.getProperty(creatorIndex).getValue();

(creatorIndex).getValue ();

if (creatorValue.isNull ())

{

PEG_TRACE_CSTRING (TRC_INDICATION_SERVICE_INTERNAL,

Line 7245

Line 7284

return true;

}

void IndicationService::_updatePropertyList

void IndicationService::_updatePropertyList(

(CIMName & className,

CIMName& className,

CIMPropertyList & propertyList,

Boolean & setTimeRemaining,

Boolean & startTimeAdded,

Line 7313

Line 7352

PEG_METHOD_EXIT ();

}

String IndicationService::_getSubscriptionLogString

String IndicationService::_getSubscriptionLogString(CIMInstance& subscription)

(CIMInstance & subscription)

{

// Get Subscription Filter namespace and Name, and Handler namespace and

Line 7329

Line 7367

CIMObjectPath handlerPath;

CIMNamespaceName handlerNS;

Array <CIMKeyBinding> handlerKeyBindings;

filterValue = subscription.getProperty (subscription.findProperty

filterValue = subscription.getProperty(subscription.findProperty(

(PEGASUS_PROPERTYNAME_FILTER)).getValue ();

PEGASUS_PROPERTYNAME_FILTER)).getValue();

filterValue.get (filterPath);

Line 7354

Line 7392

break;

}

handlerValue = subscription.getProperty

handlerValue = subscription.getProperty(

(subscription.findProperty

subscription.findProperty(PEGASUS_PROPERTYNAME_HANDLER)).getValue();

(PEGASUS_PROPERTYNAME_HANDLER)).getValue ();

handlerValue.get (handlerPath);

Line 7383

Line 7420

return logString;

}

String IndicationService::getProviderLogString

String IndicationService::getProviderLogString(CIMInstance& provider)

(CIMInstance & provider)

{

String logString;

logString = provider.getProperty (provider.findProperty

logString = provider.getProperty(

(PEGASUS_PROPERTYNAME_NAME)).getValue ().toString ();

provider.findProperty(PEGASUS_PROPERTYNAME_NAME)).getValue().toString();

return logString;

}

Line 7425

Line 7461

// Specify localOnly=false because superclass properties are needed

// Specify includeQualifiers=false because qualifiers are not needed

indicationClass = _subscriptionRepository->getClass

indicationClass = _subscriptionRepository->getClass(

(sourceNameSpace, indicationClassName, false, false, false,

sourceNameSpace, indicationClassName, false, false, false,

CIMPropertyList ());

PEG_METHOD_EXIT();

Legend:

Removed from v.1.217
changed lines
	Added in v.1.218

No CVS admin address has been configured