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.20 and 1.43

version 1.20, 2005/02/23 18:13:49

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 50

Line 52

#include <Pegasus/ProviderManager2/ProviderName.h>

#include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h>

#include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.h>

#include <Pegasus/ProviderManager2/ProviderManagerService.h>

#include <Pegasus/ProviderManager2/CMPI/CMPI_SelectExp.h>

Line 58

Line 61

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

int _jmpi_trace=0;

int JMPIProviderManager::trace=0;

#define DDD(x) if (_jmpi_trace) x;

#ifdef PEGASUS_DEBUG

#define DDD(x) if (JMPIProviderManager::trace) x;

#else

#define DDD(x)

#endif

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

#define JMPI_LOCALONLY false

/* 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"

void JMPIProviderManager::debugPrintMethodPointers (JNIEnv *env, jclass jc)

{

// cd ${PEGAUSE_HOME}/src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/tests/JMPI_TestPropertyTypes

// javap -s -p JMPI_TestPropertyTypes

static const char *methodNames[][3] = {

// CIMProvider

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

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

{"snia 2.0","initialize","(Lorg/pegasus/jmpi/CIMOMHandle;)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","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;)Ljava/util/Vector;"},

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

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

{"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;"},

/* Begin Fix for 4238 */

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

/* End Fix for 4238 */

{"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

{"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/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

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

{"snia 2.0","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

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

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

};

if (!env)

{

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: env is NULL!"<<PEGASUS_STD(endl));

return;

}

if (!jc)

{

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: jc is NULL!"<<PEGASUS_STD(endl));

return;

}

for (int i = 0; i < (int)(sizeof (methodNames)/sizeof (methodNames[0])); i++)

{

jmethodID id = env->GetMethodID(jc,methodNames[i][1], methodNames[i][2]);

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: "<<methodNames[i][0]<<", "<<methodNames[i][1]<<", id = "<<PEGASUS_STD(hex)<<(int)id<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

env->ExceptionClear();

}

env->ExceptionClear();

}

void

debugIntrospectJavaObject (JNIEnv *env, jobject jInst)

{

jclass jInstClass = env->GetObjectClass(jInst);

jclass jInstSuperClass = env->GetSuperclass(jInstClass);

jmethodID jmidGetDeclaredMethods = env->GetMethodID(jInstClass, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;");

if (!jmidGetDeclaredMethods)

{

env->ExceptionClear();

jmidGetDeclaredMethods = env->GetMethodID(jInstSuperClass, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;");

}

if (jmidGetDeclaredMethods)

{

jobjectArray jarrayDeclaredMethods = (jobjectArray)env->CallObjectMethod(jInstClass,

jmidGetDeclaredMethods);

if (jarrayDeclaredMethods)

{

for (int i = 0, iLen = env->GetArrayLength (jarrayDeclaredMethods); i < iLen; i++)

{

JMPIjvm::checkException(env);

jobject jDeclaredMethod = env->GetObjectArrayElement (jarrayDeclaredMethods, i);

jclass jDeclaredMethodClass = env->GetObjectClass (jDeclaredMethod);

JMPIjvm::checkException(env);

jmethodID jmidToString = env->GetMethodID (jDeclaredMethodClass, "toString", "()Ljava/lang/String;");

jstring jstringResult = (jstring)env->CallObjectMethod (jDeclaredMethod, jmidToString);

const char *pszResult = env->GetStringUTFChars(jstringResult, 0);

PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugIntrospectJavaObject: "<<pszResult<<PEGASUS_STD(endl);

env->ReleaseStringUTFChars (jstringResult, pszResult);

}

env->ExceptionClear();

}

void

debugDumpJavaObject (JNIEnv *env, jobject jInst)

{

jclass jInstClass = env->GetObjectClass(jInst);

jclass jInstSuperClass = env->GetSuperclass(jInstClass);

jmethodID jmidToString1 = env->GetMethodID(jInstClass, "toString", "()Ljava/lang/String;");

jmethodID jmidToString2 = env->GetMethodID(jInstSuperClass, "toString", "()Ljava/lang/String;");

if (!jmidToString1 || !jmidToString2)

{

env->ExceptionClear();

return;

}

jstring jstringResult1 = (jstring)env->CallObjectMethod(jInstClass, jmidToString1);

jstring jstringResult2 = (jstring)env->CallObjectMethod(jInstSuperClass, jmidToString2);

jstring jstringResult3 = (jstring)env->CallObjectMethod(jInst, jmidToString1);

const char *pszResult1 = env->GetStringUTFChars(jstringResult1, 0);

const char *pszResult2 = env->GetStringUTFChars(jstringResult2, 0);

const char *pszResult3 = env->GetStringUTFChars(jstringResult3, 0);

jmethodID jmidCInst = env->GetMethodID(env->GetObjectClass(jInst),JMPIjvm::jv.instanceMethodNames[22].methodName, JMPIjvm::jv.instanceMethodNames[22].signature);

PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugIntrospectJavaObject: jInstClass = "<<jInstClass<<", jInstSuperClass = "<<jInstSuperClass<<", jClassShouldBe = "<<JMPIjvm::jv.classRefs[18]<<", jmidCInst = "<<jmidCInst<<PEGASUS_STD(endl);

PEGASUS_STD(cout)<<"pszResult1 = "<<pszResult1<<PEGASUS_STD(endl);

PEGASUS_STD(cout)<<"pszResult2 = "<<pszResult2<<PEGASUS_STD(endl);

PEGASUS_STD(cout)<<"pszResult3 = "<<pszResult3<<PEGASUS_STD(endl);

env->ReleaseStringUTFChars (jstringResult1, pszResult1);

env->ReleaseStringUTFChars (jstringResult2, pszResult2);

env->ReleaseStringUTFChars (jstringResult3, pszResult3);

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;

Line 69

Line 354

JMPIProviderManager::JMPIProviderManager(Mode m)

{

mode=m;

if (getenv("JMPI_TRACE")) _jmpi_trace=1;

_subscriptionInitComplete = false;

else _jmpi_trace=0;

#ifdef PEGASUS_DEBUG

if (getenv("PEGASUS_JMPI_TRACE"))

JMPIProviderManager::trace = 1;

else

JMPIProviderManager::trace = 0;

#else

JMPIProviderManager::trace = 0;

#endif

}

JMPIProviderManager::~JMPIProviderManager(void)

Line 81

Line 374

const String &ns, const String &cn)

{

String key(ns+String("::")+cn+String("::")+CIMValue(name.getCapabilitiesMask()).toString());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::insertProvider: "<<key<<PEGASUS_STD(endl));

return provReg.insert(key,name);

}

Message * JMPIProviderManager::processMessage(Message * request) throw()

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

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

"JMPIProviderManager::processMessage()");

Message * response = 0;

Line 97

Line 391

{

case CIM_GET_INSTANCE_REQUEST_MESSAGE:

response = handleGetInstanceRequest(request);

break;

case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:

response = handleEnumerateInstancesRequest(request);

break;

case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:

response = handleEnumerateInstanceNamesRequest(request);

break;

case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:

response = handleCreateInstanceRequest(request);

break;

case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:

response = handleModifyInstanceRequest(request);

break;

case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:

response = handleDeleteInstanceRequest(request);

break;

case CIM_EXEC_QUERY_REQUEST_MESSAGE:

response = handleExecQueryRequest(request);

break;

/* case CIM_EXEC_QUERY_REQUEST_MESSAGE:

response = handleExecuteQueryRequest(request);

*/ break;

case CIM_ASSOCIATORS_REQUEST_MESSAGE:

response = handleAssociatorsRequest(request);

break;

case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:

response = handleAssociatorNamesRequest(request);

break;

case CIM_REFERENCES_REQUEST_MESSAGE:

response = handleReferencesRequest(request);

break;

case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:

response = handleReferenceNamesRequest(request);

break;

case CIM_GET_PROPERTY_REQUEST_MESSAGE:

response = handleGetPropertyRequest(request);

break;

case CIM_SET_PROPERTY_REQUEST_MESSAGE:

response = handleSetPropertyRequest(request);

break;

case CIM_INVOKE_METHOD_REQUEST_MESSAGE:

response = handleInvokeMethodRequest(request);

break;

case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:

response = handleCreateSubscriptionRequest(request);

break;

/* case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:

response = handleModifySubscriptionRequest(request);

break;

case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:

response = handleDeleteSubscriptionRequest(request);

break;

case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE:

response = handleEnableIndicationsRequest(request);

break;

case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE:

response = handleDisableIndicationsRequest(request);

break;

/* case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:

response = handleExportIndicationRequest(request);

break;

case CIM_DISABLE_MODULE_REQUEST_MESSAGE:

response = handleDisableModuleRequest(request);

break;

case CIM_ENABLE_MODULE_REQUEST_MESSAGE:

response = handleEnableModuleRequest(request);

break;

case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:

response = handleStopAllProvidersRequest(request);

break;

case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:

response = handleInitializeProviderRequest(request);

break;

case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:

response = handleSubscriptionInitCompleteRequest (request);

break;

default:

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"*** Unsupported Request "+request->getType());

response = handleUnsupportedRequest(request);

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::processMessage: Unsupported request "<<request->getType ()<<PEGASUS_STD(endl));

response = handleUnsupportedRequest(request);

break;

}

Line 229

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 274

Line 573

jobjectArray pl=NULL;

if (s) {

jstring initial=env->NewString(NULL,0);

pl=env->NewObjectArray(s,jv->StringClassRef,initial);

pl=(jobjectArray)env->NewObjectArray(s,jv->StringClassRef,initial);

for (Uint32 i=0; i<s; i++) {

env->SetObjectArrayElement

(pl,i,env->NewStringUTF(list[i].getString().getCString()));

Line 285

Line 584

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

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

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

"JMPIProviderManager::handleGetInstanceRequest");

HandlerIntro(GetInstance,message,request,response,handler,CIMInstance());

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_CIMINSTANCEPROVIDER,

METHOD_INSTANCEPROVIDER,

METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env=NULL;

Boolean mode24=false;

CIMPropertyList propertyList;

jobjectArray pl=NULL;

try {

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

Line 302

Line 604

request->nameSpace.getString(),

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

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

// make target object path

CIMObjectPath objectPath(

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

System::getHostName(),

request->nameSpace,

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

Line 318

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();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

"Calling provider.getInstance: " + pr.getName());

DDD(cerr<<"--- JMPIProviderManager::getInstance"<<endl);

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

JvmVector *jv;

JvmVector *jv = 0;

JNIEnv *env=JMPIjvm::attachThread(&jv);

JMPIjvm::checkException(env);

jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,

jv->CIMObjectPathNewI,(jint)&objectPath);

JMPIjvm::checkException(env);

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

env = JMPIjvm::attachThread(&jv);

request->instanceName.getClassName(),

false,true,true,CIMPropertyList());

JMPIjvm::checkException(env);

jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls);

JMPIjvm::checkException(env);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

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

STAT_COPYDISPATCHER

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

if (id==NULL) {

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

env->ExceptionClear();

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

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

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

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

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

JMPIjvm::checkException(env);

mode24=true;

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

}

JMPIjvm::checkException(env);

STAT_GETSTARTTIME;

jobject inst=NULL;

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

if (mode24) inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,

request->localOnly,request->includeQualifiers,request->includeClassOrigin,pl,jCc);

else inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jCc,true);

STAT_PMS_PROVIDEREND;

JMPIProvider::pm_service_op_lock op_lock(&pr);

JMPIjvm::checkException(env);

STAT_GETSTARTTIME;

handler.processing();

if (inst) {

CIMInstance *ci=((CIMInstance*)env->CallIntMethod(inst,JMPIjvm::jv.CIMInstanceCInst));

handler.deliver(*ci);

}

handler.complete();

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

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

interfaceType,

interfaceVersion);

PEG_METHOD_EXIT();

if (interfaceType == "JMPI")

{

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

// org.pegasus.jmpi.CIMClass cimClass,

// boolean localOnly)

// throws org.pegasus.jmpi.CIMException

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

"getInstance",

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

return(response);

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER;

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

}

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

if (id == NULL)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

env->ExceptionClear();

"JMPIProviderManager::handleEnumerateInstanceRequest");

HandlerIntro(EnumerateInstances,message,request,response,

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

handler,Array<CIMInstance>());

// boolean localOnly,

JNIEnv *env=NULL;

// boolean includeQualifiers,

Boolean mode24=false;

// boolean includeClassOrigin,

CIMPropertyList propertyList;

// java.lang.String[] propertyList,

jobjectArray pl=NULL;

// org.pegasus.jmpi.CIMClass cc)

// throws org.pegasus.jmpi.CIMException

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

"getInstance",

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

try {

if (id != NULL)

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

{

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

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

System::getHostName(),

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

request->nameSpace.getString(),

}

request->className.getString());

}

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;");

// make target object path

if (id != NULL)

CIMObjectPath objectPath(

{

System::getHostName(),

eMethodFound = METHOD_INSTANCEPROVIDER2;

request->nameSpace,

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

request->className);

}

/* Fix for 4238 */

}

// resolve provider name

if (id == NULL)

ProviderName name = _resolveProviderName(

{

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

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

// get cached or load new provider module

PEG_METHOD_EXIT();

JMPIProvider::OpProviderHolder ph =

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

String::EMPTY);

// convert arguments

STAT_COPYDISPATCHER

OperationContext context;

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

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

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

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

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

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

}

CIMPropertyList propertyList(request->propertyList);

JMPIjvm::checkException(env);

// forward request

switch (eMethodFound)

JMPIProvider & pr=ph.GetProvider();

{

case METHOD_CIMINSTANCEPROVIDER:

{

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

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

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

JMPIjvm::checkException(env);

"Calling provider.enumerateInstances: " + pr.getName());

DDD(cerr<<"--- JMPIProviderManager::enumerateInstances"<<endl);

CIMClass cls;

try

{

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

AutoMutex lock (pr._cimomMutex);

JvmVector *jv;

cls = pr._cimom_handle->getClass(context,

env=JMPIjvm::attachThread(&jv);

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;

}

jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,

CIMClass *pcls = new CIMClass (cls);

jv->CIMObjectPathNewI,(jint)&objectPath);

JMPIjvm::checkException(env);

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

request->className,

false,true,true,CIMPropertyList());

JMPIjvm::checkException(env);

jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls);

JMPIjvm::checkException(env);

JMPIProvider::pm_service_op_lock op_lock(&pr);

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

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

STAT_GETSTARTTIME;

JMPIjvm::checkException(env);

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

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

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

if (id==NULL) {

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

env->ExceptionClear();

id,

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

jop,

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

JMPI_LOCALONLY,

"[Lorg/pegasus/jmpi/CIMInstance;");

JMPI_INCLUDE_QUALIFIERS,

JMPIjvm::checkException(env);

request->includeClassOrigin,

mode24=true;

jPropertyList,

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

jcimClass);

}

JMPIjvm::checkException(env);

if (!mode24) {

jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,false,jCc,true);

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 jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);

