static void
generateIndication2(const char *methodname, const CMPIContext *ctx)
{
CMPIInstance *inst;
CMPIObjectPath *cop;
CMPIDateTime *dat;
CMPIArray *ar;
CMPIStatus rc;
char buffer[32];
if (enabled && activated2) {
cop = CMNewObjectPath(broker, "root/interop2", "Test_Indication", &rc);
inst = CMNewInstance(broker, cop, &rc);
sprintf(buffer, "%d", _nextUID++);
CMSetProperty(inst, "IndicationIdentifier", buffer, CMPI_chars);
dat = CMNewDateTime(broker, &rc);
CMSetProperty(inst, "IndicationTime", &dat, CMPI_dateTime);
CMSetProperty(inst, "MethodName", methodname, CMPI_chars);
ar = CMNewArray(broker, 0, CMPI_string, &rc);
CMSetProperty(inst, "CorrelatedIndications", &ar, CMPI_stringA);
rc = CBDeliverIndication(broker, ctx, "root/interop", inst);
if (rc.rc != CMPI_RC_OK) {
fprintf(stderr, "+++ Could not send the indication!\n");
}
gen2++;
}
fprintf(stderr, "+++ generateIndication2() done %d\n", gen2);
}
CMPIInstance * _makeInst_ServiceProcess( const CMPIBroker * _broker,
const CMPIObjectPath * service,
CMPIObjectPath * process,
CMPIStatus * rc) {
CMPIObjectPath * op = NULL;
CMPIInstance * ci = NULL;
_OSBASE_TRACE(4,("--- _makeInst_ServiceProcess() called"));
/* create CMPIObjectPath of this association <_ClassName> */
op = CMNewObjectPath( _broker, CMGetCharPtr(CMGetNameSpace(service,rc)),
_ClassName, rc );
if( CMIsNullObject(op) ) {
CMSetStatusWithChars( _broker, rc,
CMPI_RC_ERR_FAILED, "Create CMPIObjectPath failed." );
goto exit;
}
ci = CMNewInstance( _broker, op, rc);
if( CMIsNullObject(ci) ) {
CMSetStatusWithChars( _broker, rc,
CMPI_RC_ERR_FAILED, "Create CMPIInstance failed." );
_OSBASE_TRACE(4,("--- _makeInst_ServiceProcess() failed : %s",CMGetCharPtr(rc->msg)));
goto exit;
}
CMSetProperty( ci, _RefLeft, (CMPIValue*)&(service), CMPI_ref );
CMSetProperty( ci, _RefRight, (CMPIValue*)&(process), CMPI_ref );
exit:
_OSBASE_TRACE(4,("--- _makeInst_ServiceProcess() exited"));
return ci;
}
CMPIInstance *
make_Instance(const CMPIObjectPath * op)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIInstance *ci = NULL;
ci = CMNewInstance(_broker, op, &rc);
if (rc.rc == CMPI_RC_ERR_NOT_FOUND) {
return NULL;
}
return ci;
}
int
enqRetry(RTElement * element, const CMPIContext * ctx, int repo)
{
_SFCB_ENTER(TRACE_INDPROVIDER, "enqRetry");
// Put this one on the retry queue
if (pthread_mutex_lock(&RQlock) != 0) {
// lock failed
return 1;
}
if (RQhead == NULL) {
// Queue is empty
_SFCB_TRACE(1,("--- Adding indication to new retry queue."));
RQhead = element;
RQtail = element;
RQtail->next = element;
RQtail->prev = element;
} else {
_SFCB_TRACE(1,("--- Adding indication to retry queue."));
element->next = RQtail->next;
element->next->prev = element;
RQtail->next = element;
element->prev = RQtail;
RQtail = element;
}
if (repo==1) {
// If this needs to be persisted in the repo
// (not the initial fill from refillRetryQ)
_SFCB_TRACE(1,("--- Creating SFCB_IndicationElement instance."));
CMPIObjectPath * op=CMNewObjectPath(_broker,"root/interop","SFCB_IndicationElement",NULL);
// Add the indID as the only key
CMAddKey(op,"IndicationID",&element->instanceID,CMPI_uint32);
// Create the instance
//element->SFCBIndEle=op;
element->SFCBIndEle=op->ft->clone(op,NULL);
CMPIInstance * ci=CMNewInstance(_broker,op,NULL);
// Set all the properties
CMSetProperty(ci,"IndicationID",&element->instanceID,CMPI_uint32);
CMSetProperty(ci,"RetryCount",&(RQtail->count),CMPI_uint32);
CMSetProperty(ci,"LastDelivery",&(RQtail->lasttry),CMPI_sint32);
CMSetProperty(ci,"ld",&(element->ref),CMPI_ref);
CMSetProperty(ci,"ind",&element->ind,CMPI_ref);
CMSetProperty(ci,"sub",&element->sub,CMPI_ref);
CBCreateInstance(_broker, ctx, op, ci, NULL);
CMRelease(op);
CMRelease(ci);
}
if (pthread_mutex_unlock(&RQlock) != 0) {
// lock failed
return 1;
}
_SFCB_RETURN(0);
}
CMPIInstance * make_Instance (const CMPIObjectPath * op)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIInstance *ci = NULL;
PROV_LOG ("++++ make_Instance: CMNewInstance");
ci = CMNewInstance (_broker, op, &rc);
PROV_LOG ("++++ CMNewInstance : (%s)", strCMPIStatus (rc));
if (rc.rc == CMPI_RC_ERR_NOT_FOUND)
{
PROV_LOG (" ---- Class %s is not found in the %s namespace!",
_ClassName, _Namespace);
return NULL;
}
return ci;
}
CMPIInstance *makeInstance(const CMPIBroker *broker, const char * classname,
const char * Namespace, CWS_FILE *cwsf)
{
CMPIInstance *in = NULL;
CMPIValue val;
CMPIObjectPath *op = CMNewObjectPath(broker,
(char*)Namespace,
(char*)classname,
NULL); CMSetHostname(op,CSName());
if (!CMIsNullObject(op)) {
in = CMNewInstance(broker,op,NULL);
if (!CMIsNullObject(in)) {
CMSetProperty(in,"CSCreationClassName",CSCreationClassName(),CMPI_chars);
CMSetProperty(in,"CSName",CSName(),CMPI_chars);
CMSetProperty(in,"FSCreationClassName",FSCreationClassName(),CMPI_chars);
CMSetProperty(in,"FSName",FSName(),CMPI_chars);
CMSetProperty(in,"CreationClassName",classname,CMPI_chars);
CMSetProperty(in,"Name",cwsf->cws_name,CMPI_chars);
CMSetProperty(in,"FileSize",(CMPIValue*)&cwsf->cws_size,CMPI_uint64);
#ifndef SIMULATED
/* We don't want this code in the simulated env - time is dynamic
(diff timezones) and
the testing system might using a diff timezone and report failure */
val.uint64 = cwsf->cws_ctime;
val.dateTime = CMNewDateTimeFromBinary(broker,val.uint64*1000000,0,NULL);
CMSetProperty(in,"CreationDate",&val,CMPI_dateTime);
val.uint64 = cwsf->cws_mtime;
val.dateTime = CMNewDateTimeFromBinary(broker,val.uint64*1000000,0,NULL);
CMSetProperty(in,"LastModified",&val,CMPI_dateTime);
val.uint64 = cwsf->cws_atime;
val.dateTime = CMNewDateTimeFromBinary(broker,val.uint64*1000000,0,NULL);
CMSetProperty(in,"LastAccessed",&val,CMPI_dateTime);
#endif
val.uint64=0L;
val.boolean=(cwsf->cws_mode & 0400) != 0;
CMSetProperty(in,"Readable",&val,CMPI_boolean);
val.boolean=(cwsf->cws_mode & 0200) != 0;
CMSetProperty(in,"Writeable",&val,CMPI_boolean);
val.boolean=(cwsf->cws_mode & 0100) != 0;
CMSetProperty(in,"Executable",&val,CMPI_boolean);
}
}
return in;
}
void
ElementCapabilitiesInitInstances(const CMPIContext *ctx)
{
CMPIObjectPath *op = NULL,
*opLeft = NULL,
*opRight = NULL,
*left = NULL,
*right = NULL;
CMPIValue val;
CMPIEnumeration *enm = NULL;
CMPIInstance *ci = NULL;
CMPIContext *ctxLocal;
ctxLocal = native_clone_CMPIContext(ctx);
val.string = sfcb_native_new_CMPIString("$DefaultProvider$", NULL, 0);
ctxLocal->ft->addEntry(ctxLocal, "rerouteToProvider", &val, CMPI_string);
op = CMNewObjectPath(_broker, "root/interop", "SFCB_ElementCapabilities",
NULL);
ci = CMNewInstance(_broker, op, NULL);
opLeft =
CMNewObjectPath(_broker, "root/interop", "CIM_IndicationService",
NULL);
enm = CBEnumInstanceNames(_broker, ctx, opLeft, NULL);
left = CMGetNext(enm, NULL).value.ref;
opRight =
CMNewObjectPath(_broker, "root/interop",
"SFCB_IndicationServiceCapabilities", NULL);
enm = CBEnumInstanceNames(_broker, ctx, opRight, NULL);
right = CMGetNext(enm, NULL).value.ref;
CMAddKey(op, "ManagedElement", &left, CMPI_ref);
CMAddKey(op, "Capabilities", &right, CMPI_ref);
CMSetProperty(ci, "ManagedElement", &left, CMPI_ref);
CMSetProperty(ci, "Capabilities", &right, CMPI_ref);
CBCreateInstance(_broker, ctxLocal, op, ci, NULL);
CMRelease(ctxLocal);
return;
}
CMPIInstance * _makeInst_TestClassA(
const CMPIBroker * _broker,
const CMPIContext * ctx,
const CMPIObjectPath * cop,
const char ** properties)
{
CMPIArray *array = NULL;
CMPIValue opstatus;
CMPIValue status;
CMPIValue theKey;
CMPIObjectPath* op=NULL;
CMPIInstance* ci=NULL;
opstatus.uint16 = 0; /* Unknown */
status.uint16 = 2; /* Enabled */
theKey.uint32 = 2;
//
// Construct ObjectPath
//
op=_makePath_TestClassA(_broker,ctx,cop);
//
// Create a new instance and fill it's properties
//
ci = CMNewInstance( _broker, op, NULL);
CMRelease(op);
CMSetPropertyFilter(ci,properties,NULL);
//
// Properties of CIM_ManagedElement
//
CMSetProperty(ci,"Caption","Test class A",CMPI_chars);
CMSetProperty(
ci,
"Description",
"Test class used for all kinds of testing",
CMPI_chars);
CMSetProperty(ci,"ElementName","Instance1",CMPI_chars);
//
// Properties of CIM_ManagedSystemElement
//
array = CMNewArray(_broker,1,CMPI_uint16,NULL);
CMSetArrayElementAt(array,0,&opstatus,CMPI_uint16);
CMSetProperty(ci,"OperationalStatus",(CMPIValue*)&(array),CMPI_uint16A);
//
// Properties of CIM_EnabledLogicalElement
//
CMSetProperty(ci,"EnabledState",&status,CMPI_uint16);
CMSetProperty(ci,"OtherEnabledState","NULL",CMPI_chars);
CMSetProperty(ci,"RequestedState",&status,CMPI_uint16);
CMSetProperty(ci,"EnabledDefault",&status,CMPI_uint16);
//
// Properties of CIM_TestClass
//
CMSetProperty(ci,"theKey",&theKey,CMPI_uint32 );
CMSetProperty(ci,"theData",&theKey,CMPI_uint32 );
CMSetProperty(ci,"theString","Test Instance Number One",CMPI_chars);
return ci;
}
CMPIStatus
TestAssociationProviderReferenceNames(CMPIAssociationMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt,
const CMPIObjectPath * ref,
const char *resultClass,
const char *role)
{
CMPIInstance *ci = NULL;
CMPIObjectPath *op = NULL;
CMPIObjectPath *rop = NULL;
CMPIObjectPath *cop = NULL;
CMPIEnumeration *en = NULL;
CMPIData data;
const char *targetName = NULL;
const char *_thisClassName;
const char *_RefLeftClass = NULL;
const char *_RefRightClass = NULL;
CMPIStatus rc = { CMPI_RC_OK, NULL };
_thisClassName = _ClassName;
/*
* get object path of the target class
*/
op = get_assoc_targetClass_ObjectPath(_broker,
ref,
_RefLeftClass,
_RefRightClass, &rc);
/*
* check for a failure in creating the object path
*/
if (rc.rc != CMPI_RC_OK)
return rc;
/*
* the target class does not belong to us so just return CMPI_RC_OK
*/
if (!op) {
CMSetStatusWithChars( _broker, &rc, CMPI_RC_OK, NULL );
return rc;
}
/*
* create new object path of association
*/
rop = CMNewObjectPath(_broker,
CMGetCharsPtr(CMGetNameSpace(ref, &rc), NULL),
_thisClassName, &rc);
/*
* upcall to CIMOM; call enumInstanceNames() of the target class
*/
en = CBEnumInstanceNames(_broker, ctx, op, &rc);
/*
* as long as object path entries are found in the enumeration
*/
if (!rc.rc)
while (CMHasNext(en, &rc)) {
/*
* get the object path
*/
data = CMGetNext(en, &rc);
/*
* create new instance of the association
*/
ci = CMNewInstance(_broker, rop, &rc);
/*
* get name of the target class
*/
targetName = get_assoc_targetClass_Name(_broker,
ref,
_RefLeftClass,
_RefRightClass, &rc);
/*
* set the properties of the association instance depending on the
* constellation of the source class (parameter ref) and the target
* class (see targetName)
*/
if (strcmp(targetName, "CMPI_TEST_Person") == 0) {
CMSetProperty(ci,
"model", (CMPIValue *) & (data.value.ref), CMPI_ref);
CMSetProperty(ci, "driver", (CMPIValue *) & (ref), CMPI_ref);
} else if (strcmp(targetName, "CMPI_TEST_Vehicle") == 0) {
CMSetProperty(ci,
"model", (CMPIValue *) & (data.value.ref), CMPI_ref);
CMSetProperty(ci, "driver", (CMPIValue *) & (ref), CMPI_ref);
}
/*
* get object path of association instance
*/
cop = CMGetObjectPath(ci, &rc);
/*
* set namespace in object path of association
*/
CMSetNameSpace(cop, CMGetCharsPtr(CMGetNameSpace(ref, &rc), NULL));
/*
* and return the association object path as result of the
* referenceNames() call
*/
CMReturnObjectPath(rslt, cop);
}
return rc;
}
CMPIInstance *RegisteredProfileCreateInstance(
const char *ns,
const char *name,
CMPIStatus *status)
{
CMPIInstance *ci;
char buf[256];
CMPIValue val;
_SMI_TRACE(1,("RegisteredProfileCreateInstance() called"));
if (strcasecmp(name, ArrayName) == 0 ||
strcasecmp(name, VolumeManagementName) == 0 ||
strcasecmp(name, ServerName) == 0)
{
ci = CMNewInstance(
_BROKER,
CMNewObjectPath(_BROKER, ns, RegisteredProfileName, status),
status);
}
else
{
ci = CMNewInstance(
_BROKER,
CMNewObjectPath(_BROKER, ns, RegisteredSubProfileName, status),
status);
}
if ((status->rc != CMPI_RC_OK) || CMIsNullObject(ci))
{
_SMI_TRACE(1,("RegisteredProfileCreateInstance(): CMNewInstance() failed - %s", CMGetCharPtr(status->msg)));
CMSetStatusWithChars(_BROKER, status, CMPI_RC_ERROR_SYSTEM, "Cannot create new instance");
goto exit;
}
CMSetProperty(ci, InstanceIDName,
cmpiutilMakeInstanceID(name, buf, 256), CMPI_chars);
CMSetProperty(ci, ElementName, name, CMPI_chars);
CMSetProperty(ci, ParamName, name, CMPI_chars);
CMSetProperty(ci, Caption, name, CMPI_chars);
CMSetProperty(ci, RegisteredName, name, CMPI_chars);
val.uint16 = 11;
CMSetProperty(ci, RegisteredOrg, &val, CMPI_uint16);
CMSetProperty(ci, RegisteredVersion, RegisteredVersionValue, CMPI_chars);
CMPIArray *arr = CMNewArray(_BROKER, 1, CMPI_uint16, NULL);
val.uint16 = 2;
CMSetArrayElementAt(arr, 0, &val, CMPI_uint16);
val.array = arr;
CMSetProperty(ci, AdvertiseTypes, &val, CMPI_uint16A);
arr = CMNewArray(_BROKER, 1, CMPI_string, NULL);
val.string = CMNewString(_BROKER, NotAdvertised, NULL);
CMSetArrayElementAt(arr, 0, &val, CMPI_string);
val.array = arr;
CMSetProperty(ci, AdvertiseTypeDesc, &val, CMPI_stringA);
exit:
_SMI_TRACE(1,("RegisteredProfileCreateInstance() done"));
return ci;
}
static CMPI_THREAD_RETURN CMPI_THREAD_CDECL
thread (void *args)
{
CMPIString *str = NULL;
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIStatus rc_Eval = { CMPI_RC_OK, NULL };
CMPIStatus rc_Clone = { CMPI_RC_OK, NULL };
CMPIStatus rc_Inst = { CMPI_RC_OK, NULL };
CMPIStatus rc_Pred = { CMPI_RC_OK, NULL };
CMPIStatus rc_Array = { CMPI_RC_OK, NULL };
CMPIStatus rc_CMGetPropertyAt = { CMPI_RC_OK, NULL };
CMPIString *type = NULL;
CMPISelectExp *clone = NULL;
CMPIBoolean evalRes;
CMPIInstance *inst = NULL;
CMPIObjectPath *objPath = NULL;
CMPIString *name = NULL;
CMPIData prop_data = { 0, CMPI_null, {0} };
CMPIData data = { 0, CMPI_null, {0} };
CMPIArray *projection = NULL;
/* General purpose counters */
unsigned int idx;
CMPICount cnt;
/* Select Condition and sub conditions */
CMPISelectCond *cond = NULL;
int sub_type;
CMPISubCond *subcnd = NULL;
/* Predicate operations */
CMPICount pred_cnt;
unsigned int pred_idx;
CMPIPredicate *pred = NULL;
CMPIType pred_type;
CMPIPredOp pred_op;
CMPIString *left_side = NULL;
CMPIString *right_side = NULL;
/* Thread specific data, passed in via arguments. This could also
be passed via thread specific data.. */
void **arguments = (void **) args;
CMPIContext *ctx;
CMPISelectExp *se;
char *ns;
CMPIBroker *broker;
// Copy over the CMPISelectExp, CMPIContext, CMPIBroker and the ns from the argument.
se = (CMPISelectExp *)arguments[0];
ctx = (CMPIContext *)arguments[1];
broker = (CMPIBroker *)arguments[2];
ns = (char *)arguments[3];
free(arguments);
_thread_active = 1;
// Get the CMPIContext and attach it to this thread.
rc = CBAttachThread (broker, ctx);
// Wait until we get the green signal.
while (_thread_runs == 0)
{
broker->xft->threadSleep(1000);
}
//PROV_LOG_OPEN (_IndClassName, _ProviderLocation);
PROV_LOG ("--- CBAttachThread callled.");
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("--- %s CMPI thread(void *) running",_IndClassName);
PROV_LOG ("-- #1 Clone");
clone = CMClone (se, &rc_Clone);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Clone), (rc_Clone.msg == 0) ? "" : CMGetCharPtr(rc_Clone.msg));
if (clone)
CMRelease (clone);
/*
This functionality is not used in indication providers, but instead in
ExecQuery provider API (instance providers). But for the sake
of completness this functionality is also used here. */
PROV_LOG ("-- #1.1 CMNewSelectExp");
str = CMGetSelExpString (se, &rc);
clone =
//CMPI_CQL_NewSelectExp (broker, CMGetCharPtr (str), "CIMxCQL",
CMNewSelectExp (broker, CMGetCharPtr (str), "CIM:CQL",
&projection, &rc_Clone);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Clone), (rc_Clone.msg == 0) ? "" : CMGetCharPtr(rc_Clone.msg));
if (clone)
{
if (projection)
{
PROV_LOG ("--- #1.2 Projection list is: ");
cnt = CMGetArrayCount (projection, &rc_Array);
PROV_LOG ("---- %s, [%s]", strCMPIStatus (rc_Array),(rc_Array.msg == 0) ? "" : CMGetCharPtr(rc_Array.msg));
PROV_LOG ("--- #1.3 CMGetArrayCount, %d", cnt);
for (idx = 0; idx < cnt; idx++)
{
PROV_LOG ("--- #1.4 CMGetArrayElementAt");
data = CMGetArrayElementAt (projection, idx, &rc_Array);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Array), (rc_Array.msg == 0) ? "" : CMGetCharPtr(rc_Array.msg));
PROV_LOG ("---- type is : %d", data.type);
if (data.type == CMPI_chars)
{
PROV_LOG ("---- %s (chars)", data.value.chars);
}
if (data.type == CMPI_string)
{
PROV_LOG ("---- %s (string)",
CMGetCharPtr (data.value.string));
}
}
}
else
{
PROV_LOG
("--- #1.2 No projection list, meaning it is SELECT * .... ");
}
}
// This is how an indication provider would work.
// Create an objectpath + instance and use CMEvaluateSelExp
// OR
// use CMEvaluateSelExpUsingAccessor and pass in the function that would
// provide the properties values.
PROV_LOG ("-- #2 MakeObjectPath");
// Create instance
objPath = make_ObjectPath (broker, _Namespace, _IndClassName);
type = CDGetType (broker, objPath, &rc_Inst);
PROV_LOG ("---- %s (%s) [%s]", CMGetCharPtr (type), strCMPIStatus (rc_Inst),(rc_Inst.msg == 0) ? "" : CMGetCharPtr(rc_Inst.msg));
CMRelease (type);
PROV_LOG ("-- #3 Instance");
inst = CMNewInstance (broker, objPath, &rc_Inst);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Inst), (rc_Inst.msg == 0) ? "" : CMGetCharPtr(rc_Inst.msg));
if (rc_Inst.rc == CMPI_RC_ERR_NOT_FOUND)
{
PROV_LOG (" --- Class %s is not found in the %s namespace!",
_IndClassName, _Namespace);
PROV_LOG (" --- Aborting!!! ");
goto exit;
}
type = CDGetType (broker, inst, &rc_Inst);
if (type)
{
PROV_LOG ("---- %s (%s) [%s]", CMGetCharPtr (type), strCMPIStatus (rc_Inst),(rc_Inst.msg == 0) ? "" : CMGetCharPtr(rc_Inst.msg));
CMRelease (type);
}
PROV_LOG ("- CMGetPropertyCount: %d", CMGetPropertyCount (inst, &rc));
// Set each property.
for (idx = 0; idx < CMGetPropertyCount (inst, &rc); idx++)
{
prop_data = CMGetPropertyAt (inst, idx, &name, &rc_CMGetPropertyAt);
// Really dumb way of doing it. Just set each property with its own property name.
if (prop_data.type == CMPI_string)
{
CMSetProperty (inst, CMGetCharPtr (name), CMGetCharPtr (name),
CMPI_chars);
}
prop_data = CMGetPropertyAt (inst, idx, &name, &rc_CMGetPropertyAt);
PROV_LOG ("-- %d: %s(%s: %s: %s) [%s]", idx,
CMGetCharPtr (name),
strCMPIType (prop_data.type),
strCMPIValueState (prop_data.state),
strCMPIValue (prop_data.value),
strCMPIStatus (rc_CMGetPropertyAt));
}
PROV_LOG ("-- #4 Evaluate using instance");
evalRes = CMEvaluateSelExp (se, inst, &rc_Eval);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Eval), (rc_Eval.msg == 0) ? "" : CMGetCharPtr(rc_Eval.msg));
if (evalRes == CMPI_true)
{
PROV_LOG ("--- True, sending indication");
rc_Eval = CBDeliverIndication (broker, ctx, _Namespace, inst);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Eval), (rc_Eval.msg == 0) ? "" : CMGetCharPtr(rc_Eval.msg));
}
else
{
PROV_LOG ("--- False");
}
PROV_LOG ("-- #4.1 Evalute using accessor");
evalRes =
CMEvaluateSelExpUsingAccessor (se, instance_accessor, broker, &rc_Eval);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Eval), (rc_Eval.msg == 0) ? "" : CMGetCharPtr(rc_Eval.msg));
if (evalRes == CMPI_true)
{
PROV_LOG ("--- True, but not sending indication");
}
else
{
PROV_LOG ("--- False");
}
PROV_LOG ("-- #5 CMGetSelExpString");
str = CMGetSelExpString (se, &rc);
type = CDGetType (broker, str, &rc_Inst);
if (type != NULL)
{
PROV_LOG ("---- %s (%s) [%s]", CMGetCharPtr (type), strCMPIStatus (rc_Inst), (rc_Inst.msg == 0) ? "" : CMGetCharPtr(rc_Inst.msg));
CMRelease (type);
}
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("-- #5.1 Query is [%s]", CMGetCharPtr (str));
PROV_LOG ("-- #5.2 Query is [%s]", ns);
PROV_LOG ("-- #6 Continue evaluating using GetDOC");
{
cond = CMGetDoc (se, &rc);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
if (cond != NULL)
{
PROV_LOG ("--- #6.1 CMGetSubCondCountAndType ");
cnt = CMGetSubCondCountAndType (cond, &sub_type, &rc);
PROV_LOG ("---- %s %s", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("---- Number of disjunctives: %d, Type: %X", cnt, sub_type);
/* Parsing the disjunctives */
for (idx = 0; idx < cnt; idx++)
{
PROV_LOG ("--- #6.2 CMGetSubCondAt @ %d ", idx);
subcnd = CMGetSubCondAt (cond, idx, &rc);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc),(rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("--- #6.3 CMGetPredicateCount");
pred_cnt = CMGetPredicateCount (subcnd, &rc);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("---- Number of predicates in the conjuctives: %d",
pred_cnt);
/* Parsing throught conjuctives */
for (pred_idx = 0; pred_idx < pred_cnt; pred_idx++)
{
PROV_LOG ("--- #6.4 CMGetPredicateAt, %d", pred_idx);
pred = CMGetPredicateAt (subcnd, pred_idx, &rc);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc),(rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("--- #6.4 CMGetPredicateData");
rc = CMGetPredicateData (pred,
&pred_type,
&pred_op, &left_side, &right_side);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc),(rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("----- Type: %s , CMPIPredOp: %s, LS: %s, RS: %s",
strCMPIType (pred_type), strCMPIPredOp (pred_op),
CMGetCharPtr (left_side),
CMGetCharPtr (right_side));
PROV_LOG ("--- #6.5 Evaluate using predicate");
#ifdef CMPI_VER_100
// The CMEvaluatePredicate is gone in the CMPI 1.0 standard.
evalRes =
CMEvaluatePredicateUsingAccessor (pred, instance_accessor,
NULL, &rc_Pred);
#else
// One can also evaluate this specific predicate
evalRes =
CMEvaluatePredicate (pred, "PredicateEvaluation",
CMPI_chars, &rc_Pred);
#endif
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc_Pred), (rc_Pred.msg == 0) ? "" : CMGetCharPtr(rc_Pred.msg));
if (evalRes == CMPI_true)
{
PROV_LOG ("--- True");
}
else
{
PROV_LOG ("--- False");
}
}
}
}
}
PROV_LOG ("-- #7 GetCOD");
{
cond = CMGetCod (se, &rc);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
/* Currently this is not supported in Pegasus. */
if (cond != NULL)
{
}
}
exit:
PROV_LOG ("--- CBDetachThread called");
rc = CBDetachThread (broker, ctx);
free (ns);
PROV_LOG ("---- %s [%s]", strCMPIStatus (rc), (rc.msg == 0) ? "" : CMGetCharPtr(rc.msg));
PROV_LOG ("--- %s CMPI thread(void *) exited", _IndClassName);
_thread_active = 0;
_thread_runs = 0;
return (CMPI_THREAD_RETURN) 0;
}
static void initialize()
{
CMPIStatus rc = { CMPI_RC_OK, NULL};
CMPIArray *arr_ptr;
CMPIValue value1, value2, value_inst1, value_inst2;
CMPIInstance *instance1, *instance2, *instance3;
CMPIObjectPath *cop1, *cop2, *cop3;
value1.uint8 = 1;
value2.string = CMNewString(_broker, "Hello World", &rc);
/* create a new array to hold the instances created */
arr_ptr = CMNewArray(_broker, initArraySize, CMPI_instance, &rc);
/* create object path for instance1 */
cop1 = CMNewObjectPath(
_broker,
"root/cimv2",
_ClassName,
&rc);
/* add key (with its value) to object path to recognize instance uniquely */
CMAddKey(cop1, "Identifier", (CMPIValue *)&value1, CMPI_uint8);
/* if created object path is not null then create new instance */
if(!CMIsNullObject(cop1))
{
instance1 = CMNewInstance(_broker,
cop1,
&rc);
/* set the properties for newly created instance */
CMSetProperty(instance1, "Identifier",&value1, CMPI_uint8);
CMSetProperty(instance1, "Message", &value2, CMPI_string);
value_inst1.inst = instance1;
/* assign the created instance to array created */
rc = CMSetArrayElementAt(
arr_ptr,
numOfInst,
&value_inst1,
CMPI_instance);
/* set the validity of instance to be true.
Validity gets false if instance gets deleted using deleteInstance(). */
valid[numOfInst] = 1;
numOfInst++;
}
/* create instance 2 and add to array */
value1.uint8 = 2;
value2.string = CMNewString(_broker, "Yo Planet", &rc);
cop2 = CMNewObjectPath(
_broker,
"root/cimv2",
_ClassName,
&rc);
CMAddKey(cop2, "Identifier", (CMPIValue *)&value1, CMPI_uint8);
if(!CMIsNullObject(cop2))
{
instance2 = CMNewInstance(_broker,
cop2,
&rc);
CMSetProperty(instance2, "Identifier", &value1, CMPI_uint8);
CMSetProperty(instance2, "Message", &value2, CMPI_string);
value_inst2.inst = instance2;
rc = CMSetArrayElementAt(arr_ptr,
numOfInst,
&value_inst2,
CMPI_instance);
valid[numOfInst] = 1;
numOfInst++;
}
/* create instance 3 and add to array */
value1.uint8 = 3;
value2.string = CMNewString(_broker, "Hey Earth", &rc);
cop3 = CMNewObjectPath(
_broker,
"root/cimv2",
_ClassName,
&rc);
CMAddKey(cop3, "Identifier", (CMPIValue *)&value1, CMPI_uint8);
if(!CMIsNullObject(cop3))
{
instance3 = CMNewInstance(_broker,
cop3,
&rc);
CMSetProperty(instance3, "Identifier", &value1, CMPI_uint8);
CMSetProperty(instance3, "Message", &value2, CMPI_string);
value_inst2.inst = instance3;
rc = CMSetArrayElementAt(arr_ptr,
numOfInst,
&value_inst2,
CMPI_instance);
valid[numOfInst] = 1;
numOfInst++;
}
/* clone the array which contains instances. */
clone_arr_ptr = arr_ptr->ft->clone(arr_ptr, &rc);
}
CMPIInstance * _makeInst_Service( const CMPIBroker * _broker,
const CMPIContext * ctx,
const CMPIObjectPath * ref,
const char ** properties,
LXS_Service * lxssvc,
CMPIStatus * rc) {
CMPIObjectPath * op = NULL;
CMPIInstance * ci = NULL;
const char ** keys = NULL;
int keyCount = 0;
_OSBASE_TRACE(2,("--- _makeInst_Service() called"));
/* the sblim-cmpi-base package offers some tool methods to get common
* system data
*/
if( !get_system_name() ) {
CMSetStatusWithChars( _broker, rc,
CMPI_RC_ERR_FAILED, "no host name found" );
_OSBASE_TRACE(2,("--- _makeInst_Service() failed : %s",CMGetCharPtr(rc->msg)));
goto exit;
}
op = CMNewObjectPath( _broker, CMGetCharPtr(CMGetNameSpace(ref,rc)),
_ClassName, rc );
if( CMIsNullObject(op) ) {
CMSetStatusWithChars( _broker, rc,
CMPI_RC_ERR_FAILED, "Create CMPIObjectPath failed." );
_OSBASE_TRACE(2,("--- _makeInst_Service() failed : %s",CMGetCharPtr(rc->msg)));
goto exit;
}
ci = CMNewInstance( _broker, op, rc);
if( CMIsNullObject(ci) ) {
CMSetStatusWithChars( _broker, rc,
CMPI_RC_ERR_FAILED, "Create CMPIInstance failed." );
_OSBASE_TRACE(2,("--- _makeInst_Service() failed : %s",CMGetCharPtr(rc->msg)));
goto exit;
}
/* set property filter */
keys = calloc(5,sizeof(char*));
keys[0] = strdup("SystemCreationClassName");
keys[1] = strdup("SystemName");
keys[2] = strdup("CreationClassName");
keys[3] = strdup("Name");
CMSetPropertyFilter(ci,properties,keys);
for( ;keys[keyCount]!=NULL;keyCount++) { free((char*)keys[keyCount]); }
free(keys);
CMSetProperty( ci, "SystemCreationClassName", CSCreationClassName, CMPI_chars );
CMSetProperty( ci, "SystemName", get_system_name(), CMPI_chars );
CMSetProperty( ci, "CreationClassName", _ClassName, CMPI_chars );
CMSetProperty( ci, "Name", lxssvc->svName, CMPI_chars );
CMSetProperty( ci, "Caption", "Linux (/etc/init.d) Service", CMPI_chars);
CMSetProperty( ci, "Description", "Instances of this class represents the /etc/init.d managed Services.", CMPI_chars);
CMSetProperty( ci, "Status", lxssvc->svStatus, CMPI_chars);
CMSetProperty( ci, "Started", (CMPIValue*)&(lxssvc->svStarted), CMPI_boolean);
exit:
_OSBASE_TRACE(2,("--- _makeInst_Service() exited"));
return ci;
}
CMPIStatus TestCMPIAssociationProviderReferences(
CMPIAssociationMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref,
const char *resultClass,
const char *role ,
const char** properties)
{
CMPIInstance * ci = NULL;
CMPIObjectPath * op = NULL;
CMPIObjectPath * rop = NULL;
CMPIEnumeration * en = NULL;
CMPIData data ;
const char * targetName = NULL;
char * _thisClassName;
char * _RefLeftClass = NULL;
char * _RefRightClass = NULL;
CMPIStatus rc = {CMPI_RC_OK, NULL};
_thisClassName=_ClassName;
PROV_LOG_OPEN (_thisClassName, _ProviderLocation);
PROV_LOG ("\n\n********************* %s CMPI References() called",
_thisClassName);
/* get object path of the target class */
op = get_assoc_targetClass_ObjectPath(
_broker,
ref,
_RefLeftClass,
_RefRightClass,
&rc);
PROV_LOG (" New Object Path [%s]",
CMGetCharsPtr (CMGetNameSpace (ref, &rc),NULL));
/* create new object path of association */
rop = CMNewObjectPath(
_broker,
CMGetCharsPtr(CMGetNameSpace(ref,&rc),NULL),
_thisClassName,
&rc );
/* upcall to CIMOM; call enumInstanceNames() of the target class */
en = CBEnumInstanceNames( _broker, ctx, op, &rc);
/* as long as object path entries are found in the enumeration */
while( CMHasNext( en, &rc) )
{
/* get the object path */
data = CMGetNext( en, &rc);
{
/* create new instance of the association */
ci = CMNewInstance( _broker, rop, &rc);
/* get name of the target class */
targetName = get_assoc_targetClass_Name(
_broker,
ref,
_RefLeftClass,
_RefRightClass,
&rc);
/* set the properties of the association instance depending on the
* constellation of the source class (parameter ref) and the target
* class (see targetName)
*/
if(strcmp (targetName, "CMPI_TEST_Person")== 0)
{
CMSetProperty(
ci,
"model",
(CMPIValue*)&(data.value.ref),
CMPI_ref );
CMSetProperty( ci, "driver", (CMPIValue*)&(ref), CMPI_ref );
}
else if( strcmp( targetName,"CMPI_TEST_Vehicle") == 0 )
{
CMSetProperty(
ci,
"model",
(CMPIValue*)&(data.value.ref),
CMPI_ref );
CMSetProperty( ci, "driver", (CMPIValue*)&(ref), CMPI_ref );
}
CMReturnInstance( rslt, ci );
}
}
PROV_LOG ("\n\n********************* %s CMPI References() exited",
_thisClassName);
PROV_LOG_CLOSE ();
return rc;
}
/**
initialize function will create three instances and add them to array.
"numOfInst" will represent the number of instances in the array.
*/
static void initialize()
{
CMPIStatus rc = { CMPI_RC_OK, NULL};
CMPIArray *arr_ptr;
CMPIValue value1, value2, value_inst1, value_inst2;
CMPIInstance *instance1, *instance2, *instance3;
CMPIObjectPath *cop1, *cop2, *cop3;
CMPIObjectPath *embeddedObjPath;
CMPIInstance *emInst1;
CMPIValue valueEmInst;
value1.uint8 = 1;
value2.string = CMNewString(_broker, "\\x0C9C\\x0CA8\\x0CCD\\x0CAE"
"\\x0CA6\\x0CBF\\x0CA8\\x0CA6 \\x0CB6\\x0CC1\\x0CAD\\x0CBE"
"\\x0CB6\\x0CAF\\x0C97\\x0CB3\\x0CC1", &rc);
/* Create an embedded instance to be returned as embedded object
This is an instance of a class that does not exist which
is legal in DMTF specs.
*/
embeddedObjPath = CMNewObjectPath (
_broker,
"test/TestProvider",
"TestCMPI_EmbeddedNoClass",
&rc);
assert(rc.rc == CMPI_RC_OK);
valueEmInst.uint32 = 1;
rc = CMAddKey(embeddedObjPath,"id",&valueEmInst, CMPI_uint32);
assert(rc.rc == CMPI_RC_OK);
emInst1 = CMNewInstance(_broker, embeddedObjPath, &rc);
assert(rc.rc == CMPI_RC_OK);
valueEmInst.uint32 = 1999;
rc = CMSetProperty(emInst1, "id", &valueEmInst, CMPI_uint32);
assert(rc.rc == CMPI_RC_OK);
// set the new instance into a value container
valueEmInst.inst = emInst1;
/* create a new array to hold the instances created */
arr_ptr = CMNewArray(_broker, initArraySize, CMPI_instance, &rc);
/* create object path for instance1 */
cop1 = CMNewObjectPath(
_broker,
"root/SampleProvider",
_ClassName,
&rc);
/* add key (with its value) to object path to recognize instance uniquely */
CMAddKey(cop1, "Identifier", (CMPIValue *)&value1, CMPI_uint8);
/* if created object path is not null then create new instance */
if(!CMIsNullObject(cop1))
{
instance1 = CMNewInstance(_broker,
cop1,
&rc);
/* set the properties for newly created instance */
CMSetProperty(instance1, "Identifier",&value1, CMPI_uint8);
CMSetProperty(instance1, "Message", &value2, CMPI_string);
CMSetProperty(instance1, "emObject", &valueEmInst, CMPI_instance);
value_inst1.inst = instance1;
/* assign the created instance to array created */
rc = CMSetArrayElementAt(
arr_ptr,
numOfInst,
&value_inst1,
CMPI_instance);
/* set the validity of instance to be true.
Validity gets false if instance gets deleted using deleteInstance(). */
valid[numOfInst] = 1;
numOfInst++;
}
/* create instance 2 and add to array */
value1.uint8 = 2;
value2.string = CMNewString(_broker, "\\x0CA8\\x0CBE\\x0CB3"
"\\x0CC6\\x0CA6\\x0CBF\\x0CA8", &rc);
cop2 = CMNewObjectPath(
_broker,
"root/SampleProvider",
_ClassName,
&rc);
CMAddKey(cop2, "Identifier", (CMPIValue *)&value1, CMPI_uint8);
if(!CMIsNullObject(cop2))
{
instance2 = CMNewInstance(_broker,
cop2,
&rc);
CMSetProperty(instance2, "Identifier", &value1, CMPI_uint8);
CMSetProperty(instance2, "Message", &value2, CMPI_string);
value_inst2.inst = instance2;
rc = CMSetArrayElementAt(arr_ptr,
numOfInst,
&value_inst2,
CMPI_instance);
valid[numOfInst] = 1;
numOfInst++;
}
/* create instance 3 and add to array */
value1.uint8 = 3;
value2.string = CMNewString(_broker, "\\x0C9C", &rc);
cop3 = CMNewObjectPath(
_broker,
"root/SampleProvider",
_ClassName,
&rc);
CMAddKey(cop3, "Identifier", (CMPIValue *)&value1, CMPI_uint8);
if(!CMIsNullObject(cop3))
{
instance3 = CMNewInstance(_broker,
cop3,
&rc);
CMSetProperty(instance3, "Identifier", &value1, CMPI_uint8);
CMSetProperty(instance3, "Message", &value2, CMPI_string);
CMSetProperty(instance3, "emObject", &valueEmInst, CMPI_instance);
value_inst2.inst = instance3;
rc = CMSetArrayElementAt(arr_ptr,
numOfInst,
&value_inst2,
CMPI_instance);
valid[numOfInst] = 1;
numOfInst++;
}
/* clone the array which contains instances. */
clone_arr_ptr = arr_ptr->ft->clone(arr_ptr, &rc);
}
CMPIInstance* KBase_ToInstance(
const KBase* self,
CMPIStatus* st)
{
KPos pos;
CMPIObjectPath* cop;
CMPIInstance* ci;
/* Check parameters */
if (self->magic != KMAGIC)
{
KSetStatus(st, ERR_FAILED);
return NULL;
}
if (!self->ns)
{
/* Ignore */
}
/* Create object path */
if (!(cop = KBase_ToObjectPath(self, st)))
{
return NULL;
}
/* Create instance */
if (!(ci = CMNewInstance(self->cb, cop, st)))
return NULL;
/* Set properties */
KFirst(&pos, self);
while (KMore(&pos))
{
CMPIData cd;
const KValue* value = (const KValue*)pos.field;
if (value->exists)
{
CMPIStatus st;
cd = _data(value, pos.tag);
if (value->null)
st = CMSetProperty(ci, pos.name, NULL, cd.type);
else
st = CMSetProperty(ci, pos.name, &cd.value, cd.type);
if (!KOkay(st))
{
/* ATTN: log this but do not return! */
}
}
KNext(&pos);
}
return ci;
}
CMPIStatus TestInstanceProviderExecQuery (
CMPIInstanceMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * referencePath,
const char *query,
const char *lang)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIStatus rc_Eval = { CMPI_RC_OK, NULL };
CMPIStatus rc_Clone = { CMPI_RC_OK, NULL };
CMPIStatus rc_Array = { CMPI_RC_OK, NULL };
CMPISelectExp *se_def = NULL;
CMPICount cnt = 0;
CMPIArray *projection = NULL;
unsigned int j = 0;
CMPIBoolean evalRes;
CMPIData arr_data;
CMPIInstance *instance1;
CMPIObjectPath *cop1;
CMPIData data;
CMPIValue value1;
const char* prop_name;
CMPIData retProp;
/*create the select expression */
se_def = CMNewSelectExp (_broker, query, lang, &projection, &rc_Clone);
if (se_def)
{
/*loop over instances in array to evaluate for requested properties */
for (j = 0; j < numOfInst ; j++)
{
/*check for validity of Instance,that its not deleted */
if(valid[j] == 1)
{
/*get the element from array */
arr_data = CMGetArrayElementAt(
clone_arr_ptr,
j,
&rc);
/*Evaluate the instance using this select expression */
evalRes = CMEvaluateSelExp(se_def,arr_data.value.inst, &rc_Eval);
if (evalRes)
{
/*check if any of properties are requested */
if (projection)
{
/*get number of properties requested */
cnt = CMGetArrayCount (projection, &rc_Array);
/*if count is not equal to number of properties of
instance */
if(cnt == 1)
{
/*check for the properties, requested */
data = CMGetArrayElementAt(
projection,
0,
&rc_Array);
prop_name = CMGetCharsPtr (
data.value.string,
&rc);
/*create the new instance that has to be returned */
cop1 = CMNewObjectPath(
_broker,
"root/cimv2",
_ClassName,
&rc);
instance1 = CMNewInstance(_broker,
cop1,
&rc);
/*if property name is "Identifier",
gets its value from instance */
if(!strcmp(prop_name, "Identifier"))
{
retProp = CMGetProperty(
arr_data.value.inst,
"Identifier",
&rc);
value1.uint8 = retProp.value.uint8;
CMSetProperty(
instance1,
"Identifier",
(CMPIValue *)&value1,
CMPI_uint8);
}
/*if property name is "Message",
gets its value from instance */
if(!strcmp(prop_name, "Message"))
{
retProp = CMGetProperty(
arr_data.value.inst,
"Message",
&rc);
value1.string = retProp.value.string;
CMSetProperty(
instance1,
"Message",
(CMPIValue *)&value1,
CMPI_string);
}
/*if the query is evaluated return instance */
CMReturnInstance (rslt, instance1);
}
}
else
{
CMReturnInstance(rslt, arr_data.value.inst);
}
}
}
}
}
CMReturnDone (rslt);
CMReturn (CMPI_RC_OK);
}
CMPIInstance * _makeInst_TestClass(
const CMPIBroker * _broker,
const CMPIContext * ctx,
const CMPIObjectPath * ref,
const char ** properties,
CMPIStatus * rc,
unsigned int theKey)
{
CMPIValue opstatus;
CMPIValue status;
CMPIObjectPath * op = NULL;
CMPIInstance * ci = NULL;
char * theName = NULL;
CMPIArray *array = NULL;
char **keys = NULL;
int keyCount = 0;
opstatus.uint16 = 0; /* Unknown */
status.uint16 = 2; /* Enabled */
//
// Initialize Name
//
theName = calloc(1,20);
sprintf(theName, "%u", theKey);
//
// Construct ObjectPath
//
op = CMNewObjectPath(
_broker,
CMGetCharsPtr(CMGetNameSpace(ref,rc), NULL),
_ClassName,
rc);
if (CMIsNullObject(op))
{
CMSetStatusWithChars(
_broker,
rc,
CMPI_RC_ERR_FAILED,
"Create CMPIObjectPath failed." );
goto exit;
}
//
// Create a new instance and fill it's properties
//
ci = CMNewInstance( _broker, op, rc);
if (CMIsNullObject(ci))
{
CMSetStatusWithChars(
_broker,
rc,
CMPI_RC_ERR_FAILED,
"Create CMPIInstance failed." );
goto exit;
}
//
// Set property filter
//
keys = calloc(2,sizeof(char*));
keys[0] = strdup("theKey");
CMSetPropertyFilter(ci,properties,(const char**)keys);
for (;keys[keyCount]!=NULL;keyCount++)
{
free((char*)keys[keyCount]);
}
free(keys);
//
// Properties of CIM_ManagedElement
//
CMSetProperty(ci,"Caption","Performance Test class",CMPI_chars);
CMSetProperty(
ci,
"Description",
"Test class used for all kinds of testing",
CMPI_chars);
CMSetProperty(ci,"ElementName",theName,CMPI_chars);
//
// Properties of CIM_ManagedSystemElement
//
// TBD: InstallDate
array = CMNewArray(_broker,1,CMPI_uint16,rc);
CMSetArrayElementAt(array,0,&opstatus,CMPI_uint16);
CMSetProperty(ci,"OperationalStatus",(CMPIValue*)&(array),CMPI_uint16A);
//
// Properties of CIM_EnabledLogicalElement
//
CMSetProperty( ci, "EnabledState", &status, CMPI_uint16);
CMSetProperty( ci, "RequestedState", &status, CMPI_uint16);
CMSetProperty( ci, "EnabledDefault", &status, CMPI_uint16);
//
// Properties of CIM_TestClass
//
CMSetProperty(ci,"theKey",&theKey , CMPI_uint32 );
CMSetProperty(ci,"theData",&theKey , CMPI_uint32 );
CMSetProperty(ci,"theString0","Test Data Number Zero",CMPI_chars);
CMSetProperty(ci,"theString1","Test Data Number One",CMPI_chars);
CMSetProperty(ci,"theString2","Test Data Number Two",CMPI_chars);
CMSetProperty(ci,"theString3","Test Data Number Three",CMPI_chars);
CMSetProperty(ci,"theString4","Test Data Number Four",CMPI_chars);
CMSetProperty(ci,"theString5","Test Data Number Five",CMPI_chars);
CMSetProperty(ci,"theString6","Test Data Number Six",CMPI_chars);
CMSetProperty(ci,"theString7","Test Data Number Seven",CMPI_chars);
CMSetProperty(ci,"theString8","Test Data Number Eight",CMPI_chars);
CMSetProperty(ci,"theString9","Test Data Number Nine",CMPI_chars);
exit:
free(theName);
return ci;
}
// To increase the coverage in CMPIBrokerEnc.cpp
static int _testBrokerEnc (const CMPIContext * ctx,
const CMPIResult * rslt)
{
int flag = 1 ;
int count;
char* msgId;
char* illegal;
char path[100];
void* hdl;
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIString *type;
CMPIString *cmpiStr;
CMPIBoolean bol=0;
CMPIBoolean bool=0;
CMPIArray* cmpiArray = NULL ;
CMPIInstance* instance = NULL;
CMPIInstance* instance1 = NULL;
CMPIInstance* instanceErr = NULL;
CMPIObjectPath* objPath = NULL;
CMPIObjectPath* objPath1 = NULL;
CMPICount cmpiCnt = 5;
CMPIType cmpiType = CMPI_uint64;
CMPIDateTime* cmpiDateTime = NULL ;
CMPIMsgFileHandle msgFileHandle;
CMPIEnumeration* cmpiEnum;
CMPISelectExp* selExp;
CMPIValue val;
CMPIError* err;
CMPIStatus* rc1 = NULL;
CMPIArgs* args = NULL;
void* handle;
CMPIInstanceFT* funcTable;
PROV_LOG ("++++ _testBrokerEnc ");
PROV_LOG ("++++ ObjectPath testing");
objPath1 = CMNewObjectPath (_broker, NULL, _ClassName, &rc);
PROV_LOG ("++++ New object path with NULL namespace creation : (%s)",
strCMPIStatus (rc));
CMRelease(objPath1);
objPath1 = CMNewObjectPath (_broker, _Namespace, "abc", &rc);
PROV_LOG ("++++ New object path with wrong classname : (%s)",
strCMPIStatus (rc));
instance = CMNewInstance(_broker, NULL, &rc);
PROV_LOG ("++++ New Instance with NULL object path : (%s)",
strCMPIStatus (rc));
handle = objPath1->hdl;
objPath1->hdl=NULL;
instance = CMNewInstance(_broker, objPath1, &rc);
PROV_LOG ("++++ New Instance with object path handle set to NULL: (%s)",
strCMPIStatus (rc));
objPath1->hdl = handle;
objPath = make_ObjectPath(_broker, _Namespace, _ClassName);
instance = CMNewInstance(_broker, objPath, &rc);
PROV_LOG ("++++ New Instance creation status: (%s)",
strCMPIStatus (rc));
instance1 = CMClone(instance, &rc);
instanceErr = CMClone(instance, &rc);
cmpiStr = CMNewString(_broker, NULL, &rc);
PROV_LOG ("++++ Status of mbNewString with NULL parameter:(%s)",
strCMPIStatus (rc));
err = CMNewCMPIError(_broker, "abc", "abc", "abc", 4, 5, 6, rc1);
if (err)
{
PROV_LOG ("++++ CMNewCMPIError called with null rc");
}
cmpiDateTime = CMNewDateTimeFromChars(_broker, "datetime", &rc);
PROV_LOG ("++++ Status of CMNewDateTimeFromChars with junk parameter:(%s)",
strCMPIStatus (rc));
if (!CMClassPathIsA(_broker, NULL, NULL, &rc))
{
PROV_LOG ("++++ Error Status of CMClassPathIsA:(%s)",
strCMPIStatus (rc));
}
if (!CMClassPathIsA(_broker, objPath, NULL, &rc))
{
PROV_LOG ("++++ Error Status of CMClassPathIsA:(%s)",
strCMPIStatus (rc));
}
illegal = "$";
if (!CMClassPathIsA(_broker, objPath, illegal, &rc))
{
PROV_LOG ("++++ Error Status of CMClassPathIsA:(%s)",
strCMPIStatus (rc));
}
rc = CMLogMessage(_broker,
2,
"TestProvider",
"Testing Severity 2 in TestCMPIBrokerEnc",
NULL);
PROV_LOG ("++++ Status of CMLogMessage with Severity 2:(%s)",
strCMPIStatus (rc));
rc = CMLogMessage(_broker,
3,
"TestProvider",
"Testing Severity 3 in TestCMPIBrokerEnc",
NULL);
PROV_LOG ("++++ Status of CMLogMessage with Severity 3:(%s)",
strCMPIStatus (rc));
rc = CMLogMessage(_broker,
4,
"TestProvider",
"Testing Severity 4 in TestCMPIBrokerEnc",
NULL);
PROV_LOG ("++++ Status of CMLogMessage with Severity 4:(%s)",
strCMPIStatus (rc));
rc = CMTraceMessage(_broker,
2,
"CMPIProvider",
"Tracing for level 2",
NULL);
PROV_LOG ("++++ Status of CMTraceMessage with level 2:(%s)",
strCMPIStatus (rc));
rc = CMTraceMessage(_broker,
3,
"CMPIProvider",
"Tracing for level 3",
NULL);
PROV_LOG ("++++ Status of CMTraceMessage with level 3:(%s)",
strCMPIStatus (rc));
rc = CMTraceMessage(_broker,
4,
"CMPIProvider",
"Tracing for level 4",
NULL);
PROV_LOG ("++++ Status of CMTraceMessage with level 4:(%s)",
strCMPIStatus (rc));
cmpiStr = CMNewString(_broker, "Tracing for level 5", &rc);
rc = CMTraceMessage(_broker,
5,
"CMPIProvider",
NULL,
cmpiStr);
PROV_LOG ("++++ Status of CMTraceMessage with level 5:(%s)",
strCMPIStatus (rc));
CMRelease(cmpiStr);
PROV_LOG ("++++ Calling mbEncToString function ");
type = CDToString (_broker, _broker, &rc);
PROV_LOG ("++++ Error status of mbEncToString with wrong object path:"
" (%s)",
strCMPIStatus (rc));
type = CDToString (_broker, NULL, &rc);
PROV_LOG ("++++ Error status of mbEncToString with NULL parameter:"
" (%s)",
strCMPIStatus (rc));
type = CDToString (_broker, type, &rc);
PROV_LOG ("++++ Passing CMPIString to mbEncToString successes : (%s)",
strCMPIStatus (rc));
type = CDToString (_broker, objPath, &rc);
PROV_LOG ("++++ Passing CMPIObjectPath to mbEncToString successes : (%s)",
strCMPIStatus (rc));
handle = objPath1->hdl;
objPath1->hdl = NULL;
type = CDToString (_broker, objPath1, &rc);
if ( rc.rc == CMPI_RC_ERR_INVALID_PARAMETER)
{
PROV_LOG ("++++ Error status of mbEncToString with object path with "
"NULL handle: (%s)",
strCMPIStatus (rc));
}
objPath1->hdl = handle;
val.boolean = 1;
rc = CMSetProperty (instance, "Boolean", &val, CMPI_boolean);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_boolean : (%s)",
strCMPIStatus (rc));
val.uint8 = 8;
rc = CMSetProperty (instance, "Uint8", &val, CMPI_uint8);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint8 : (%s)",
strCMPIStatus (rc));
val.uint16 = 16;
rc = CMSetProperty (instance, "Uint16", &val, CMPI_uint16);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint16 : (%s)",
strCMPIStatus (rc));
val.uint32 = 32;
rc = CMSetProperty (instance, "Uint32", &val, CMPI_uint32);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint32 : (%s)",
strCMPIStatus (rc));
val.uint64 = 64;
rc = CMSetProperty (instance, "Uint64", &val, CMPI_uint64);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_uint64 : (%s)",
strCMPIStatus (rc));
val.sint8 = -8;
rc = CMSetProperty (instance, "Sint8", &val, CMPI_sint8);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint8 : (%s)",
strCMPIStatus (rc));
val.sint16 = -16;
rc = CMSetProperty (instance, "Sint16", &val, CMPI_sint16);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint16 : (%s)",
strCMPIStatus (rc));
val.sint32 = -32;
rc = CMSetProperty (instance, "Sint32", &val, CMPI_sint32);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint32 : (%s)",
strCMPIStatus (rc));
val.sint64 = -64;
rc = CMSetProperty (instance, "Sint64", &val, CMPI_sint64);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_sint64 : (%s)",
strCMPIStatus (rc));
val.real32 = 32.32;
rc = CMSetProperty (instance, "Real32", &val, CMPI_real32);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_real32 : (%s)",
strCMPIStatus (rc));
val.real64 = 64.64;
rc = CMSetProperty (instance, "Real64", &val, CMPI_real64);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_real64 : (%s)",
strCMPIStatus (rc));
val.char16 = 'c';
rc = CMSetProperty (instance, "Char16", &val, CMPI_char16);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_char16 : (%s)",
strCMPIStatus (rc));
cmpiDateTime = CMNewDateTime (_broker, &rc);
val.dateTime = cmpiDateTime;
rc = CMSetProperty (instance, "DateTime", &val, CMPI_dateTime);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_dateTime : (%s)",
strCMPIStatus (rc));
val.ref = objPath;
rc = CMSetProperty (instance, "Ref", &val, CMPI_ref);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_ref : (%s)",
strCMPIStatus (rc));
val.inst = instance1;
rc = CMSetProperty (instance, "Instance", &val, CMPI_instance);
PROV_LOG ("++++ Status of CMSetProperty of type CMPI_instance : (%s)",
strCMPIStatus (rc));
type = CDToString (_broker, instance, &rc);
PROV_LOG ("++++ Passing CMPIInstance to mbEncToString successes : (%s)",
strCMPIStatus (rc));
args = CMNewArgs(_broker, &rc);
PROV_LOG ("++++ Status of CMNewArgs : (%s)", strCMPIStatus (rc));
type = CDToString (_broker, args, &rc);
PROV_LOG ("++++ Passing CMPIArgs to mbEncToString successes : (%s)",
strCMPIStatus (rc));
PROV_LOG ("++++ Calling mbEncGetType function ");
rc1 = NULL;
type = CDGetType (_broker, NULL, rc1);
if (!type)
{
PROV_LOG ("++++ Error calling mbEncGetType with NULL rc");
}
rc1 = NULL;
funcTable = instanceErr->ft;
instanceErr->ft = NULL;
type = CDGetType (_broker, instanceErr, rc1);
if (!type)
{
PROV_LOG ("++++ Error calling mbEncGetType with wrong parameter and"
" NULL rc");
}
type = CDGetType (_broker, instanceErr, &rc);
PROV_LOG ("++++ Error status of mbEncGetType with wrong input : (%s)",
strCMPIStatus (rc));
instanceErr->ft = funcTable;
type = CDGetType (_broker, NULL, &rc);
PROV_LOG ("++++ Error status of mbEncGetType with NULL input : (%s)",
strCMPIStatus (rc));
type = CDGetType (_broker, instance, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIInstance"
" : (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CDGetType (_broker, objPath, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIObjectPath:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
cmpiStr = CMNewString(_broker, "Test1", & rc);
type = CDGetType (_broker, cmpiStr, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIString:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CDGetType (_broker, _broker, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIBroker:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
cmpiArray = CMNewArray(_broker, cmpiCnt,cmpiType, &rc);
type = CDGetType (_broker, cmpiArray, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIArray:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CDGetType (_broker, cmpiDateTime, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIDateTime:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CDGetType (_broker, ctx, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIContext:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CDGetType (_broker, rslt, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIResult:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
rc1 = NULL;
selExp = CMNewSelectExp(_broker,
"SELECT c,b FROM TestCMPI_Indication WHERE c='c' OR b=1",
"WQL",
NULL,
rc1);
PROV_LOG ("++++ CMNewSelectExp with rc set to NULL Called");
selExp = CMNewSelectExp(_broker,
"SELECT c,b FROM TestCMPI_Indication",
"WQL",
NULL,
&rc);
PROV_LOG ("++++ Status of CMNewSelectExp: (%s) ",
strCMPIStatus (rc));
type = CDGetType (_broker, selExp, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPISelectExp:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
handle = objPath1->hdl;
objPath1->hdl = NULL;
rc = CMRelease(objPath1);
PROV_LOG ("++++ Status of CMRelease(objPath1): (%s)",
strCMPIStatus (rc));
objPath1->hdl = handle;
rc = CMRelease(objPath1);
PROV_LOG ("++++ Status of CMRelease(objPath1): (%s)",
strCMPIStatus (rc));
objPath1 = CMNewObjectPath(_broker,
"test/TestProvider",
"TestCMPI_Instance",
&rc);
PROV_LOG ("++++ Status of CMNewObjectPath for TestCMPI_Instance : (%s)",
strCMPIStatus (rc));
PROV_LOG_CLOSE();
cmpiEnum = CBEnumInstances(_broker, ctx, objPath1, NULL, &rc);
PROV_LOG_OPEN (_ClassName, _ProviderLocation);
PROV_LOG ("++++ Status of CBEnumInstances : (%s)",
strCMPIStatus (rc));
type = CDGetType (_broker, cmpiEnum, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIEnumeration:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CDGetType (_broker, args, &rc);
PROV_LOG ("++++ Status of mbEncGetType with input of type CMPIArgs:"
" (%s) type(%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
PROV_LOG ("++++ Calling mbEncIsOfType function ");
bol = CDIsOfType (_broker, NULL, "No object", rc1);
if(!bol)
{
PROV_LOG ("++++Calling mbEncIsOfType with NULL rc and wrong"
" parameters");
}
bol = CDIsOfType (_broker, instance, "CMPIInstance", rc1);
if(!bol)
{
PROV_LOG ("++++ Calling mbEncIsOfType with NULL rc");
}
bol = CDIsOfType (_broker, NULL, "No object", &rc);
PROV_LOG ("++++ Error Status of mbEncIsOfType : (%s)", strCMPIStatus (rc));
bol = CDIsOfType (_broker, instance, "CMPIInstance", &rc);
if ( bol )
{
PROV_LOG ("++++ CDIsOfType for CMPIInstance status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, instance, "CMPI", &rc);
if ( !bol )
{
PROV_LOG ("++++ CDIsOfType for CMPIInstance status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, objPath, "CMPIObjectPath", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIObjectPath status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, objPath, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIObjectPath status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiDateTime, "CMPIDateTime", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIDateTime status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiDateTime, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIDateTime status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiStr, "CMPIString", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIString status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiStr, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIString status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, _broker, "CMPIBroker", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIBroker status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, _broker, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIBroker status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiArray, "CMPIArray", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIArray status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiArray, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIArray status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, rslt, "CMPIResult", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIResult status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, rslt, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIResult status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, ctx, "CMPIContext", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIContext status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, ctx, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIContext status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiEnum, "CMPIEnumeration", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIEnumeration status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, cmpiEnum, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIEnumeration status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
/* Testcase to increase coverage in CMPI_Enumeration.cpp*/
rc = CMRelease(cmpiEnum);
PROV_LOG ("++++ Status of CMRelease on cmpiEnum :(%s)",
strCMPIStatus (rc));
/**********************************************************/
bol = CDIsOfType (_broker, selExp, "CMPISelectExp", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPISelectExp status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, selExp, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CDIsOfType for CMPISelectExp status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, args, "CMPIArgs", &rc);
if (bol)
{
PROV_LOG ("++++ CDIsOfType for CMPIArgs status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
bol = CDIsOfType (_broker, args, "CMPI", &rc);
if (!bol)
{
PROV_LOG ("++++ CdIsOfType for CMPIArgs status is (%s) : %d",
strCMPIStatus (rc),
bol);
}
type = CMGetMessage (_broker,
"msgid",
"Test 0 arguments",
&rc,
0);
PROV_LOG ("++++ Status of GetMessage with 0 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0",
&rc,
CMFmtArgs1(CMFmtChars("one argument")));
PROV_LOG ("++++ Status of GetMessage with 1 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1",
&rc,
CMFmtArgs2(CMFmtChars("Sint32 ::"),
CMFmtSint(-1)));
PROV_LOG ("++++ Status of GetMessage with 2 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2",
&rc,
CMFmtArgs3(CMFmtChars("Sint32, Uint32 ::"),
CMFmtSint(-1),
CMFmtUint(1)));
PROV_LOG ("++++ Status of GetMessage with 3 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2, $3",
&rc,
CMFmtArgs4(CMFmtChars("Sint32, Uint32, Sint64 ::"),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64)));
PROV_LOG ("++++ Status of GetMessage with 4 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2, $3, $4",
&rc,
CMFmtArgs5(CMFmtChars("Sint32, Uint32, Sint64, Uint64 ::"),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64)));
PROV_LOG ("++++ Status of GetMessage with 5 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2, $3, $4, $5",
&rc,
CMFmtArgs6(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64 ::"),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64)));
PROV_LOG ("++++ Status of GetMessage with 6 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2, $3, $4, $5, $6",
&rc,
CMFmtArgs7(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64,"
" Boolean:: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64),
CMFmtBoolean(1)));
PROV_LOG ("++++ Status of GetMessage with 7 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2, $3, $4, $5, $6, $7",
&rc,
CMFmtArgs8(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64,"
" Boolean, chars:: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64),
CMFmtBoolean(1),
CMFmtChars("chars")));
PROV_LOG ("++++ Status of GetMessage with 8 arguments(%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage (_broker,
"msgid",
"Test $0 $1, $2, $3, $4, $5, $6, $7, $8",
&rc,
CMFmtArgs9(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64,"
" Boolean, chars, String :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64),
CMFmtBoolean(1),
CMFmtChars("chars"),
CMFmtString(cmpiStr)));
PROV_LOG ("++++ Status of GetMessage with 9 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
strcpy(path,"path");
rc = CMOpenMessageFile(_broker, path, &msgFileHandle);
PROV_LOG ("++++ Status of CMOpenMessageFile (%s) ",
strCMPIStatus (rc));
type = CMGetMessage2(_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test zero arguments",
&rc,
0);
PROV_LOG ("++++ Status of GetMessage2 with 0 argument (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2(_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0",
&rc,
CMFmtArgs1(CMFmtChars("Single argument")));
PROV_LOG ("++++ Status of GetMessage2 with 1 argument (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2(_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1",
&rc,
CMFmtArgs2(CMFmtChars("Sint32 ::"),CMFmtSint(1)));
PROV_LOG ("++++ Status of GetMessage2 with 2 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2",
&rc,
CMFmtArgs3(CMFmtChars("Sint32, Uint32 :: "),
CMFmtSint(-1),
CMFmtUint(1)));
PROV_LOG ("++++ Status of GetMessage2 with 3 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2, $3",
&rc,
CMFmtArgs4(CMFmtChars("Sint32, Uint32, Sint64 :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64)));
PROV_LOG ("++++ Status of GetMessage2 with 4 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2, $3, $4",
&rc,
CMFmtArgs5(CMFmtChars("Sint32, Uint32, Sint64, Uint64 :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64)));
PROV_LOG ("++++ Status of GetMessage2 with 5 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2, $3, $4, $5",
&rc,
CMFmtArgs6(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64 :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64)));
PROV_LOG ("++++ Status of GetMessage2 with 6 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2, $3, $4, $5, $6",
&rc,
CMFmtArgs7(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64,"
" Boolean :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64),
CMFmtBoolean(1)));
PROV_LOG ("++++ Status of GetMessage2 with 7 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2, $3, $4, $5, $6, $7",
&rc,
CMFmtArgs8(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64,"
" Boolean, chars :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64),
CMFmtBoolean(1),
CMFmtChars("chars")));
PROV_LOG ("++++ Status of GetMessage2 with 8 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
type = CMGetMessage2 (_broker,
"Common.CIMStatusCode.CIM_ERR_SUCCESS",
msgFileHandle,
"Test $0 $1, $2, $3, $4, $5, $6, $7, $8",
&rc,
CMFmtArgs9(CMFmtChars("Sint32, Uint32, Sint64, Uint64, Real64,"
" Boolean, chars, String :: "),
CMFmtSint(-1),
CMFmtUint(1),
CMFmtSint64(-64),
CMFmtUint64(64),
CMFmtReal(64.64),
CMFmtBoolean(1),
CMFmtChars("chars"),
CMFmtString(cmpiStr)));
PROV_LOG ("++++ Status of GetMessage2 with 9 arguments (%s) type (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(type, NULL));
rc = CMCloseMessageFile(_broker, msgFileHandle);
PROV_LOG ("++++ Status of CMCloseMessageFile (%s) ",
strCMPIStatus (rc));
CMRelease(instance1);
CMRelease(instanceErr);
return flag ;
}
CMPIInstance *SoftwareIdentityCreateInstance(
const char *ns,
const char *name,
CMPIStatus *status)
{
CMPIInstance *ci;
char buf[256];
CMPIValue val;
_SMI_TRACE(1,("SoftwareIdentityCreateInstance() called"));
if (strcasecmp(name, SMIVolumeManagementName) == 0)
{
ci = CMNewInstance(
_BROKER,
CMNewObjectPath(_BROKER, ns, VolumeManagementSoftwareName, status),
status);
if ((status->rc != CMPI_RC_OK) || CMIsNullObject(ci))
{
_SMI_TRACE(1,("SoftwareIdentityCreateInstance(): CMNewInstance() failed - %s", CMGetCharPtr(status->msg)));
CMSetStatusWithChars(_BROKER, status, CMPI_RC_ERROR_SYSTEM, "Cannot create new instance");
goto exit;
}
CMSetProperty(ci, InstanceIDName,
cmpiutilMakeInstanceID(name, buf, 256), CMPI_chars);
CMSetProperty(ci, ElementName, VMProfileName, CMPI_chars);
CMSetProperty(ci, ParamName, VMProfileName, CMPI_chars);
CMSetProperty(ci, Caption, VMProfileName, CMPI_chars);
CMSetProperty(ci, Description, VMProfileName, CMPI_chars);
CMSetProperty(ci, VersionString, VersionStringValue, CMPI_chars);
CMSetProperty(ci, Manufacturer, ManufacturerName, CMPI_chars);
CMSetProperty(ci, Status, OK, CMPI_chars);
val.uint16 = 5;
CMSetProperty(ci, HealthState, &val, CMPI_uint16);
CMPIArray *arr = CMNewArray(_BROKER, 2, CMPI_uint16, NULL);
val.uint16 = 3;
CMSetArrayElementAt(arr, 0, &val, CMPI_uint16);
val.uint16 = 5;
CMSetArrayElementAt(arr, 1, &val, CMPI_uint16);
val.array = arr;
CMSetProperty(ci, Classifications, &val, CMPI_uint16A);
arr = CMNewArray(_BROKER, 1, CMPI_uint16, NULL);
val.uint16 = 2;
CMSetArrayElementAt(arr, 0, &val, CMPI_uint16);
val.array = arr;
CMSetProperty(ci, OperationalStatus, &val, CMPI_uint16A);
}
else if (strcasecmp(name, SMIArrayName) == 0)
{
ci = CMNewInstance(
_BROKER,
CMNewObjectPath(_BROKER, ns, ArraySoftwareName, status),
status);
if ((status->rc != CMPI_RC_OK) || CMIsNullObject(ci))
{
_SMI_TRACE(1,("SoftwareIdentityCreateInstance(): CMNewInstance() failed - %s", CMGetCharPtr(status->msg)));
CMSetStatusWithChars(_BROKER, status, CMPI_RC_ERROR_SYSTEM, "Cannot create new instance");
goto exit;
}
CMSetProperty(ci, InstanceIDName,
cmpiutilMakeInstanceID(name, buf, 256), CMPI_chars);
CMSetProperty(ci, ElementName, ArrayProfileName, CMPI_chars);
CMSetProperty(ci, ParamName, ArrayProfileName, CMPI_chars);
CMSetProperty(ci, Caption, ArrayProfileName, CMPI_chars);
CMSetProperty(ci, Description, ArrayProfileName, CMPI_chars);
CMSetProperty(ci, VersionString, VersionStringValue, CMPI_chars);
CMSetProperty(ci, Manufacturer, ManufacturerName, CMPI_chars);
CMSetProperty(ci, Status, OK, CMPI_chars);
val.uint16 = 5;
CMSetProperty(ci, HealthState, &val, CMPI_uint16);
CMPIArray *arr = CMNewArray(_BROKER, 2, CMPI_uint16, NULL);
val.uint16 = 3;
CMSetArrayElementAt(arr, 0, &val, CMPI_uint16);
val.uint16 = 5;
CMSetArrayElementAt(arr, 1, &val, CMPI_uint16);
val.array = arr;
CMSetProperty(ci, Classifications, &val, CMPI_uint16A);
arr = CMNewArray(_BROKER, 1, CMPI_uint16, NULL);
val.uint16 = 2;
CMSetArrayElementAt(arr, 0, &val, CMPI_uint16);
val.array = arr;
CMSetProperty(ci, OperationalStatus, &val, CMPI_uint16A);
}
exit:
_SMI_TRACE(1,("SoftwareIdentityCreateInstance() done"));
return ci;
}
