pegasus/src/Pegasus/ProviderManager2/JMPI/JMPIProviderManager.cpp - diff

Return to JMPIProviderManager.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI

Diff for /pegasus/src/Pegasus/ProviderManager2/JMPI/JMPIProviderManager.cpp between version 1.35 and 1.43

version 1.35, 2005/10/28 18:33:20

version 1.43, 2006/03/08 23:14:30

Line 1

//%2005////////////////////////////////////////////////////////////////////////

//%2006////////////////////////////////////////////////////////////////////////

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

Line 8

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 66

Line 68

#else

#define DDD(x)

#endif

// request->localOnly is replaced with JMPI_LOCALONLY for getInstance () and enumerateInstances ()

#define JMPI_LOCALONLY false

#define JMPI_DEEPINHERITANCE true

/* Fix for 4092 */

// request->includeQualifiers is replaced with JMPI_INCLUDE_QUALIFIERS for getInstance (),

// setInstance (), enumerateInstances (), associators (), and references ()

#define JMPI_INCLUDE_QUALIFIERS false

#include "Convert.h"

Line 81

Line 87

// CIMProvider

// cimom-2003-11-24/org/snia/wbem/provider/CIMProvider.java

// src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMProvider.java

{"","initialize","(Lorg/pegasus/jmpi/CIMOMHandle;)V"},

{"snia 2.0","initialize","(Lorg/pegasus/jmpi/CIMOMHandle;)V"},

{"","cleanup","()V"},

{"snia 2.0","cleanup","()V"},

// InstanceProvider

// cimom-2003-11-24/org/snia/wbem/provider/InstanceProvider.java

// src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMInstanceProvider.java

{"snia 2.0","enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;"},

{"pegasus 2.4","enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;"},

/* Begin Fix for 4189 */

{"pegasus 2.5","enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZZZ[Ljava/lang/String;)Ljava/util/Vector;"},

{"pegasus 2.5","enumerateInstances","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},

/* End Fix for 4189 */

{"snia 2.0","enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;"},

{"snia 2.0","enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},

{"pegasus 2.4","enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},

{"pegasus 2.4","enumerateInstanceNames","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMObjectPath;"},

/* Begin Fix for 4238 */

{"pegasus 2.5","enumerateInstanceNames","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},

{"pegasus 2.5","getInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZZ[Ljava/lang/String;)Lorg/pegasus/jmpi/CIMInstance;"},

/* End Fix for 4238 */

{"snia 2.0","getInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;"},

{"pegasus 2.4","getInstance","(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)Lorg/pegasus/jmpi/CIMInstance;"},

{"","createInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;"},

/* Begin Fix for 4238 */

{"","setInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V"},

{"pegasus 2.5","getInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Lorg/pegasus/jmpi/CIMInstance;"},

{"","deleteInstance","(Lorg/pegasus/jmpi/CIMObjectPath;)V"},

/* End Fix for 4238 */

{"","execQuery","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},

{"snia 2.0","createInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;"},

{"snia 2.0","setInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V"},

{"pegasus 2.4","setInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V"},

{"snia 2.0","deleteInstance","(Lorg/pegasus/jmpi/CIMObjectPath;)V"},

{"snia 2.0","execQuery","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},

{"pegasus 2.4","execQuery","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;"},

{"pegasus 2.5","execQuery","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"},

// MethodProvider

// cimom-2003-11-24/org/snia/wbem/provider/MethodProvider.java

// src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMMethodProvider.java

{"","invokeMethod","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;"},

{"snia 2.0","invokeMethod","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;"},

{"pegasus 2.4","invokeMethod","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;"},

// PropertyProvider

// cimom-2003-11-24/org/snia/wbem/provider/PropertyProvider.java

// src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/PropertyProvider.java

{"snia 2.0","getPropertyValue","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;"},

{"snia 2.0","setPropertyValue","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V"},

// AssociatorProvider

// cimom-2003-11-24/org/snia/wbem/provider20/AssociatorProvider.java

// src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMAssociationProvider.java

// src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/AssociatorProvider.java

{"snia 2.0","associators","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},

{"pegasus 2.4","associators","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},

{"snia 2.0","associatorNames","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"},

{"pegasus 2.4","associatorNames","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"},

{"snia 2.0","references","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},

{"pegasus 2.4","references","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},

{"snia 2.0","referenceNames","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;"},

{"pegasus 2.4","referenceNames","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;"},

// CIMProviderRouter

// cimom-2003-11-24/org/snia/wbem/provider20/CIMProviderRouter.java

// EventProvider

// cimom-2003-11-24/org/snia/wbem/provider20/EventProvider.java

// src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/EventProvider.java

{"","authorizeFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)V"},

{"snia 2.0","activateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},

{"","mustPoll","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;)Z"},

{"snia 2.0","deActivateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},

{"","activateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},

{"","deActivateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},

// IndicationHandler

// cimom-2003-11-24/org/snia/wbem/provider20/IndicationHandler.java

// ProviderAdapter

// cimom-2003-11-24/org/snia/wbem/provider20/ProviderAdapter.java

// JMPI_TestPropertyTypes

{"","findObjectPath","(Lorg/pegasus/jmpi/CIMObjectPath;)I"},

{"JMPI_TestPropertyTypes","findObjectPath","(Lorg/pegasus/jmpi/CIMObjectPath;)I"},

{"","testPropertyTypesValue","(Lorg/pegasus/jmpi/CIMInstance;)V"}

{"JMPI_TestPropertyTypes","testPropertyTypesValue","(Lorg/pegasus/jmpi/CIMInstance;)V"}

};

if (!env)

Line 225

Line 247

env->ExceptionClear();

}

bool JMPIProviderManager::getInterfaceType (ProviderIdContainer pidc,

String& interfaceType,

String& interfaceVersion)

{

///CIMInstance ciProvider = pidc.getProvider ();

CIMInstance ciProviderModule = pidc.getModule ();

Uint32 idx;

bool fRet = true;

///PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: ciProvider = "<<ciProvider.getPath ().toString ()<<PEGASUS_STD(endl);

///PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: ciProviderModule = "<<ciProviderModule.getPath ().toString ()<<PEGASUS_STD(endl);

idx = ciProviderModule.findProperty ("InterfaceType");

if (idx != PEG_NOT_FOUND)

{

CIMValue itValue;

itValue = ciProviderModule.getProperty (idx).getValue ();

itValue.get (interfaceType);

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: interfaceType = "<<interfaceType<<PEGASUS_STD(endl));

}

else

{

fRet = false;

}

idx = ciProviderModule.findProperty ("InterfaceVersion");

if (idx != PEG_NOT_FOUND)

{

CIMValue itValue;

itValue = ciProviderModule.getProperty (idx).getValue ();

itValue.get (interfaceVersion);

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: interfaceVersion = "<<interfaceVersion<<PEGASUS_STD(endl));

}

else

{

fRet = false;

}

return fRet;

}

bool JMPIProviderManager::interfaceIsUsed (JNIEnv *env,

jobject jObject,

String searchInterfaceName)

{

jobjectArray jInterfaces = 0;

jsize jInterfacesLength = 0;

bool fFound = false;

if (!jObject)

{

return false;

}

jInterfaces = (jobjectArray)env->CallObjectMethod (env->GetObjectClass (jObject),

JMPIjvm::jv.ClassGetInterfaces);

if (!jInterfaces)

{

return false;

}

jInterfacesLength = env->GetArrayLength (jInterfaces);

for (jsize i = 0; !fFound && i < jInterfacesLength; i++)

{

jobject jInterface = env->GetObjectArrayElement (jInterfaces, i);

if (jInterface)

{

jstring jInterfaceName = (jstring)env->CallObjectMethod (jInterface,

JMPIjvm::jv.ClassGetName);

if (jInterfaceName)

{

const char *pszInterfaceName = env->GetStringUTFChars (jInterfaceName,

0);

String interfaceName = pszInterfaceName;

if (String::equal (interfaceName, searchInterfaceName))

{

fFound = true;

}

env->ReleaseStringUTFChars (jInterfaceName, pszInterfaceName);

}

return fFound;

}

JMPIProviderManager::IndProvTab JMPIProviderManager::provTab;

JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab;

JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg;

Line 406

Line 528

PEGASUS_ASSERT(response != 0); \

response->setKey(request->getKey()); \

response->setHttpMethod(request->getHttpMethod()); \

type1##ResponseHandler handler(request, response);

type1##ResponseHandler handler(request, response, _responseChunkCallback);

#define VOIDINTRO );

#define NOVOIDINTRO(type) ,type);

Line 468

Line 590

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_CIMINSTANCEPROVIDER,

METHOD_PEGASUS_25,

METHOD_INSTANCEPROVIDER,

METHOD_SNIA_PROVIDER20,

METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 499

Line 621

name.getLogicalName());

OperationContext context;

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

// forward request

JMPIProvider &pr=ph.GetProvider();

Line 510

Line 636

env = JMPIjvm::attachThread(&jv);

if (!env)

{

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

"Could not initialize the JVM (Java Virtual Machine) runtime environment."));

}

////////DDD(debugPrintMethodPointers (env, (jclass)pr.jProviderClass));

JMPIProvider::pm_service_op_lock op_lock(&pr);

STAT_GETSTARTTIME;

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

/* Fix for 4238 */

getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),

// public abstract org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath cop,

interfaceType,

// org.pegasus.jmpi.CIMClass cimClass,

interfaceVersion);

// boolean localOnly

// boolean includeQualifiers,

// boolean includeClassOrigin,

// String propertyList[])

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"getInstance",

"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZZ[Ljava/lang/String;)Lorg/pegasus/jmpi/CIMInstance;");

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_25;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_PEGASUS_25."<<PEGASUS_STD(endl));

}

/* Fix for 4238 */

if (id == NULL)

if (interfaceType == "JMPI")

{

env->ExceptionClear();

// public org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath cop,

// public abstract org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMClass cimClass,

// boolean localOnly)

// throws org.pegasus.jmpi.CIMException

Line 549

Line 673

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_INSTANCEPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));

}

if (id == NULL)

Line 571

Line 694

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));

}

else if (interfaceType == "JMPIExperimental")

{

/* Fix for 4238 */

// public org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.OperationContext oc

// org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMClass cimClass,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// String propertyList[])

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"getInstance",

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Lorg/pegasus/jmpi/CIMInstance;");

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));

}