JMPIjvm::checkException(env);

CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));

JMPIjvm::checkException(env);

handler.deliver(inst);

if (jciRet) {

}

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

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

handler.deliver(*ciRet);

}

handler.complete();

break;

}

else {

/* Fix for 4238 */

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

case METHOD_INSTANCEPROVIDER2:

request->localOnly,request->includeQualifiers,request->includeClassOrigin,pl,jCc);

{

JMPIjvm::checkException(env);

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

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

STAT_PMS_PROVIDEREND;

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

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

JMPIjvm::checkException(env);

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);

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

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

JMPIjvm::checkException(env);

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

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

id,

joc,

jop,

jcimClass,

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 (jciRet) {

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

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

handler.deliver(*ciRet);

}

handler.complete();

break;

}

/* Fix for 4238 */

case METHOD_INSTANCEPROVIDER:

{

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

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

JMPIjvm::checkException(env);

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);

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

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

JMPIjvm::checkException(env);

// Modified for Bugzilla# 3679

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

id,

jop,

jcimClass,

JMPI_LOCALONLY);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jciRet) {

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

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

handler.deliver(*ciRet);

}

handler.complete();

break;

}

case METHOD_UNKNOWN:

{

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

break;

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

{

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

HandlerIntro(EnumerateInstances,message,request,response,handler,Array<CIMInstance>());

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::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->className.getString());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: 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.enumerateInstances: " + pr.getName());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Calling provider enumerateInstances: "<<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,

// boolean localOnly)

// throws org.pegasus.jmpi.CIMException

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

"enumInstances",

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

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER;

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

}

if (id == NULL)

{

env->ExceptionClear();

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

// boolean localOnly,

// boolean includeQualifiers,

// 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;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;");

if (id != NULL)

{

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

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 abstract org.pegasus.jmpi.CIMInstance[] 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,

"enumInstances",

"(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_CIMINSTANCEPROVIDER2;

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_CIMINSTANCEPROVIDER:

{

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);

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

id,

jcop,

JMPI_LOCALONLY,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList,

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 jInst=env->GetObjectArrayElement(jAr,i);

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;

}

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;

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);

jobjectArray jAr = (jobjectArray)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);

CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));

}

handler.processing();

if (jAr) {

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

JMPIjvm::checkException(env);

handler.deliver(inst);

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);

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);

/* 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);

iop.setNameSpace(op.getNameSpace());

ciRet->setPath(iop);

/* Fix for 4237*/

handler.deliver(*ciRet);

}

handler.complete();

break;

}

/* Fix for 4189 */

case METHOD_INSTANCEPROVIDER:

{

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);

// Modified for Bugzilla# 3679

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

id,

jcop,

request->deepInheritance,

jcc,

JMPI_LOCALONLY);

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);

/* 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);

iop.setNameSpace(op.getNameSpace());

ciRet->setPath(iop);

/* Fix for 4237*/

handler.deliver(*ciRet);

}

handler.complete();

break;

}

case METHOD_UNKNOWN:

{

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

break;

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

{

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

HandlerIntro(EnumerateInstanceNames,message,request,response, handler,Array<CIMObjectPath>());

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::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->className.getString());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: 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());

// 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));

JMPIProvider &pr = ph.GetProvider();

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));

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)

// throws org.pegasus.jmpi.CIMException

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

"enumInstances",

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

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER;

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

}

if (id == NULL)

{

env->ExceptionClear();

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

// org.pegasus.jmpi.CIMClass cc)

// throws org.pegasus.jmpi.CIMException

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

"enumerateInstanceNames",

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

if (id != NULL)

{

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

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_CIMINSTANCEPROVIDER:

{

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::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

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

id,

jcop,

jcimClass);

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 jcopRet = env->GetObjectArrayElement(jAr,i);

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_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;

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);

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

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

JMPIjvm::checkException(env);

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

id,

joc,

jcop,

jcimClass);

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 jcopRet = env->GetObjectArrayElement(jAr,i);

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_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::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

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

