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

Return to JMPIProviderManager.cpp CVS log

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

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

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

version 1.65, 2008/01/08 20:15:14

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 27

Line 29

//==============================================================================

// Author: Adrian Schuur, schuur@de.ibm.com

// Modified By: Seema Gupta (gseema@in.ibm.com) for PEP135

// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for PEP#101

//%/////////////////////////////////////////////////////////////////////////////

// NOCHKSRC

#include "JMPIProviderManager.h"

Line 45

Line 43

#include <Pegasus/Common/Logger.h>

#include <Pegasus/Common/MessageLoader.h> //l10n

#include <Pegasus/Common/Constants.h>

#include <Pegasus/Common/FileSystem.h>

#include <Pegasus/Common/ArrayInternal.h>

#include <Pegasus/Config/ConfigManager.h>

#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>

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

Line 66

Line 62

#else

#define DDD(x)

#endif

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

#define JMPI_LOCALONLY false

#define JMPI_DEEPINHERITANCE true

/* Fix for 4092 */

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

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

#define JMPI_INCLUDE_QUALIFIERS false

#include "Convert.h"

Line 81

// CIMProvider

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

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

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

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

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

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

// InstanceProvider

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

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

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

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

/* Begin Fix for 4189 */

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

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

/* End Fix for 4189 */

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

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

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

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

/* Begin Fix for 4238 */

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

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

/* End Fix for 4238 */

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

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

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

/* Begin Fix for 4238 */

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

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

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

/* End Fix for 4238 */

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

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

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

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

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

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

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

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

// MethodProvider

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

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

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

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

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

// PropertyProvider

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

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

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

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

// AssociatorProvider

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

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

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

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

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

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

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

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

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

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

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

// CIMProviderRouter

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

// EventProvider

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

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

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

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

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

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

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

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

// IndicationHandler

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

// ProviderAdapter

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

// JMPI_TestPropertyTypes

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

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

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

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

};

if (!env)

Line 141

Line 157

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

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

env->ExceptionClear();

}

Line 225

Line 241

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;

Mutex JMPIProviderManager::mutexProvTab;

JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab;

Mutex JMPIProviderManager::mutexSelxTab;

JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg;

Mutex JMPIProviderManager::mutexProvReg;

JMPIProviderManager::JMPIProviderManager(Mode m)

JMPIProviderManager::JMPIProviderManager()

{

mode=m;

_subscriptionInitComplete = false;

#ifdef PEGASUS_DEBUG

Line 251

Line 369

Boolean JMPIProviderManager::insertProvider(const ProviderName & name,

const String &ns, const String &cn)

{

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

String key(ns + String("::") + cn);

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

return provReg.insert(key,name);

Boolean ret = false;

{

AutoMutex lock (mutexProvReg);

ret = provReg.insert(key,name);

}

return ret;

}

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

Line 360

Line 486

break;

default:

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,

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

"*** Unsupported Request %d",

request->getType()

));

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

response = handleUnsupportedRequest(request);

Line 393

Line 521

#define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL)

#define HandlerIntroBase(type,type1,message,request,response,handler,respType) \

#define HandlerIntroBase(type,type1,message,request,response,handler) \

CIM##type##RequestMessage * request = \

dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *>(message)); \

PEGASUS_ASSERT(request != 0); \

CIM##type##ResponseMessage * response = \

new CIM##type##ResponseMessage( \

dynamic_cast<CIM##type##ResponseMessage*>(request->buildResponse()); \

request->messageId, \

CIMException(), \

request->queueIds.copyAndPop() \

respType \

PEGASUS_ASSERT(response != 0); \

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

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

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

type1##ResponseHandler handler(request, response);

#define VOIDINTRO );

#define NOVOIDINTRO(type) ,type);

#define METHODINTRO ,CIMValue(), Array<CIMParamValue>(), request->methodName );

#define HandlerIntroVoid(type,message,request,response,handler) \

HandlerIntroBase(type,type,message,request,response,handler,VOIDINTRO)

#define HandlerIntroMethod(type,message,request,response,handler) \

HandlerIntroBase(type,type,message,request,response,handler,METHODINTRO)

#define HandlerIntroInd(type,message,request,response,handler) \

HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)

HandlerIntroBase(type,Operation,message,request,response,handler)

#define HandlerIntroInit(type,message,request,response,handler) \

HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)

HandlerIntroBase(type,Operation,message,request,response,handler)

#define HandlerIntro(type,message,request,response,handler,respType) \

#define HandlerIntro(type,message,request,response,handler) \

HandlerIntroBase(type,type,message,request,response,handler,NOVOIDINTRO(respType))

HandlerIntroBase(type,type,message,request,response,handler)

#define HandlerCatch(handler) \

catch(CIMException & e) \

Line 440

Line 551

handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); \

} \

catch(...) \

{ PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \

{ PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \

"Exception: Unknown"); \

handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \

}

Line 464

Line 575

{

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

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

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

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_CIMINSTANCEPROVIDER,

METHOD_PEGASUS_25,

METHOD_INSTANCEPROVIDER,

METHOD_SNIA_PROVIDER20,

METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 499

Line 610

name.getLogicalName());

OperationContext context;

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

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

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

// forward request

JMPIProvider &pr=ph.GetProvider();

Line 510

Line 625

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

STAT_GETSTARTTIME;

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

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

}

jmethodID id = NULL;

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

/* Fix for 4238 */

JMPIProvider::pm_service_op_lock op_lock(&pr);

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

// org.pegasus.jmpi.CIMClass cimClass,

// boolean localOnly

// boolean includeQualifiers,

// boolean includeClassOrigin,

// String propertyList[])

// throws org.pegasus.jmpi.CIMException

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

"getInstance",

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

if (id != NULL)

jmethodID id = NULL;

{

String interfaceType;

eMethodFound = METHOD_PEGASUS_25;

String interfaceVersion;

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

}

/* Fix for 4238 */

if (id == NULL)

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

{

interfaceType,

env->ExceptionClear();

interfaceVersion);

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

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

Line 549

Line 658

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_INSTANCEPROVIDER;

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

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

}

if (id == NULL)

Line 571

Line 679

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

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

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

}

else if (interfaceType == "JMPIExperimental")

{

/* Fix for 4238 */

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

// org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMClass cimClass,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// String propertyList[])

// throws org.pegasus.jmpi.CIMException

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

"getInstance",

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

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER2;

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

}

/* Fix for 4238 */

}

if (id == NULL)

{

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

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,

MessageLoaderParms(

"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",

"Could not find a method for the provider based on "

"InterfaceType."));

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_CIMINSTANCEPROVIDER:

{

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

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

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

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

JMPIjvm::checkException(env);

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

CIMClass cls;

try

{

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

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->instanceName.getClassName(),

false,

true,

CIMPropertyList());

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

}

catch (CIMException e)

{

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

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

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

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

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

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

JMPIjvm::checkException(env);

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

StatProviderTimeMeasurement providerTime(response);

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

id,

jop,

request->localOnly,

JMPI_LOCALONLY,

request->includeQualifiers,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList,

jcimClass);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jciRet) {

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

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

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

handler.deliver(*ciRet);

}

Line 631

Line 789

}

/* Fix for 4238 */

case METHOD_PEGASUS_25:

case METHOD_INSTANCEPROVIDER2:

{

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

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

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

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

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

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

JMPIjvm::checkException(env);

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

CIMClass cls;

try

{

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

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->instanceName.getClassName(),

false,

true,

CIMPropertyList());

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

}

catch (CIMException e)

{

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

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

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

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

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

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

JMPIjvm::checkException(env);

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

StatProviderTimeMeasurement providerTime(response);

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

id,

joc,

jop,

jcimClass,

JMPI_LOCALONLY,

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

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

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

handler.deliver(*ciRet);

}

Line 681

Line 865

}

/* Fix for 4238 */

case METHOD_SNIA_PROVIDER20:

case METHOD_INSTANCEPROVIDER:

{

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

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

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

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

JMPIjvm::checkException(env);

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

CIMClass cls;

try

{

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

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->instanceName.getClassName(),

false,

true,

CIMPropertyList());

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

}

catch (CIMException e)

{

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

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

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

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

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

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

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

// Modified for Bugzilla# 3679

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

id,

Line 713

Line 914

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jciRet) {

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

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

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

handler.deliver(*ciRet);

}

Line 740

Line 939

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 749

Line 946