/* Fix for 4238 */

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: No method found!"<<PEGASUS_STD(endl));

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

"Could not find a method for the provider based on InterfaceType."));

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_CIMINSTANCEPROVIDER:

{

jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef);

JMPIjvm::checkException(env);

CIMClass cls = pr._cimom_handle->getClass(context,

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->instanceName.getClassName(),

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

Line 608

Line 781

jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,

id,

jop,

request->localOnly,

JMPI_LOCALONLY,

request->includeQualifiers,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList,

jcimClass);

Line 631

Line 804

}

/* Fix for 4238 */

case METHOD_PEGASUS_25:

case METHOD_INSTANCEPROVIDER2:

{

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef);

JMPIjvm::checkException(env);

CIMClass cls = pr._cimom_handle->getClass(context,

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->instanceName.getClassName(),

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

Line 657

Line 848

jobjectArray jPropertyList = getList(jv,env,request->propertyList);

jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,

id,

joc,

jop,

jcimClass,

JMPI_LOCALONLY,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList);

Line 668

Line 859

STAT_PMS_PROVIDEREND;

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

handler.processing();

if (jciRet) {

Line 681

Line 879

}

/* Fix for 4238 */

case METHOD_SNIA_PROVIDER20:

case METHOD_INSTANCEPROVIDER:

{

jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef);

JMPIjvm::checkException(env);

CIMClass cls = pr._cimom_handle->getClass(context,

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->instanceName.getClassName(),

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

Line 753

Line 966

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_CIMINSTANCEPROVIDER,

METHOD_PEGASUS_25,

METHOD_CIMINSTANCEPROVIDER2,

METHOD_SNIA_PROVIDER20,

METHOD_INSTANCEPROVIDER,

METHOD_INSTANCEPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 779

Line 993

request->operationContext.get(ProviderIdContainer::NAME));

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph =

JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),

name.getLogicalName(),

String::EMPTY);

// convert arguments

Line 801

Line 1015

env = JMPIjvm::attachThread(&jv);

if (!env)

{

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

"Could not initialize the JVM (Java Virtual Machine) runtime environment."));

}

JMPIProvider::pm_service_op_lock op_lock(&pr);

STAT_GETSTARTTIME;

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

/* Fix for 4189 */

getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),

// public synchronized Vector enumInstances(CIMObjectPath cop,

interfaceType,

// CIMClass cimClass,

interfaceVersion);

if (interfaceType == "JMPI")

{

// public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop,

// boolean deep,

// boolean localOnly,

// org.pegasus.jmpi.CIMClass cimClass,

// boolean includeQualifiers,

// boolean localOnly)

// boolean includeClassOrigin,

// String propertyList[])

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"enumInstances",

"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZZZ[Ljava/lang/String;)Ljava/util/Vector;");

"(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;");

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_25;

eMethodFound = METHOD_INSTANCEPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_PEGASUS_25."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));

}

/* Fix for 4189 */

if (id == NULL)

{

env->ExceptionClear();

// public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop,

// public org.pegasus.jmpi.CIMInstance[] enumInstances (org.pegasus.jmpi.CIMObjectPath cop,

// boolean deep,

// boolean localOnly,

// org.pegasus.jmpi.CIMClass cimClass,

// boolean includeQualifiers,

// boolean localOnly)

// boolean includeClassOrigin,

// java.lang.String[] propertyList,

// org.pegasus.jmpi.CIMClass cimClass)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"enumInstances",

"(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;");

"(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;");

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));

}

else if (interfaceType == "JMPIExperimental")

{

/* Fix for 4189 */

// public abstract java.util.Vector enumerateInstances (org.pegasus.jmpi.OperationContext oc

// org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMClass cimClass,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"enumerateInstances",

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Ljava/util/Vector;");

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));

}