id,

joc,

jcop,

jcimClass);

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);

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

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_INSTANCEPROVIDER:

{

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::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

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

id,

jcop,

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);

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

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::handleEnumerateInstanceNamesRequest: should not be here!"<<PEGASUS_STD(endl));

break;

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

{

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

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

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER

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::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));

// make target object path

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

request->nameSpace,

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

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

// 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.createInstance: " + ph.GetProvider().getName());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: Calling provider createInstance: "<<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 org.pegasus.jmpi.CIMObjectPath createInstance (org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMInstance cimInstance)

// throws org.pegasus.jmpi.CIMException

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

"createInstance",

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

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER;

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

}

else if (interfaceType == "JMPIExperimental")

{

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

// org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMInstance cimInstance)

// throws org.pegasus.jmpi.CIMException

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

"createInstance",

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

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER2;

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_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->newInstance);

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

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 jcopRet = env->CallObjectMethod((jobject)pr.jProvider,

id,

jcop,

jci);

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_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->newInstance);

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

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 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::handleCreateInstanceRequest: should not be here!"<<PEGASUS_STD(endl));

break;

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

{

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

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

typedef enum {

METHOD_UNKNOWN = 0,

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::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

request->modifiedInstance.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->modifiedInstance.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 = providerManager.getProvider (name.getPhysicalName(),

name.getLogicalName(),

String::EMPTY);

// forward request

JMPIProvider &pr = ph.GetProvider();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.modifyInstance: " + pr.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));

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 void setInstance (org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMInstance cimInstance)

// org.pegasus.jmpi.throws CIMException

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

"setInstance",

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

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER;

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

}

if (id == NULL)

{

env->ExceptionClear();

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

// 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");

if (id != NULL)

{

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

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

}

else if (interfaceType == "JMPIExperimental")

{

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

// org.pegasus.jmpi.CIMObjectPath op,

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

// throws org.pegasus.jmpi.CIMException

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

"setInstance",

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

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER2;

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

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: 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);

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);

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

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

id,

joc,

jcop,

jci);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

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

JMPIjvm::checkException(env);

}

break;

}

case METHOD_CIMINSTANCEPROVIDER:

{

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);

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);

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

id,

jcop,

jci,

JMPI_INCLUDE_QUALIFIERS,

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);

JMPIjvm::checkException(env);

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);

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

id,

jcop,

jci);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

break;

}

case METHOD_UNKNOWN:

{

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

break;

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

{

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

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

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER

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",

System::getHostName(),

request->nameSpace.getString(),

request->instanceName.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->instanceName.getKeyBindings());

// 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.deleteInstance: " + 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;

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());

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);

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());

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->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());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Calling provider associators: "<<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;

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;

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)

// throws org.pegasus.jmpi.CIMException

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

"associatorNames",

"(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_ASSOCIATORPROVIDER;

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

}

if (id == NULL)

{

env->ExceptionClear();

// 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)

// throws org.pegasus.jmpi.CIMException

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

"associatorNames",

"(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_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);

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 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_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);

#ifdef PEGASUS_DEBUG

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

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: pathName = "<<objectPath->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->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {

JMPIjvm::checkException(env);

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

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_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);

#ifdef PEGASUS_DEBUG

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

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: pathName = "<<objectPath->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);

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);

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

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::handleAssociatorNamesRequest: should not be here!"<<PEGASUS_STD(endl));

break;

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

{

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

HandlerIntro(References,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::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

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

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

// make target object path

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

request->nameSpace,

request->objectName.getClassName(),

request->objectName.getKeyBindings());

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

request->nameSpace,

request->resultClass.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.references: " + pr.getName());

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Calling provider references: "<<pr.getName()<<", role: "<<request->role<<" aCls: "<<request->resultClass<<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 java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String role,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

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

"references",

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

if (id != NULL)

{

eMethodFound = METHOD_ASSOCIATORPROVIDER;

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

}

if (id == NULL)

{

env->ExceptionClear();

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

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String role,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

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

"references",

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

if (id != NULL)

{

eMethodFound = METHOD_CIMASSOCIATORPROVIDER;

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

}

else if (interfaceType == "JMPIExperimental")

{

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

// org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String role,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

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

"references",

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

if (id != NULL)

{

eMethodFound = METHOD_ASSOCIATORPROVIDER2;

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

}

if (id == NULL)

{

env->ExceptionClear();

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

// org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String role,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

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

"references",

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

if (id != NULL)

{

eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;

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

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: 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, resultPath);

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 jRole = env->NewStringUTF(request->role.getCString());

JMPIjvm::checkException(env);

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

#ifdef PEGASUS_DEBUG

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

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

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

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

#endif

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

id,

jAssociationName,

jPathName,

jRole,

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::handleReferencesRequest: 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, resultPath);

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 jRole = env->NewStringUTF(request->role.getCString());

JMPIjvm::checkException(env);

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

#ifdef PEGASUS_DEBUG

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

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

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

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

#endif

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

id,

joc,

jAssociationName,

jPathName,

jRole,

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::handleReferencesRequest: 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, resultPath);

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 jRole = env->NewStringUTF(request->role.getCString());

JMPIjvm::checkException(env);

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

#ifdef PEGASUS_DEBUG

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

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));

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

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

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

#endif

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

id,

jAssociationName,

jPathName,

jRole,

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::handleReferencesRequest: 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, resultPath);

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 jRole = env->NewStringUTF(request->role.getCString());

JMPIjvm::checkException(env);

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

#ifdef PEGASUS_DEBUG

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

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));

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

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

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

#endif

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

id,

joc,

jAssociationName,

jPathName,

jRole,

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);

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::handleReferencesRequest: 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::handleReferencesRequest: should not be here!"<<PEGASUS_STD(endl));

break;

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

{

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

HandlerIntro(ReferenceNames,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::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

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

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: 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->objectName.getKeyBindings());

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

request->nameSpace,

request->resultClass.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);

JMPIProvider &pr = ph.GetProvider();

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

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: Calling provider referenceNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->resultClass<<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 java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String role)

// throws org.pegasus.jmpi.CIMException

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

"referenceNames",

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

if (id != NULL)

{

eMethodFound = METHOD_ASSOCIATORPROVIDER;

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

}

if (id == NULL)

{

env->ExceptionClear();

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

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String role)

// throws org.pegasus.jmpi.CIMException

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

"referenceNames",

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

if (id != NULL)

{

eMethodFound = METHOD_CIMASSOCIATORPROVIDER;

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

}

else if (interfaceType == "JMPIExperimental")

{

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

// org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String role)

// throws org.pegasus.jmpi.CIMException

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

"referenceNames",

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

if (id != NULL)

{

eMethodFound = METHOD_ASSOCIATORPROVIDER2;

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

}

if (id == NULL)

{

env->ExceptionClear();

// public org.pegasus.jmpi.CIMObjectPath[] referenceNames (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.CIMObjectPath assocName,

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String role)

// throws org.pegasus.jmpi.CIMException

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

"referenceNames",

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

if (id != NULL)

{

eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;

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

}

handler.complete();

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

if (id == NULL)

{

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

PEG_METHOD_EXIT();

return(response);

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."));

}

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

JMPIjvm::checkException(env);

switch (eMethodFound)

{

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

case METHOD_CIMASSOCIATORPROVIDER:

{

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

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

HandlerIntro(EnumerateInstanceNames,message,request,response,

JMPIjvm::checkException(env);

handler,Array<CIMObjectPath>());

JNIEnv *env=NULL;

Boolean mode24=false;

CIMPropertyList propertyList;

jobjectArray pl=NULL;

try {

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

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

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

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

System::getHostName(),

request->nameSpace.getString(),

request->className.getString());

// make target object path

JMPIjvm::checkException(env);

CIMObjectPath objectPath(

System::getHostName(),

request->nameSpace,

request->className);

// resolve provider name

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

ProviderName name = _resolveProviderName(

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

// get cached or load new provider module

JMPIjvm::checkException(env);

JMPIProvider::OpProviderHolder ph =

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

// convert arguments

#ifdef PEGASUS_DEBUG

OperationContext context;

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

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

#endif

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

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

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

id,

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

jPathName,

jAssociationName,

jRole);

JMPIProvider & pr=ph.GetProvider();

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

handler.processing();

"Calling provider.enumerateInstanceNames: " + pr.getName());

if (jVec) {

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

JMPIjvm::checkException(env);

DDD(cerr<<"--- JMPIProviderManager::enumerateInstanceNames"<<endl);

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

JMPIjvm::checkException(env);

JvmVector *jv;

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

env=JMPIjvm::attachThread(&jv);

jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,

jv->CIMObjectPathNewI,(jint)&objectPath);

JMPIjvm::checkException(env);

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

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

request->className,

false,true,true,CIMPropertyList());

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, resultPath);

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

JMPIjvm::checkException(env);

jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls);

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

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

JMPIjvm::checkException(env);

JMPIProvider::pm_service_op_lock op_lock(&pr);

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

STAT_GETSTARTTIME;

JMPIjvm::checkException(env);

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

#ifdef PEGASUS_DEBUG

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

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

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

#endif

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

id,

joc,

jPathName,

jAssociationName,

jRole);

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 jcopRet = env->GetObjectArrayElement(jVec,i);

JMPIjvm::checkException(env);

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