{

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

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

HandlerIntro(EnumerateInstances,message,request,response,handler);

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_CIMINSTANCEPROVIDER,

METHOD_PEGASUS_25,

METHOD_CIMINSTANCEPROVIDER2,

METHOD_SNIA_PROVIDER20,

METHOD_INSTANCEPROVIDER,

METHOD_INSTANCEPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 779

Line 977

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

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph =

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

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

name.getLogicalName(),

String::EMPTY);

// convert arguments

Line 801

Line 999

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,

MessageLoaderParms(

"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",

"Could not initialize the JVM (Java Virtual Machine) "

"runtime environment."));

}

STAT_GETSTARTTIME;

JMPIProvider::pm_service_op_lock op_lock(&pr);

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

/* Fix for 4189 */

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

// public synchronized Vector enumInstances(CIMObjectPath cop,

interfaceType,

// CIMClass cimClass,

interfaceVersion);

if (interfaceType == "JMPI")

{

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

// boolean deep,

// boolean localOnly,

// org.pegasus.jmpi.CIMClass cimClass,

// boolean includeQualifiers,

// boolean localOnly)

// boolean includeClassOrigin,

// String propertyList[])

// throws org.pegasus.jmpi.CIMException

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

"enumInstances",

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

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

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_25;

eMethodFound = METHOD_INSTANCEPROVIDER;

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

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

}

/* Fix for 4189 */

if (id == NULL)

{

env->ExceptionClear();

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

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

// boolean deep,

// boolean localOnly,

// org.pegasus.jmpi.CIMClass cimClass,

// boolean includeQualifiers,

// boolean localOnly)

// boolean includeClassOrigin,

// java.lang.String[] propertyList,

// org.pegasus.jmpi.CIMClass cimClass)

// throws org.pegasus.jmpi.CIMException

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

"enumInstances",

"enumerateInstances",

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

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

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

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

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

}

else if (interfaceType == "JMPIExperimental")

{

/* Fix for 4189 */

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

// org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMClass cimClass,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList)

// throws org.pegasus.jmpi.CIMException

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

"enumerateInstances",

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

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER2;

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

}

/* Fix for 4189 */

if (id == NULL)

{

env->ExceptionClear();

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

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

// boolean localOnly,

// org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMClass cimClass,

// boolean includeQualifiers,

// boolean includeClassOrigin,

// java.lang.String[] propertyList,

// java.lang.String[] propertyList)

// org.pegasus.jmpi.CIMClass cc)

// throws org.pegasus.jmpi.CIMException

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

"enumerateInstances",

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

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

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

eMethodFound = METHOD_CIMINSTANCEPROVIDER2;

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

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

}

if (id == NULL)

{

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

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

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

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_CIMINSTANCEPROVIDER:

{

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

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

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

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

JMPIjvm::checkException(env);

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

CIMClass cls;

try

{

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

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

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

}

catch (CIMException e)

{

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

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

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

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

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

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

JMPIjvm::checkException(env);

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

StatProviderTimeMeasurement providerTime(response);

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

id,

jcop,

request->localOnly,

JMPI_LOCALONLY,

request->includeQualifiers,

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++) {

Line 920

Line 1180

JMPIjvm::checkException(env);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

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

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

JMPIjvm::checkException(env);

handler.deliver(*ciRet);

/* Fix for 4237 */

}

CIMClass cls;

}

handler.complete();

break;

}

/* Fix for 4189 */

try

case METHOD_PEGASUS_25:

{

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

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

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

AutoMutex lock (pr._cimomMutex);

JMPIjvm::checkException(env);

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

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

CIMClass *pcls = new CIMClass (cls);

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:

{

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

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

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

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,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);

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

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

JMPIjvm::checkException(env);

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

StatProviderTimeMeasurement providerTime(response);

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

id,

joc,

jcop,

jcc,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList);

JMPIjvm::checkException(env);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, 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:

{

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

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

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

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,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);

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

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

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

JMPIjvm::checkException(env);

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

StatProviderTimeMeasurement providerTime(response);

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

id,

joc,

jcop,

jcc,

request->deepInheritance,

JMPI_LOCALONLY,

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

Line 980

Line 1401

JMPIjvm::checkException(env);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

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

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

/* Fix for 4237 */

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

CIMClass cls;

try

{

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

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

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

}

catch (CIMException e)

{

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

throw;

}

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

CIMObjectPath iop = ciRet->buildPath(cls);

Line 1009

Line 1445

}

/* Fix for 4189 */

case METHOD_SNIA_PROVIDER20:

case METHOD_INSTANCEPROVIDER:

{

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

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

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

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

JMPIjvm::checkException(env);

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

CIMClass cls;

try

{

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

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

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

}

catch (CIMException e)

{

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

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

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

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

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

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

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

// Modified for Bugzilla# 3679

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

id,

Line 1042

Line 1495

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jVec) {

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

Line 1053

Line 1504

JMPIjvm::checkException(env);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

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

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

/* Fix for 4237 */

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

CIMClass cls;

try

{

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

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

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

}

catch (CIMException e)

{

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

throw;

}

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

CIMObjectPath iop = ciRet->buildPath(cls);

Line 1094

Line 1560

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 1103

Line 1567

{

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

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

HandlerIntro(EnumerateInstanceNames,message,request,response, handler);

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_CIMINSTANCEPROVIDER,

METHOD_SNIA_PROVIDER20,

METHOD_CIMINSTANCEPROVIDER2,

METHOD_INSTANCEPROVIDER,

METHOD_INSTANCEPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 1132

Line 1598

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

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph =

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

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

name.getLogicalName());

// convert arguments

OperationContext context;

Line 1146

Line 1612

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

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

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

JvmVector *jv = 0;

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

STAT_GETSTARTTIME;

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

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

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

interfaceType,

interfaceVersion);

if (interfaceType == "JMPI")

{

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

// boolean deep,

// org.pegasus.jmpi.CIMClass cimClass)

Line 1168

Line 1649

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_INSTANCEPROVIDER;

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

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

}

if (id == NULL)

Line 1185

Line 1666

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

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

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

}

else if (interfaceType == "JMPIExperimental")

{

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

// org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMClass cimClass)

// throws org.pegasus.jmpi.CIMException

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

"enumerateInstanceNames",

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

if (id != NULL)

{

eMethodFound = METHOD_INSTANCEPROVIDER2;

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

}

if (id == NULL)

{

env->ExceptionClear();

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

// org.pegasus.jmpi.CIMObjectPath cop,

// org.pegasus.jmpi.CIMClass cimClass)

// throws org.pegasus.jmpi.CIMException

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

"enumerateInstanceNames",

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

if (id != NULL)

{

eMethodFound = METHOD_CIMINSTANCEPROVIDER2;

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

}

if (id == NULL)

{

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

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

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

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_CIMINSTANCEPROVIDER:

{

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

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

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

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

JMPIjvm::checkException(env);

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

CIMClass cls;

try

{

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

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

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

}

catch (CIMException e)

{

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

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

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

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

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

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

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

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

id,

jcop,

Line 1224

Line 1769

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jAr) {

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

Line 1235

Line 1778

JMPIjvm::checkException(env);

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

jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

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

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

JMPIjvm::checkException(env);

Line 1247

Line 1790

break;

}

case METHOD_SNIA_PROVIDER20:

case METHOD_CIMINSTANCEPROVIDER2:

{

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

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

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

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

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

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

JMPIjvm::checkException(env);

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

CIMClass cls;

try

{

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

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

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

}

catch (CIMException e)

{

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

throw;

}

CIMClass *pcls = new CIMClass (cls);

JMPIjvm::checkException(env);

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

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

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

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

JMPIjvm::checkException(env);

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

StatProviderTimeMeasurement providerTime(response);

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

id,

joc,

jcop,

true,

jcimClass);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

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

JMPIjvm::checkException(env);

}

handler.processing();

if (jVec) {

if (jAr) {

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

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

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

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

jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

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

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

JMPIjvm::checkException(env);

Line 1301

Line 1869

break;

}

case METHOD_UNKNOWN:

case METHOD_INSTANCEPROVIDER2:

{

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

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

break;

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

}

HandlerCatch(handler);

if (env) JMPIjvm::detachThread();

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

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

PEG_METHOD_EXIT();

JMPIjvm::checkException(env);

STAT_COPYDISPATCHER

CIMClass cls;

return(response);

try

}

{

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

AutoMutex lock (pr._cimomMutex);

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

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

request->className,

false,

true,

CIMPropertyList());

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

}

catch (CIMException e)

{

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

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

throw;

}

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

CIMClass *pcls = new CIMClass (cls);

typedef enum {

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

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

id,

joc,

jcop,

jcimClass);

JMPIjvm::checkException(env);

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

jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

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

JMPIjvm::checkException(env);

handler.deliver(*copRet);

}

handler.complete();

break;

}