/* Fix for 4189 */

if (id == NULL)

{

env->ExceptionClear();

// public org.pegasus.jmpi.CIMInstance[] enumerateInstances (org.pegasus.jmpi.CIMObjectPath op,

// public abstract org.pegasus.jmpi.CIMInstance[] enumerateInstances (org.pegasus.jmpi.OperationContext oc

// boolean localOnly,

// org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMClass cimClass,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList,

// java.lang.String[] propertyList)

// org.pegasus.jmpi.CIMClass cc)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"enumerateInstances",

"enumInstances",

"(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;");

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

eMethodFound = METHOD_CIMINSTANCEPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_CIMINSTANCEPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: No method found!"<<PEGASUS_STD(endl));

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

"Could not find a method for the provider based on InterfaceType."));

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_CIMINSTANCEPROVIDER:

{

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

JMPIjvm::checkException(env);

CIMClass cls = pr._cimom_handle->getClass(context,

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

Line 897

Line 1177

JMPIjvm::checkException(env);

jobjectArray jPropertyList = getList(jv,env,request->propertyList);

jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

jcop,

request->localOnly,

JMPI_LOCALONLY,

request->includeQualifiers,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList,

jcc);

Line 923

Line 1202

jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

/* Fix for 4237 */

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

const CIMObjectPath& op = ciRet->getPath();

CIMObjectPath iop = ciRet->buildPath(cls);

JMPIjvm::checkException(env);

handler.deliver(*ciRet);

Line 932

Line 1237

break;

}

/* Fix for 4189 */

case METHOD_CIMINSTANCEPROVIDER2:

case METHOD_PEGASUS_25:

{

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

JMPIjvm::checkException(env);

CIMClass cls = pr._cimom_handle->getClass(context,

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

Line 957

Line 1279

JMPIjvm::checkException(env);

jobjectArray jPropertyList = getList(jv,env,request->propertyList);

jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,

jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

joc,

jcop,

jcc,

request->deepInheritance,

JMPI_LOCALONLY,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList);

Line 971

Line 1292

STAT_PMS_PROVIDEREND;

handler.processing();

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

handler.processing();

if (jAr) {

for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {

JMPIjvm::checkException(env);

jobject jciRet = env->GetObjectArrayElement(jAr,i);

JMPIjvm::checkException(env);

jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

/* Fix for 4237 */

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

const CIMObjectPath& op = ciRet->getPath();

CIMObjectPath iop = ciRet->buildPath(cls);

JMPIjvm::checkException(env);

handler.deliver(*ciRet);

}

handler.complete();

break;

}

/* Fix for 4189 */

case METHOD_INSTANCEPROVIDER2:

{

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

JMPIjvm::checkException(env);

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass (context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);

jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef);

JMPIjvm::checkException(env);

jobjectArray jPropertyList = getList(jv,env,request->propertyList);

jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,

id,

joc,

jcop,

jcc,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

handler.processing();

if (jVec) {

for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {

JMPIjvm::checkException(env);

Line 984

Line 1422

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

/* Fix for 4237 */

CIMClass cls = pr._cimom_handle->getClass(context,

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

const CIMObjectPath& op = ciRet->getPath();

CIMObjectPath iop = ciRet->buildPath(cls);

Line 1009

Line 1462

}

/* Fix for 4189 */

case METHOD_SNIA_PROVIDER20:

case METHOD_INSTANCEPROVIDER:

{

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

JMPIjvm::checkException(env);

CIMClass cls = pr._cimom_handle->getClass(context,

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

Line 1057

Line 1525

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

/* Fix for 4237 */

CIMClass cls = pr._cimom_handle->getClass(context,

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

const CIMObjectPath& op = ciRet->getPath();

CIMObjectPath iop = ciRet->buildPath(cls);

Line 1107

Line 1590

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_CIMINSTANCEPROVIDER,

METHOD_SNIA_PROVIDER20,

METHOD_CIMINSTANCEPROVIDER2,

METHOD_INSTANCEPROVIDER,

METHOD_INSTANCEPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 1132

Line 1617

request->operationContext.get(ProviderIdContainer::NAME));

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph =

JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());

name.getLogicalName());

// convert arguments

OperationContext context;

Line 1146

Line 1631

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.enumerateInstanceNames: " + pr.getName());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Calling provider : enumerateInstanceNames"<<pr.getName()<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Calling provider : enumerateInstanceNames: "<<pr.getName()<<PEGASUS_STD(endl));

JvmVector *jv = 0;

env = JMPIjvm::attachThread(&jv);

if (!env)

{

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

"Could not initialize the JVM (Java Virtual Machine) runtime environment."));

}

JMPIProvider::pm_service_op_lock op_lock(&pr);

STAT_GETSTARTTIME;

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),

interfaceType,

interfaceVersion);

if (interfaceType == "JMPI")

{

// public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop,

// boolean deep,

// org.pegasus.jmpi.CIMClass cimClass)

Line 1168

Line 1672

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_INSTANCEPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));

}

if (id == NULL)

Line 1185

Line 1689

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));

}

else if (interfaceType == "JMPIExperimental")

{

// public abstract java.util.Vector enumerateInstanceNames (org.pegasus.jmpi.OperationContext oc

// org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMClass cimClass)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"enumerateInstanceNames",

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

env->ExceptionClear();

// public abstract org.pegasus.jmpi.CIMObjectPath[] enumerateInstanceNames (org.pegasus.jmpi.OperationContext oc

// org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMClass cimClass)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"enumerateInstanceNames",

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMObjectPath;");

if (id != NULL)

{

eMethodFound = METHOD_CIMINSTANCEPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_CIMINSTANCEPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: No method found!"<<PEGASUS_STD(endl));

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

"Could not find a method for the provider based on InterfaceType."));

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_CIMINSTANCEPROVIDER:

{

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

JMPIjvm::checkException(env);

CIMClass cls = pr._cimom_handle->getClass(context,

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

Line 1247

Line 1815

break;

}

case METHOD_SNIA_PROVIDER20:

case METHOD_CIMINSTANCEPROVIDER2:

{

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

JMPIjvm::checkException(env);

CIMClass cls = pr._cimom_handle->getClass(context,

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

Line 1270

Line 1856

JMPIjvm::checkException(env);

jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,

jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

joc,

jcop,

true,

jcimClass);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

handler.processing();

if (jVec) {

if (jAr) {

for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {

for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {

JMPIjvm::checkException(env);

jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);

jobject jcopRet = env->GetObjectArrayElement(jAr,i);

JMPIjvm::checkException(env);

Line 1301

Line 1894

break;

}

case METHOD_UNKNOWN:

case METHOD_INSTANCEPROVIDER2:

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: should not be here!"<<PEGASUS_STD(endl));

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

break;

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

PEG_METHOD_EXIT();

JMPIjvm::checkException(env);

STAT_COPYDISPATCHER

CIMClass cls;

return(response);

try

}

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

Message * JMPIProviderManager::handleCreateInstanceRequest(const Message * message) throw()

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleCreateInstanceRequest");

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

HandlerIntro(CreateInstance,message,request,response,handler,CIMObjectPath());

CIMClass *pcls = new CIMClass (cls);

typedef enum {

JMPIjvm::checkException(env);

METHOD_UNKNOWN = 0,

METHOD_SNIA_PROVIDER20,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

try {

jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);

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

jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);

"JMPIProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->newInstance.getPath().getClassName().getString());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->newInstance.getPath().getClassName().getString()<<PEGASUS_STD(endl));

JMPIjvm::checkException(env);

// make target object path

jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,

CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),

id,

request->nameSpace,

joc,

request->newInstance.getPath().getClassName(),

jcop,

request->newInstance.getPath().getKeyBindings());

jcimClass);