if (id==NULL) {

env->ExceptionClear();

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

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

"[Lorg/pegasus/jmpi/CIMObjectPath;");

JMPIjvm::checkException(env);

mode24=true;

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

handler.deliver(*copRet);

}

handler.complete();

break;

}

case METHOD_ASSOCIATORPROVIDER:

{

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

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 jRole = env->NewStringUTF(request->role.getCString());

JMPIjvm::checkException(env);

if (!mode24) {

#ifdef PEGASUS_DEBUG

jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,true,jCc);

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

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: pathName = "<<resultPath->toString ()<<PEGASUS_STD(endl));

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

#endif

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

id,

jAssociationName,

jPathName,

jRole);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

Line 606

Line 5189

if (jVec) {

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

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod

(jCop,JMPIjvm::jv.CIMObjectPathCInst));

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

JMPIjvm::checkException(env);

handler.deliver(*cop);

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

handler.deliver(*copRet);

}

handler.complete();

break;

}

else {

jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jCc);

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, resultPath);

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 jRole = env->NewStringUTF(request->role.getCString());

JMPIjvm::checkException(env);

#ifdef PEGASUS_DEBUG

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

DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: pathName = "<<resultPath->toString ()<<PEGASUS_STD(endl));

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

#endif

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

id,

joc,

jAssociationName,

jPathName,

jRole);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

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

JMPIjvm::checkException(env);

}

handler.processing();

if (jAr) {

if (jVec) {

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

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

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod

(jCop,JMPIjvm::jv.CIMObjectPathCInst));

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

JMPIjvm::checkException(env);

handler.deliver(*cop);

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

handler.deliver(*copRet);

}

handler.complete();

break;

}

case METHOD_UNKNOWN:

{

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

break;

}

HandlerCatch(handler);

Line 643

Line 5285

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

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

"JMPIProviderManager::handleCreateInstanceRequest");

HandlerIntro(CreateInstance,message,request,response,

HandlerIntro(GetProperty,message,request,response,handler,CIMValue());

handler,CIMObjectPath());

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PROPERTYPROVIDER,

METHOD_PROPERTYPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env=NULL;

try {

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

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

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

System::getHostName(),

request->nameSpace.getString(),

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

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

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

// make target object path

CIMObjectPath objectPath(

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

System::getHostName(),

request->nameSpace,

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

request->instanceName.getClassName(),

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

request->instanceName.getKeyBindings());

// 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(),

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,

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

"Calling provider.createInstance: " +

ph.GetProvider().getName());

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

DDD(cerr<<"--- JMPIProviderManager::createInstances"<<endl);

JvmVector *jv = 0;

JvmVector *jv;

env=JMPIjvm::attachThread(&jv);

jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,

if (!env)

jv->CIMObjectPathNewI,(jint)&objectPath);

{

JMPIjvm::checkException(env);

PEG_METHOD_EXIT();

jobject jInst=env->NewObject(jv->CIMInstanceClassRef,

jv->CIMInstanceNewI,(jint)&request->newInstance);

STAT_COPYDISPATCHER

JMPIjvm::checkException(env);

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=env->GetMethodID((jclass)pr.jProviderClass,"createInstance",

jmethodID id = NULL;

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

String interfaceType;

JMPIjvm::checkException(env);

String interfaceVersion;

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

interfaceType,

interfaceVersion);

jobject jCop=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jInst);

if (interfaceType == "JMPI")

{

// public abstract org.pegasus.jmpi.CIMValue getPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,

// java.lang.String oclass,

// java.lang.String pName)

// throws org.pegasus.jmpi.CIMException

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

"getPropertyValue",

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;");

STAT_PMS_PROVIDEREND;

if (id != NULL)

{

eMethodFound = METHOD_PROPERTYPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found METHOD_PROPERTYPROVIDER."<<PEGASUS_STD(endl));

}

else if (interfaceType == "JMPIExperimental")

{

// public abstract org.pegasus.jmpi.CIMValue getPropertyValue (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.CIMObjectPath cop,

// java.lang.String oclass,

// java.lang.String pName)

// throws org.pegasus.jmpi.CIMException

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

"getPropertyValue",

" (Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;");

JMPIjvm::checkException(env);

if (id != NULL)

handler.processing();

{

if (jCop) {

eMethodFound = METHOD_PROPERTYPROVIDER2;

CIMObjectPath cop=*((CIMObjectPath*)env->CallIntMethod(jCop,JMPIjvm::jv.CIMObjectPathCInst));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found METHOD_PROPERTYPROVIDER2."<<PEGASUS_STD(endl));

handler.deliver(cop);

}

handler.complete();

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

if (id == NULL)

{

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

PEG_METHOD_EXIT();

return(response);

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."));

}

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

JMPIjvm::checkException(env);

switch (eMethodFound)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

case METHOD_PROPERTYPROVIDER:

"JMPIProviderManager::handleModifyInstanceRequest");

{

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

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

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

JMPIjvm::checkException(env);

JNIEnv *env=NULL;

Boolean mode24=false;

CIMPropertyList propertyList;

jobjectArray pl=NULL;

try {

jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());

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

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

System::getHostName(),

request->nameSpace.getString(),

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

// make target object path

JMPIjvm::checkException(env);

CIMObjectPath objectPath(

System::getHostName(),

request->nameSpace,

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

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

// resolve provider name

jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());

ProviderName name = _resolveProviderName(

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

// get cached or load new provider module

JMPIjvm::checkException(env);

JMPIProvider::OpProviderHolder ph =

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

// convert arguments

STAT_GETSTARTTIME;

OperationContext context;

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

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

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

id,

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

jcop,

joclass,

jpName);

CIMPropertyList propertyList(request->propertyList);

JMPIjvm::checkException(env);

// forward request

STAT_PMS_PROVIDEREND;

JMPIProvider & pr=ph.GetProvider();

handler.processing();

if (jvalRet)

{

jint jvalRetRef = env->CallIntMethod(jvalRet,JMPIjvm::jv.CIMValueCInst);

CIMValue *valRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jvalRetRef);

JMPIjvm::checkException(env);

handler.deliver(*valRet);

}

handler.complete();

break;

}

case METHOD_PROPERTYPROVIDER2:

{

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 joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());

JMPIjvm::checkException(env);

jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

JMPIjvm::checkException(env);

"Calling provider.modifyInstance: " + pr.getName());

DDD(cerr<<"--- JMPIProviderManager::modifyInstance"<<endl);

STAT_GETSTARTTIME;

JvmVector *jv;

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

env=JMPIjvm::attachThread(&jv);

id,

joc,

jcop,

joclass,

jpName);

jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,

jv->CIMObjectPathNewI,(jint)&objectPath);

JMPIjvm::checkException(env);

jobject jInst=env->NewObject(jv->CIMInstanceClassRef,

jv->CIMInstanceNewI,(jint)&request->modifiedInstance);

JMPIjvm::checkException(env);

JMPIProvider::pm_service_op_lock op_lock(&pr);

STAT_PMS_PROVIDEREND;

STAT_GETSTARTTIME;

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

if (joc)

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

{

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

if (id==NULL) {

env->ExceptionClear();

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

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

JMPIjvm::checkException(env);

mode24=true;

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

}

JMPIjvm::checkException(env);

if (!mode24) env->CallVoidMethod((jobject)pr.jProvider,id,jRef,jInst);

handler.processing();

else env->CallVoidMethod((jobject)pr.jProvider,id,jRef,jInst,pl);

STAT_PMS_PROVIDEREND;

if (jvalRet)

{

jint jvalRetRef = env->CallIntMethod(jvalRet,JMPIjvm::jv.CIMValueCInst);

CIMValue *valRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jvalRetRef);

JMPIjvm::checkException(env);

JMPIjvm::detachThread();

handler.deliver(*valRet);

}

handler.complete();

break;

}

case METHOD_UNKNOWN:

{

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

break;

}

HandlerCatch(handler);

Line 823

Line 5523

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

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

"JMPIProviderManager::handleDeleteInstanceRequest");

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

HandlerIntroVoid(DeleteInstance,message,request,response,

typedef enum {

handler);

METHOD_UNKNOWN = 0,

METHOD_PROPERTYPROVIDER,

METHOD_PROPERTYPROVIDER2,

} 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::handleSetPropertyRequest - Host name: $0 Name space: $1 Class name: $2",

System::getHostName(),

request->nameSpace.getString(),

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

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

// make target object path

CIMObjectPath objectPath(

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

System::getHostName(),

request->nameSpace,

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

Line 853

Line 5562

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,

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

"Calling provider.deleteInstance: " + pr.getName());

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

DDD(cerr<<"--- JMPIProviderManager::modifyInstance"<<endl);

JvmVector *jv = 0;

JvmVector *jv;

env=JMPIjvm::attachThread(&jv);

jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,

if (!env)

jv->CIMObjectPathNewI,(jint)&objectPath);