case METHOD_INSTANCEPROVIDER:

{

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

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,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);

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

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

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

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

id,

jcop,

true,

jcimClass);

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

jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, 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();

return(response);

}

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

{

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

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

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_SNIA_PROVIDER20,

METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER

METHOD_INSTANCEPROVIDER2 // same as METHOD_CIMINSTANCEPROVIDER2

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 1352

Line 2067

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

Line 1374

Line 2082

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

STAT_GETSTARTTIME;

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

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

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

interfaceType,

interfaceVersion);

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

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,

Line 1389

Line 2112

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_INSTANCEPROVIDER;

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

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

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

case METHOD_INSTANCEPROVIDER:

{

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

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

JMPIjvm::checkException(env);

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

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

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

JMPIjvm::checkException(env);

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

StatProviderTimeMeasurement providerTime(response);

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

id,

jcop,

jci);

JMPIjvm::checkException(env);

handler.processing();

if (jcopRet) {

jlong jCopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

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

handler.deliver(*copRet);

}

handler.complete();

break;

}

case METHOD_INSTANCEPROVIDER2:

{

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

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

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

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

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

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

JMPIjvm::checkException(env);

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

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

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

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

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

JMPIjvm::checkException(env);

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

StatProviderTimeMeasurement providerTime(response);

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

jlong jCopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

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

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

handler.deliver(*copRet);

}

Line 1446

Line 2244

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 1455

Line 2251

{

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

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

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

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_CIMINSTANCEPROVIDER,

METHOD_SNIA_PROVIDER20,

METHOD_INSTANCEPROVIDER,

METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 1487

Line 2284

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

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph =

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

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

name.getLogicalName(),

String::EMPTY);

// convert arguments

OperationContext context;

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

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

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

// forward request

JMPIProvider &pr = ph.GetProvider();

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

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

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

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

JvmVector *jv = 0;

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

STAT_GETSTARTTIME;

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

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

Line 1524

Line 2329

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_INSTANCEPROVIDER;

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

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

}

if (id == NULL)

Line 1543

Line 2348

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

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

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

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

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

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_INSTANCEPROVIDER2:

{

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

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

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

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

JMPIjvm::checkException(env);

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

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

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

JMPIjvm::checkException(env);

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

StatProviderTimeMeasurement providerTime(response);

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

id,

joc,

jcop,

jci);

JMPIjvm::checkException(env);

if (joc)

{

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

JMPIjvm::checkException(env);

}

break;

}

case METHOD_CIMINSTANCEPROVIDER:

{

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

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

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

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

JMPIjvm::checkException(env);

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

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

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

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

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

JMPIjvm::checkException(env);

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

StatProviderTimeMeasurement providerTime(response);

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

id,

jcop,

jci,

JMPI_INCLUDE_QUALIFIERS,

jPropertyList);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

break;

}

case METHOD_SNIA_PROVIDER20:

case METHOD_INSTANCEPROVIDER:

{

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

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

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

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

JMPIjvm::checkException(env);

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

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

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

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

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

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

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

id,

jcop,

jci);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

break;

}

Line 1616

Line 2487

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 1625

Line 2494

{

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

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

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

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_SNIA_PROVIDER20,

METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER

METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 1654

Line 2524

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

// forward request

OperationContext context;

JMPIProvider &pr = ph.GetProvider();

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

Line 1675

Line 2539

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

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

}

STAT_GETSTARTTIME;

JMPIProvider::pm_service_op_lock op_lock(&pr);

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,

Line 1689

Line 2568

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_INSTANCEPROVIDER;

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

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

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

case METHOD_INSTANCEPROVIDER2:

{

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

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

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

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

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

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

id,

joc,

jcop);

JMPIjvm::checkException(env);

if (joc)

{

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

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

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

JMPIjvm::checkException(env);

}

break;

}

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

case METHOD_INSTANCEPROVIDER:

{

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

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

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

StatProviderTimeMeasurement providerTime(response);

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

id,

jcop);

JMPIjvm::checkException(env);

break;

}

Line 1725

Line 2661

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 1734

Line 2668

{

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

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

HandlerIntro(ExecQuery,message,request,response,handler);

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_CIMINSTANCEPROVIDER,

METHOD_SNIA_PROVIDER20,

METHOD_CIMINSTANCEPROVIDER2,

METHOD_INSTANCEPROVIDER,

METHOD_INSTANCEPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 1763

Line 2699

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;

Line 1784

Line 2721

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

STAT_GETSTARTTIME;

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

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,

Line 1802

Line 2754

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_INSTANCEPROVIDER;

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

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

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

// java.lang.String query,

// java.lang.String ql,

// org.pegasus.jmpi.CIMClass cc)

// org.pegasus.jmpi.CIMClass cimClass)

// throws org.pegasus.jmpi.CIMException

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

"execQuery",

Line 1821

Line 2773

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

eMethodFound = METHOD_CIMINSTANCEPROVIDER;

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

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

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

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

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_CIMINSTANCEPROVIDER:

{

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

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, 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);

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

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

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

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

id,

jcop,

jquery,

jqueryLanguage,

jCc);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

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

JMPIjvm::checkException(env);

handler.deliver(*ciRet);

}

handler.complete();

break;

}

case METHOD_CIMINSTANCEPROVIDER2:

{

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

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

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

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

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

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

JMPIjvm::checkException(env);

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

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

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

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

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

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

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

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

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

id,

joc,

jcop,

jquery,

jqueryLanguage,

Line 1871

Line 2964

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

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

JMPIjvm::checkException(env);

}

handler.processing();

if (jAr) {

Line 1882

Line 2980

JMPIjvm::checkException(env);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

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

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

JMPIjvm::checkException(env);

Line 1894

Line 2992

break;

}

case METHOD_SNIA_PROVIDER20:

case METHOD_INSTANCEPROVIDER2:

{

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

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

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

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

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

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

JMPIjvm::checkException(env);

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

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

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

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

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

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

JMPIjvm::checkException(env);

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

StatProviderTimeMeasurement providerTime(response);

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

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

id,

joc,

jcop,

jCc,

jquery,

jqueryLanguage);

JMPIjvm::checkException(env);

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

if (joc)

{

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

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

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

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: jciRet = "<<jciRet<<PEGASUS_STD(endl));

JMPIjvm::checkException(env);

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

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

JMPIjvm::checkException(env);

handler.deliver(*ciRet);

}

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: done!"<<PEGASUS_STD(endl));

handler.complete();

break;

}

case METHOD_INSTANCEPROVIDER:

{

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

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, 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);

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

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

JMPIjvm::checkException(env);

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

StatProviderTimeMeasurement providerTime(response);

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

id,

jcop,

jquery,

Line 1932

Line 3134

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jVec) {

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

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

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

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

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

JMPIjvm::checkException(env);

Line 1968

Line 3168

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 1977

Line 3175

{

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

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

HandlerIntro(Associators,message,request,response,handler);

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_CIMASSOCIATORPROVIDER,

METHOD_SNIA_PROVIDER20,

METHOD_CIMASSOCIATORPROVIDER2,

METHOD_ASSOCIATORPROVIDER,

METHOD_ASSOCIATORPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 2010

Line 3210

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;

Line 2031

Line 3232

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

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

}

STAT_GETSTARTTIME;

JMPIProvider::pm_service_op_lock op_lock(&pr);

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

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

interfaceType,

interfaceVersion);

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

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,

Line 2050

Line 3266

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

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

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_ASSOCIATORPROVIDER;

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

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

}

if (id == NULL)