// resolve provider name

JMPIjvm::checkException(env);

ProviderName name = _resolveProviderName(

request->operationContext.get(ProviderIdContainer::NAME));

// get cached or load new provider module

STAT_PMS_PROVIDEREND;

JMPIProvider::OpProviderHolder ph =

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),

String::EMPTY);

// convert arguments

if (joc)

OperationContext context;

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

// forward request

JMPIProvider &pr = ph.GetProvider();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createInstance: " + ph.GetProvider().getName());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: Calling provider createInstance: "<<pr.getName()<<PEGASUS_STD(endl));

JMPIjvm::checkException(env);

}

JvmVector *jv = 0;

handler.processing();

if (jVec) {

for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {

JMPIjvm::checkException(env);

env = JMPIjvm::attachThread(&jv);

jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);

JMPIProvider::pm_service_op_lock op_lock(&pr);

JMPIjvm::checkException(env);

STAT_GETSTARTTIME;

jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);

jmethodID id = NULL;

JMPIjvm::checkException(env);

// public abstract org.pegasus.jmpi.CIMObjectPath createInstance (org.pegasus.jmpi.CIMObjectPath cop,

handler.deliver(*copRet);

// org.pegasus.jmpi.CIMInstance cimInstance)

}

// throws org.pegasus.jmpi.CIMException

}

id = env->GetMethodID((jclass)pr.jProviderClass,

handler.complete();

"createInstance",

break;

"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;");

}

if (id != NULL)

case METHOD_INSTANCEPROVIDER:

{

eMethodFound = METHOD_SNIA_PROVIDER20;

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

}

JMPIjvm::checkException(env);

switch (eMethodFound)

CIMClass cls;

try

{

case METHOD_SNIA_PROVIDER20:

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

CIMInstance *ci = new CIMInstance (request->newInstance);

jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);

jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);

jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);

jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);

JMPIjvm::checkException(env);

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl));

jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,

jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider,

id,

jcop,

jci);

true,

jcimClass);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jVec) {

for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {

JMPIjvm::checkException(env);

if (jcopRet) {

jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);

jint jCopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCopRetRef);

JMPIjvm::checkException(env);

jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);

JMPIjvm::checkException(env);

handler.deliver(*copRet);

}

handler.complete();

break;

}

case METHOD_UNKNOWN:

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: should not be here!"<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: should not be here!"<<PEGASUS_STD(endl));

break;

}

Line 1451

Line 2060

return(response);

}

Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw()

Message * JMPIProviderManager::handleCreateInstanceRequest(const Message * message) throw()

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleModifyInstanceRequest");

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleCreateInstanceRequest");

HandlerIntroVoid(ModifyInstance,message,request,response,handler);

HandlerIntro(CreateInstance,message,request,response,handler,CIMObjectPath());

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER

METHOD_SNIA_PROVIDER20,

METHOD_INSTANCEPROVIDER2 // same as METHOD_CIMINSTANCEPROVIDER2

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

try {

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

"JMPIProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2",

"JMPIProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->modifiedInstance.getPath().getClassName().getString());

request->newInstance.getPath().getClassName().getString());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->modifiedInstance.getPath().getClassName().getString()<<PEGASUS_STD(endl));

// make target object path

CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->modifiedInstance.getPath ().getClassName(),

request->newInstance.getPath().getClassName(),

request->modifiedInstance.getPath ().getKeyBindings());

request->newInstance.getPath().getKeyBindings());

// resolve provider name

ProviderName name = _resolveProviderName(

request->operationContext.get(ProviderIdContainer::NAME));

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: provider name physical = "<<name.getPhysicalName()<<", logical = "<<name.getLogicalName()<<PEGASUS_STD(endl));

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph =

JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

name.getLogicalName(),

String::EMPTY);

// convert arguments

OperationContext context;

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

// forward request

JMPIProvider &pr = ph.GetProvider();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.modifyInstance: " + pr.getName());

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createInstance: " + ph.GetProvider().getName());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: Calling provider "<<PEGASUS_STD(hex)<<(int)&pr<<PEGASUS_STD(dec)<<", name = "<<pr.getName ()<<", module = "<<pr.getModule()<<" modifyInstance: "<<pr.getName()<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: Calling provider createInstance: "<<pr.getName()<<PEGASUS_STD(endl));

////////DDD(debugPrintMethodPointers (env, (jclass)pr.jProviderClass));

JvmVector *jv = 0;

env = JMPIjvm::attachThread(&jv);

if (!env)

{

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

"Could not initialize the JVM (Java Virtual Machine) runtime environment."));

}

JMPIProvider::pm_service_op_lock op_lock(&pr);

STAT_GETSTARTTIME;

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

// public abstract void setInstance (org.pegasus.jmpi.CIMObjectPath cop,

getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),

interfaceType,

interfaceVersion);

if (interfaceType == "JMPI")

{

// public org.pegasus.jmpi.CIMObjectPath createInstance (org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMInstance cimInstance)

// org.pegasus.jmpi.throws CIMException

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"setInstance",

"createInstance",

"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V");

"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;");

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_INSTANCEPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));

}

if (id == NULL)

else if (interfaceType == "JMPIExperimental")

{

env->ExceptionClear();

// public org.pegasus.jmpi.CIMObjectPath createInstance (org.pegasus.jmpi.OperationContext oc

// org.pegasus.jmpi.CIMObjectPath cop,

// public void setInstance (org.pegasus.jmpi.CIMObjectPath op,

// org.pegasus.jmpi.CIMInstance cimInstance)

// org.pegasus.jmpi.CIMInstance ci,

// boolean includeQualifiers,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"setInstance",

"createInstance",

"(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V");

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;");

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

eMethodFound = METHOD_INSTANCEPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: No method found!"<<PEGASUS_STD(endl));

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

"Could not find a method for the provider based on InterfaceType."));

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_INSTANCEPROVIDER:

{

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

JMPIjvm::checkException(env);

CIMInstance *ci = new CIMInstance (request->modifiedInstance);

CIMInstance *ci = new CIMInstance (request->newInstance);

jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);

jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);

JMPIjvm::checkException(env);

jobjectArray jPropertyList = getList(jv,env,request->propertyList);

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl));

env->CallVoidMethod((jobject)pr.jProvider,

jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider,

id,

jcop,

jci,

jci);

jPropertyList);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jcopRet) {

jint jCopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCopRetRef);

