CMPIStatus
IndCIMXMLHandlerDeleteInstance(CMPIInstanceMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt,
const CMPIObjectPath * cop)
{
CMPIStatus st = { CMPI_RC_OK, NULL };
CMPIArgs *in,
*out = NULL;
CMPIObjectPath *op;
CMPIData rv;
_SFCB_ENTER(TRACE_INDPROVIDER, "IndCIMXMLHandlerDeleteInstance");
if (interOpNameSpace(cop, &st) == 0)
_SFCB_RETURN(st);
internalProviderGetInstance(cop, &st);
if (st.rc)
_SFCB_RETURN(st);
in = CMNewArgs(_broker, NULL);
CMAddArg(in, "key", &cop, CMPI_ref);
op = CMNewObjectPath(_broker, "root/interop",
"cim_indicationsubscription", &st);
rv = CBInvokeMethod(_broker, ctx, op, "_removeHandler", in, out, &st);
if (st.rc == CMPI_RC_OK) {
st = InternalProviderDeleteInstance(NULL, ctx, rslt, cop);
}
_SFCB_RETURN(st);
}
static void TCPCOMM_invokeMethod(int socket, CONST CMPIBroker * broker,
CONST CMPIContext * context)
{
CMPIArgs *in, *out;
CMPIData result;
CMPIStatus rc;
CMPIObjectPath *cop;
char *method;
cop = (__sft)->deserialize_CMPIObjectPath(socket, broker);
method = (__sft)->deserialize_string(socket, broker);
in = (__sft)->deserialize_CMPIArgs(socket, broker);
out = CMNewArgs(broker, NULL);
result = CBInvokeMethod(broker, context, cop, method, in, out, &rc);
(__sft)->serialize_CMPIStatus(socket, &rc);
(__sft)->serialize_CMPIArgs(socket, out);
(__sft)->serialize_CMPIData(socket, result);
}
CMPIStatus
IndCIMXMLHandlerCreateInstance(CMPIInstanceMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt,
const CMPIObjectPath * cop,
const CMPIInstance *ci)
{
CMPIStatus st = { CMPI_RC_OK, NULL };
CMPIArgs *in,
*out = NULL;
CMPIObjectPath *op;
CMPIData rv;
unsigned short persistenceType;
_SFCB_ENTER(TRACE_INDPROVIDER, "IndCIMXMLHandlerCreateInstance");
if (interOpNameSpace(cop, &st) == 0)
_SFCB_RETURN(st);
internalProviderGetInstance(cop, &st);
if (st.rc == CMPI_RC_ERR_FAILED)
_SFCB_RETURN(st);
if (st.rc == CMPI_RC_OK) {
setStatus(&st, CMPI_RC_ERR_ALREADY_EXISTS, NULL);
_SFCB_RETURN(st);
}
CMPIInstance *ciLocal = CMClone(ci, NULL);
memLinkInstance(ciLocal);
CMPIObjectPath* copLocal = CMClone(cop, NULL);
memLinkObjectPath(copLocal);
setCCN(copLocal,ciLocal,"CIM_ComputerSystem");
CMPIString *sysname=ciLocal->ft->getProperty(ciLocal,"SystemName",&st).value.string;
if (sysname == NULL || sysname->hdl == NULL) {
char hostName[512];
hostName[0]=0;
gethostname(hostName,511); /* should be the same as SystemName of IndicationService */
CMAddKey(copLocal, "SystemName", hostName, CMPI_chars);
CMSetProperty(ciLocal,"SystemName",hostName,CMPI_chars);
}
CMPIString *dest =
CMGetProperty(ciLocal, "destination", &st).value.string;
if (dest == NULL || CMGetCharPtr(dest) == NULL) {
setStatus(&st, CMPI_RC_ERR_FAILED,
"Destination property not found; is required");
CMRelease(ciLocal);
_SFCB_RETURN(st);
} else { /* if no scheme is given, assume http (as
* req. for param by mof) */
char *ds = CMGetCharPtr(dest);
if (strstr(ds, "://") == NULL) {
char *prefix = "http://";
int n = strlen(ds) + strlen(prefix) + 1;
char *newdest = (char *) malloc(n * sizeof(char));
strcpy(newdest, prefix);
strcat(newdest, ds);
CMSetProperty(ciLocal, "destination", newdest, CMPI_chars);
free(newdest);
}
}
CMPIData persistence =
CMGetProperty(ciLocal, "persistencetype", &st);
if (persistence.state == CMPI_nullValue
|| persistence.state == CMPI_notFound) {
persistenceType = 2; /* default is 2 = permanent */
} else if (persistence.value.uint16 < 1 || persistence.value.uint16 > 3) {
setStatus(&st, CMPI_RC_ERR_FAILED,
"PersistenceType property must be 1, 2, or 3");
CMRelease(ciLocal);
_SFCB_RETURN(st);
} else {
persistenceType = persistence.value.uint16;
}
CMSetProperty(ciLocal, "persistencetype", &persistenceType, CMPI_uint16);
if (CMClassPathIsA(_broker, copLocal, "cim_listenerdestination", NULL)) {
//get the creation timestamp
struct timeval tv;
struct timezone tz;
char context[100];
gettimeofday(&tv, &tz);
struct tm cttm;
char * gtime = (char *) malloc(15 * sizeof(char));
memset(gtime, 0, 15 * sizeof(char));
if (gmtime_r(&tv.tv_sec, &cttm) != NULL) {
strftime(gtime, 15, "%Y%m%d%H%M%S", &cttm);
}
// Even though reliable indications may be disabled, we need to do this
// in case it ever gets enabled.
// Get the IndicationService name
CMPIObjectPath * isop = CMNewObjectPath(_broker, "root/interop", "CIM_IndicationService", NULL);
CMPIEnumeration * isenm = _broker->bft->enumerateInstances(_broker, ctx, isop, NULL, NULL);
CMPIData isinst = CMGetNext(isenm, NULL);
CMPIData mc = CMGetProperty(isinst.value.inst, "Name", NULL);
// build the context string
sprintf (context,"%s#%s#",mc.value.string->ft->getCharPtr(mc.value.string,NULL),gtime);
CMPIValue scontext;
scontext.string = sfcb_native_new_CMPIString(context, NULL, 0);
free(gtime);
// set the properties
CMSetProperty(ciLocal, "SequenceContext", &scontext, CMPI_string);
CMPIValue zarro = {.sint64 = -1 };
CMSetProperty(ciLocal, "LastSequenceNumber", &zarro, CMPI_sint64);
}
CMPIString *str = CDToString(_broker, copLocal, NULL);
CMPIString *ns = CMGetNameSpace(copLocal, NULL);
_SFCB_TRACE(1,
("--- handler %s %s", (char *) ns->hdl, (char *) str->hdl));
in = CMNewArgs(_broker, NULL);
CMAddArg(in, "handler", &ciLocal, CMPI_instance);
CMAddArg(in, "key", &copLocal, CMPI_ref);
op = CMNewObjectPath(_broker, "root/interop",
"cim_indicationsubscription", &st);
rv = CBInvokeMethod(_broker, ctx, op, "_addHandler", in, out, &st);
if (st.rc == CMPI_RC_OK) {
st = InternalProviderCreateInstance(NULL, ctx, rslt, copLocal, ciLocal);
}
else {
rv=CBInvokeMethod(_broker,ctx,op,"_removeHandler",in,out,NULL);
}
_SFCB_RETURN(st);
}
CMPIStatus
IndCIMXMLHandlerModifyInstance(CMPIInstanceMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt,
const CMPIObjectPath * cop,
const CMPIInstance *ci,
const char **properties)
{
CMPIStatus st = { CMPI_RC_ERR_NOT_SUPPORTED, NULL };
_SFCB_ENTER(TRACE_INDPROVIDER, "IndCIMXMLHandlerSetInstance");
_SFCB_RETURN(st);
}
CMPIStatus
getRefs(const CMPIContext *ctx, const CMPIResult *rslt,
const CMPIObjectPath * cop,
const char *assocClass,
const char *resultClass,
const char *role,
const char *resultRole,
const char **propertyList, int associatorFunction)
{
UtilList *refs = UtilFactory->newList(memAddUtilList, memUnlinkEncObj);
char *ns = (char *) CMGetNameSpace(cop, NULL)->hdl;
CMPIStatus st = { CMPI_RC_OK, NULL };
_SFCB_ENTER(TRACE_INTERNALPROVIDER, "getRefs");
if (assocClass != NULL) {
CMPIObjectPath *path;
if (assocForName(ns, assocClass, role, resultRole) == NULL) {
/*
* for an unknown class we just return nothing
*/
_SFCB_RETURN(st);
}
path = CMNewObjectPath(_broker, ns, assocClass, NULL);
SafeInternalProviderAddEnumInstances(refs, NULL, ctx, path,
propertyList, &st, 1);
}
else {
CMPIData rv;
CMPIObjectPath *op =
CMNewObjectPath(Broker, ns, "$ClassProvider$", &st);
CMPIArgs *in = CMNewArgs(Broker, NULL);
CMPIArgs *out = CMNewArgs(Broker, NULL);
rv = CBInvokeMethod(Broker, ctx, op, "getassocs", in, out, &st);
if (out) {
int i,
m;
CMPIArray *ar = CMGetArg(out, "assocs", &st).value.array;
for (i = 0, m = CMGetArrayCount(ar, NULL); i < m; i++) {
char *name =
CMGetArrayElementAt(ar, i, NULL).value.string->hdl;
if (name) {
CMPIObjectPath *cop = CMNewObjectPath(Broker, ns, name, NULL);
if (cop) {
SafeInternalProviderAddEnumInstances(refs, NULL, ctx, cop,
propertyList, &st, 1);
}
}
_SFCB_TRACE(1, ("--- assoc %s", name));
}
}
}
if (role) {
// filter out the associations not matching the role property
CMPIInstance *ci;
UtilStringBuffer *pn = normalizeObjectPathStrBuf(cop);
for (ci = refs->ft->getFirst(refs); ci; ci = refs->ft->getNext(refs)) {
CMPIData data = CMGetProperty(ci, role, NULL);
if ((data.state & CMPI_notFound) ||
data.type != CMPI_ref ||
objectPathEquals(pn, data.value.ref, NULL, 0) == 0) {
refs->ft->removeCurrent(refs);
}
}
pn->ft->release(pn);
}
else {
// filter out associations not referencing pathName
CMPIInstance *ci;
int matched,
i,
m;
UtilStringBuffer *pn = normalizeObjectPathStrBuf(cop);
for (ci = refs->ft->getFirst(refs); ci; ci = refs->ft->getNext(refs)) {
for (matched = 0, i = 0, m = CMGetPropertyCount(ci, NULL); i < m;
i++) {
CMPIData data = CMGetPropertyAt(ci, i, NULL, NULL);
if (data.type == CMPI_ref
&& objectPathEquals(pn, data.value.ref, NULL, 0)) {
matched = 1;
break;
}
}
if (matched == 0)
refs->ft->removeCurrent(refs);
}
pn->ft->release(pn);
}
if (associatorFunction == REF) {
CMPIInstance *ci;
for (ci = refs->ft->getFirst(refs); ci; ci = refs->ft->getNext(refs)) {
CMReturnInstance(rslt, ci);
}
refs->ft->release(refs);
_SFCB_RETURN(st);
}
else if (associatorFunction == REF_NAME) {
CMPIInstance *ci;
for (ci = refs->ft->getFirst(refs); ci; ci = refs->ft->getNext(refs)) {
CMPIObjectPath *ref = CMGetObjectPath(ci, NULL);
CMReturnObjectPath(rslt, ref);
}
refs->ft->release(refs);
_SFCB_RETURN(st);
}
else {
// Use hashtable to avoid dup'd associators
CMPIInstance *ci;
UtilHashTable *assocs =
UtilFactory->newHashTable(61, UtilHashTable_charKey);
UtilStringBuffer *pn = normalizeObjectPathStrBuf(cop);
for (ci = refs->ft->getFirst(refs); ci; ci = refs->ft->getNext(refs)) {
// Q: for ASSOC_NAME we should not require the
// object exist if we go by the book, should we?
// The current approach retrieves the instances
// via the CIMOM handle
if (resultRole) {
CMPIData data = CMGetProperty(ci, resultRole, NULL);
UtilStringBuffer *an = NULL;
if ((data.state & CMPI_notFound) == 0 && data.type == CMPI_ref &&
objectPathEquals(pn, data.value.ref, &an, 0) == 0) {
if (resultClass == NULL
|| CMClassPathIsA(Broker, data.value.ref, resultClass,
NULL)) {
CMPIInstance *aci =
CBGetInstance(Broker, ctx, data.value.ref, propertyList,
&st);
assocs->ft->put(assocs, an->ft->getCharPtr(an), aci);
}
}
}
else {
// must loop over the properties to find ref instances
int i,
m;
for (i = 0, m = CMGetPropertyCount(ci, NULL); i < m; i++) {
CMPIData data = CMGetPropertyAt(ci, i, NULL, NULL);
if (data.type == CMPI_ref) {
CMPIObjectPath *ref = data.value.ref;
CMPIString *tns = CMGetNameSpace(ref, NULL);
if (tns == NULL || tns->hdl == NULL)
CMSetNameSpace(ref, ns);
UtilStringBuffer *an = NULL;
if (objectPathEquals(pn, ref, &an, 0) == 0) {
if (resultClass == NULL
|| CMClassPathIsA(Broker, ref, resultClass, NULL)) {
CMPIInstance *aci =
CBGetInstance(Broker, ctx, ref, propertyList, &st);
if (aci)
assocs->ft->put(assocs, an->ft->getCharPtr(an), aci);
}
}
}
}
}
}
{
HashTableIterator *it;
char *an;
CMPIInstance *aci;
for (it =
assocs->ft->getFirst(assocs, (void **) &an, (void **) &aci); it;
it =
assocs->ft->getNext(assocs, it, (void **) &an,
(void **) &aci)) {
if (associatorFunction == ASSOC)
CMReturnInstance(rslt, aci);
else {
CMPIObjectPath *op = CMGetObjectPath(aci, NULL);
CMReturnObjectPath(rslt, op);
}
}
}
refs->ft->release(refs);
assocs->ft->release(assocs);
pn->ft->release(pn);
_SFCB_RETURN(st);
}
}
static CMPIStatus
enumInstances(CMPIInstanceMI * mi,
const CMPIContext *ctx, void *rslt,
const CMPIObjectPath * ref,
const char **properties,
void (*retFnc) (void *, CMPIInstance *), int ignprov)
{
CMPIStatus st = { CMPI_RC_OK, NULL };
CMPIStatus sti = { CMPI_RC_OK, NULL };
BlobIndex *bi;
CMPIString *cn = CMGetClassName(ref, NULL);
CMPIString *ns = CMGetNameSpace(ref, NULL);
const char *nss = ns->ft->getCharPtr(ns, NULL);
const char *cns = cn->ft->getCharPtr(cn, NULL);
const char *bnss = repositoryNs(nss);
int len,
i,
ac = 0;
CMPIInstance *ci;
CMPIArgs *in,
*out;
CMPIObjectPath *op;
CMPIArray *ar;
CMPIData rv;
const char **keyList;
_SFCB_ENTER(TRACE_INTERNALPROVIDER, "enumInstances");
_SFCB_TRACE(1, ("--- %s %s", nss, cns));
in = CMNewArgs(Broker, NULL);
out = CMNewArgs(Broker, NULL);
if (ignprov)
CMAddArg(in, "classignoreprov", cns, CMPI_chars);
else
CMAddArg(in, "class", cns, CMPI_chars);
op = CMNewObjectPath(Broker, bnss, "$ClassProvider$", &sti);
_SFCB_TRACE(1, ("--- getallchildren"));
rv = CBInvokeMethod(Broker, ctx, op, "getallchildren", in, out, &sti);
_SFCB_TRACE(1, ("--- getallchildren rc: %d", sti.rc));
ar = CMGetArg(out, "children", NULL).value.array;
if (ar)
ac = CMGetArrayCount(ar, NULL);
_SFCB_TRACE(1, ("--- getallchildren ar: %p count: %d", ar, ac));
for (i = 0; cns; i++) {
_SFCB_TRACE(1, ("--- looking for %s", cns));
if ((bi = _getIndex(bnss, cns)) != NULL) {
for (ci = ipGetFirst(bi, &len, NULL, 0); ci;
ci = ipGetNext(bi, &len, NULL, 0)) {
if (properties) {
keyList = getKeyList(ci->ft->getObjectPath(ci, NULL));
ci->ft->setPropertyFilter(ci, properties, keyList);
if (keyList) {
free(keyList);
}
}
_SFCB_TRACE(1, ("--- returning instance %p", ci));
retFnc(rslt, ci);
}
}
freeBlobIndex(&bi, 1);
if (i < ac)
cns = (char *) CMGetArrayElementAt(ar, i, NULL).value.string->hdl;
else
cns = NULL;
}
_SFCB_RETURN(st);
}
CMPIStatus
InternalProviderEnumInstanceNames(CMPIInstanceMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt,
const CMPIObjectPath * ref)
{
CMPIStatus st = { CMPI_RC_OK, NULL };
CMPIStatus sti = { CMPI_RC_OK, NULL };
BlobIndex *bi;
CMPIString *cn = CMGetClassName(ref, NULL);
CMPIString *ns = CMGetNameSpace(ref, NULL);
CMPIObjectPath *cop;
const char *nss = ns->ft->getCharPtr(ns, NULL);
const char *cns = cn->ft->getCharPtr(cn, NULL);
const char *bnss = repositoryNs(nss);
size_t ekl;
int i,
ac = 0;
char copKey[8192] = "";
char *kp;
CMPIArgs *in,
*out;
CMPIObjectPath *op;
CMPIArray *ar;
CMPIData rv;
_SFCB_ENTER(TRACE_INTERNALPROVIDER, "InternalProviderEnumInstanceNames");
_SFCB_TRACE(1, ("%s %s", nss, cns));
in = CMNewArgs(Broker, NULL);
out = CMNewArgs(Broker, NULL);
CMAddArg(in, "class", cns, CMPI_chars);
op = CMNewObjectPath(Broker, bnss, "$ClassProvider$", &sti);
rv = CBInvokeMethod(Broker, ctx, op, "getallchildren", in, out, &sti);
ar = CMGetArg(out, "children", NULL).value.array;
if (ar)
ac = CMGetArrayCount(ar, NULL);
for (i = 0; cns; i++) {
if ((bi = _getIndex(bnss, cns)) != NULL) {
if (ipGetFirst(bi, NULL, &kp, &ekl)) {
while (1) {
strcpy(copKey, nss);
strcat(copKey, ":");
strcat(copKey, cns);
strcat(copKey, ".");
strncat(copKey, kp, ekl);
cop = getObjectPath(copKey, NULL);
if (cop)
CMReturnObjectPath(rslt, cop);
else {
CMPIStatus st = { CMPI_RC_ERR_FAILED, NULL };
return st;
}
if (bi->next < bi->dSize && ipGetNext(bi, NULL, &kp, &ekl)) {
continue;
}
break;
}
}
freeBlobIndex(&bi, 1);
}
if (i < ac)
cns = (char *) CMGetArrayElementAt(ar, i, NULL).value.string->hdl;
else
cns = NULL;
}
_SFCB_RETURN(st);
}
CMPIStatus
IndCIMXMLHandlerInvokeMethod(CMPIMethodMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt,
const CMPIObjectPath * ref,
const char *methodName,
const CMPIArgs * in, CMPIArgs * out)
{
_SFCB_ENTER(TRACE_INDPROVIDER, "IndCIMXMLHandlerInvokeMethod");
CMPIStatus st = { CMPI_RC_OK, NULL };
int drc = 0;
struct timeval tv;
struct timezone tz;
static unsigned int indID=1;
if (interOpNameSpace(ref, &st) == 0)
_SFCB_RETURN(st);
if (strcasecmp(methodName, "_deliver") == 0) {
#ifndef SETTABLERETRY
// On the first indication, check if reliable indications are enabled.
if (RIEnabled == -1) {
#endif
CMPIObjectPath *op=CMNewObjectPath(_broker,"root/interop","CIM_IndicationService",NULL);
CMPIEnumeration *isenm = _broker->bft->enumerateInstances(_broker, ctx, op, NULL, NULL);
CMPIData isinst=CMGetNext(isenm,NULL);
CMPIData mc=CMGetProperty(isinst.value.inst,"DeliveryRetryAttempts",NULL);
RIEnabled=mc.value.uint16;
#ifndef SETTABLERETRY
}
#endif
CMPIInstance *indo=CMGetArg(in,"indication",NULL).value.inst;
CMPIInstance *ind=CMClone(indo,NULL);
CMPIContext *ctxLocal=NULL;
CMPIObjectPath *iop=NULL,*subop=NULL;
CMPIInstance *sub=NULL;
if (RIEnabled) {
ctxLocal = prepareUpcall((CMPIContext *) ctx);
// Set the indication sequence values
iop=CMGetObjectPath(ind,NULL);
CMAddKey(iop,"SFCB_IndicationID",&indID,CMPI_uint32);
CMSetProperty(ind,"SFCB_IndicationID",&indID,CMPI_uint32);
// Prevent this property from showing up in the indication
filterFlagProperty(ind, "SFCB_IndicationID");
sub=CMGetArg(in,"subscription",NULL).value.inst;
CMPIData handler=CMGetProperty(sub, "Handler", &st);
CMPIObjectPath *hop=handler.value.ref;
// Get the handler instance from the hashtable via a
// methodcall to interopProvider
in=CMNewArgs(_broker,NULL);
CMAddArg(in,"handler",&hop,CMPI_ref);
out=CMNewArgs(_broker,NULL);
CMPIObjectPath* sop=CMNewObjectPath(_broker,"root/interop","cim_indicationsubscription",&st);
CBInvokeMethod(_broker,ctx,sop,"_getHandler",in,out,&st);
CMPIInstance *hdlr=CMGetArg(out,"hin",NULL).value.inst;
if (hdlr == NULL) {
mlogf(M_ERROR,M_SHOW,"Deliver indication failed, hdlr is null. rc:%d\n",st.rc);
_SFCB_RETURN(st);
}
// Build the complete sequence context
// Get the stub from the handler
CMPIString *context = CMGetProperty(hdlr, "SequenceContext", &st).value.string;
// and add the sfcb start time
char *cstr=malloc( (strlen(context->ft->getCharPtr(context,NULL)) + strlen(sfcBrokerStart) + 1) * sizeof(char));
sprintf(cstr,"%s%s",context->ft->getCharPtr(context,NULL),sfcBrokerStart);
context = sfcb_native_new_CMPIString(cstr, NULL, 0);
// and put it in the indication
CMSetProperty(ind, "SequenceContext", &context, CMPI_string);
free(cstr);
CMRelease(context);
// Get the proper sequence number
CMPIValue lastseq = CMGetProperty(hdlr, "LastSequenceNumber", &st).value;
lastseq.sint64++;
// Handle wrapping of the signed int
if (lastseq.sint64 < 0) lastseq.sint64=0;
// Update the last used number in the handler
CMSetProperty(hdlr, "LastSequenceNumber", &lastseq.sint64, CMPI_sint64);
in=CMNewArgs(_broker,NULL);
CMAddArg(in,"handler",&hdlr,CMPI_instance);
CMAddArg(in,"key",&hop,CMPI_ref);
CBInvokeMethod(_broker,ctx,sop,"_updateHandler",in,NULL,&st);
if (st.rc != CMPI_RC_OK) {
mlogf(M_ERROR,M_SHOW,"Failed to update LastSequenceNumber. rc:%d\n",st.rc);
}
// And the indication
CMSetProperty(ind, "SequenceNumber", &lastseq, CMPI_sint64);
}
// Now send the indication
drc = deliverInd(ref, in, ind);
switch (drc) {
case 0: /* Success */
case 400: /* Bad Request XML */
case 501: /* Not Implemented */
break;
default:
if (RIEnabled){
_SFCB_TRACE(1,("--- Indication delivery failed, adding to retry queue"));
// Indication delivery failed, send to retry queue
// build an element
RTElement *element;
element = malloc(sizeof(*element));
element->ref=ref->ft->clone(ref,NULL);
// Get the OP of the subscription and indication
subop=CMGetObjectPath(sub,NULL);
element->sub=subop->ft->clone(subop,NULL);
element->ind=iop->ft->clone(iop,NULL);
element->indInst=ind->ft->clone(ind,NULL);
// Store other attrs
element->instanceID=indID;
element->count=0;
gettimeofday(&tv, &tz);
element->lasttry=tv.tv_sec;
indID++;
// Add it to the retry queue
enqRetry(element,ctx,1);
// And launch the thread if it isn't already running
pthread_attr_init(&tattr);
pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
if (retryRunning == 0) {
retryRunning = 1;
_SFCB_TRACE(1,("--- Starting retryExport thread"));
CMPIContext *pctx = native_clone_CMPIContext(ctx);
pthread_create(&t, &tattr, &retryExport, (void *) pctx);
}
}
break;
}
if (RIEnabled) {
CMRelease(ctxLocal);
}
CMRelease(ind);
}
else {
printf("--- ClassProvider: Invalid request %s\n", methodName);
st.rc = CMPI_RC_ERR_METHOD_NOT_FOUND;
}
_SFCB_RETURN(st);
}
CMPIStatus
TestCMPIErrorProviderInvokeMethod (CMPIMethodMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref,
const char *methodName,
const CMPIArgs * in, CMPIArgs * out)
{
CMPIString *class_name = NULL;
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIError *cmpiError;
CMPIError *cmpiErrorClone;
CMPICount i, arrSize;
CMPIObjectPath *objPath = NULL;
CMPIUint32 brokerCapabilities;
/* CMPIError data */
const char* inOwningEntity = "ACME";
CMPIString* outOwningEntity;
const char* inMsgID = "ACME0023";
CMPIString* outMsgID;
const char* inMsg = "ACME0023 Need to restock Road Runner bait and traps.";
CMPIString* outMsg;
const CMPIErrorSeverity inSev = ErrorSevMedium;
CMPIErrorSeverity outSev;
const CMPIErrorProbableCause inPc = Equipment_Malfunction;
CMPIErrorProbableCause outPc;
const CMPIrc inCIMStatusCode = CMPI_RC_ERR_FAILED;
CMPIrc outCIMStatusCode;
const char * inCIMStatusCodeDesc = "another failed attempt at road "
"runner elimination";
CMPIString* outCIMStatusCodeDesc;
const CMPIErrorType inErrType = OtherErrorType;
CMPIErrorType outErrType;
const char* inOtherErrType = "Pervasive Coyote Incompetance";
CMPIString* outOtherErrType;
const char* inPcd = "Incorrect use of equipment";
CMPIString* outPcd;
CMPIArray *inRecActions;
CMPIArray *outRecActions;
CMPIArray *inMsgArgs;
CMPIArray *outMsgArgs;
CMPIValue raOne;
CMPIValue raTwo;
const char* inErrSource = "Acme bomb";
CMPIString* outErrSource;
const CMPIErrorSrcFormat inErrSourceFormat = CMPIErrSrcOther;
CMPIErrorSrcFormat outErrSourceFormat;
const char* inOtherErrSourceFormat = "no idea";
CMPIString* outOtherErrSourceFormat;
CMPIData retData;
PROV_LOG_OPEN (_ClassName, _ProviderLocation);
PROV_LOG ("Calling CBGetBrokerCapabilities");
brokerCapabilities = CBGetBrokerCapabilities(_broker);
if (brokerCapabilities & CMPI_MB_Supports_Extended_Error)
{
PROV_LOG("CMPI_MB_Supports_Extended_Error Support : True");
}
else
{
PROV_LOG("CMPI_MB_Supports_Extended_Error Support : False");
CMReturnWithString(CMPI_RC_ERR_NOT_SUPPORTED,
CMNewString(_broker,
"Extended error support not avilable", NULL));
}
PROV_LOG ("--- %s CMPI InvokeMethod() called", _ClassName);
class_name = CMGetClassName (ref, &rc);
PROV_LOG ("InvokeMethod: checking for correct classname [%s]",
CMGetCharsPtr (class_name,NULL));
PROV_LOG ("Calling CMNewCMPIError");
cmpiError = CMNewCMPIError(_broker, inOwningEntity, inMsgID, inMsg,
inSev, inPc, inCIMStatusCode, &rc);
PROV_LOG ("++++ (%s) CMNewCMPIError", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorType");
rc = CMSetErrorType(cmpiError, inErrType);
PROV_LOG ("++++ (%s) CMSetErrorType", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetOtherErrorType");
rc = CMSetOtherErrorType(cmpiError, inOtherErrType);
PROV_LOG ("++++ (%s) CMSetOtherErrorType", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetProbableCauseDescription");
rc = CMSetProbableCauseDescription(cmpiError, inPcd);
PROV_LOG ("++++ (%s) CMSetProbableCauseDescription", strCMPIStatus (rc));
inRecActions = CMNewArray(_broker, 2, CMPI_string, &rc);
PROV_LOG ("++++ (%s) CMNewArray", strCMPIStatus (rc));
raOne.string = CMNewString(_broker, "Fire coyote.", &rc);
PROV_LOG ("++++ (%s) CMNewString", strCMPIStatus (rc));
rc = CMSetArrayElementAt(inRecActions, 0, &raOne, CMPI_string);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc));
raTwo.string = CMNewString(_broker, "Give peace a chance.", &rc);
PROV_LOG ("++++ (%s) CMNewString", strCMPIStatus (rc));
rc = CMSetArrayElementAt(inRecActions, 1, &raTwo, CMPI_string);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [1]", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetRecommendedActions");
rc = CMSetRecommendedActions(cmpiError, inRecActions);
PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorSource");
rc = CMSetErrorSource(cmpiError, inErrSource);
PROV_LOG ("++++ (%s) CMSetErrorSource", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorSourceFormat");
rc = CMSetErrorSourceFormat(cmpiError, inErrSourceFormat);
PROV_LOG ("++++ (%s) CMSetErrorSourceFormat", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetOtherErrorSourceFormat");
rc = CMSetOtherErrorSourceFormat(cmpiError, inOtherErrSourceFormat);
PROV_LOG ("++++ (%s) CMSetOtherErrorSourceFormat", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetCIMStatusCodeDescription");
rc = CMSetCIMStatusCodeDescription(cmpiError, inCIMStatusCodeDesc);
PROV_LOG ("++++ (%s) CMSetCIMStatusCodeDescription", strCMPIStatus (rc));
inMsgArgs = CMNewArray(_broker, 1, CMPI_string, &rc);
PROV_LOG ("++++ (%s) CMNewArray", strCMPIStatus (rc));
raOne.string = CMNewString(_broker, "no real inserts", &rc);
PROV_LOG ("++++ (%s) CMNewString", strCMPIStatus (rc));
rc = CMSetArrayElementAt(inMsgArgs, 0, &raOne, CMPI_string);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetMessageArguments");
rc = CMSetMessageArguments(cmpiError, inMsgArgs);
PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc));
PROV_LOG ("First clone the CMPIError.");
cmpiErrorClone = CMClone(cmpiError, &rc);
PROV_LOG ("++++ (%s) CMClone", strCMPIStatus (rc));
PROV_LOG ("Ok, reading back fields to verify");
PROV_LOG ("Calling CMGetErrorType");
outErrType = CMGetErrorType(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetErrorType (%d)", strCMPIStatus (rc), outErrType);
PROV_LOG ("Calling CMGetOtherErrorType");
outOtherErrType = CMGetOtherErrorType(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetOtherErrorType (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outOtherErrType,NULL));
PROV_LOG ("Calling CMGetOwningEntity");
outOwningEntity = CMGetOwningEntity(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetOwningEntity (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outOwningEntity,NULL));
PROV_LOG ("Calling CMGetMessageID");
outMsgID = CMGetMessageID(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetMessageID (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outMsgID,NULL));
PROV_LOG ("Calling CMGetErrorMessage");
outMsg = CMGetErrorMessage(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetErrorMessage (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outMsg,NULL));
PROV_LOG ("Calling CMGetPerceivedSeverity");
outSev = CMGetPerceivedSeverity(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetPerceivedSeverity (%d)", strCMPIStatus (rc),
outSev);
PROV_LOG ("Calling CMGetProbableCause");
outPc = CMGetProbableCause(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetProbableCause (%d)", strCMPIStatus (rc),
outPc);
PROV_LOG ("Calling CMGetProbableCauseDescription");
outPcd = CMGetProbableCauseDescription(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetProbableCauseDescription (%s)",
strCMPIStatus (rc),
CMGetCharsPtr(outPcd,NULL));
PROV_LOG ("Calling CMGetRecommendedActions");
outRecActions = CMGetRecommendedActions(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetRecommendedActions", strCMPIStatus (rc));
arrSize = CMGetArrayCount(outRecActions, &rc);
PROV_LOG ("++++ (%s) CMGetArrayCount (%d)", strCMPIStatus (rc), arrSize);
for (i = 0 ; i < arrSize ; i++)
{
CMPIData dta = CMGetArrayElementAt(outRecActions, i, &rc);
PROV_LOG ("++++ (%s) CMGetArrayElementAt (%d:%s)", strCMPIStatus (rc),
i, CMGetCharsPtr(dta.value.string,NULL));
}
PROV_LOG ("Calling CMGetErrorSource");
outErrSource = CMGetErrorSource(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetErrorSource (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outErrSource,NULL));
PROV_LOG ("Calling CMGetErrorSourceFormat");
outErrSourceFormat = CMGetErrorSourceFormat(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetErrorSourceFormat (%d)", strCMPIStatus (rc),
outErrSourceFormat);
PROV_LOG ("Calling CMGetOtherErrorSourceFormat");
outOtherErrSourceFormat = CMGetOtherErrorSourceFormat(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetOtherErrorSourceFormat (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outOtherErrSourceFormat,NULL));
PROV_LOG ("Calling CMGetCIMStatusCode");
outCIMStatusCode = CMGetCIMStatusCode(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetCIMStatusCode (%d)", strCMPIStatus (rc),
outCIMStatusCode);
PROV_LOG ("Calling CMGetCIMStatusCodeDescription");
outCIMStatusCodeDesc = CMGetCIMStatusCodeDescription(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetCIMStatusCodeDescription (%s)", strCMPIStatus (rc),
CMGetCharsPtr(outCIMStatusCodeDesc,NULL));
PROV_LOG ("Calling CMGetMessageArguments");
outMsgArgs = CMGetMessageArguments(cmpiErrorClone, &rc);
PROV_LOG ("++++ (%s) CMGetMessageArguments", strCMPIStatus (rc));
arrSize = CMGetArrayCount(outMsgArgs, &rc);
PROV_LOG ("++++ (%s) CMGetArrayCount (%d)", strCMPIStatus (rc), arrSize);
for (i = 0 ; i < arrSize ; i++)
{
CMPIData dta = CMGetArrayElementAt(outMsgArgs, i, &rc);
PROV_LOG ("++++ (%s) CMGetArrayElementAt (%d:%s)", strCMPIStatus (rc),
i, CMGetCharsPtr(dta.value.string,NULL));
}
PROV_LOG ("Calling CMPIResultFT.returnData");
rc = (rslt)->ft->returnError (rslt, cmpiErrorClone);
PROV_LOG ("++++ (%s) returnData", strCMPIStatus (rc));
PROV_LOG ("Releasing cloned CMPIError");
rc = CMRelease(cmpiErrorClone);
PROV_LOG ("++++ (%s) CMClone", strCMPIStatus (rc));
//Test Error Paths
PROV_LOG ("Testing for Error Paths in CMPI_Error.cpp");
PROV_LOG ("Calling CMNewCMPIError");
cmpiError = CMNewCMPIError(_broker,
inOwningEntity,
inMsgID,
inMsg,
inSev,
inPc,
inCIMStatusCode,
&rc);
PROV_LOG ("++++ (%s) CMNewCMPIError", strCMPIStatus (rc));
PROV_LOG ("Calling CMGetErrorType without setting the ErrorType");
outErrType = CMGetErrorType(cmpiError, &rc);
if (!outErrType)
{
PROV_LOG ("++++ (%s) CMGetErrorType (%d)", strCMPIStatus (rc),
outErrType);
}
PROV_LOG ("Calling CMGetOtherErrorType without setting the OtherErrorType");
outOtherErrType = CMGetOtherErrorType(cmpiError, &rc);
if (outOtherErrType == NULL)
{
PROV_LOG ("++++ (%s) CMGetOtherErrorType", strCMPIStatus (rc));
}
PROV_LOG ("Testing CMSetMessageArguments");
CMRelease(inMsgArgs);
inMsgArgs = CMNewArray(_broker, 1, CMPI_uint32, &rc);
PROV_LOG ("++++ (%s) CMNewArray inMsgArgs of CMPI_uint32 type",
strCMPIStatus (rc));
raOne.uint32 = 32;
rc = CMSetArrayElementAt(inMsgArgs, 0, &raOne, CMPI_uint32);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetMessageArguments with input array of uint32");
rc = CMSetMessageArguments(cmpiError, inMsgArgs);
PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc));
inMsgArgs->hdl = NULL;
PROV_LOG ("Calling CMSetMessageArguments with input array with NULL handle");
rc = CMSetMessageArguments(cmpiError, inMsgArgs);
PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc));
PROV_LOG ("Testing CMSetRecommendedActions");
CMRelease(inRecActions);
inRecActions = CMNewArray(_broker, 1, CMPI_uint32, &rc);
PROV_LOG ("++++ (%s) CMNewArray inRecActions of CMPI_uint32",
strCMPIStatus (rc));
raOne.uint32 = 32;
rc = CMSetArrayElementAt(inRecActions, 0, &raOne, CMPI_uint32);
PROV_LOG ("++++ (%s) CMSetArrayElementAt [0]", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetRecommendedActions with input array of CMPI_uint32");
rc = CMSetRecommendedActions(cmpiError, inRecActions);
PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc));
inRecActions->hdl = NULL;
PROV_LOG ("Calling CMSetRecommendedActions with input array"
" with NULL handle");
rc = CMSetRecommendedActions(cmpiError, inRecActions);
PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc));
/* Cases when CMPIError object handle is NULL*/
cmpiError->hdl = NULL;
PROV_LOG ("Clone the CMPIError with NULL handle.");
cmpiErrorClone = CMClone(cmpiError, &rc);
if (cmpiErrorClone == NULL)
{
PROV_LOG ("++++ (%s) CMClone", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetErrorType with NULL handle");
outErrType = CMGetErrorType(cmpiError, &rc);
if (!outErrType)
{
PROV_LOG ("++++ (%s) CMGetErrorType (%d)", strCMPIStatus (rc),
outErrType);
}
PROV_LOG ("Calling CMGetOtherErrorType with NULL handle");
outOtherErrType = CMGetOtherErrorType(cmpiError, &rc);
if (outOtherErrType == NULL)
{
PROV_LOG ("++++ (%s) CMGetOtherErrorType ", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetOwningEntity with NULL handle");
outOwningEntity = CMGetOwningEntity(cmpiError, &rc);
if (outOwningEntity == NULL)
{
PROV_LOG ("++++ (%s) CMGetOwningEntity ", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetMessageID with NULL handle");
outMsgID = CMGetMessageID(cmpiError, &rc);
if (!outMsgID)
{
PROV_LOG ("++++ (%s) CMGetMessageID", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetErrorMessage with NULL handle");
outMsg = CMGetErrorMessage(cmpiError, &rc);
if (!outMsg)
{
PROV_LOG ("++++ (%s) CMGetErrorMessage", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetPerceivedSeverity with NULL handle");
outSev = CMGetPerceivedSeverity(cmpiError, &rc);
if (!outSev)
{
PROV_LOG ("++++ (%s) CMGetPerceivedSeverity (%d)", strCMPIStatus (rc),
outSev);
}
PROV_LOG ("Calling CMGetProbableCause with NULL handle");
outPc = CMGetProbableCause(cmpiError, &rc);
if (!outPc)
{
PROV_LOG ("++++ (%s) CMGetProbableCause (%d)", strCMPIStatus (rc),
outPc);
}
PROV_LOG ("Calling CMGetProbableCauseDescription with NULL handle");
outPcd = CMGetProbableCauseDescription(cmpiError, &rc);
if (!outPcd)
{
PROV_LOG ("++++ (%s) CMGetProbableCauseDescription ",
strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetRecommendedActions with NULL handle");
outRecActions = CMGetRecommendedActions(cmpiError, &rc);
if (!outRecActions)
{
PROV_LOG ("++++ (%s) CMGetRecommendedActions", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetErrorSource with NULL handle");
outErrSource = CMGetErrorSource(cmpiError, &rc);
if (!outErrSource)
{
PROV_LOG ("++++ (%s) CMGetErrorSource", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetErrorSourceFormat with NULL handle");
outErrSourceFormat = CMGetErrorSourceFormat(cmpiError, &rc);
if (!outErrSourceFormat)
{
PROV_LOG ("++++ (%s) CMGetErrorSourceFormat (%d)", strCMPIStatus (rc),
outErrSourceFormat);
}
PROV_LOG ("Calling CMGetOtherErrorSourceFormat with NULL handle");
outOtherErrSourceFormat = CMGetOtherErrorSourceFormat(cmpiError, &rc);
if (!outOtherErrSourceFormat)
{
PROV_LOG ("++++ (%s) CMGetOtherErrorSourceFormat", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetCIMStatusCode with NULL handle");
outCIMStatusCode = CMGetCIMStatusCode(cmpiError, &rc);
if (!outCIMStatusCode)
{
PROV_LOG ("++++ (%s) CMGetCIMStatusCode (%d)", strCMPIStatus (rc),
outCIMStatusCode);
}
PROV_LOG ("Calling CMGetCIMStatusCodeDescription with NULL handle");
outCIMStatusCodeDesc = CMGetCIMStatusCodeDescription(cmpiError, &rc);
if (!outCIMStatusCodeDesc)
{
PROV_LOG ("++++ (%s) CMGetCIMStatusCodeDescription", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMGetMessageArguments with NULL handle");
outMsgArgs = CMGetMessageArguments(cmpiError, &rc);
if (!outMsgArgs)
{
PROV_LOG ("++++ (%s) CMGetMessageArguments", strCMPIStatus (rc));
}
PROV_LOG ("Calling CMSetErrorType with NULL handle");
rc = CMSetErrorType(cmpiError, inErrType);
PROV_LOG ("++++ (%s) CMSetErrorType", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetOtherErrorType with NULL handle");
rc = CMSetOtherErrorType(cmpiError, inOtherErrType);
PROV_LOG ("++++ (%s) CMSetOtherErrorType", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetProbableCauseDescription with NULL handle");
rc = CMSetProbableCauseDescription(cmpiError, inPcd);
PROV_LOG ("++++ (%s) CMSetProbableCauseDescription", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetRecommendedActions with NULL handle");
rc = CMSetRecommendedActions(cmpiError, inRecActions);
PROV_LOG ("++++ (%s) CMSetRecommendedActions", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorSource with NULL handle");
rc = CMSetErrorSource(cmpiError, inErrSource);
PROV_LOG ("++++ (%s) CMSetErrorSource", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetErrorSourceFormat with NULL handle");
rc = CMSetErrorSourceFormat(cmpiError, inErrSourceFormat);
PROV_LOG ("++++ (%s) CMSetErrorSourceFormat", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetOtherErrorSourceFormat with NULL handle");
rc = CMSetOtherErrorSourceFormat(cmpiError, inOtherErrSourceFormat);
PROV_LOG ("++++ (%s) CMSetOtherErrorSourceFormat", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetCIMStatusCodeDescription with NULL handle");
rc = CMSetCIMStatusCodeDescription(cmpiError, inCIMStatusCodeDesc);
PROV_LOG ("++++ (%s) CMSetCIMStatusCodeDescription", strCMPIStatus (rc));
PROV_LOG ("Calling CMSetMessageArguments with NULL handle");
rc = CMSetMessageArguments(cmpiError, inMsgArgs);
PROV_LOG ("++++ (%s) CMSetMessageArguments", strCMPIStatus (rc));
PROV_LOG_CLOSE();
// Test case to increase coverage in CMPI_Broker.cpp
objPath = CMNewObjectPath (_broker,
"test/TestProvider",
"TestCMPI_Method",
&rc);
retData = CBInvokeMethod(_broker,
ctx,
objPath,
"testReturn",
in,
out,
&rc);
PROV_LOG_OPEN (_ClassName, _ProviderLocation);
if(retData.value.uint32 == 2 && rc.rc == CMPI_RC_OK)
{
PROV_LOG ("++++ (%s) CMInvokeMethod", strCMPIStatus (rc));
}
PROV_LOG ("--- %s CMPI InvokeMethod() exited with CMPI_RC_ERR_FAILED",
_ClassName);
PROV_LOG_CLOSE();
CMReturnWithString(inCIMStatusCode,
CMNewString(_broker, "TestError invokeMethod() expected failure", NULL));
}