{

env->ExceptionClear();

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

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

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String resultClass,

// java.lang.String role,

// java.lang.String resultRole,

Line 2073

Line 3289

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

"associators",

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

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

//@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;"

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

eMethodFound = METHOD_CIMASSOCIATORPROVIDER;

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

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

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

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

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_CIMASSOCIATORPROVIDER:

{

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

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

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

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

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

Line 2109

Line 3385

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

Line 2116

Line 3393

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

#endif

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

StatProviderTimeMeasurement providerTime(response);

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

id,

jAssociationName,

jPathName,

jResultClass,

jRole,

jResultRole,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

JMPIjvm::checkException(env);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, 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:

{

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

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

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

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

JMPIjvm::checkException(env);

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

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,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

StatProviderTimeMeasurement providerTime(response);

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

id,

joc,

jAssociationName,

jPathName,

jResultClass,

jRole,

jResultRole,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList);

JMPIjvm::checkException(env);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

JMPIjvm::checkException(env);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, 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:

{

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

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

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

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

JMPIjvm::checkException(env);

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

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,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

StatProviderTimeMeasurement providerTime(response);

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++) {

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

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

JMPIjvm::checkException(env);

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

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

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

CIMClass cls;

try

{

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

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

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

}

catch (CIMException e)

{

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

throw;

}

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

CIMObjectPath iop = ciRet->buildPath(cls);

Line 2166

Line 3673

break;

}

case METHOD_SNIA_PROVIDER20:

case METHOD_ASSOCIATORPROVIDER:

{

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

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

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

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

JMPIjvm::checkException(env);

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

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

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

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

JMPIjvm::checkException(env);

Line 2196

Line 3703

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

#endif

StatProviderTimeMeasurement providerTime(response);

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

id,

jAssociationName,

Line 2209

Line 3718

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jVec) {

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

Line 2220

Line 3727

JMPIjvm::checkException(env);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

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

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

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

CIMClass cls;

try

{

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

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

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

}

catch (CIMException e)

{

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

throw;

}

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

CIMObjectPath iop = ciRet->buildPath(cls);

Line 2257

Line 3779

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 2266

Line 3786

{

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

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

HandlerIntro(AssociatorNames,message,request,response,handler);

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_CIMASSOCIATORPROVIDER,

METHOD_SNIA_PROVIDER20

METHOD_CIMASSOCIATORPROVIDER2,

METHOD_ASSOCIATORPROVIDER,

METHOD_ASSOCIATORPROVIDER2

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 2299

Line 3821

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

Line 2320

Line 3836

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

STAT_GETSTARTTIME;

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

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

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

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

interfaceType,

interfaceVersion);

if (interfaceType == "JMPI")

{

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

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String resultClass,

// java.lang.String role,

Line 2335

Line 3866

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

//@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath; Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_ASSOCIATORPROVIDER;

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

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

}

if (id == NULL)

{

env->ExceptionClear();

// public 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 abstract java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,

// 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/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");

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

//@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;"

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;

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

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

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

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

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_CIMASSOCIATORPROVIDER:

{

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

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

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

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

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

Line 2393

Line 3976

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

#endif

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

StatProviderTimeMeasurement providerTime(response);

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

id,

jAssociationName,

jPathName,

jResultClass,

jRole,

jResultRole);

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

jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

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

JMPIjvm::checkException(env);

handler.deliver(*copRet);

}

handler.complete();

break;

}

case METHOD_CIMASSOCIATORPROVIDER2:

{

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

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

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

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

JMPIjvm::checkException(env);

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

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,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

StatProviderTimeMeasurement providerTime(response);

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

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

JMPIjvm::checkException(env);

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

JMPIjvm::checkException(env);

jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

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

JMPIjvm::checkException(env);

handler.deliver(*copRet);

}

handler.complete();

break;

}

case METHOD_ASSOCIATORPROVIDER:

{

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

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

JMPIjvm::checkException(env);

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

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,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

StatProviderTimeMeasurement providerTime(response);

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

id,

jAssociationName,

jPathName,

jResultClass,

jRole,

jResultRole);

JMPIjvm::checkException(env);

handler.processing();

if (jVec) {

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

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

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

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

jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

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

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

JMPIjvm::checkException(env);

Line 2425

Line 4136

break;

}

case METHOD_SNIA_PROVIDER20:

case METHOD_ASSOCIATORPROVIDER2:

{

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

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

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

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

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

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

JMPIjvm::checkException(env);

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

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

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

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

JMPIjvm::checkException(env);

Line 2451

Line 4165

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

#endif

StatProviderTimeMeasurement providerTime(response);

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

id,

joc,

jAssociationName,

jPathName,

jResultClass,

Line 2461

Line 4178

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

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

JMPIjvm::checkException(env);

}

handler.processing();

if (jVec) {

Line 2472

Line 4194

JMPIjvm::checkException(env);

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

jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

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

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

JMPIjvm::checkException(env);

Line 2497

Line 4219

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 2506

Line 4226

{

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

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

HandlerIntro(References,message,request,response,handler);

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_CIMASSOCIATORPROVIDER,

METHOD_SNIA_PROVIDER20,

METHOD_CIMASSOCIATORPROVIDER2,

METHOD_ASSOCIATORPROVIDER,

METHOD_ASSOCIATORPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 2539

Line 4261

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;

Line 2560

Line 4283

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

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

}

STAT_GETSTARTTIME;

JMPIProvider::pm_service_op_lock op_lock(&pr);

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

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

interfaceType,

interfaceVersion);

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

if (interfaceType == "JMPI")

{

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

// org.pegasus.jmpi.CIMObjectPath pathName,

// java.lang.String role,

// boolean includeQualifiers,

Line 2576

Line 4314

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

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

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_ASSOCIATORPROVIDER;

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

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 abstract java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName,

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

Line 2596

Line 4377

// throws org.pegasus.jmpi.CIMException

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

"references",

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

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

//@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;"

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;

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

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

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

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

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_CIMASSOCIATORPROVIDER:

{

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

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

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

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

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

Line 2635

Line 4427

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

#endif

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

StatProviderTimeMeasurement providerTime(response);

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

id,

jAssociationName,

jPathName,

jRole,

false,

JMPI_INCLUDE_QUALIFIERS,

false,

request->includeClassOrigin,

jPropertyList);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jVec) {

if (jAr) {

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

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

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

JMPIjvm::checkException(env);

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

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

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

CIMClass cls;

try

{

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

AutoMutex lock (pr._cimomMutex);

cls = pr._cimom_handle->getClass(context,

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

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

}

catch (CIMException e)

{

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

throw;

}

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

CIMObjectPath iop = ciRet->buildPath(cls);

Line 2683

Line 4491

break;

}

case METHOD_SNIA_PROVIDER20:

case METHOD_CIMASSOCIATORPROVIDER2:

{

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

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

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

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

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

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

JMPIjvm::checkException(env);

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

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

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

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

JMPIjvm::checkException(env);

Line 2703

Line 4514

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

StatProviderTimeMeasurement providerTime(response);

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

id,

joc,

jAssociationName,

jPathName,

jRole,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList);

JMPIjvm::checkException(env);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

JMPIjvm::checkException(env);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, 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:

{

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

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

JMPIjvm::checkException(env);

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

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,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

StatProviderTimeMeasurement providerTime(response);

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

id,

jAssociationName,

jPathName,

jRole,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, 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:

{

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

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

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

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

JMPIjvm::checkException(env);

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

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,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

StatProviderTimeMeasurement providerTime(response);

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

id,

joc,

jAssociationName,

jPathName,

jRole,

JMPI_INCLUDE_QUALIFIERS,

request->includeClassOrigin,

jPropertyList);

JMPIjvm::checkException(env);

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

jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);

CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, 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();

return(response);

}

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

{

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

HandlerIntro(ReferenceNames,message,request,response,handler);

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

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

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

}

if (id == NULL)

{

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

PEG_METHOD_EXIT();

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:

{

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

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

JMPIjvm::checkException(env);

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

jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,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: role = "<<request->role<<PEGASUS_STD(endl));

#endif

StatProviderTimeMeasurement providerTime(response);

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

id,

jAssociationName,

jPathName,

jRole,

jAssociationName,

JMPI_INCLUDE_QUALIFIERS,

jRole);

request->includeClassOrigin,

jPropertyList);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jVec) {

if (jAr) {

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

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

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

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

jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

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

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

request->nameSpace,

ciRet->getClassName(),

false,

true,

CIMPropertyList());

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

CIMObjectPath iop = ciRet->buildPath(cls);

JMPIjvm::checkException(env);

iop.setNameSpace(op.getNameSpace());

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

ciRet->setPath(iop);

handler.deliver(*ciRet);

handler.deliver(*copRet);

}

handler.complete();

break;

}

case METHOD_UNKNOWN:

case METHOD_CIMASSOCIATORPROVIDER2:

{

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

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

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

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

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

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

typedef enum {

JMPIjvm::checkException(env);

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_SNIA_PROVIDER20,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

try {

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

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

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

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

System::getHostName(),

request->nameSpace.getString(),

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

JMPIjvm::checkException(env);

// make target object path

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

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

JMPIjvm::checkException(env);

ProviderName name = _resolveProviderName(

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

// get cached or load new provider module

#ifdef PEGASUS_DEBUG

JMPIProvider::OpProviderHolder ph =

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

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

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

#endif

// convert arguments

StatProviderTimeMeasurement providerTime(response);

OperationContext context;

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

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

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

id,

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

joc,

jPathName,

jAssociationName,

jRole);

JMPIProvider &pr = ph.GetProvider();

JMPIjvm::checkException(env);

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

if (joc)

{

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

JMPIjvm::checkException(env);

}

JvmVector *jv = 0;

handler.processing();

if (jAr) {

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

JMPIjvm::checkException(env);

env = JMPIjvm::attachThread(&jv);

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

JMPIProvider::pm_service_op_lock op_lock(&pr);

JMPIjvm::checkException(env);

STAT_GETSTARTTIME;

jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

jmethodID id = NULL;

JMPIjvm::checkException(env);

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

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

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

//@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath; Ljava/lang/String;)Ljava/util/Vector;"

if (id != NULL)

handler.deliver(*copRet);

{

eMethodFound = METHOD_SNIA_PROVIDER20;

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

}

if (id == NULL)

{

env->ExceptionClear();

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

// java.lang.String role)

// throws org.pegasus.jmpi.CIMException

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

"referenceNames",

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

//@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;"

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

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

}

handler.complete();

break;

}

if (id == NULL)

case METHOD_ASSOCIATORPROVIDER:

{

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

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

}

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

JMPIjvm::checkException(env);

switch (eMethodFound)

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

{

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

case METHOD_PEGASUS_24:

{

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

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

JMPIjvm::checkException(env);

Line 2892

Line 5087

#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

StatProviderTimeMeasurement providerTime(response);

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

id,

jAssociationName,

jPathName,

jRole);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

handler.processing();

if (jVec) {

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

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

JMPIjvm::checkException(env);

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

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

JMPIjvm::checkException(env);

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

jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

JMPIjvm::checkException(env);

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

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

handler.deliver(*copRet);

}

Line 2926

Line 5123

break;

}

case METHOD_SNIA_PROVIDER20:

case METHOD_ASSOCIATORPROVIDER2:

{

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

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

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

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

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

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

JMPIjvm::checkException(env);

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

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

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

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

JMPIjvm::checkException(env);

Line 2948

Line 5148

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

#endif

StatProviderTimeMeasurement providerTime(response);

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

Line 2967

Line 5175

JMPIjvm::checkException(env);

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

jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);

JMPIjvm::checkException(env);

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

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

handler.deliver(*copRet);

}

Line 2993

Line 5201

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 3002

Line 5208

{

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

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

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

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_SNIA_PROVIDER20,

METHOD_PROPERTYPROVIDER,

METHOD_PROPERTYPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 3031

Line 5238

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

Line 3052

Line 5253

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

STAT_GETSTARTTIME;

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

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

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

interfaceType,

interfaceVersion);

if (interfaceType == "JMPI")

{

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

// java.lang.String oclass,

// java.lang.String pName)

Line 3069

Line 5285

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_PROPERTYPROVIDER;

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

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

if (id != NULL)

{

eMethodFound = METHOD_PROPERTYPROVIDER2;

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

}

if (id == NULL)

{

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

PEG_METHOD_EXIT();

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_SNIA_PROVIDER20:

case METHOD_PROPERTYPROVIDER:

{

jlong jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref);

JMPIjvm::checkException(env);

jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());

JMPIjvm::checkException(env);

jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,

id,

jcop,

joclass,

jpName);

JMPIjvm::checkException(env);

handler.processing();

if (jvalRet)

{

jlong jvalRetRef = env->CallLongMethod(jvalRet,JMPIjvm::jv.CIMValueCInst);

CIMValue *valRet = DEBUG_ConvertJavaToC (jlong, CIMValue*, jvalRetRef);

JMPIjvm::checkException(env);

handler.deliver(*valRet);

}

handler.complete();

break;

}

case METHOD_PROPERTYPROVIDER2:

{

jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);

jlong jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref);

JMPIjvm::checkException(env);

Line 3097

Line 5381

JMPIjvm::checkException(env);

STAT_GETSTARTTIME;

StatProviderTimeMeasurement providerTime(response);

jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,

id,

joc,

jcop,

joclass,

jpName);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

handler.processing();

if (jvalRet)

{

jint jvalRetRef = env->CallIntMethod(jvalRet,JMPIjvm::jv.CIMValueCInst);

jlong jvalRetRef = env->CallLongMethod(jvalRet,JMPIjvm::jv.CIMValueCInst);

CIMValue *valRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jvalRetRef);

CIMValue *valRet = DEBUG_ConvertJavaToC (jlong, CIMValue*, jvalRetRef);

JMPIjvm::checkException(env);

Line 3137

Line 5427

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 3146

Line 5434

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleSetPropertyRequest");

HandlerIntroVoid(SetProperty,message,request,response,handler);

HandlerIntro(SetProperty,message,request,response,handler);

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_SNIA_PROVIDER20,

METHOD_PROPERTYPROVIDER,

METHOD_PROPERTYPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 3175

Line 5464

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();

Line 3196

Line 5479

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

"Could not initialize the JVM (Java Virtual Machine) runtime environment."));

}

STAT_GETSTARTTIME;

JMPIProvider::pm_service_op_lock op_lock(&pr);

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),

interfaceType,

interfaceVersion);

if (interfaceType == "JMPI")

{

// public abstract void setPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,

// java.lang.String oclass,

// java.lang.String pName,

Line 3214

Line 5512

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_PROPERTYPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));

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");

if (id != NULL)

{

eMethodFound = METHOD_PROPERTYPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found METHOD_PROPERTYPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found no method!"<<PEGASUS_STD(endl));

PEG_METHOD_EXIT();

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_SNIA_PROVIDER20:

case METHOD_PROPERTYPROVIDER:

{

jlong jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref);

JMPIjvm::checkException(env);

jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());

JMPIjvm::checkException(env);

jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());

JMPIjvm::checkException(env);

CIMValue *val = new CIMValue (request->newValue);

JMPIjvm::checkException(env);

jlong jvalref = DEBUG_ConvertCToJava (CIMValue*, jlong, val);

jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewJ, jvalref);

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

env->CallVoidMethod ((jobject)pr.jProvider,

id,

jcop,

joclass,

jpName,

jval);

JMPIjvm::checkException(env);

break;

}

case METHOD_PROPERTYPROVIDER2:

{

jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);

jlong jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref);

JMPIjvm::checkException(env);

Line 3246

Line 5610

JMPIjvm::checkException(env);

jint jvalref = DEBUG_ConvertCToJava (CIMValue*, jint, val);

jlong jvalref = DEBUG_ConvertCToJava (CIMValue*, jlong, val);

jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewI, jvalref);

jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewJ, jvalref);

JMPIjvm::checkException(env);

STAT_GETSTARTTIME;

StatProviderTimeMeasurement providerTime(response);

env->CallVoidMethod ((jobject)pr.jProvider,

id,

joc,

jcop,

joclass,

jpName,

Line 3262

Line 5627

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

break;

}

Line 3279

Line 5649

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 3288

Line 5656

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleInvokeMethodRequest");

HandlerIntroMethod(InvokeMethod,message,request,response,handler);

HandlerIntro(InvokeMethod,message,request,response,handler);

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_PEGASUS_24,

METHOD_CIMMETHODPROVIDER,

METHOD_SNIA_PROVIDER20,

METHOD_CIMMETHODPROVIDER2,

METHOD_METHODPROVIDER,

METHOD_METHODPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

Line 3318

Line 5688

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));

JMPIProvider &pr=ph.GetProvider();

Line 3338

Line 5702

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

"Could not initialize the JVM (Java Virtual Machine) runtime environment."));

}

STAT_GETSTARTTIME;

JMPIProvider::pm_service_op_lock op_lock(&pr);

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),

interfaceType,

interfaceVersion);

if (interfaceType == "JMPI")

{

// public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath cop,

// java.lang.String name,

// java.util.Vector in,

Line 3355

Line 5734

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_METHODPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_METHODPROVIDER."<<PEGASUS_STD(endl));

}