handler.deliver(*copRet);

}

handler.complete();

break;

}

case METHOD_SNIA_PROVIDER20:

case METHOD_INSTANCEPROVIDER2:

{

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

JMPIjvm::checkException(env);

CIMInstance *ci = new CIMInstance (request->modifiedInstance);

CIMInstance *ci = new CIMInstance (request->newInstance);

jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);

jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);

JMPIjvm::checkException(env);

env->CallVoidMethod((jobject)pr.jProvider,

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl));

jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider,

id,

joc,

jcop,

jci);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

handler.processing();

if (jcopRet) {

jint jCopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCopRetRef);

handler.deliver(*copRet);

}

handler.complete();

break;

}

case METHOD_UNKNOWN:

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: should not be here!"<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: should not be here!"<<PEGASUS_STD(endl));

break;

}

Line 1621

Line 2282

return(response);

}

Message * JMPIProviderManager::handleDeleteInstanceRequest(const Message * message) throw()

Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw()

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleDeleteInstanceRequest");

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleModifyInstanceRequest");

HandlerIntroVoid(DeleteInstance,message,request,response,handler);

HandlerIntroVoid(ModifyInstance,message,request,response,handler);

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_SNIA_PROVIDER20,

METHOD_CIMINSTANCEPROVIDER,

METHOD_INSTANCEPROVIDER,

METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

try {

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

"JMPIProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2",

"JMPIProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

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

request->modifiedInstance.getPath().getClassName().getString());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->instanceName.getClassName().getString()<<PEGASUS_STD(endl));

// make target object path

CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->instanceName.getClassName(),

request->modifiedInstance.getPath ().getClassName(),

request->instanceName.getKeyBindings());

request->modifiedInstance.getPath ().getKeyBindings());

// resolve provider name

ProviderName name = _resolveProviderName(

request->operationContext.get(ProviderIdContainer::NAME));

// get cached or load new provider module

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: provider name physical = "<<name.getPhysicalName()<<", logical = "<<name.getLogicalName()<<PEGASUS_STD(endl));

JMPIProvider::OpProviderHolder ph =

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

// convert arguments

OperationContext context;

context.insert(request->operationContext.get(IdentityContainer::NAME));

// get cached or load new provider module

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

name.getLogicalName(),

String::EMPTY);

// forward request

JMPIProvider &pr = ph.GetProvider();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteInstance: " + pr.getName());

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.modifyInstance: " + pr.getName());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: Calling provider deleteInstance: "<<pr.getName()<<PEGASUS_STD(endl));

JvmVector *jv = 0;

env = JMPIjvm::attachThread(&jv);

if (!env)

{

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

"Could not initialize the JVM (Java Virtual Machine) runtime environment."));

}

JMPIProvider::pm_service_op_lock op_lock(&pr);

STAT_GETSTARTTIME;

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

// public abstract void deleteInstance (org.pegasus.jmpi.CIMObjectPath cop)

getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),

// throws org.pegasus.jmpi.CIMException

interfaceType,

interfaceVersion);

if (interfaceType == "JMPI")

{

// public abstract void setInstance (org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMInstance cimInstance)

// org.pegasus.jmpi.throws CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"deleteInstance",

"setInstance",

"(Lorg/pegasus/jmpi/CIMObjectPath;)V");

"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V");

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_INSTANCEPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));

}

JMPIjvm::checkException(env);

if (id == NULL)

switch (eMethodFound)

{

case METHOD_SNIA_PROVIDER20:

{

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

env->ExceptionClear();

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

JMPIjvm::checkException(env);

env->CallVoidMethod((jobject)pr.jProvider,id,jcop);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

// public void setInstance (org.pegasus.jmpi.CIMObjectPath op,

break;

// org.pegasus.jmpi.CIMInstance ci,

}

// boolean includeQualifiers,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"setInstance",

"(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V");

case METHOD_UNKNOWN:

if (id != NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: should not be here!"<<PEGASUS_STD(endl));

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

break;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

else if (interfaceType == "JMPIExperimental")

Message * JMPIProviderManager::handleExecQueryRequest(const Message * message) throw()

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleExecQueryRequest");

// public abstract void setInstance (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.CIMObjectPath op,

HandlerIntro(ExecQuery,message,request,response,handler,Array<CIMObject>());

// org.pegasus.jmpi.CIMInstance cimInstance);

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_SNIA_PROVIDER20,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

try {

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

"JMPIProviderManager::handleExecQueryRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->className.getString());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));

// make target object path

CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->className);

// resolve provider name

ProviderName name = _resolveProviderName(

request->operationContext.get(ProviderIdContainer::NAME));

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph =

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

// convert arguments

OperationContext context;

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

// forward request

JMPIProvider &pr = ph.GetProvider();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.execQuery: " + pr.getName());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Calling provider execQuery: "<<pr.getName()<<", queryLanguage: "<<request->queryLanguage<<", query: "<<request->query<<PEGASUS_STD(endl));

JvmVector *jv = 0;

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

STAT_GETSTARTTIME;

jmethodID id = NULL;

// public abstract java.util.Vector execQuery (org.pegasus.jmpi.CIMObjectPath cop,

// java.lang.String queryStatement,

// int ql,

// org.pegasus.jmpi.CIMClass cimClass)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"execQuery",

"setInstance",

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V");

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_INSTANCEPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

env->ExceptionClear();

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: No method found!"<<PEGASUS_STD(endl));

// public abstract org.pegasus.jmpi.CIMInstance[] execQuery(org.pegasus.jmpi.CIMObjectPath op,

PEG_METHOD_EXIT();

// java.lang.String query,

// java.lang.String ql,

// org.pegasus.jmpi.CIMClass cc)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"execQuery",

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;");

if (id != NULL)

STAT_COPYDISPATCHER

{

eMethodFound = METHOD_PEGASUS_24;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));

}

if (id == NULL)

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

{

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found no method!"<<PEGASUS_STD(endl));

"Could not find a method for the provider based on InterfaceType."));

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_INSTANCEPROVIDER2:

{

jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

JMPIjvm::checkException(env);

jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());

jstring jquery = env->NewStringUTF(request->query.getCString());

CIMClass cls = pr._cimom_handle->getClass(context,

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

request->nameSpace,

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

request->className,

false,

true,

CIMPropertyList());

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);

CIMInstance *ci = new CIMInstance (request->modifiedInstance);

jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);

jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);

jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);

JMPIjvm::checkException(env);

jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

jobjectArray jPropertyList = getList(jv,env,request->propertyList);

env->CallVoidMethod((jobject)pr.jProvider,

id,

joc,

jcop,

jquery,

jci);

jqueryLanguage,

jCc);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (joc)

if (jAr) {

{

for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

jobject jciRet = env->GetObjectArrayElement(jAr,i);

JMPIjvm::checkException(env);

jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

JMPIjvm::checkException(env);

handler.deliver(*ciRet);

}

handler.complete();

break;

}

case METHOD_SNIA_PROVIDER20:

case METHOD_CIMINSTANCEPROVIDER:

{

jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

JMPIjvm::checkException(env);

jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());