{

JMPIjvm::checkException(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=env->GetMethodID((jclass)pr.jProviderClass,"deleteInstance",

jmethodID id = NULL;

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

String interfaceType;

JMPIjvm::checkException(env);

String interfaceVersion;

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

interfaceType,

interfaceVersion);

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

if (interfaceType == "JMPI")

{

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

// java.lang.String oclass,

// java.lang.String pName,

// org.pegasus.jmpi.CIMValue val)

// throws org.pegasus.jmpi.CIMException

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

"setPropertyValue",

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

STAT_PMS_PROVIDEREND;

if (id != NULL)

{

eMethodFound = METHOD_PROPERTYPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found METHOD_PROPERTYPROVIDER."<<PEGASUS_STD(endl));

}

else if (interfaceType == "JMPIExperimental")

{

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

// org.pegasus.jmpi.CIMObjectPath cop,

// java.lang.String oclass,

// java.lang.String pName,

// org.pegasus.jmpi.CIMValue val)

// throws org.pegasus.jmpi.CIMException

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

"setPropertyValue",

" (Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V");

JMPIjvm::checkException(env);

if (id != NULL)

JMPIjvm::detachThread();

{

eMethodFound = METHOD_PROPERTYPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found METHOD_PROPERTYPROVIDER2."<<PEGASUS_STD(endl));

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

if (id == NULL)

{

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

PEG_METHOD_EXIT();

return(response);

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);

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

switch (eMethodFound)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

case METHOD_PROPERTYPROVIDER:

"JMPIProviderManager::handleAssociatorsRequest");

{

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

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

HandlerIntro(Associators,message,request,response,

JMPIjvm::checkException(env);

handler,Array<CIMObject>());

JNIEnv *env=NULL;

Boolean mode24=false;

CIMPropertyList propertyList;

jobjectArray pl=NULL;

try {

jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());

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

JMPIjvm::checkException(env);

CIMObjectPath objectPath(

System::getHostName(),

request->nameSpace,

request->objectName.getClassName());

objectPath.setKeyBindings(request->objectName.getKeyBindings());

jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());

CIMObjectPath assocPath(

JMPIjvm::checkException(env);

System::getHostName(),

request->nameSpace,

request->assocClass.getString());

// resolve provider name

CIMValue *val = new CIMValue (request->newValue);

ProviderName name = _resolveProviderName(

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

// get cached or load new provider module

JMPIjvm::checkException(env);

JMPIProvider::OpProviderHolder ph =

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

// convert arguments

jint jvalref = DEBUG_ConvertCToJava (CIMValue*, jint, val);

OperationContext context;

jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewI, jvalref);

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

JMPIjvm::checkException(env);

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

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

// forward request

STAT_GETSTARTTIME;

JMPIProvider & pr=ph.GetProvider();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

"Calling provider.associators: " + pr.getName());

id,

jcop,

joclass,

jpName,

jval);

DDD(cerr<<"--- JMPIProviderManager::associators"<<

JMPIjvm::checkException(env);

" role: >"<<request->role<<"< aCls "<<

request->assocClass<<endl);

JvmVector *jv;

STAT_PMS_PROVIDEREND;

env=JMPIjvm::attachThread(&jv);

break;

}

jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,

case METHOD_PROPERTYPROVIDER2:

jv->CIMObjectPathNewI,(jint)&objectPath);

{

JMPIjvm::checkException(env);

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);

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

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

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

JMPIjvm::checkException(env);

JMPIProvider::pm_service_op_lock op_lock(&pr);

jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());

STAT_GETSTARTTIME;

JMPIjvm::checkException(env);

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

jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"

"Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");

if (id==NULL) {

env->ExceptionClear();

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

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"

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

JMPIjvm::checkException(env);

mode24=true;

}

JMPIjvm::checkException(env);

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

CIMValue *val = new CIMValue (request->newValue);

if (!mode24) {

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

rClass,rRole,resRole,false,false,pl);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

jint jvalref = DEBUG_ConvertCToJava (CIMValue*, jint, val);

jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewI, jvalref);

handler.processing();

if (jVec) {

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

JMPIjvm::checkException(env);

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

JMPIjvm::checkException(env);

CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));

JMPIjvm::checkException(env);

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

STAT_GETSTARTTIME;

inst.getClassName(),false,true,true,CIMPropertyList());

const CIMObjectPath& op=inst.getPath();

CIMObjectPath iop=inst.buildPath(cls);

iop.setNameSpace(op.getNameSpace());

inst.setPath(iop);

handler.deliver(inst);

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

}

id,

}

joc,

}

jcop,

joclass,

jpName,

jval);

else {

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

rClass,rRole,resRole,false,false,pl);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

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

handler.processing();

if (jAr) {

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

JMPIjvm::checkException(env);

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

JMPIjvm::checkException(env);

CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));

JMPIjvm::checkException(env);

}

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

STAT_PMS_PROVIDEREND;

inst.getClassName(),false,true,true,CIMPropertyList());

break;

const CIMObjectPath& op=inst.getPath();

CIMObjectPath iop=inst.buildPath(cls);

iop.setNameSpace(op.getNameSpace());

inst.setPath(iop);

handler.deliver(inst);

}

case METHOD_UNKNOWN:

{

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

break;

}

handler.complete();

}

HandlerCatch(handler);

Line 1054

Line 5757

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

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

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

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

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

"JMPIProviderManager::handleAssociatorNamesRequest");

HandlerIntroMethod(InvokeMethod,message,request,response,handler);

HandlerIntro(AssociatorNames,message,request,response,

typedef enum {

handler,Array<CIMObjectPath>());

METHOD_UNKNOWN = 0,

METHOD_CIMMETHODPROVIDER,

METHOD_CIMMETHODPROVIDER2,

METHOD_METHODPROVIDER,

METHOD_METHODPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env=NULL;

Boolean mode24=false;

CIMPropertyList propertyList;

jobjectArray pl=NULL;

try {

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

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

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

System::getHostName(),

request->nameSpace.getString(),

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

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

// make target object path

CIMObjectPath objectPath(

System::getHostName(),

request->nameSpace,

request->objectName.getClassName());

objectPath.setKeyBindings(request->objectName.getKeyBindings());

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

CIMObjectPath assocPath(

// make target object path

System::getHostName(),

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

request->nameSpace,

request->assocClass.getString());

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

// 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,

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

"Calling provider.associatorNames: " + pr.getName());

DDD(cerr<<"--- JMPIProviderManager::associatorNames"<<

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

" role: >"<<request->role<<"< aCls "<<

request->assocClass<<endl);

JvmVector *jv = 0;

JvmVector *jv;

env=JMPIjvm::attachThread(&jv);

jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,

if (!env)

jv->CIMObjectPathNewI,(jint)&objectPath);

{

JMPIjvm::checkException(env);

PEG_METHOD_EXIT();

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

STAT_COPYDISPATCHER

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

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

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

JMPIjvm::checkException(env);

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=env->GetMethodID((jclass)pr.jProviderClass,"associatorNames",

jmethodID id = NULL;

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"

String interfaceType;

"Ljava/lang/String;)Ljava/util/Vector;");

String interfaceVersion;

if (id==NULL) {

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

env->ExceptionClear();

interfaceType,

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

interfaceVersion);

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"

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

JMPIjvm::checkException(env);

mode24=true;

}

JMPIjvm::checkException(env);

if (!mode24) {

if (interfaceType == "JMPI")

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

{

rClass,rRole,resRole);

// public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath cop,

JMPIjvm::checkException(env);

// java.lang.String name,

// java.util.Vector in,

STAT_PMS_PROVIDEREND;

// java.util.Vector out)

// throws org.pegasus.jmpi.CIMException

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

"invokeMethod",

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

handler.processing();

if (id != NULL)

if (jVec) {

{

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

eMethodFound = METHOD_METHODPROVIDER;

JMPIjvm::checkException(env);

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_METHODPROVIDER."<<PEGASUS_STD(endl));

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

JMPIjvm::checkException(env);

CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod

(jCop,JMPIjvm::jv.CIMObjectPathCInst));

JMPIjvm::checkException(env);

handler.deliver(*cop);

}

handler.complete();

}

else {

if (id == NULL)

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

{

rClass,rRole,resRole);

env->ExceptionClear();

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

// public org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath op,

// java.lang.String methodName,

// org.pegasus.jmpi.CIMArgument[] inArgs,

// org.pegasus.jmpi.CIMArgument[] outArgs)

// throws org.pegasus.jmpi.CIMException

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

"invokeMethod",

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");

handler.processing();

if (id != NULL)

if (jAr) {

{

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

eMethodFound = METHOD_CIMMETHODPROVIDER;

JMPIjvm::checkException(env);

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_CIMMETHODPROVIDER."<<PEGASUS_STD(endl));

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

JMPIjvm::checkException(env);

CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod

(jCop,JMPIjvm::jv.CIMObjectPathCInst));

JMPIjvm::checkException(env);

handler.deliver(*cop);

}

handler.complete();

}

HandlerCatch(handler);

else if (interfaceType == "JMPIExperimental")