if (id == NULL)

Line 3374

Line 5753

if (id != NULL)

{

eMethodFound = METHOD_PEGASUS_24;

eMethodFound = METHOD_CIMMETHODPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_CIMMETHODPROVIDER."<<PEGASUS_STD(endl));

}

else if (interfaceType == "JMPIExperimental")

{

// public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.OperationContext oc,

// org.pegasus.jmpi.CIMObjectPath cop,

// 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;");

if (id != NULL)

{

eMethodFound = METHOD_METHODPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_METHODPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

env->ExceptionClear();

// public org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.OperationContext oc,

// 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/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");

if (id != NULL)

{

eMethodFound = METHOD_CIMMETHODPROVIDER2;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_CIMMETHODPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: No method found!"<<PEGASUS_STD(endl));

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",

"Could not find a method for the provider based on InterfaceType."));

}

JMPIjvm::checkException(env);

switch (eMethodFound)

{

case METHOD_PEGASUS_24:

case METHOD_CIMMETHODPROVIDER:

{

jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);

JMPIjvm::checkException(env);

jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());

JMPIjvm::checkException(env);

Uint32 m=request->inParameters.size();

jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);

for (Uint32 i=0; i<m; i++) {

CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);

jlong jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jlong, parm);

jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewJ,jArgRef);

env->SetObjectArrayElement(jArIn,i,jArg);

}

jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);

StatProviderTimeMeasurement providerTime(response);

jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,

id,

jcop,

jMethod,

jArIn,

jArOut);

JMPIjvm::checkException(env);

handler.processing();

jlong jValueRetRef = env->CallLongMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);

CIMValue *valueRet = DEBUG_ConvertJavaToC (jlong, CIMValue*, jValueRetRef);

handler.deliver(*valueRet);

for (int i=0; i<24; i++) {

jobject jArg = env->GetObjectArrayElement(jArOut,i);

JMPIjvm::checkException(env);

if (jArg==NULL)

break;

jlong jpRef = env->CallLongMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);

CIMParamValue *p = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jpRef);

JMPIjvm::checkException(env);

handler.deliverParamValue(*p);

}

handler.complete();

break;

}

case METHOD_CIMMETHODPROVIDER2:

{

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);

jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);

JMPIjvm::checkException(env);

Line 3400

Line 5895

for (Uint32 i=0; i<m; i++) {

CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);

jint jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);

jlong jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jlong, parm);

jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jArgRef);

jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewJ,jArgRef);

env->SetObjectArrayElement(jArIn,i,jArg);

}

jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);

StatProviderTimeMeasurement providerTime(response);

jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,

id,

joc,

jcop,

jMethod,

jArIn,

jArOut);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

handler.processing();

jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);

jlong jValueRetRef = env->CallLongMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);

CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);

CIMValue *valueRet = DEBUG_ConvertJavaToC (jlong, CIMValue*, jValueRetRef);

handler.deliver(*valueRet);

Line 3433

Line 5936

if (jArg==NULL)

break;

jint jpRef = env->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);

jlong jpRef = env->CallLongMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);

CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jpRef);

CIMParamValue *p = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jpRef);

JMPIjvm::checkException(env);

Line 3445

Line 5948

break;

}

case METHOD_SNIA_PROVIDER20:

case METHOD_METHODPROVIDER:

{

jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);

JMPIjvm::checkException(env);

jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());

JMPIjvm::checkException(env);

jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew);

JMPIjvm::checkException(env);

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());

jlong jpRef = DEBUG_ConvertCToJava (CIMProperty*, jlong, p);

jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewJ,jpRef);

env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);

}

jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,

id,

jcop,

jMethod,

jVecIn,

jVecOut);

JMPIjvm::checkException(env);

handler.processing();

jlong jValueRetRef = env->CallLongMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);

CIMValue *valueRet = DEBUG_ConvertJavaToC (jlong, CIMValue*, jValueRetRef);

handler.deliver(*valueRet);

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);

jlong jpRef = env->CallLongMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);

CIMProperty *p = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jpRef);

JMPIjvm::checkException(env);

handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));

}

handler.complete();

break;

}

case METHOD_METHODPROVIDER2:

{

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);

jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);

jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);

JMPIjvm::checkException(env);

Line 3465

Line 6037

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);

jlong jpRef = DEBUG_ConvertCToJava (CIMProperty*, jlong, p);

jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jpRef);

jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewJ,jpRef);

env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);

}

Line 3474

Line 6046

jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,

id,

joc,

jcop,

jMethod,

jVecIn,

jVecOut);

JMPIjvm::checkException(env);

STAT_PMS_PROVIDEREND;

if (joc)

{

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

JMPIjvm::checkException(env);

}

handler.processing();

jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);

jlong jValueRetRef = env->CallLongMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);

CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);

CIMValue *valueRet = DEBUG_ConvertJavaToC (jlong, CIMValue*, jValueRetRef);

handler.deliver(*valueRet);

Line 3499

Line 6079

JMPIjvm::checkException(env);

jint jpRef = env->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);

jlong jpRef = env->CallLongMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);

CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jpRef);

CIMProperty *p = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jpRef);

JMPIjvm::checkException(env);

Line 3524

Line 6104

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 3540

Line 6118

return 0;

}

WQLSelectStatement *

newSelectExp (String& query,

String& queryLanguage)

{

WQLSelectStatement *stmt = new WQLSelectStatement (queryLanguage, query);

try

{

WQLParser::parse (query, *stmt);

}

catch (const Exception &e)

{

cerr << "Error: newSelectExp caught: " << e.getMessage () << endl;

}

return stmt;

}

Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw()

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleCreateSubscriptionRequest");

Line 3548

Line 6144

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_SNIA_PROVIDER20,

METHOD_EVENTPROVIDER,

METHOD_EVENTPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

try {

String providerName,

String fileName,

providerLocation;

providerName,

CIMInstance req_provider,

providerLocation;

req_providerModule;

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);

fileName = resolveFileName (providerLocation);

Logger::put (Logger::STANDARD_LOG,

System::CIMSERVER,

Logger::TRACE,

"JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",

System::getHostName(),

request->nameSpace.getString(),

providerName);

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: hostname = "

<<System::getHostName()

<<", namespace = "

<<request->nameSpace.getString()

<<", providername = "

<<providerName

<<", fileName = "

<<fileName

<<PEGASUS_STD(endl));

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph = providerManager.getProvider (fileName,

providerName,

String::EMPTY);

// Save the provider instance from the request

ph.GetProvider ().setProviderInstance (req_provider);

JMPIProvider &pr = ph.GetProvider ();

// Increment count of current subscriptions for this provider

pr.testIfZeroAndIncrementSubscriptions ();

SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get (SubscriptionFilterConditionContainer::NAME);

indProvRecord *prec = NULL;

bool fNewPrec = false;

{

AutoMutex lock (mutexProvTab);

ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);

provTab.lookup (providerName, prec);

req_provider = pidc.getProvider();

if (!prec)

req_providerModule = pidc.getModule();

{

fNewPrec = true;

LocateIndicationProviderNames(req_provider, req_providerModule,providerName,providerLocation);

prec = new indProvRecord ();

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

// convert arguments

"JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",

prec->ctx = new OperationContext ();

System::getHostName(),

request->nameSpace.getString(),

providerName);

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl));

prec->ctx->insert (request->operationContext.get (IdentityContainer::NAME));

prec->ctx->insert (request->operationContext.get (AcceptLanguageListContainer::NAME));

prec->ctx->insert (request->operationContext.get (ContentLanguageListContainer::NAME));

prec->ctx->insert (request->operationContext.get (SubscriptionInstanceContainer::NAME));

prec->ctx->insert (request->operationContext.get (SubscriptionFilterConditionContainer::NAME));

String fileName = resolveFileName(providerLocation);

prec->enabled = true;

// get cached or load new provider module

prec->handler = new EnableIndicationsResponseHandler (0,

JMPIProvider::OpProviderHolder ph =

providerManager.getProvider(fileName, providerName, String::EMPTY);

req_provider,

_indicationCallback,

_responseChunkCallback);

indProvRecord *prec = NULL;

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Adding to provTab "<<providerName<<PEGASUS_STD(endl));

provTab.lookup(providerName,prec);

provTab.insert (providerName, prec);

}

if (prec)

{

AutoMutex lock (prec->mutex);

prec->count++;

}