jstring jquery = env->NewStringUTF(request->query.getCString());

CIMClass cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);

CIMInstance *ci = new CIMInstance (request->modifiedInstance);

jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);

jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);

jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);

JMPIjvm::checkException(env);

jint jql = 0; // @BUG - how to convert?

jobjectArray jPropertyList = getList(jv,env,request->propertyList);

jobjectArray jVec = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

env->CallVoidMethod((jobject)pr.jProvider,

id,

jcop,

jquery,

jci,

jql,

JMPI_INCLUDE_QUALIFIERS,

jCc);

jPropertyList);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

break;

}

case METHOD_INSTANCEPROVIDER:

{

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

handler.processing();

if (jVec) {

for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {

JMPIjvm::checkException(env);

jobject jciRet = env->GetObjectArrayElement(jVec,i);

CIMInstance *ci = new CIMInstance (request->modifiedInstance);

jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);

jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);

JMPIjvm::checkException(env);

jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

env->CallVoidMethod((jobject)pr.jProvider,

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

id,

jcop,

jci);

JMPIjvm::checkException(env);

handler.deliver(*ciRet);

STAT_PMS_PROVIDEREND;

}

handler.complete();

break;

}

case METHOD_UNKNOWN:

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: should not be here!"<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: should not be here!"<<PEGASUS_STD(endl));

break;

}

Line 1973

Line 2533

return(response);

}

Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw()

Message * JMPIProviderManager::handleDeleteInstanceRequest(const Message * message) throw()

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest");

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleDeleteInstanceRequest");

HandlerIntro(Associators,message,request,response,handler,Array<CIMObject>());

HandlerIntroVoid(DeleteInstance,message,request,response,handler);

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER

METHOD_SNIA_PROVIDER20,

METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

try {

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

"JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2",

"JMPIProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

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

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

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<PEGASUS_STD(endl));

// make target object path

CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->objectName.getClassName(),

request->instanceName.getClassName(),

request->objectName.getKeyBindings());

request->instanceName.getKeyBindings());

CIMObjectPath *assocPath = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->assocClass.getString());

// resolve provider name

ProviderName name = _resolveProviderName(

request->operationContext.get(ProviderIdContainer::NAME));

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph =

JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),

providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);

name.getLogicalName(),

String::EMPTY);

// convert arguments

OperationContext context;

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

// forward request

JMPIProvider &pr = ph.GetProvider();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associators: " + pr.getName());

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteInstance: " + pr.getName());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Calling provider associators: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: Calling provider deleteInstance: "<<pr.getName()<<PEGASUS_STD(endl));

JvmVector *jv = 0;

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

"Could not initialize the JVM (Java Virtual Machine) runtime environment."));

}

JMPIProvider::pm_service_op_lock op_lock(&pr);

STAT_GETSTARTTIME;

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),

interfaceType,

interfaceVersion);

if (interfaceType == "JMPI")

{

// public abstract void deleteInstance (org.pegasus.jmpi.CIMObjectPath cop)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"deleteInstance",

"(Lorg/pegasus/jmpi/CIMObjectPath;)V");

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));

}

else if (interfaceType == "JMPIExperimental")

{

// public abstract void deleteInstance (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.CIMObjectPath cop)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"deleteInstance",

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;)V");

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: No method found!"<<PEGASUS_STD(endl));

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

"Could not find a method for the provider based on InterfaceType."));

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_INSTANCEPROVIDER2:

{

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

JMPIjvm::checkException(env);

env->CallVoidMethod((jobject)pr.jProvider,

id,

joc,

jcop);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

break;

}

case METHOD_INSTANCEPROVIDER:

{

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

JMPIjvm::checkException(env);

env->CallVoidMethod((jobject)pr.jProvider,

id,

jcop);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

break;

}

case METHOD_UNKNOWN:

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: should not be here!"<<PEGASUS_STD(endl));

break;

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * JMPIProviderManager::handleExecQueryRequest(const Message * message) throw()

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleExecQueryRequest");

HandlerIntro(ExecQuery,message,request,response,handler,Array<CIMObject>());

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_CIMINSTANCEPROVIDER,

METHOD_CIMINSTANCEPROVIDER2,

METHOD_INSTANCEPROVIDER,

METHOD_INSTANCEPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

try {

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

"JMPIProviderManager::handleExecQueryRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->className.getString());

// make target object path

CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->className);

// resolve provider name

ProviderName name = _resolveProviderName(

request->operationContext.get(ProviderIdContainer::NAME));

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),

name.getLogicalName(),

String::EMPTY);

// convert arguments

OperationContext context;

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

// forward request

JMPIProvider &pr = ph.GetProvider();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.execQuery: " + pr.getName());

JvmVector *jv = 0;

env = JMPIjvm::attachThread(&jv);

if (!env)

{

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

"Could not initialize the JVM (Java Virtual Machine) runtime environment."));

}

JMPIProvider::pm_service_op_lock op_lock(&pr);

STAT_GETSTARTTIME;

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),

interfaceType,

interfaceVersion);

if (interfaceType == "JMPI")

{

// public abstract java.util.Vector execQuery (org.pegasus.jmpi.CIMObjectPath cop,

// java.lang.String queryStatement,

// int ql,

// org.pegasus.jmpi.CIMClass cimClass)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"execQuery",

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

env->ExceptionClear();

// public abstract org.pegasus.jmpi.CIMInstance[] execQuery(org.pegasus.jmpi.CIMObjectPath cop,

// java.lang.String query,

// java.lang.String ql,

// org.pegasus.jmpi.CIMClass cimClass)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"execQuery",

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;");

if (id != NULL)

{

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));

}

else if (interfaceType == "JMPIExperimental")

{

// public abstract java.util.Vector execQuery (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMClass cimClass,

// java.lang.String queryStatement,

// java.lang.String queryLanguage)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"execQuery",

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

env->ExceptionClear();

// public abstract org.pegasus.jmpi.CIMInstance[] execQuery (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMClass cimClass,

// java.lang.String queryStatement,

// java.lang.String queryLanguage)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"execQuery",

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");

if (id != NULL)

{

eMethodFound = METHOD_CIMINSTANCEPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_CIMINSTANCEPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found no method!"<<PEGASUS_STD(endl));

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

"Could not find a method for the provider based on InterfaceType."));

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_CIMINSTANCEPROVIDER:

{

jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);

JMPIjvm::checkException(env);

jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());

jstring jquery = env->NewStringUTF(request->query.getCString());

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);

jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);

JMPIjvm::checkException(env);

jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

jcop,

jquery,

jqueryLanguage,

jCc);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jAr) {

for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {

JMPIjvm::checkException(env);

jobject jciRet = env->GetObjectArrayElement(jAr,i);

JMPIjvm::checkException(env);

jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

JMPIjvm::checkException(env);

handler.deliver(*ciRet);

}

handler.complete();

break;

}

case METHOD_CIMINSTANCEPROVIDER2:

{

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);

JMPIjvm::checkException(env);

jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());

jstring jquery = env->NewStringUTF(request->query.getCString());

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);

jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);