{

if (env) JMPIjvm::detachThread();

// public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.CIMObjectPath cop,

PEG_METHOD_EXIT();

// java.lang.String name,

// java.util.Vector in,

// java.util.Vector out)

// throws org.pegasus.jmpi.CIMException

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

"invokeMethod",

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

return(response);

if (id != NULL)

{

eMethodFound = METHOD_METHODPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_METHODPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

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

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

env->ExceptionClear();

"JMPIProviderManager::handleReferencesRequest");

HandlerIntro(References,message,request,response,

handler,Array<CIMObject>());

JNIEnv *env=NULL;

Boolean mode24=false;

CIMPropertyList propertyList;

jobjectArray pl=NULL;

try {

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

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

System::getHostName(),

request->nameSpace.getString(),

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

// make target object path

CIMObjectPath objectPath(

System::getHostName(),

request->nameSpace,

request->objectName.getClassName());

objectPath.setKeyBindings(request->objectName.getKeyBindings());

CIMObjectPath resultPath(

System::getHostName(),

request->nameSpace,

request->resultClass.getString());

// resolve provider name

// public org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.OperationContext oc,

ProviderName name = _resolveProviderName(

// org.pegasus.jmpi.CIMObjectPath op,

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

// java.lang.String methodName,

// org.pegasus.jmpi.CIMArgument[] inArgs,

// org.pegasus.jmpi.CIMArgument[] outArgs)

// throws org.pegasus.jmpi.CIMException

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

"invokeMethod",

"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");

// get cached or load new provider module

if (id != NULL)

JMPIProvider::OpProviderHolder ph =

{

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

eMethodFound = METHOD_CIMMETHODPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_CIMMETHODPROVIDER2."<<PEGASUS_STD(endl));

}

// convert arguments

if (id == NULL)

OperationContext context;

{

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

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

PEG_METHOD_EXIT();

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

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

// forward request

STAT_COPYDISPATCHER

JMPIProvider & pr=ph.GetProvider();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

"Calling provider.references: " + pr.getName());

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

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

}

DDD(cerr<<"--- JMPIProviderManager::references"<<" role: >"<<request->role<<"< aCls "<<

JMPIjvm::checkException(env);

request->resultClass<<endl);

JvmVector *jv;

switch (eMethodFound)

env=JMPIjvm::attachThread(&jv);

{

case METHOD_CIMMETHODPROVIDER:

{

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

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

jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,

jv->CIMObjectPathNewI,(jint)&objectPath);

JMPIjvm::checkException(env);

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

jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());

JMPIjvm::checkException(env);

JMPIProvider::pm_service_op_lock op_lock(&pr);

Uint32 m=request->inParameters.size();

STAT_GETSTARTTIME;

jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);

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

for (Uint32 i=0; i<m; i++) {

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"

CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);

"ZZ[Ljava/lang/String;)Ljava/util/Vector;");

jint jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);

jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jArgRef);

if (id==NULL) {

env->SetObjectArrayElement(jArIn,i,jArg);

env->ExceptionClear();

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

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"

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

JMPIjvm::checkException(env);

mode24=true;

}

JMPIjvm::checkException(env);

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

jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);

if (!mode24) {

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

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

id,

rRole,false,false,pl);

jcop,

jMethod,

jArIn,

jArOut);

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 jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);

JMPIjvm::checkException(env);

CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));

JMPIjvm::checkException(env);

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

jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);

inst.getClassName(),false,true,true,CIMPropertyList());

CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);

const CIMObjectPath& op=inst.getPath();

CIMObjectPath iop=inst.buildPath(cls);

iop.setNameSpace(op.getNameSpace());

inst.setPath(iop);

handler.deliver(inst);

handler.deliver(*valueRet);

}

for (int i=0; i<24; i++) {

handler.complete();

jobject jArg = env->GetObjectArrayElement(jArOut,i);

}

else {

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

rRole,false,false,pl);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (jArg==NULL)

break;

handler.processing();

jint jpRef = env->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);

if (jAr) {

CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jpRef);

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

JMPIjvm::checkException(env);

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

JMPIjvm::checkException(env);

CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));

JMPIjvm::checkException(env);

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

JMPIjvm::checkException(env);

inst.getClassName(),false,true,true,CIMPropertyList());

const CIMObjectPath& op=inst.getPath();

CIMObjectPath iop=inst.buildPath(cls);

iop.setNameSpace(op.getNameSpace());

inst.setPath(iop);

handler.deliver(inst);

handler.deliverParamValue(*p);

}

handler.complete();

break;

}

case METHOD_CIMMETHODPROVIDER2:

HandlerCatch(handler);

{

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

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

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);

return(response);

jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());

}

JMPIjvm::checkException(env);

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

Uint32 m=request->inParameters.size();

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

"JMPIProviderManager::handleReferenceNamesRequest");

HandlerIntro(ReferenceNames,message,request,response,

jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);

handler,Array<CIMObjectPath>());

JNIEnv *env=NULL;

Boolean mode24=false;

CIMPropertyList propertyList;

jobjectArray pl=NULL;

try {

for (Uint32 i=0; i<m; i++) {

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

CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);

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

jint jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);

System::getHostName(),

jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jArgRef);

request->nameSpace.getString(),

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

// make target object path

env->SetObjectArrayElement(jArIn,i,jArg);

CIMObjectPath objectPath(

}

System::getHostName(),

request->nameSpace,

request->objectName.getClassName());

objectPath.setKeyBindings(request->objectName.getKeyBindings());

jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);

CIMObjectPath resultPath(

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

System::getHostName(),

id,

request->nameSpace,

joc,

request->resultClass.getString());

jcop,

jMethod,

jArIn,

jArOut);

JMPIjvm::checkException(env);

// resolve provider name

STAT_PMS_PROVIDEREND;

ProviderName name = _resolveProviderName(

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

// get cached or load new provider module

if (joc)

JMPIProvider::OpProviderHolder ph =

{

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

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

// convert arguments

JMPIjvm::checkException(env);

OperationContext context;

}

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

handler.processing();

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

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

JMPIProvider & pr=ph.GetProvider();

jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);

CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

handler.deliver(*valueRet);

"Calling provider.referenceNames: " + pr.getName());

for (int i=0; i<24; i++) {

jobject jArg = env->GetObjectArrayElement(jArOut,i);

DDD(cerr<<"--- JMPIProviderManager::referenceNames"<<" role: >"<<request->role<<"< aCls "<<

JMPIjvm::checkException(env);

request->resultClass<<endl);

JvmVector *jv;

if (jArg==NULL)

env=JMPIjvm::attachThread(&jv);

break;

jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,

jint jpRef = env->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);

jv->CIMObjectPathNewI,(jint)&objectPath);

CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jpRef);

JMPIjvm::checkException(env);

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

JMPIjvm::checkException(env);

JMPIProvider::pm_service_op_lock op_lock(&pr);

handler.deliverParamValue(*p);

}

STAT_GETSTARTTIME;

handler.complete();

break;

}

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

case METHOD_METHODPROVIDER:

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

{

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

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

if (id==NULL) {

env->ExceptionClear();

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

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

JMPIjvm::checkException(env);

mode24=true;

}

JMPIjvm::checkException(env);

if (!mode24) {

jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());

jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,rRole);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew);

handler.processing();

if (jVec) {

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

JMPIjvm::checkException(env);

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

JMPIjvm::checkException(env);

CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod

(jCop,JMPIjvm::jv.CIMObjectPathCInst));

JMPIjvm::checkException(env);

handler.deliver(*cop);

}

handler.complete();

}

else {

for (int i=0,m=request->inParameters.size(); i<m; i++)

jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,rRole);

{

JMPIjvm::checkException(env);

const CIMParamValue &parm = request->inParameters[i];

const CIMValue v = parm.getValue();

CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize());

jint jpRef = DEBUG_ConvertCToJava (CIMProperty*, jint, p);

jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jpRef);

STAT_PMS_PROVIDEREND;

env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);

}

handler.processing();

jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);

if (jAr) {

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

JMPIjvm::checkException(env);

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

JMPIjvm::checkException(env);

CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod

(jCop,JMPIjvm::jv.CIMObjectPathCInst));

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

id,

jcop,

jMethod,

jVecIn,

jVecOut);

JMPIjvm::checkException(env);

handler.deliver(*cop);

}

handler.complete();

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

STAT_PMS_PROVIDEREND;

PEG_METHOD_EXIT();

handler.processing();

return(response);

jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);

}

CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);

handler.deliver(*valueRet);

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

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

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

JMPIjvm::checkException(env);

"JMPIProviderManager::handleInvokeMethodRequest");

HandlerIntroMethod(InvokeMethod,message,request,response,

handler);

JNIEnv *env=NULL;

Boolean mode24=false;

try {

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

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

System::getHostName(),

request->nameSpace.getString(),

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

// make target object path

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

CIMObjectPath objectPath(

System::getHostName(),

request->nameSpace,

request->instanceName.getClassName(),

request->instanceName.getKeyBindings());

// resolve provider name

JMPIjvm::checkException(env);

ProviderName name = _resolveProviderName(

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

// get cached or load new provider module

jint jpRef = env->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);

JMPIProvider::OpProviderHolder ph =

CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jpRef);

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

// convert arguments

JMPIjvm::checkException(env);

OperationContext context;

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

handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));

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

}

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

JMPIProvider & pr=ph.GetProvider();

handler.complete();

break;

}

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

case METHOD_METHODPROVIDER2:

"Calling provider.invokeMethod: " + pr.getName());

{

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

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

JvmVector *jv;

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

env=JMPIjvm::attachThread(&jv);

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

jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,

jv->CIMObjectPathNewI,(jint)&objectPath);

JMPIjvm::checkException(env);

jstring jMethod=env->NewStringUTF(request->methodName.getString().getCString());

JMPIjvm::checkException(env);

STAT_GETSTARTTIME;

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

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"

"Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;");

if (id==NULL) {

env->ExceptionClear();

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

"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"

"[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");

JMPIjvm::checkException(env);

mode24=true;

}

JMPIjvm::checkException(env);