else

{

prec=new indProvRecord();

provTab.insert(providerName,prec);

}

// Save the provider instance from the request

ph.GetProvider ().setProviderInstance (req_provider);

// Add a selection record for JNI CIMOMHandle deliverEvent calls

indSelectRecord *srec = new indSelectRecord();

const CIMObjectPath &sPath = request->subscriptionInstance.getPath();

selxTab.insert(sPath.toString(),srec);

{

srec->query = request->query;

srec->queryLanguage = sub_cntr.getQueryLanguage ();

srec->propertyList = request->propertyList;

// convert arguments

CIMOMHandleQueryContext *qContext = new CIMOMHandleQueryContext (CIMNamespaceName (request->nameSpace.getString ()),

OperationContext *context=new OperationContext();

*pr._cimom_handle);

srec->qContext = qContext;

if (prec->ctx==NULL)

CIMObjectPath sPath = request->subscriptionInstance.getPath ();

{

Array<CIMKeyBinding> kb;

prec->ctx=context;

}

context->insert(request->operationContext.get(IdentityContainer::NAME));

// Technically we only need Name and Handler for uniqueness

context->insert(request->operationContext.get(AcceptLanguageListContainer::NAME));

kb = sPath.getKeyBindings ();

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();

// Add an entry for every provider.

kb.append (CIMKeyBinding ("Provider",

pr.getName (),

CIMKeyBinding::STRING));

SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get

sPath.setKeyBindings (kb);

(SubscriptionFilterConditionContainer::NAME);

JMPIProvider &pr = ph.GetProvider();

AutoMutex lock (mutexSelxTab);

CIMOMHandleQueryContext *qcontext=new CIMOMHandleQueryContext(CIMNamespaceName(request->nameSpace.getString()),

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Adding to selxTab "<<sPath.toString ()<<PEGASUS_STD(endl));

*pr._cimom_handle);

CMPI_SelectExp *eSelx = new CMPI_SelectExp(*context,

selxTab.insert (sPath.toString (), srec);

qcontext,

request->query,

sub_cntr.getQueryLanguage());

srec->eSelx=eSelx;

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: For selxTab "<<sPath.toString ()<<", srec = "<<PEGASUS_STD(hex)<<(long)srec<<PEGASUS_STD(dec)<<", qContext = "<<PEGASUS_STD(hex)<<(long)qContext<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

srec->qContext=qcontext;

}

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createSubscriptionRequest: " + pr.getName());

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++) {

JvmVector *jv = 0;

CIMObjectPath className(

System::getHostName(),

request->nameSpace,

request->classNames[i]);

eSelx->classNames.append(className);

}

CIMPropertyList propertyList = request->propertyList;

env = JMPIjvm::attachThread(&jv);

if (!propertyList.isNull())

if (!env)

{

Array<CIMName> p = propertyList.getPropertyNameArray();

PEG_METHOD_EXIT();

int pCount = p.size();

eSelx->props=(const char**)malloc((1+pCount)*sizeof(char*));

for (int i=0; i<pCount; i++)

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

{

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

eSelx->props[i]=strdup(p[i].getString().getCString());

"Could not initialize the JVM (Java Virtual Machine) runtime environment."));

}

eSelx->props[pCount]=NULL;

}

JvmVector *jv = 0;

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

STAT_GETSTARTTIME;

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

getInterfaceType (pidc,

interfaceType,

interfaceVersion);

// public void authorizeFilter (org.pegasus.jmpi.SelectExp filter,

if (interfaceType == "JMPI")

{

// public void activateFilter (org.pegasus.jmpi.SelectExp filter,

// java.lang.String eventType,

// org.pegasus.jmpi.CIMObjectPath classPath,

// java.lang.String owner)

// boolean firstActivation)

// throws org.pegasus.jmpi.CIMException

id = env->GetMethodID((jclass)pr.jProviderClass,

"activateFilter",

Line 3686

Line 6321

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_EVENTPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));

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();

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_SNIA_PROVIDER20:

case METHOD_EVENTPROVIDER:

{

jint jSelRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);

WQLSelectStatement *stmt = newSelectExp (srec->query,

jobject jSel = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jSelRef);

srec->queryLanguage);

jlong jStmtRef = DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, stmt);

jobject jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewJ,jStmtRef);

JMPIjvm::checkException(env);

jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);

jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);

JMPIjvm::checkException(env);

jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());

CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->classNames[0]);

jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

env->CallVoidMethod((jobject)pr.jProvider,

id,

jSel,

jSelectExp,

jType,

jcop,

(jboolean)0);

(jboolean)fNewPrec);

JMPIjvm::checkException(env);

break;

}

case METHOD_EVENTPROVIDER2:

// Increment count of current subscriptions for this provider

if (ph.GetProvider ().testIfZeroAndIncrementSubscriptions ())

{

jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);

// If there were no current subscriptions before the increment,

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);

// the first subscription has been created

// Call the provider's enableIndications method

WQLSelectStatement *stmt = newSelectExp (srec->query,

srec->queryLanguage);

if (_subscriptionInitComplete)

jlong jStmtRef = DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, stmt);

jobject jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewJ,jStmtRef);

JMPIjvm::checkException(env);

jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());

JMPIjvm::checkException(env);

CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->classNames[0]);

jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

env->CallVoidMethod ((jobject)pr.jProvider,

id,

joc,

jSelectExp,

jType,

jcop,

(jboolean)fNewPrec);

JMPIjvm::checkException(env);

if (joc)

{

prec->enabled = true;

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

CIMRequestMessage * request = 0;

CIMResponseMessage * response = 0;

prec->handler = new EnableIndicationsResponseHandler

(request, response, req_provider, _indicationCallback);

}

STAT_PMS_PROVIDEREND;

JMPIjvm::checkException(env);

}

break;

}

Line 3749

Line 6444

break;

}

HandlerCatch(handler);

Line 3768

Line 6462

typedef enum {

METHOD_UNKNOWN = 0,

METHOD_SNIA_PROVIDER20,

METHOD_EVENTPROVIDER,

METHOD_EVENTPROVIDER2,

} METHOD_VERSION;

METHOD_VERSION eMethodFound = METHOD_UNKNOWN;

JNIEnv *env = NULL;

bool fFreePrec = false;

indProvRecord *prec = NULL;

indSelectRecord *srec = NULL;

try {

String providerName,

String fileName,

providerName,

providerLocation;

CIMInstance req_provider,

req_providerModule;

Line 3783

Line 6482

req_provider = pidc.getProvider();

req_providerModule = pidc.getModule();

LocateIndicationProviderNames(req_provider, req_providerModule, providerName,providerLocation);

LocateIndicationProviderNames (req_provider,

req_providerModule,

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

providerName,

providerLocation);

fileName = resolveFileName (providerLocation);

Logger::put (Logger::STANDARD_LOG,

System::CIMSERVER,

Logger::TRACE,

"JMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",

System::getHostName(),

request->nameSpace.getString(),

providerName);

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl));

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: hostname = "

<<System::getHostName()

String fileName = resolveFileName(providerLocation);

<<", namespace = "

<<request->nameSpace.getString()

<<", providername = "

<<providerName

<<", fileName = "

<<fileName

<<PEGASUS_STD(endl));

// get cached or load new provider module

JMPIProvider::OpProviderHolder ph =

JMPIProvider::OpProviderHolder ph = providerManager.getProvider (fileName,

providerManager.getProvider(fileName, providerName, String::EMPTY);

providerName,

String::EMPTY);

indProvRecord *prec = NULL;

JMPIProvider &pr = ph.GetProvider ();

{

AutoMutex lock (mutexProvTab);

provTab.lookup(providerName,prec);

}