JMPIjvm::checkException(env);

jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

joc,

jcop,

jquery,

jqueryLanguage,

jCc);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

handler.processing();

if (jAr) {

for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {

JMPIjvm::checkException(env);

jobject jciRet = env->GetObjectArrayElement(jAr,i);

JMPIjvm::checkException(env);

jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

JMPIjvm::checkException(env);

handler.deliver(*ciRet);

}

handler.complete();

break;

}

case METHOD_INSTANCEPROVIDER2:

{

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);

JMPIjvm::checkException(env);

jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());

jstring jquery = env->NewStringUTF(request->query.getCString());

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);

jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);

JMPIjvm::checkException(env);

jobjectArray jVec = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

joc,

jcop,

jCc,

jquery,

jqueryLanguage);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

handler.processing();

if (jVec) {

for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {

JMPIjvm::checkException(env);

jobject jciRet = env->GetObjectArrayElement(jVec,i);

JMPIjvm::checkException(env);

jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

JMPIjvm::checkException(env);

handler.deliver(*ciRet);

}

handler.complete();

break;

}

case METHOD_INSTANCEPROVIDER:

{

jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);

JMPIjvm::checkException(env);

jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());

jstring jquery = env->NewStringUTF(request->query.getCString());

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);

jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);

JMPIjvm::checkException(env);

jint jql = 0; // @BUG - how to convert?

jobjectArray jVec = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

jcop,

jquery,

jql,

jCc);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jVec) {

for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {

JMPIjvm::checkException(env);

jobject jciRet = env->GetObjectArrayElement(jVec,i);

JMPIjvm::checkException(env);

jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

JMPIjvm::checkException(env);

handler.deliver(*ciRet);

}

handler.complete();

break;

}

case METHOD_UNKNOWN:

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: should not be here!"<<PEGASUS_STD(endl));

break;

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw()

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest");

HandlerIntro(Associators,message,request,response,handler,Array<CIMObject>());

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_CIMASSOCIATORPROVIDER,

METHOD_CIMASSOCIATORPROVIDER2,

METHOD_ASSOCIATORPROVIDER,

METHOD_ASSOCIATORPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

try {

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

"JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

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

// make target object path

CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->objectName.getClassName(),

request->objectName.getKeyBindings());

CIMObjectPath *assocPath = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->assocClass.getString());

// resolve provider name

ProviderName name = _resolveProviderName(

request->operationContext.get(ProviderIdContainer::NAME));

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),

name.getLogicalName(),

String::EMPTY);

// convert arguments

OperationContext context;

context.insert(request->operationContext.get(IdentityContainer::NAME));

context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));

// forward request

JMPIProvider &pr = ph.GetProvider();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associators: " + pr.getName());

JvmVector *jv = 0;

env = JMPIjvm::attachThread(&jv);

if (!env)

{

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

"Could not initialize the JVM (Java Virtual Machine) runtime environment."));

}

JMPIProvider::pm_service_op_lock op_lock(&pr);

STAT_GETSTARTTIME;

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),

interfaceType,

interfaceVersion);

if (interfaceType == "JMPI")

{

// public java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String resultClass,

// java.lang.String role,

// java.lang.String resultRole,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"associators",

"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");

if (id != NULL)

{

eMethodFound = METHOD_ASSOCIATORPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

env->ExceptionClear();

// public org.pegasus.jmpi.CIMInstance[] associators (org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String resultClass,

// java.lang.String role,

// java.lang.String resultRole,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"associators",

"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");

if (id != NULL)

{

eMethodFound = METHOD_CIMASSOCIATORPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));

}

else if (interfaceType == "JMPIExperimental")

{

// public java.util.Vector associators (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String resultClass,

// java.lang.String role,

// java.lang.String resultRole,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"associators",

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");

if (id != NULL)

{

eMethodFound = METHOD_ASSOCIATORPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

env->ExceptionClear();

// public org.pegasus.jmpi.CIMInstance[] associators (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String resultClass,

// java.lang.String role,

// java.lang.String resultRole,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"associators",

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");

if (id != NULL)

{

eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl));

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

"Could not find a method for the provider based on InterfaceType."));

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_CIMASSOCIATORPROVIDER:

{

jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);

jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);

JMPIjvm::checkException(env);

jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);

JMPIjvm::checkException(env);

jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());

jstring jRole = env->NewStringUTF(request->role.getCString());

jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());

JMPIjvm::checkException(env);

jobjectArray jPropertyList = getList(jv,env,request->propertyList);

#ifdef PEGASUS_DEBUG

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));

#endif

jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

jAssociationName,

jPathName,

jResultClass,

jRole,

jResultRole,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jVec) {

for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {

JMPIjvm::checkException(env);

jobject jciRet = env->GetObjectArrayElement(jVec,i);

JMPIjvm::checkException(env);

jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

JMPIjvm::checkException(env);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

const CIMObjectPath& op = ciRet->getPath();

CIMObjectPath iop = ciRet->buildPath(cls);

JMPIjvm::checkException(env);

iop.setNameSpace(op.getNameSpace());

ciRet->setPath(iop);

handler.deliver(*ciRet);

}

handler.complete();

break;

}

case METHOD_CIMASSOCIATORPROVIDER2:

{

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);

jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);

JMPIjvm::checkException(env);

jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);

JMPIjvm::checkException(env);

jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());

jstring jRole = env->NewStringUTF(request->role.getCString());

jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());

JMPIjvm::checkException(env);

jobjectArray jPropertyList = getList(jv,env,request->propertyList);

#ifdef PEGASUS_DEBUG

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));

#endif

jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

joc,

jAssociationName,

jPathName,

jResultClass,

jRole,

jResultRole,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

handler.processing();

if (jVec) {

for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {

JMPIjvm::checkException(env);

jobject jciRet = env->GetObjectArrayElement(jVec,i);

JMPIjvm::checkException(env);

jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

JMPIjvm::checkException(env);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

const CIMObjectPath& op = ciRet->getPath();

CIMObjectPath iop = ciRet->buildPath(cls);

JMPIjvm::checkException(env);

iop.setNameSpace(op.getNameSpace());

ciRet->setPath(iop);

handler.deliver(*ciRet);

}

handler.complete();

break;

}

case METHOD_ASSOCIATORPROVIDER2:

{

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);

jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);

JMPIjvm::checkException(env);

jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);

JMPIjvm::checkException(env);

jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());

jstring jRole = env->NewStringUTF(request->role.getCString());

jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());

JMPIjvm::checkException(env);

jobjectArray jPropertyList = getList(jv,env,request->propertyList);

#ifdef PEGASUS_DEBUG

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));

#endif

jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

joc,

jAssociationName,

jPathName,

jResultClass,

jRole,

jResultRole,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

handler.processing();

if (jVec) {

for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {

JMPIjvm::checkException(env);

jobject jciRet = env->GetObjectArrayElement(jVec,i);

JMPIjvm::checkException(env);

jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

JMPIjvm::checkException(env);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

const CIMObjectPath& op = ciRet->getPath();

CIMObjectPath iop = ciRet->buildPath(cls);

JMPIjvm::checkException(env);

iop.setNameSpace(op.getNameSpace());

ciRet->setPath(iop);

handler.deliver(*ciRet);

}

handler.complete();

break;

}