if (!mode24) {

jobject jVecIn=env->NewObject(jv->VectorClassRef,jv->VectorNew);

JMPIjvm::checkException(env);

for (int i=0,m=request->inParameters.size(); i<m; i++) {

for (int i=0,m=request->inParameters.size(); i<m; i++)

{

const CIMParamValue & parm=request->inParameters[i];

const CIMValue v=parm.getValue();

CIMProperty *p=new CIMProperty(parm.getParameterName(),v,v.getArraySize());

jobject prop=env->NewObject(jv->CIMPropertyClassRef,

jint jpRef = DEBUG_ConvertCToJava (CIMProperty*, jint, p);

jv->CIMPropertyNewI,(jint)p);

jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jpRef);

env->CallVoidMethod(jVecIn,jv->VectorAddElement,prop);

env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);

}

jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);

JMPIjvm::checkException(env);

jobject jValue=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jMethod,jVecIn,jVecOut);

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

id,

joc,

jcop,

jMethod,

jVecIn,

jVecOut);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (joc)

{

CIMValue *v=((CIMValue*)env->CallIntMethod(jValue,JMPIjvm::jv.CIMValueCInst));

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

handler.deliver(*v);

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

JMPIjvm::checkException(env);

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

JMPIjvm::checkException(env);

CIMProperty *p=((CIMProperty*)env->CallIntMethod(jProp,JMPIjvm::jv.PropertyCInst));

JMPIjvm::checkException(env);

handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));

}

handler.complete();

}

else {

Uint32 m=request->inParameters.size();

jobjectArray jArIn=env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);

handler.processing();

for (Uint32 i=0; i<m; i++) {

CIMParamValue *parm=new CIMParamValue(request->inParameters[i]);

jobject jArg=env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,(jint)parm);

env->SetObjectArrayElement(jArIn,i,jArg);

}

jobjectArray jArOut=env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);

jobject jValue=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jMethod,jArIn,jArOut);

jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);

JMPIjvm::checkException(env);

CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);

STAT_PMS_PROVIDEREND;

handler.deliver(*valueRet);

handler.processing();

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

{

JMPIjvm::checkException(env);

CIMValue *v=((CIMValue*)env->CallIntMethod(jValue,JMPIjvm::jv.CIMValueCInst));

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

handler.deliver(*v);

for (int i=0; i<24; i++) {

jobject jArg=env->GetObjectArrayElement(jArOut,i);

JMPIjvm::checkException(env);

if (jArg==NULL) break;

CIMParamValue *p=((CIMParamValue*)env->CallIntMethod(jArg,JMPIjvm::jv.ArgumentCInst));

jint jpRef = env->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);

CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jpRef);

JMPIjvm::checkException(env);

handler.deliverParamValue(*p);

handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));

}

handler.complete();

break;

}

case METHOD_UNKNOWN:

{

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

break;

}

HandlerCatch(handler);

Line 1632

Line 6220

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 1650

Line 6240

{

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

HandlerIntroInd(CreateSubscription,message,request,response,

HandlerIntroInd(CreateSubscription,message,request,response,handler);

handler);

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_EVENTPROVIDER,

METHOD_EVENTPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env=NULL;

try {

const CIMObjectPath &x=request->subscriptionInstance.getPath();

String providerName,

providerLocation;

CIMInstance req_provider,

req_providerModule;

String providerName,providerLocation;

CIMInstance req_provider, req_providerModule;

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

req_provider = pidc.getProvider();

req_providerModule = pidc.getModule();

LocateIndicationProviderNames(req_provider, req_providerModule,providerName,providerLocation);

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

Line 1669

Line 6269

request->nameSpace.getString(),

providerName);

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl));

String fileName = resolveFileName(providerLocation);

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph =

JMPIProvider::OpProviderHolder ph = providerManager.getProvider (fileName, providerName,

providerManager.getProvider(fileName, providerName, String::EMPTY);

String::EMPTY);

indProvRecord *prec=NULL;

provTab.lookup(providerName,prec);

if (prec) prec->count++;

else {

if (prec)

{

prec->count++;

}

else

{

prec=new indProvRecord();

provTab.insert(providerName,prec);

}

// Save the provider instance from the request

ph.GetProvider ().setProviderInstance (req_provider);

indSelectRecord *srec=new indSelectRecord();

const CIMObjectPath &sPath=request->subscriptionInstance.getPath();

selxTab.insert(sPath.toString(),srec);

// convert arguments

OperationContext *context=new OperationContext();

if (prec->ctx==NULL) {

if (prec->ctx==NULL)

{

prec->ctx=context;

}

Line 1698

Line 6313

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

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

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

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

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

CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();

Line 1706

Line 6320

SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get

(SubscriptionFilterConditionContainer::NAME);

JMPIProvider &pr = ph.GetProvider();

CIMOMHandleQueryContext *qcontext=new CIMOMHandleQueryContext(CIMNamespaceName(request->nameSpace.getString()),

*pr._cimom_handle);

CMPI_SelectExp *eSelx=new CMPI_SelectExp(*context,

NULL,

qcontext,

request->nameSpace.getString(),

request->query,

sub_cntr.getQueryLanguage());

srec->eSelx=eSelx;

JMPIProvider & pr=ph.GetProvider();

srec->eSelx=eSelx;

srec->qContext=qcontext;

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

"Calling provider.createSubscriptionRequest: " + pr.getName());

DDD(cerr<<"--- JMPIProviderManager::createSubscriptionRequest"<<endl);

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

for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) {

CIMObjectPath className(

Line 1729

Line 6346

}

CIMPropertyList propertyList = request->propertyList;

if (!propertyList.isNull()) {

if (!propertyList.isNull())

{

Array<CIMName> p=propertyList.getPropertyNameArray();

int pCount=p.size();

eSelx->props=(const char**)malloc((1+pCount)*sizeof(char*));

for (int i=0; i<pCount; i++) {

for (int i=0; i<pCount; i++)

{

eSelx->props[i]=strdup(p[i].getString().getCString());

}

eSelx->props[pCount]=NULL;

}

JvmVector *jv;

JvmVector *jv = 0;

env=JMPIjvm::attachThread(&jv);

jobject jSel=env->NewObject(jv->SelectExpClassRef,

if (!env)

jv->SelectExpNewI,(jint)eSelx);

{

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 void activateFilter (org.pegasus.jmpi.SelectExp filter,

// java.lang.String eventType,

// org.pegasus.jmpi.CIMObjectPath classPath,

// boolean firstActivation)

// throws org.pegasus.jmpi.CIMException

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

"activateFilter",

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

if (id != NULL)

{

eMethodFound = METHOD_EVENTPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: found METHOD_EVENTPROVIDER."<<PEGASUS_STD(endl));

}

else if (interfaceType == "JMPIExperimental")

{

// public void activateFilter (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.SelectExp filter,

// java.lang.String eventType,

// org.pegasus.jmpi.CIMObjectPath classPath,

// boolean firstActivation)

// throws org.pegasus.jmpi.CIMException

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

"activateFilter",

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

if (id != NULL)

{

eMethodFound = METHOD_EVENTPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: found METHOD_EVENTPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: 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_EVENTPROVIDER:

{

jint jSelRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);

jobject jSel = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jSelRef);

JMPIjvm::checkException(env);

jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);

jv->CIMObjectPathNewI,(jint)&eSelx->classNames[0]);

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

JMPIjvm::checkException(env);

jstring jType=env->NewStringUTF(request->nameSpace.getString().getCString());

JMPIjvm::checkException(env);

JMPIProvider::pm_service_op_lock op_lock(&pr);

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

id,

jSel,

jType,

jcop,

(jboolean)0);

STAT_GETSTARTTIME;

JMPIjvm::checkException(env);

// Increment count of current subscriptions for this provider

if (ph.GetProvider ().testIfZeroAndIncrementSubscriptions ())

{

// If there were no current subscriptions before the increment,

// the first subscription has been created

// Call the provider's enableIndications method

if (_subscriptionInitComplete)

{

prec->enabled = true;

CIMRequestMessage * request = 0;

CIMResponseMessage * response = 0;

prec->handler = new EnableIndicationsResponseHandler (

request,

response,

req_provider,

_indicationCallback,

_responseChunkCallback);

}

STAT_PMS_PROVIDEREND;

break;

}

case METHOD_EVENTPROVIDER2:

{

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

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

jint jSelRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);

jobject jSel = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jSelRef);

JMPIjvm::checkException(env);

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);

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

JMPIjvm::checkException(env);

jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());

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

"(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"

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

JMPIjvm::checkException(env);

env->CallVoidMethod((jobject)pr.jProvider,id,jSel,jType,

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

jRef,(jboolean)0);

id,

joc,

jSel,

jType,

jcop,

(jboolean)0);

JMPIjvm::checkException(env);

if (joc)

{

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

JMPIjvm::checkException(env);

}

// Increment count of current subscriptions for this provider

if (ph.GetProvider ().testIfZeroAndIncrementSubscriptions ())

{

// If there were no current subscriptions before the increment,

// the first subscription has been created

// Call the provider's enableIndications method

if (_subscriptionInitComplete)

{

prec->enabled = true;

CIMRequestMessage * request = 0;

CIMResponseMessage * response = 0;

prec->handler = new EnableIndicationsResponseHandler(

request,

response,

req_provider,

_indicationCallback,

_responseChunkCallback);

}

STAT_PMS_PROVIDEREND;

break;

}

case METHOD_UNKNOWN:

{

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

break;

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

return(response);

Line 1780

Line 6579

{

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

HandlerIntroInd(DeleteSubscription,message,request,response,

HandlerIntroInd(DeleteSubscription,message,request,response,handler);

handler);

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_EVENTPROVIDER,

METHOD_EVENTPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env=NULL;

try {

String providerName,providerLocation;

String providerName,

CIMInstance req_provider, req_providerModule;

providerLocation;

CIMInstance req_provider,

req_providerModule;

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

req_provider = pidc.getProvider();

req_providerModule = pidc.getModule();

LocateIndicationProviderNames(req_provider, req_providerModule,

LocateIndicationProviderNames(req_provider, req_providerModule, providerName,providerLocation);

providerName,providerLocation);

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

"JMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",

Line 1799

Line 6607

request->nameSpace.getString(),

providerName);

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl));

String fileName = resolveFileName(providerLocation);

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph =

JMPIProvider::OpProviderHolder ph = providerManager.getProvider (fileName, providerName,

providerManager.getProvider(fileName, providerName, String::EMPTY);

String::EMPTY);

indProvRecord *prec=NULL;

provTab.lookup(providerName,prec);

if (--prec->count<=0) {

if (--prec->count <= 0)

{

provTab.remove(providerName);

prec=NULL;

}

Line 1816

Line 6627

indSelectRecord *srec=NULL;

const CIMObjectPath &sPath=request->subscriptionInstance.getPath();

String sPathString=sPath.toString();

selxTab.lookup(sPathString,srec);

CMPI_SelectExp *eSelx=srec->eSelx;

selxTab.remove(sPathString);

CIMOMHandleQueryContext *qContext = srec->qContext;

// convert arguments

OperationContext context;

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

selxTab.remove(sPathString);

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

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

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

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

CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();

JMPIProvider & pr=ph.GetProvider();

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

"Calling provider.deleteSubscriptionRequest: " + pr.getName());

DDD(cerr<<"--- JMPIProviderManager::deleteSubscriptionRequest"<<endl);

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

JvmVector *jv = 0;

JvmVector *jv;

env=JMPIjvm::attachThread(&jv);

jobject jSel=env->NewObject(jv->SelectExpClassRef,

if (!env)

jv->SelectExpNewI,(jint)eSelx);

{

JMPIjvm::checkException(env);

PEG_METHOD_EXIT();

jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,

STAT_COPYDISPATCHER

jv->CIMObjectPathNewI,(jint)&eSelx->classNames[0]);

JMPIjvm::checkException(env);

jstring jType=env->NewStringUTF(request->nameSpace.getString().getCString());

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

JMPIjvm::checkException(env);

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=env->GetMethodID((jclass)pr.jProviderClass,"deActivateFilter",

jmethodID id = NULL;

"(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"

String interfaceType;

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

String interfaceVersion;

JMPIjvm::checkException(env);

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

env->CallVoidMethod((jobject)pr.jProvider,id,jSel,jType,

interfaceType,

jRef,(jboolean)(prec==NULL));

interfaceVersion);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (interfaceType == "JMPI")

{

// public void deActivateFilter (org.pegasus.jmpi.SelectExp filter,

// java.lang.String eventType,

// org.pegasus.jmpi.CIMObjectPath classPath,

// boolean lastActivation)

// throws org.pegasus.jmpi.CIMException

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

"deActivateFilter",

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

delete eSelx;

if (id != NULL)

{

eMethodFound = METHOD_EVENTPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: found METHOD_EVENTPROVIDER."<<PEGASUS_STD(endl));

}

else if (interfaceType == "JMPIExperimental")

{

// public void deActivateFilter (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.SelectExp filter,

// java.lang.String eventType,

// org.pegasus.jmpi.CIMObjectPath classPath,

// boolean lastActivation)

// throws org.pegasus.jmpi.CIMException

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

"deActivateFilter",

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

if (id != NULL)

{

eMethodFound = METHOD_EVENTPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: found METHOD_EVENTPROVIDER2."<<PEGASUS_STD(endl));

}

HandlerCatch(handler);

}

if (id == NULL)

{

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

PEG_METHOD_EXIT();

return(response);

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."));

}

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

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_EVENTPROVIDER:

{

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

jint jObj = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);

jobject jSel = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jObj);

HandlerIntroInd(EnableIndications,message,request,response,

JMPIjvm::checkException(env);

handler);

try {

String providerName,providerLocation;

CIMInstance req_provider, req_providerModule;

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

req_provider = pidc.getProvider();

req_providerModule = pidc.getModule();

LocateIndicationProviderNames(req_provider, req_providerModule,

jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);

providerName,providerLocation);

indProvRecord *provRec;

jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);

if (provTab.lookup(providerName,provRec)) {

provRec->enabled=true;

provRec->handler=new EnableIndicationsResponseHandler(

request, response, req_provider, _indicationCallback);

}

String fileName = resolveFileName(providerLocation);

JMPIjvm::checkException(env);

// get cached or load new provider module

jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());

JMPIProvider::OpProviderHolder ph =

providerManager.getProvider(fileName, providerName, String::EMPTY);

JMPIjvm::checkException(env);

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

id,

jSel,

jType,

jRef,

(jboolean)(prec==NULL));

JMPIjvm::checkException(env);

// Decrement count of current subscriptions for this provider

if (ph.GetProvider ().decrementSubscriptionsAndTestIfZero ())

{

// If there are no current subscriptions after the decrement,

// the last subscription has been deleted

// Call the provider's disableIndications method

if (_subscriptionInitComplete)

{

prec->enabled = false;

if (prec->handler) delete prec->handler;

prec->handler = NULL;

}

HandlerCatch(handler);

PEG_METHOD_EXIT();

STAT_PMS_PROVIDEREND;

return(response);

delete eSelx;

delete qContext;

delete srec;

break;

}

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

case METHOD_EVENTPROVIDER2:

{

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

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

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

HandlerIntroInd(DisableIndications,message,request,response,

jint jObj = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);

handler);

jobject jSel = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jObj);

try {

String providerName,providerLocation;

CIMInstance req_provider, req_providerModule;

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

req_provider = pidc.getProvider();

JMPIjvm::checkException(env);

req_providerModule = pidc.getModule();

jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);

LocateIndicationProviderNames(req_provider, req_providerModule,

jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);

providerName,providerLocation);

indProvRecord *provRec;

JMPIjvm::checkException(env);

if (provTab.lookup(providerName,provRec)) {

provRec->enabled=false;

jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());

if (provRec->handler) delete provRec->handler;

provRec->handler=NULL;

JMPIjvm::checkException(env);

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

id,

joc,

jSel,

jType,

jRef,

(jboolean)(prec==NULL));

JMPIjvm::checkException(env);

if (joc)

{

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

JMPIjvm::checkException(env);

}

String fileName = resolveFileName(providerLocation);

// Decrement count of current subscriptions for this provider

if (ph.GetProvider ().decrementSubscriptionsAndTestIfZero ())

{

// If there are no current subscriptions after the decrement,

// the last subscription has been deleted

// Call the provider's disableIndications method

if (_subscriptionInitComplete)

{

prec->enabled = false;

if (prec->handler) delete prec->handler;

prec->handler = NULL;

}

// get cached or load new provider module

STAT_PMS_PROVIDEREND;

JMPIProvider::OpProviderHolder ph =

providerManager.getProvider(fileName, providerName, String::EMPTY);

delete eSelx;

delete qContext;

delete srec;

break;

}

case METHOD_UNKNOWN:

{

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

break;

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 2080

Line 6984

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);

String::EMPTY);

}

HandlerCatch(handler);

Line 2092

Line 6996

return(response);

}

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

Message * JMPIProviderManager::handleSubscriptionInitCompleteRequest (const Message * message)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

"JMPIProviderManager::handleUnsupportedRequest");

"JMPIProviderManager::handleSubscriptionInitCompleteRequest");

CIMSubscriptionInitCompleteRequestMessage * request =

dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>

(const_cast <Message *> (message));

PEGASUS_ASSERT (request != 0);

CIMSubscriptionInitCompleteResponseMessage * response =

dynamic_cast <CIMSubscriptionInitCompleteResponseMessage *>

(request->buildResponse ());

PEGASUS_ASSERT (response != 0);

// Set indicator

_subscriptionInitComplete = true;

// For each provider that has at least one subscription, call

// provider's enableIndications method

Array <JMPIProvider *> enableProviders;

enableProviders = providerManager.getIndicationProvidersToEnable ();

Uint32 numProviders = enableProviders.size ();

for (Uint32 i = 0; i < numProviders; i++)

{

try

{

CIMInstance provider;

provider = enableProviders [i]->getProviderInstance ();

// Get cached or load new provider module

JMPIProvider::OpProviderHolder ph = providerManager.getProvider

(enableProviders [i]->getModule ()->getFileName (),

enableProviders [i]->getName ());

indProvRecord * prec = NULL;

provTab.lookup (enableProviders [i]->getName (), prec);

if (prec)

{

prec->enabled = true;

CIMRequestMessage * request = 0;

CIMResponseMessage * response = 0;

prec->handler = new EnableIndicationsResponseHandler(

request,

response,

provider,

_indicationCallback,

_responseChunkCallback);

}

catch (CIMException & e)

{

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"CIMException: " + e.getMessage ());

}

catch (Exception & e)

{

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Exception: " + e.getMessage ());

}

catch(...)

{

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Unknown error in handleSubscriptionInitCompleteRequest");

}

PEG_METHOD_EXIT ();

return (response);

}

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

{

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

CIMRequestMessage* request =

dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));

PEGASUS_ASSERT(request != 0 );

Legend:

Removed from v.1.20
changed lines
	Added in v.1.43

No CVS admin address has been configured