{

AutoMutex lock (prec->mutex);

if (--prec->count <= 0)

{

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Removing provTab "<<providerName<<PEGASUS_STD(endl));

provTab.remove(providerName);

prec=NULL;

fFreePrec = true;

}

indSelectRecord *srec = NULL;

{

const CIMObjectPath &sPath = request->subscriptionInstance.getPath();

CIMObjectPath sPath = request->subscriptionInstance.getPath ();

String sPathString = sPath.toString();

Array<CIMKeyBinding> kb;

selxTab.lookup(sPathString,srec);

// Technically we only need Name and Handler for uniqueness

kb = sPath.getKeyBindings ();

CMPI_SelectExp *eSelx = srec->eSelx;

// Add an entry for every provider.

CIMOMHandleQueryContext *qContext = srec->qContext;

kb.append (CIMKeyBinding ("Provider",

pr.getName (),

CIMKeyBinding::STRING));

selxTab.remove(sPathString);

sPath.setKeyBindings (kb);

// convert arguments

String sPathString = sPath.toString ();

OperationContext context;

context.insert(request->operationContext.get(IdentityContainer::NAME));

AutoMutex lock (mutexSelxTab);

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();

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Removing selxTab "<<sPathString<<PEGASUS_STD(endl));

JMPIProvider & pr=ph.GetProvider();

if (!selxTab.lookup (sPathString, srec))

{

PEGASUS_ASSERT(0);

}

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: For selxTab "<<sPathString<<", srec = "<<PEGASUS_STD(hex)<<(long)srec<<PEGASUS_STD(dec)<<", qContext = "<<PEGASUS_STD(hex)<<(long)srec->qContext<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

selxTab.remove (sPathString);

}

PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteSubscriptionRequest: " + pr.getName());

Line 3840

Line 6571

env = JMPIjvm::attachThread(&jv);

JMPIProvider::pm_service_op_lock op_lock(&pr);

if (!env)

{

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,

MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",

"Could not initialize the JVM (Java Virtual Machine) runtime environment."));

}

STAT_GETSTARTTIME;

JMPIProvider::pm_service_op_lock op_lock(&pr);

jmethodID id = NULL;

String interfaceType;

String interfaceVersion;

getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),

interfaceType,

interfaceVersion);

if (interfaceType == "JMPI")

{

// public void deActivateFilter (org.pegasus.jmpi.SelectExp filter,

// java.lang.String eventType,

// org.pegasus.jmpi.CIMObjectPath classPath,

Line 3857

Line 6603

if (id != NULL)

{

eMethodFound = METHOD_SNIA_PROVIDER20;

eMethodFound = METHOD_EVENTPROVIDER;

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));

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/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::handleDeleteSubscriptionRequest: found METHOD_EVENTPROVIDER2."<<PEGASUS_STD(endl));

}

if (id == NULL)

{

DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: No method found!"<<PEGASUS_STD(endl));

PEG_METHOD_EXIT();

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_SNIA_PROVIDER20:

case METHOD_EVENTPROVIDER:

{

jint jObj = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);

WQLSelectStatement *stmt = newSelectExp (srec->query,

jobject jSel = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jObj);

srec->queryLanguage);

jlong jStmtRef = DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, stmt);

jobject jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewJ,jStmtRef);

JMPIjvm::checkException(env);

jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());

JMPIjvm::checkException(env);

CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->classNames[0]);

jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

env->CallVoidMethod ((jobject)pr.jProvider,

id,

jSelectExp,

jType,

jcop,

(jboolean)fFreePrec);

JMPIjvm::checkException(env);

break;

}

jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);

case METHOD_EVENTPROVIDER2:

{

jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext);

jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef);

jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);

WQLSelectStatement *stmt = newSelectExp (srec->query,

srec->queryLanguage);

jlong jStmtRef = DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, stmt);

jobject jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewJ,jStmtRef);

JMPIjvm::checkException(env);

Line 3882

Line 6691

JMPIjvm::checkException(env);

CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),

request->nameSpace,

request->classNames[0]);

jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);

jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef);

JMPIjvm::checkException(env);

StatProviderTimeMeasurement providerTime(response);

env->CallVoidMethod((jobject)pr.jProvider,

id,

jSel,

joc,

jSelectExp,

jType,

jRef,

jcop,

(jboolean)(prec==NULL));

(jboolean)fFreePrec);

JMPIjvm::checkException(env);

if (joc)

// 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;

env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);

if (prec->handler) delete prec->handler;

prec->handler = NULL;

}

STAT_PMS_PROVIDEREND;

delete eSelx;

JMPIjvm::checkException(env);

delete qContext;

}

delete srec;

break;

}

Line 3923

Line 6726

break;

}

// Decrement count of current subscriptions for this provider

pr.decrementSubscriptionsAndTestIfZero ();

}

HandlerCatch(handler);

if (srec)

{

delete srec->qContext;

}

delete srec;

if (fFreePrec)

{

delete prec->ctx;

delete prec->handler;

delete prec;

}

if (env) JMPIjvm::detachThread();

PEG_METHOD_EXIT();

STAT_COPYDISPATCHER

return(response);

}

Line 3974

Line 6793

PEGASUS_ASSERT(response != 0);

// preserve message key

response->setKey(request->getKey());

// Set HTTP method in response from request

Line 4008

Line 6824

PEGASUS_ASSERT(response != 0);

// preserve message key

response->setKey(request->getKey());

// Set HTTP method in response from request

response->setHttpMethod (request->getHttpMethod ());

Line 4036

Line 6849

PEGASUS_ASSERT(response != 0);

// preserve message key

response->setKey(request->getKey());

// Set HTTP method in response from request

response->setHttpMethod (request->getHttpMethod ());

Line 4063

Line 6873

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 4102

Line 6912

// provider's enableIndications method

Array <JMPIProvider *> enableProviders;

enableProviders = providerManager.getIndicationProvidersToEnable ();

Uint32 numProviders = enableProviders.size ();

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSubscriptionInitCompleteRequest: numProviders = "<<numProviders<<PEGASUS_STD(endl));

#if 0

for (Uint32 i = 0; i < numProviders; i++)

{

try

{

CIMInstance provider;

provider = enableProviders [i]->getProviderInstance ();

DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSubscriptionInitCompleteRequest: name = "<<enableProviders[i]->getName ()<<PEGASUS_STD(endl));

// Get cached or load new provider module

JMPIProvider::OpProviderHolder ph = providerManager.getProvider

JMPIProvider::OpProviderHolder ph = providerManager.getProvider (enableProviders[i]->getModule ()->getFileName (),

(enableProviders [i]->getModule ()->getFileName (),

enableProviders [i]->getName ());

indProvRecord * prec = NULL;

provTab.lookup (enableProviders [i]->getName (), prec);

if (prec)

{

prec->enabled = true;

AutoMutex lock (mutexProvTab);

CIMRequestMessage * request = 0;

CIMResponseMessage * response = 0;

provTab.lookup (enableProviders[i]->getName (), prec);

prec->handler = new EnableIndicationsResponseHandler

(request, response, provider, _indicationCallback);

}

catch (CIMException & e)

Line 4142

Line 6955

}

catch(...)

{

PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

PEG_TRACE_CSTRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Unknown error in handleSubscriptionInitCompleteRequest");

}

#endif

PEG_METHOD_EXIT ();

return (response);

Line 4172

Line 6986

{

String providerName;

String fileName;

String interfaceName;

String moduleName;

CIMValue genericValue;

genericValue = providerId.getModule().getProperty(

providerId.getModule().findProperty("Name")).getValue();

genericValue.get(moduleName);

genericValue = providerId.getProvider().getProperty(

providerId.getProvider().findProperty("Name")).getValue();

genericValue.get(providerName);

Line 4184

Line 7002

genericValue.get(fileName);

fileName = resolveFileName(fileName);

// ATTN: This attribute is probably not required

return ProviderName(moduleName, providerName, fileName);

genericValue = providerId.getModule().getProperty(

providerId.getModule().findProperty("InterfaceType")).getValue();

genericValue.get(interfaceName);

return ProviderName(providerName, fileName, interfaceName, 0);

}

String JMPIProviderManager::resolveFileName(String fileName)

{

String name;

String name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));

#if defined(PEGASUS_OS_TYPE_WINDOWS)

// physfilename = everything up to the delimiter pointing at class start

name = fileName; // + String(".dll");

// in case there is no delimiter anymore, it takes the entire filename

#elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)

String physfilename = fileName.subString(0, fileName.find(":"));

name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));

// look in all(multiple) homed pathes for the physical file

name.append(String("/") + fileName); // + String(".sl"));

name = FileSystem::getAbsoluteFileName(name, physfilename);

#elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)

// construct back the fully specified jar:<classname> provider name

name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));

name = FileSystem::extractFilePath(name) + fileName;

name.append(String("/") + fileName); // + String(".so"));

#elif defined(PEGASUS_OS_OS400)

name = filrName;

#else

name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));

name.append(String("/") + fileName); // + String(".so"));

#endif

return name;

}

Legend:

Removed from v.1.35
changed lines
	Added in v.1.65

No CVS admin address has been configured