case METHOD_ASSOCIATORPROVIDER:

{

jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);

jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);

JMPIjvm::checkException(env);

jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);

JMPIjvm::checkException(env);

jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());

jstring jRole = env->NewStringUTF(request->role.getCString());

jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());

JMPIjvm::checkException(env);

jobjectArray jPropertyList = getList(jv,env,request->propertyList);

#ifdef PEGASUS_DEBUG

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));

#endif

jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

jAssociationName,

jPathName,

jResultClass,

jRole,

jResultRole,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jVec) {

for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {

JMPIjvm::checkException(env);

jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);

JMPIjvm::checkException(env);

jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

CIMClass cls;

try

{

DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));

}

catch (CIMException e)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

const CIMObjectPath& op = ciRet->getPath();

CIMObjectPath iop = ciRet->buildPath(cls);

JMPIjvm::checkException(env);

iop.setNameSpace(op.getNameSpace());

ciRet->setPath(iop);

handler.deliver(*ciRet);

}

handler.complete();

break;

}

case METHOD_UNKNOWN:

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl));

break;

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw()

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorNamesRequest");

HandlerIntro(AssociatorNames,message,request,response,handler,Array<CIMObjectPath>());

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_CIMASSOCIATORPROVIDER,

METHOD_CIMASSOCIATORPROVIDER2,

METHOD_ASSOCIATORPROVIDER,

METHOD_ASSOCIATORPROVIDER2

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

try {

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

"JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

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

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<", assocName = "<<request->assocClass.getString()<<PEGASUS_STD(endl));

// make target object path

CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->objectName.getClassName(),

request->objectName.getKeyBindings());

CIMObjectPath *assocPath = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->assocClass.getString());

// resolve provider name

ProviderName name = _resolveProviderName(

request->operationContext.get(ProviderIdContainer::NAME));

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),

name.getLogicalName(),

String::EMPTY);

// forward request

JMPIProvider &pr = ph.GetProvider();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associatorNames: " + pr.getName());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: Calling provider associatorNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));

JvmVector *jv = 0;

env = JMPIjvm::attachThread(&jv);

if (!env)

{

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

"Could not initialize the JVM (Java Virtual Machine) runtime environment."));

}

JMPIProvider::pm_service_op_lock op_lock(&pr);

STAT_GETSTARTTIME;

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

// public abstract java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,

getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),

interfaceType,

interfaceVersion);

if (interfaceType == "JMPI")

{

// public java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String resultClass,

// java.lang.String role,

// java.lang.String resultRole,

// java.lang.String resultRole)

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"associators",

"associatorNames",

"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");

"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");

//@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath; Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_ASSOCIATORPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

env->ExceptionClear();

// public abstract java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,

// public org.pegasus.jmpi.CIMObjectPath[] associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String resultClass,

// java.lang.String role,

// java.lang.String resultRole,

// java.lang.String resultRole)

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"associators",

"associatorNames",

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");

"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");

//@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;"

if (id != NULL)

{

eMethodFound = METHOD_CIMASSOCIATORPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));

}

else if (interfaceType == "JMPIExperimental")

{

// public java.util.Vector associatorNames (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String resultClass,

// java.lang.String role,

// java.lang.String resultRole)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"associatorNames",

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");

if (id != NULL)

{

eMethodFound = METHOD_ASSOCIATORPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

env->ExceptionClear();

// public org.pegasus.jmpi.CIMObjectPath[] associatorNames (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String resultClass,

// java.lang.String role,

// java.lang.String resultRole)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"associatorNames",

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");

if (id != NULL)

{

eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found no method!"<<PEGASUS_STD(endl));

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

"Could not find a method for the provider based on InterfaceType."));

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_CIMASSOCIATORPROVIDER:

{

jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);

jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);

JMPIjvm::checkException(env);

jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);

JMPIjvm::checkException(env);

jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());

jstring jRole = env->NewStringUTF(request->role.getCString());

jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());

JMPIjvm::checkException(env);

#ifdef PEGASUS_DEBUG

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));

#endif

jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

jAssociationName,

jPathName,

jResultClass,

jRole,

jResultRole);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jVec) {

for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {

JMPIjvm::checkException(env);

jobject jcopRet = env->GetObjectArrayElement(jVec,i);

JMPIjvm::checkException(env);

jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRet);

JMPIjvm::checkException(env);

handler.deliver(*copRet);

}

handler.complete();

break;

}

case METHOD_CIMASSOCIATORPROVIDER2:

{

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);

jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);

JMPIjvm::checkException(env);

jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);

JMPIjvm::checkException(env);

jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());

jstring jRole = env->NewStringUTF(request->role.getCString());

jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());

JMPIjvm::checkException(env);

#ifdef PEGASUS_DEBUG

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));

#endif

jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

joc,

jAssociationName,

jPathName,

jResultClass,

jRole,

jResultRole);

if (id != NULL)

JMPIjvm::checkException(env);

{

eMethodFound = METHOD_PEGASUS_24;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));

}

if (id == NULL)

STAT_PMS_PROVIDEREND;

if (joc)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl));

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

handler.processing();

if (jVec) {

for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {

JMPIjvm::checkException(env);

switch (eMethodFound)

jobject jcopRet = env->GetObjectArrayElement(jVec,i);

{

case METHOD_PEGASUS_24:

JMPIjvm::checkException(env);

jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRet);

JMPIjvm::checkException(env);

handler.deliver(*copRet);

}

handler.complete();

break;

}

case METHOD_ASSOCIATORPROVIDER:

{

jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);

jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);

JMPIjvm::checkException(env);

jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);

JMPIjvm::checkException(env);

jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());

jstring jRole = env->NewStringUTF(request->role.getCString());

jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());

JMPIjvm::checkException(env);

jobjectArray jPropertyList = getList(jv,env,request->propertyList);

#ifdef PEGASUS_DEBUG

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));

#endif

jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,

id,

jAssociationName,

jPathName,

jResultClass,

jRole,

jResultRole,

jResultRole);

false,

jPropertyList);

JMPIjvm::checkException(env);

Line 2132

Line 4185

handler.processing();

if (jVec) {

for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {

for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {

JMPIjvm::checkException(env);

jobject jciRet = env->GetObjectArrayElement(jVec,i);

JMPIjvm::checkException(env);

jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);

JMPIjvm::checkException(env);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);

jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

CIMClass cls = pr._cimom_handle->getClass(context,

CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

const CIMObjectPath& op = ciRet->getPath();

CIMObjectPath iop = ciRet->buildPath(cls);

JMPIjvm::checkException(env);

iop.setNameSpace(op.getNameSpace());

handler.deliver(*copRet);

ciRet->setPath(iop);

handler.deliver(*ciRet);

}

handler.complete();

break;

}

case METHOD_SNIA_PROVIDER20:

case METHOD_ASSOCIATORPROVIDER2:

{

jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);

jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);

jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);

Line 2184

Line 4225