version 1.41, 2006/02/10 22:20:44
|
version 1.41.2.4, 2006/06/23 17:44:59
|
|
|
#include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.h> | #include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.h> |
#include <Pegasus/ProviderManager2/ProviderManagerService.h> | #include <Pegasus/ProviderManager2/ProviderManagerService.h> |
| |
#include <Pegasus/ProviderManager2/CMPI/CMPI_SelectExp.h> |
|
|
|
|
|
PEGASUS_USING_STD; | PEGASUS_USING_STD; |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
|
|
env->ExceptionClear(); | env->ExceptionClear(); |
} | } |
| |
|
bool JMPIProviderManager::getInterfaceType (ProviderIdContainer pidc, |
|
String& interfaceType, |
|
String& interfaceVersion) |
|
{ |
|
///CIMInstance ciProvider = pidc.getProvider (); |
|
CIMInstance ciProviderModule = pidc.getModule (); |
|
Uint32 idx; |
|
bool fRet = true; |
|
|
|
///PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: ciProvider = "<<ciProvider.getPath ().toString ()<<PEGASUS_STD(endl); |
|
///PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: ciProviderModule = "<<ciProviderModule.getPath ().toString ()<<PEGASUS_STD(endl); |
|
|
|
idx = ciProviderModule.findProperty ("InterfaceType"); |
|
|
|
if (idx != PEG_NOT_FOUND) |
|
{ |
|
CIMValue itValue; |
|
|
|
itValue = ciProviderModule.getProperty (idx).getValue (); |
|
|
|
itValue.get (interfaceType); |
|
|
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: interfaceType = "<<interfaceType<<PEGASUS_STD(endl)); |
|
} |
|
else |
|
{ |
|
fRet = false; |
|
} |
|
|
|
idx = ciProviderModule.findProperty ("InterfaceVersion"); |
|
|
|
if (idx != PEG_NOT_FOUND) |
|
{ |
|
CIMValue itValue; |
|
|
|
itValue = ciProviderModule.getProperty (idx).getValue (); |
|
|
|
itValue.get (interfaceVersion); |
|
|
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: interfaceVersion = "<<interfaceVersion<<PEGASUS_STD(endl)); |
|
} |
|
else |
|
{ |
|
fRet = false; |
|
} |
|
|
|
return fRet; |
|
} |
|
|
|
bool JMPIProviderManager::interfaceIsUsed (JNIEnv *env, |
|
jobject jObject, |
|
String searchInterfaceName) |
|
{ |
|
jobjectArray jInterfaces = 0; |
|
jsize jInterfacesLength = 0; |
|
bool fFound = false; |
|
|
|
if (!jObject) |
|
{ |
|
return false; |
|
} |
|
|
|
jInterfaces = (jobjectArray)env->CallObjectMethod (env->GetObjectClass (jObject), |
|
JMPIjvm::jv.ClassGetInterfaces); |
|
|
|
if (!jInterfaces) |
|
{ |
|
return false; |
|
} |
|
|
|
jInterfacesLength = env->GetArrayLength (jInterfaces); |
|
|
|
for (jsize i = 0; !fFound && i < jInterfacesLength; i++) |
|
{ |
|
jobject jInterface = env->GetObjectArrayElement (jInterfaces, i); |
|
|
|
if (jInterface) |
|
{ |
|
jstring jInterfaceName = (jstring)env->CallObjectMethod (jInterface, |
|
JMPIjvm::jv.ClassGetName); |
|
|
|
if (jInterfaceName) |
|
{ |
|
const char *pszInterfaceName = env->GetStringUTFChars (jInterfaceName, |
|
0); |
|
String interfaceName = pszInterfaceName; |
|
|
|
if (String::equal (interfaceName, searchInterfaceName)) |
|
{ |
|
fFound = true; |
|
} |
|
|
|
env->ReleaseStringUTFChars (jInterfaceName, pszInterfaceName); |
|
} |
|
} |
|
} |
|
|
|
return fFound; |
|
} |
|
|
JMPIProviderManager::IndProvTab JMPIProviderManager::provTab; | JMPIProviderManager::IndProvTab JMPIProviderManager::provTab; |
|
Mutex JMPIProviderManager::mutexProvTab; |
JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab; | JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab; |
|
Mutex JMPIProviderManager::mutexSelxTab; |
JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg; | JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg; |
|
Mutex JMPIProviderManager::mutexProvReg; |
| |
JMPIProviderManager::JMPIProviderManager(Mode m) | JMPIProviderManager::JMPIProviderManager(Mode m) |
{ | { |
|
|
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::insertProvider: "<<key<<PEGASUS_STD(endl)); | 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() | Message * JMPIProviderManager::processMessage(Message * request) throw() |
|
|
PEGASUS_ASSERT(response != 0); \ | PEGASUS_ASSERT(response != 0); \ |
response->setKey(request->getKey()); \ | response->setKey(request->getKey()); \ |
response->setHttpMethod(request->getHttpMethod()); \ | response->setHttpMethod(request->getHttpMethod()); \ |
type1##ResponseHandler handler(request, response); |
type1##ResponseHandler handler(request, response, _responseChunkCallback); |
| |
#define VOIDINTRO ); | #define VOIDINTRO ); |
#define NOVOIDINTRO(type) ,type); | #define NOVOIDINTRO(type) ,type); |
|
|
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | 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; |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; | METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env = NULL; | JNIEnv *env = NULL; |
|
|
name.getLogicalName()); | name.getLogicalName()); |
OperationContext context; | 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 | // forward request |
JMPIProvider &pr=ph.GetProvider(); | JMPIProvider &pr=ph.GetProvider(); |
| |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | jmethodID id = NULL; |
|
String interfaceType; |
|
String interfaceVersion; |
| |
/* Fix for 4238 */ |
getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME), |
// public abstract org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath cop, |
interfaceType, |
// org.pegasus.jmpi.CIMClass cimClass, |
interfaceVersion); |
// boolean 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;ZZ[Ljava/lang/String;)Lorg/pegasus/jmpi/CIMInstance;"); |
|
|
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_PEGASUS_25; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_PEGASUS_25."<<PEGASUS_STD(endl)); |
|
} |
|
/* Fix for 4238 */ |
|
| |
if (id == NULL) |
if (interfaceType == "JMPI") |
{ | { |
env->ExceptionClear(); |
// public org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath cop, |
|
|
// public abstract org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath cop, |
|
// org.pegasus.jmpi.CIMClass cimClass, | // org.pegasus.jmpi.CIMClass cimClass, |
// boolean localOnly) | // boolean localOnly) |
// throws org.pegasus.jmpi.CIMException | // throws org.pegasus.jmpi.CIMException |
|
|
| |
if (id != NULL) | 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) | if (id == NULL) |
|
|
| |
if (id != NULL) | if (id != NULL) |
{ | { |
eMethodFound = METHOD_PEGASUS_24; |
eMethodFound = METHOD_CIMINSTANCEPROVIDER; |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl)); |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl)); |
|
} |
|
} |
|
} |
|
else if (interfaceType == "JMPIExperimental") |
|
{ |
|
/* Fix for 4238 */ |
|
// public org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.OperationContext oc |
|
// org.pegasus.jmpi.CIMObjectPath cop, |
|
// org.pegasus.jmpi.CIMClass cimClass, |
|
// boolean includeQualifiers, |
|
// boolean includeClassOrigin, |
|
// String propertyList[]) |
|
// throws org.pegasus.jmpi.CIMException |
|
id = env->GetMethodID((jclass)pr.jProviderClass, |
|
"getInstance", |
|
"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Lorg/pegasus/jmpi/CIMInstance;"); |
|
|
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_INSTANCEPROVIDER2; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl)); |
|
} |
|
/* Fix for 4238 */ |
} | } |
|
|
|
if (id == NULL) |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: No method found!"<<PEGASUS_STD(endl)); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | switch (eMethodFound) |
{ | { |
case METHOD_PEGASUS_24: |
case METHOD_CIMINSTANCEPROVIDER: |
{ | { |
jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef); | jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef); |
|
|
} | } |
| |
/* Fix for 4238 */ | /* Fix for 4238 */ |
case METHOD_PEGASUS_25: |
case METHOD_INSTANCEPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef); | jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef); |
| |
|
|
jobjectArray jPropertyList = getList(jv,env,request->propertyList); | jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider, | jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jop, | jop, |
jcimClass, | jcimClass, |
JMPI_INCLUDE_QUALIFIERS, | JMPI_INCLUDE_QUALIFIERS, |
|
|
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | handler.processing(); |
| |
if (jciRet) { | if (jciRet) { |
|
|
} | } |
/* Fix for 4238 */ | /* Fix for 4238 */ |
| |
case METHOD_SNIA_PROVIDER20: |
case METHOD_INSTANCEPROVIDER: |
{ | { |
jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef); | jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef); |
|
|
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
METHOD_PEGASUS_24, |
METHOD_CIMINSTANCEPROVIDER, |
METHOD_PEGASUS_25, |
METHOD_CIMINSTANCEPROVIDER2, |
METHOD_SNIA_PROVIDER20, |
METHOD_INSTANCEPROVIDER, |
|
METHOD_INSTANCEPROVIDER2, |
} METHOD_VERSION; | } METHOD_VERSION; |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; | METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env = NULL; | JNIEnv *env = NULL; |
|
|
request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // 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); |
| |
// convert arguments | // convert arguments |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | jmethodID id = NULL; |
|
String interfaceType; |
|
String interfaceVersion; |
| |
/* Fix for 4189 */ |
getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME), |
// public java.util.Vector enumerateInstances (org.pegasus.jmpi.CIMObjectPath cop, |
interfaceType, |
|
interfaceVersion); |
|
|
|
if (interfaceType == "JMPI") |
|
{ |
|
// public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop, |
|
// boolean deep, |
// org.pegasus.jmpi.CIMClass cimClass, | // org.pegasus.jmpi.CIMClass cimClass, |
// boolean includeQualifiers, |
// boolean localOnly) |
// boolean includeClassOrigin, |
|
// java.lang.String[] propertyList) |
|
// throws org.pegasus.jmpi.CIMException | // throws org.pegasus.jmpi.CIMException |
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"enumerateInstances", |
"enumInstances", |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Ljava/util/Vector;"); |
"(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;"); |
| |
if (id != NULL) | 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) | if (id == NULL) |
{ | { |
env->ExceptionClear(); | 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 | // throws org.pegasus.jmpi.CIMException |
id = env->GetMethodID((jclass)pr.jProviderClass, | 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) | 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) | if (id == NULL) |
{ | { |
env->ExceptionClear(); | env->ExceptionClear(); |
| |
// public org.pegasus.jmpi.CIMInstance[] enumInstances (org.pegasus.jmpi.CIMObjectPath cop, |
// 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 includeQualifiers, |
// boolean includeClassOrigin, | // boolean includeClassOrigin, |
// java.lang.String[] propertyList, |
// java.lang.String[] propertyList) |
// org.pegasus.jmpi.CIMClass cimClass) |
|
// throws org.pegasus.jmpi.CIMException | // throws org.pegasus.jmpi.CIMException |
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"enumInstances", |
"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) | if (id != NULL) |
{ | { |
eMethodFound = METHOD_PEGASUS_24; |
eMethodFound = METHOD_CIMINSTANCEPROVIDER2; |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl)); |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_CIMINSTANCEPROVIDER2."<<PEGASUS_STD(endl)); |
} | } |
} | } |
|
} |
|
|
|
if (id == NULL) |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: No method found!"<<PEGASUS_STD(endl)); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
|
} |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | switch (eMethodFound) |
{ | { |
case METHOD_PEGASUS_24: |
case METHOD_CIMINSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
|
|
break; | break; |
} | } |
| |
/* Fix for 4189 */ |
case METHOD_CIMINSTANCEPROVIDER2: |
case METHOD_PEGASUS_25: |
|
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
| |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); | jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, |
jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jcop, | jcop, |
jcc, | jcc, |
JMPI_INCLUDE_QUALIFIERS, | JMPI_INCLUDE_QUALIFIERS, |
|
|
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | 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); | JMPIjvm::checkException(env); |
| |
jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
jobject jciRet = env->GetObjectArrayElement(jAr,i); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
iop.setNameSpace(op.getNameSpace()); |
|
|
|
ciRet->setPath(iop); |
|
/* Fix for 4237*/ |
|
|
|
handler.deliver(*ciRet); | handler.deliver(*ciRet); |
} | } |
} | } |
handler.complete(); | handler.complete(); |
break; | break; |
} | } |
/* Fix for 4189 */ |
|
| |
case METHOD_SNIA_PROVIDER20: |
/* Fix for 4189 */ |
|
case METHOD_INSTANCEPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
// Modified for Bugzilla# 3679 |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, | jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jcop, | jcop, |
request->deepInheritance, |
|
jcc, | jcc, |
JMPI_LOCALONLY); |
JMPI_INCLUDE_QUALIFIERS, |
|
request->includeClassOrigin, |
|
jPropertyList); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | handler.processing(); |
if (jVec) { | if (jVec) { |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { | for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
|
|
handler.complete(); | handler.complete(); |
break; | break; |
} | } |
|
/* Fix for 4189 */ |
| |
case METHOD_UNKNOWN: |
case METHOD_INSTANCEPROVIDER: |
{ | { |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: should not be here!"<<PEGASUS_STD(endl)); |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
break; |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
} |
|
} |
|
} |
|
HandlerCatch(handler); |
|
| |
if (env) JMPIjvm::detachThread(); |
JMPIjvm::checkException(env); |
| |
PEG_METHOD_EXIT(); |
CIMClass cls; |
| |
STAT_COPYDISPATCHER |
try |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl)); |
|
AutoMutex lock (pr._cimomMutex); |
| |
return(response); |
cls = pr._cimom_handle->getClass(context, |
|
request->nameSpace, |
|
request->className, |
|
false, |
|
true, |
|
true, |
|
CIMPropertyList()); |
|
DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl)); |
} | } |
|
catch (CIMException e) |
Message * JMPIProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw() |
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest"); |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl)); |
|
throw; |
HandlerIntro(EnumerateInstanceNames,message,request,response, handler,Array<CIMObjectPath>()); |
} |
| |
typedef enum { |
CIMClass *pcls = new CIMClass (cls); |
METHOD_UNKNOWN = 0, |
|
METHOD_PEGASUS_24, |
|
METHOD_PEGASUS_25, |
|
METHOD_SNIA_PROVIDER20, |
|
} METHOD_VERSION; |
|
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
|
JNIEnv *env = NULL; |
|
| |
try { |
JMPIjvm::checkException(env); |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"JMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2", |
jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
System::getHostName(), |
jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef); |
request->nameSpace.getString(), |
|
request->className.getString()); |
JMPIjvm::checkException(env); |
|
|
|
// Modified for Bugzilla# 3679 |
|
jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jcop, |
|
request->deepInheritance, |
|
jcc, |
|
JMPI_LOCALONLY); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
if (jVec) { |
|
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
|
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
|
|
|
/* Fix for 4237 */ |
|
CIMClass cls; |
|
|
|
try |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl)); |
|
AutoMutex lock (pr._cimomMutex); |
|
|
|
cls = pr._cimom_handle->getClass(context, |
|
request->nameSpace, |
|
ciRet->getClassName(), |
|
false, |
|
true, |
|
true, |
|
CIMPropertyList()); |
|
DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl)); |
|
} |
|
catch (CIMException e) |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl)); |
|
throw; |
|
} |
|
|
|
const CIMObjectPath& op = ciRet->getPath(); |
|
CIMObjectPath iop = ciRet->buildPath(cls); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
iop.setNameSpace(op.getNameSpace()); |
|
|
|
ciRet->setPath(iop); |
|
/* Fix for 4237*/ |
|
|
|
handler.deliver(*ciRet); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_UNKNOWN: |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: should not be here!"<<PEGASUS_STD(endl)); |
|
break; |
|
} |
|
} |
|
} |
|
HandlerCatch(handler); |
|
|
|
if (env) JMPIjvm::detachThread(); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
return(response); |
|
} |
|
|
|
Message * JMPIProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest"); |
|
|
|
HandlerIntro(EnumerateInstanceNames,message,request,response, handler,Array<CIMObjectPath>()); |
|
|
|
typedef enum { |
|
METHOD_UNKNOWN = 0, |
|
METHOD_CIMINSTANCEPROVIDER, |
|
METHOD_CIMINSTANCEPROVIDER2, |
|
METHOD_INSTANCEPROVIDER, |
|
METHOD_INSTANCEPROVIDER2, |
|
} METHOD_VERSION; |
|
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
|
JNIEnv *env = NULL; |
|
|
|
try { |
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"JMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2", |
|
System::getHostName(), |
|
request->nameSpace.getString(), |
|
request->className.getString()); |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl)); |
| |
|
|
request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // 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 | // convert arguments |
OperationContext context; | OperationContext context; |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | 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, | // public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop, |
// boolean deep, | // boolean deep, |
// org.pegasus.jmpi.CIMClass cimClass) | // org.pegasus.jmpi.CIMClass cimClass) |
|
|
| |
if (id != NULL) | 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) | if (id == NULL) |
{ | { |
env->ExceptionClear(); | env->ExceptionClear(); |
| |
// public org.pegasus.jmpi.CIMObjectPath[] enumerateInstanceNames (org.pegasus.jmpi.CIMObjectPath cop, |
// public org.pegasus.jmpi.CIMObjectPath[] enumerateInstanceNames (org.pegasus.jmpi.CIMObjectPath op, |
// org.pegasus.jmpi.CIMClass cimClass) |
// org.pegasus.jmpi.CIMClass cc) |
// throws org.pegasus.jmpi.CIMException | // throws org.pegasus.jmpi.CIMException |
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"enumerateInstanceNames", | "enumerateInstanceNames", |
|
|
| |
if (id != NULL) | 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) | if (id == NULL) |
{ | { |
env->ExceptionClear(); | env->ExceptionClear(); |
| |
// public java.util.Vector enumerateInstanceNames (org.pegasus.jmpi.CIMObjectPath cop, |
// public abstract org.pegasus.jmpi.CIMObjectPath[] enumerateInstanceNames (org.pegasus.jmpi.OperationContext oc |
|
// org.pegasus.jmpi.CIMObjectPath cop, |
// org.pegasus.jmpi.CIMClass cimClass) | // org.pegasus.jmpi.CIMClass cimClass) |
// throws org.pegasus.jmpi.CIMException | // throws org.pegasus.jmpi.CIMException |
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"enumerateInstanceNames", | "enumerateInstanceNames", |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"); |
"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMObjectPath;"); |
| |
if (id != NULL) | if (id != NULL) |
{ | { |
eMethodFound = METHOD_PEGASUS_25; |
eMethodFound = METHOD_CIMINSTANCEPROVIDER2; |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_PEGASUS_25."<<PEGASUS_STD(endl)); |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_CIMINSTANCEPROVIDER2."<<PEGASUS_STD(endl)); |
|
} |
} | } |
} | } |
| |
if (id == NULL) | if (id == NULL) |
{ | { |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: No method found!"<<PEGASUS_STD(endl)); | DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: No method found!"<<PEGASUS_STD(endl)); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | switch (eMethodFound) |
{ | { |
case METHOD_PEGASUS_24: |
case METHOD_CIMINSTANCEPROVIDER: |
|
{ |
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
CIMClass cls; |
|
|
|
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, |
|
true, |
|
CIMPropertyList()); |
|
DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl)); |
|
} |
|
catch (CIMException e) |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl)); |
|
throw; |
|
} |
|
|
|
CIMClass *pcls = new CIMClass (cls); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
|
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jcop, |
|
jcimClass); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
if (jAr) { |
|
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jcopRet = env->GetObjectArrayElement(jAr,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
|
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
handler.deliver(*copRet); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_CIMINSTANCEPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
| |
|
|
| |
jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jcop, | jcop, |
jcimClass); | jcimClass); |
| |
|
|
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | handler.processing(); |
if (jAr) { | if (jAr) { |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { | for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
|
|
break; | break; |
} | } |
| |
case METHOD_PEGASUS_25: |
case METHOD_INSTANCEPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
| |
|
|
| |
jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, | jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jcop, | jcop, |
jcimClass); | jcimClass); |
| |
|
|
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | handler.processing(); |
if (jVec) { | if (jVec) { |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { | for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
|
|
break; | break; |
} | } |
| |
case METHOD_SNIA_PROVIDER20: |
case METHOD_INSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
|
|
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
METHOD_SNIA_PROVIDER20, |
METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER |
|
METHOD_INSTANCEPROVIDER2 // same as METHOD_CIMINSTANCEPROVIDER2 |
} METHOD_VERSION; | } METHOD_VERSION; |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; | METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env = NULL; | JNIEnv *env = NULL; |
|
|
request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // 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); |
| |
// 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 | // forward request |
JMPIProvider &pr = ph.GetProvider(); | JMPIProvider &pr = ph.GetProvider(); |
| |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | jmethodID id = NULL; |
|
String interfaceType; |
|
String interfaceVersion; |
| |
// public abstract org.pegasus.jmpi.CIMObjectPath createInstance (org.pegasus.jmpi.CIMObjectPath cop, |
getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME), |
|
interfaceType, |
|
interfaceVersion); |
|
|
|
if (interfaceType == "JMPI") |
|
{ |
|
// public org.pegasus.jmpi.CIMObjectPath createInstance (org.pegasus.jmpi.CIMObjectPath cop, |
// org.pegasus.jmpi.CIMInstance cimInstance) | // org.pegasus.jmpi.CIMInstance cimInstance) |
// throws org.pegasus.jmpi.CIMException | // throws org.pegasus.jmpi.CIMException |
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
|
|
| |
if (id != NULL) | 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(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | switch (eMethodFound) |
{ | { |
case METHOD_SNIA_PROVIDER20: |
case METHOD_INSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
|
|
break; | break; |
} | } |
| |
case METHOD_UNKNOWN: |
case METHOD_INSTANCEPROVIDER2: |
{ | { |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: should not be here!"<<PEGASUS_STD(endl)); |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
break; |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
} |
|
} |
|
} |
|
HandlerCatch(handler); |
|
| |
if (env) JMPIjvm::detachThread(); |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
| |
PEG_METHOD_EXIT(); |
JMPIjvm::checkException(env); |
| |
STAT_COPYDISPATCHER |
CIMInstance *ci = new CIMInstance (request->newInstance); |
|
jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci); |
|
jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef); |
| |
return(response); |
JMPIjvm::checkException(env); |
|
|
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl)); |
|
|
|
jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
joc, |
|
jcop, |
|
jci); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
|
handler.processing(); |
|
|
|
if (jcopRet) { |
|
jint jCopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
|
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCopRetRef); |
|
|
|
handler.deliver(*copRet); |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_UNKNOWN: |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: should not be here!"<<PEGASUS_STD(endl)); |
|
break; |
|
} |
|
} |
|
} |
|
HandlerCatch(handler); |
|
|
|
if (env) JMPIjvm::detachThread(); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
return(response); |
} | } |
| |
Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw() | Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw() |
|
|
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
METHOD_PEGASUS_24, |
METHOD_CIMINSTANCEPROVIDER, |
METHOD_SNIA_PROVIDER20, |
METHOD_INSTANCEPROVIDER, |
|
METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2 |
} METHOD_VERSION; | } METHOD_VERSION; |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; | METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env = NULL; | JNIEnv *env = NULL; |
|
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: provider name physical = "<<name.getPhysicalName()<<", logical = "<<name.getLogicalName()<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: provider name physical = "<<name.getPhysicalName()<<", logical = "<<name.getLogicalName()<<PEGASUS_STD(endl)); |
| |
// get cached or load new provider module | // 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 | // forward request |
JMPIProvider &pr = ph.GetProvider(); | JMPIProvider &pr = ph.GetProvider(); |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | 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, | // public abstract void setInstance (org.pegasus.jmpi.CIMObjectPath cop, |
// org.pegasus.jmpi.CIMInstance cimInstance) | // org.pegasus.jmpi.CIMInstance cimInstance) |
// org.pegasus.jmpi.throws CIMException | // org.pegasus.jmpi.throws CIMException |
|
|
| |
if (id != NULL) | 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) | if (id == NULL) |
|
|
| |
if (id != NULL) | 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(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | switch (eMethodFound) |
{ | { |
case METHOD_PEGASUS_24: |
case METHOD_INSTANCEPROVIDER2: |
|
{ |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
CIMInstance *ci = new CIMInstance (request->modifiedInstance); |
|
jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci); |
|
jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
|
|
|
env->CallVoidMethod((jobject)pr.jProvider, |
|
id, |
|
joc, |
|
jcop, |
|
jci); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
break; |
|
} |
|
|
|
case METHOD_CIMINSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
|
|
break; | break; |
} | } |
| |
case METHOD_SNIA_PROVIDER20: |
case METHOD_INSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
|
|
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
METHOD_SNIA_PROVIDER20, |
METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER |
|
METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2 |
} METHOD_VERSION; | } METHOD_VERSION; |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; | METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env = NULL; | JNIEnv *env = NULL; |
|
|
request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // 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 | // forward request |
JMPIProvider &pr = ph.GetProvider(); | JMPIProvider &pr = ph.GetProvider(); |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | 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) | // public abstract void deleteInstance (org.pegasus.jmpi.CIMObjectPath cop) |
// throws org.pegasus.jmpi.CIMException | // throws org.pegasus.jmpi.CIMException |
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
|
|
| |
if (id != NULL) | 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(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | switch (eMethodFound) |
{ | { |
case METHOD_SNIA_PROVIDER20: |
case METHOD_INSTANCEPROVIDER2: |
|
{ |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
env->CallVoidMethod((jobject)pr.jProvider, |
|
id, |
|
joc, |
|
jcop); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
break; |
|
} |
|
|
|
case METHOD_INSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
|
|
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
METHOD_PEGASUS_24, |
METHOD_CIMINSTANCEPROVIDER, |
METHOD_PEGASUS_25, |
METHOD_CIMINSTANCEPROVIDER2, |
METHOD_SNIA_PROVIDER20, |
METHOD_INSTANCEPROVIDER, |
|
METHOD_INSTANCEPROVIDER2, |
} METHOD_VERSION; | } METHOD_VERSION; |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; | METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env = NULL; | JNIEnv *env = NULL; |
|
|
request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // 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 | // convert arguments |
OperationContext context; | OperationContext context; |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | 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, | // public abstract java.util.Vector execQuery (org.pegasus.jmpi.CIMObjectPath cop, |
// java.lang.String queryStatement, | // java.lang.String queryStatement, |
// int ql, | // int ql, |
|
|
| |
if (id != NULL) | 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) | if (id == NULL) |
|
|
| |
if (id != NULL) | 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) | if (id == NULL) |
{ | { |
env->ExceptionClear(); | env->ExceptionClear(); |
| |
// public abstract java.util.Vector execQuery(org.pegasus.jmpi.CIMObjectPath cop, |
// public abstract org.pegasus.jmpi.CIMInstance[] execQuery (org.pegasus.jmpi.OperationContext oc, |
|
// org.pegasus.jmpi.CIMObjectPath cop, |
// org.pegasus.jmpi.CIMClass cimClass, | // org.pegasus.jmpi.CIMClass cimClass, |
// java.lang.String query, |
// java.lang.String queryStatement, |
// java.lang.String ql) |
// java.lang.String queryLanguage) |
// throws org.pegasus.jmpi.CIMException | // throws org.pegasus.jmpi.CIMException |
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"execQuery", | "execQuery", |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"); |
"(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) | if (id != NULL) |
{ | { |
eMethodFound = METHOD_PEGASUS_25; |
eMethodFound = METHOD_CIMINSTANCEPROVIDER2; |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_PEGASUS_25."<<PEGASUS_STD(endl)); |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_CIMINSTANCEPROVIDER2."<<PEGASUS_STD(endl)); |
|
} |
} | } |
} | } |
| |
if (id == NULL) | if (id == NULL) |
{ | { |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found no method!"<<PEGASUS_STD(endl)); | DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found no method!"<<PEGASUS_STD(endl)); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | switch (eMethodFound) |
{ | { |
case METHOD_PEGASUS_24: |
case METHOD_CIMINSTANCEPROVIDER: |
{ | { |
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
|
|
break; | break; |
} | } |
| |
case METHOD_PEGASUS_25: |
case METHOD_CIMINSTANCEPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobjectArray jVec = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jcop, | jcop, |
jCc, |
|
jquery, | jquery, |
jqueryLanguage); |
jqueryLanguage, |
|
jCc); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | 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); | JMPIjvm::checkException(env); |
| |
jobject jciRet = env->GetObjectArrayElement(jVec,i); |
jobject jciRet = env->GetObjectArrayElement(jAr,i); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
break; | break; |
} | } |
| |
case METHOD_SNIA_PROVIDER20: |
case METHOD_INSTANCEPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
| |
|
|
| |
CIMClass *pcls = new CIMClass (cls); | CIMClass *pcls = new CIMClass (cls); |
| |
JMPIjvm::checkException(env); |
|
|
|
jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); | jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
| |
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls); | jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jql = 0; // @BUG - how to convert? |
jobject jVec = env->CallObjectMethod ((jobject)pr.jProvider, |
|
|
jobjectArray jVec = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, | id, |
|
joc, |
jcop, | jcop, |
|
jCc, |
jquery, | jquery, |
jql, |
jqueryLanguage); |
jCc); |
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | handler.processing(); |
if (jVec) { |
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); | JMPIjvm::checkException(env); |
| |
jobject jciRet = env->GetObjectArrayElement(jVec,i); |
jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: jciRet = "<<jciRet<<PEGASUS_STD(endl)); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
handler.deliver(*ciRet); | handler.deliver(*ciRet); |
} | } |
} | } |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: done!"<<PEGASUS_STD(endl)); |
handler.complete(); | handler.complete(); |
break; | break; |
} | } |
| |
case METHOD_UNKNOWN: |
case METHOD_INSTANCEPROVIDER: |
{ | { |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: should not be here!"<<PEGASUS_STD(endl)); |
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
break; |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
} |
|
} |
|
} |
|
HandlerCatch(handler); |
|
|
|
if (env) JMPIjvm::detachThread(); |
|
| |
PEG_METHOD_EXIT(); |
JMPIjvm::checkException(env); |
| |
STAT_COPYDISPATCHER |
jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString()); |
|
jstring jquery = env->NewStringUTF(request->query.getCString()); |
| |
return(response); |
CIMClass cls; |
} |
|
| |
Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw() |
try |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest"); |
DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl)); |
|
AutoMutex lock (pr._cimomMutex); |
HandlerIntro(Associators,message,request,response,handler,Array<CIMObject>()); |
|
|
|
typedef enum { |
|
METHOD_UNKNOWN = 0, |
|
METHOD_PEGASUS_24, |
|
METHOD_SNIA_PROVIDER20, |
|
} METHOD_VERSION; |
|
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
|
JNIEnv *env = NULL; |
|
| |
try { |
cls = pr._cimom_handle->getClass(context, |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
request->nameSpace, |
|
request->className, |
|
false, |
|
true, |
|
true, |
|
CIMPropertyList()); |
|
DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl)); |
|
} |
|
catch (CIMException e) |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl)); |
|
throw; |
|
} |
|
|
|
CIMClass *pcls = new CIMClass (cls); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
|
|
|
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jql = 0; // @BUG - how to convert? |
|
|
|
jobject jVec = env->CallObjectMethod ((jobject)pr.jProvider, |
|
id, |
|
jcop, |
|
jquery, |
|
jql, |
|
jCc); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
if (jVec) { |
|
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
|
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
handler.deliver(*ciRet); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_UNKNOWN: |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: should not be here!"<<PEGASUS_STD(endl)); |
|
break; |
|
} |
|
} |
|
} |
|
HandlerCatch(handler); |
|
|
|
if (env) JMPIjvm::detachThread(); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
return(response); |
|
} |
|
|
|
Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest"); |
|
|
|
HandlerIntro(Associators,message,request,response,handler,Array<CIMObject>()); |
|
|
|
typedef enum { |
|
METHOD_UNKNOWN = 0, |
|
METHOD_CIMASSOCIATORPROVIDER, |
|
METHOD_CIMASSOCIATORPROVIDER2, |
|
METHOD_ASSOCIATORPROVIDER, |
|
METHOD_ASSOCIATORPROVIDER2, |
|
} METHOD_VERSION; |
|
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
|
JNIEnv *env = NULL; |
|
|
|
try { |
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2", | "JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2", |
System::getHostName(), | System::getHostName(), |
request->nameSpace.getString(), | request->nameSpace.getString(), |
|
|
request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // 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 | // convert arguments |
OperationContext context; | OperationContext context; |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | 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, | // org.pegasus.jmpi.CIMObjectPath pathName, |
// java.lang.String resultClass, | // java.lang.String resultClass, |
// java.lang.String role, | // java.lang.String role, |
|
|
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"associators", | "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;"); | "(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) | 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 org.pegasus.jmpi.CIMInstance[] associators (org.pegasus.jmpi.CIMObjectPath assocName, |
|
// org.pegasus.jmpi.CIMObjectPath pathName, |
|
// java.lang.String resultClass, |
|
// java.lang.String role, |
|
// java.lang.String resultRole, |
|
// boolean includeQualifiers, |
|
// boolean includeClassOrigin, |
|
// java.lang.String[] propertyList) |
|
// throws org.pegasus.jmpi.CIMException |
|
// |
|
id = env->GetMethodID((jclass)pr.jProviderClass, |
|
"associators", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;"); |
|
|
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_CIMASSOCIATORPROVIDER; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl)); |
|
} |
|
} |
|
} |
|
else if (interfaceType == "JMPIExperimental") |
|
{ |
|
// public java.util.Vector associators (org.pegasus.jmpi.OperationContext oc, |
|
// org.pegasus.jmpi.CIMObjectPath assocName, |
|
// org.pegasus.jmpi.CIMObjectPath pathName, |
|
// java.lang.String resultClass, |
|
// java.lang.String role, |
|
// java.lang.String resultRole, |
|
// boolean includeQualifiers, |
|
// boolean includeClassOrigin, |
|
// java.lang.String[] propertyList) |
|
// throws org.pegasus.jmpi.CIMException |
|
// |
|
id = env->GetMethodID((jclass)pr.jProviderClass, |
|
"associators", |
|
"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"); |
|
|
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_ASSOCIATORPROVIDER2; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl)); |
} | } |
| |
if (id == NULL) | if (id == NULL) |
{ | { |
env->ExceptionClear(); | env->ExceptionClear(); |
| |
// public abstract java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName, |
// 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 resultClass, |
// java.lang.String role, | // java.lang.String role, |
// java.lang.String resultRole, | // java.lang.String resultRole, |
|
|
// | // |
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"associators", | "associators", |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;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;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) | if (id != NULL) |
{ | { |
eMethodFound = METHOD_PEGASUS_24; |
eMethodFound = METHOD_CIMASSOCIATORPROVIDER2; |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl)); |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl)); |
|
} |
} | } |
} | } |
| |
if (id == NULL) | if (id == NULL) |
{ | { |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl)); | DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl)); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | switch (eMethodFound) |
{ | { |
case METHOD_PEGASUS_24: |
case METHOD_CIMASSOCIATORPROVIDER: |
{ | { |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); | jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); | jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString()); | jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString()); |
jstring jRole = env->NewStringUTF(request->role.getCString()); | jstring jRole = env->NewStringUTF(request->role.getCString()); |
jstring jResultRole = env->NewStringUTF(request->resultRole.getCString()); | jstring jResultRole = env->NewStringUTF(request->resultRole.getCString()); |
|
|
| |
#ifdef PEGASUS_DEBUG | #ifdef PEGASUS_DEBUG |
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl)); | 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: resultClass = "<<request->resultClass<<PEGASUS_STD(endl)); |
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<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: resultRole = "<<request->resultRole<<PEGASUS_STD(endl)); |
|
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl)); |
#endif | #endif |
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jAssociationName, | jAssociationName, |
|
jPathName, |
jResultClass, | jResultClass, |
jRole, | jRole, |
jResultRole, | jResultRole, |
|
|
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
handler.processing(); | 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); | JMPIjvm::checkException(env); |
| |
jobject jciRet = env->GetObjectArrayElement(jVec,i); |
jobject jciRet = env->GetObjectArrayElement(jAr,i); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
break; | break; |
} | } |
| |
case METHOD_SNIA_PROVIDER20: |
case METHOD_CIMASSOCIATORPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); | jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); | jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
| |
|
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl)); |
#endif | #endif |
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jAssociationName, | jAssociationName, |
jPathName, | jPathName, |
jResultClass, | jResultClass, |
|
|
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | 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); | JMPIjvm::checkException(env); |
| |
jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
jobject jciRet = env->GetObjectArrayElement(jAr,i); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); | jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
|
|
|
JMPIjvm::checkException(env); |
|
|
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); | CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMClass cls; | CIMClass cls; |
| |
|
|
break; | break; |
} | } |
| |
case METHOD_UNKNOWN: |
case METHOD_ASSOCIATORPROVIDER2: |
{ | { |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl)); |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
break; |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
} |
|
} |
|
} |
|
HandlerCatch(handler); |
|
| |
if (env) JMPIjvm::detachThread(); |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
|
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
| |
PEG_METHOD_EXIT(); |
JMPIjvm::checkException(env); |
| |
STAT_COPYDISPATCHER |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
| |
return(response); |
JMPIjvm::checkException(env); |
} |
|
| |
Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw() |
jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString()); |
{ |
jstring jRole = env->NewStringUTF(request->role.getCString()); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorNamesRequest"); |
jstring jResultRole = env->NewStringUTF(request->resultRole.getCString()); |
| |
HandlerIntro(AssociatorNames,message,request,response,handler,Array<CIMObjectPath>()); |
JMPIjvm::checkException(env); |
| |
typedef enum { |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
METHOD_UNKNOWN = 0, |
|
METHOD_PEGASUS_24, |
|
METHOD_SNIA_PROVIDER20 |
|
} METHOD_VERSION; |
|
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
|
JNIEnv *env = NULL; |
|
| |
try { |
#ifdef PEGASUS_DEBUG |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl)); |
"JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2", |
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl)); |
System::getHostName(), |
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl)); |
request->nameSpace.getString(), |
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl)); |
request->objectName.getClassName().getString()); |
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 |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<", assocName = "<<request->assocClass.getString()<<PEGASUS_STD(endl)); |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
joc, |
|
jAssociationName, |
|
jPathName, |
|
jResultClass, |
|
jRole, |
|
jResultRole, |
|
JMPI_INCLUDE_QUALIFIERS, |
|
request->includeClassOrigin, |
|
jPropertyList); |
| |
// make target object path |
JMPIjvm::checkException(env); |
CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(), |
|
request->nameSpace, |
|
request->objectName.getClassName(), |
|
request->objectName.getKeyBindings()); |
|
CIMObjectPath *assocPath = new CIMObjectPath (System::getHostName(), |
|
request->nameSpace, |
|
request->assocClass.getString()); |
|
| |
// resolve provider name |
STAT_PMS_PROVIDEREND; |
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
|
| |
// get cached or load new provider module |
if (joc) |
JMPIProvider::OpProviderHolder ph = |
{ |
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
| |
// convert arguments |
JMPIjvm::checkException(env); |
OperationContext context; |
} |
| |
context.insert(request->operationContext.get(IdentityContainer::NAME)); |
handler.processing(); |
context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
if (jVec) { |
context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
|
JMPIjvm::checkException(env); |
| |
// forward request |
jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
|
CIMClass cls; |
|
|
|
try |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl)); |
|
AutoMutex lock (pr._cimomMutex); |
|
|
|
cls = pr._cimom_handle->getClass(context, |
|
request->nameSpace, |
|
ciRet->getClassName(), |
|
false, |
|
true, |
|
true, |
|
CIMPropertyList()); |
|
DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl)); |
|
} |
|
catch (CIMException e) |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl)); |
|
throw; |
|
} |
|
|
|
const CIMObjectPath& op = ciRet->getPath(); |
|
CIMObjectPath iop = ciRet->buildPath(cls); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
iop.setNameSpace(op.getNameSpace()); |
|
ciRet->setPath(iop); |
|
|
|
handler.deliver(*ciRet); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_ASSOCIATORPROVIDER: |
|
{ |
|
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
|
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString()); |
|
jstring jRole = env->NewStringUTF(request->role.getCString()); |
|
jstring jResultRole = env->NewStringUTF(request->resultRole.getCString()); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
|
|
|
#ifdef PEGASUS_DEBUG |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl)); |
|
#endif |
|
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jAssociationName, |
|
jPathName, |
|
jResultClass, |
|
jRole, |
|
jResultRole, |
|
JMPI_INCLUDE_QUALIFIERS, |
|
request->includeClassOrigin, |
|
jPropertyList); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
if (jVec) { |
|
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
|
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
|
CIMClass cls; |
|
|
|
try |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl)); |
|
AutoMutex lock (pr._cimomMutex); |
|
|
|
cls = pr._cimom_handle->getClass(context, |
|
request->nameSpace, |
|
ciRet->getClassName(), |
|
false, |
|
true, |
|
true, |
|
CIMPropertyList()); |
|
DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl)); |
|
} |
|
catch (CIMException e) |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl)); |
|
throw; |
|
} |
|
|
|
const CIMObjectPath& op = ciRet->getPath(); |
|
CIMObjectPath iop = ciRet->buildPath(cls); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
iop.setNameSpace(op.getNameSpace()); |
|
ciRet->setPath(iop); |
|
|
|
handler.deliver(*ciRet); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_UNKNOWN: |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl)); |
|
break; |
|
} |
|
} |
|
} |
|
HandlerCatch(handler); |
|
|
|
if (env) JMPIjvm::detachThread(); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
return(response); |
|
} |
|
|
|
Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorNamesRequest"); |
|
|
|
HandlerIntro(AssociatorNames,message,request,response,handler,Array<CIMObjectPath>()); |
|
|
|
typedef enum { |
|
METHOD_UNKNOWN = 0, |
|
METHOD_CIMASSOCIATORPROVIDER, |
|
METHOD_CIMASSOCIATORPROVIDER2, |
|
METHOD_ASSOCIATORPROVIDER, |
|
METHOD_ASSOCIATORPROVIDER2 |
|
} METHOD_VERSION; |
|
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
|
JNIEnv *env = NULL; |
|
|
|
try { |
|
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
"JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2", |
|
System::getHostName(), |
|
request->nameSpace.getString(), |
|
request->objectName.getClassName().getString()); |
|
|
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<", assocName = "<<request->assocClass.getString()<<PEGASUS_STD(endl)); |
|
|
|
// make target object path |
|
CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(), |
|
request->nameSpace, |
|
request->objectName.getClassName(), |
|
request->objectName.getKeyBindings()); |
|
CIMObjectPath *assocPath = new CIMObjectPath (System::getHostName(), |
|
request->nameSpace, |
|
request->assocClass.getString()); |
|
|
|
// resolve provider name |
|
ProviderName name = _resolveProviderName( |
|
request->operationContext.get(ProviderIdContainer::NAME)); |
|
|
|
// get cached or load new provider module |
|
JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(), |
|
name.getLogicalName(), |
|
String::EMPTY); |
|
|
|
// forward request |
JMPIProvider &pr = ph.GetProvider(); | JMPIProvider &pr = ph.GetProvider(); |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associatorNames: " + pr.getName()); | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associatorNames: " + pr.getName()); |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | jmethodID id = NULL; |
|
String interfaceType; |
|
String interfaceVersion; |
|
|
|
getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME), |
|
interfaceType, |
|
interfaceVersion); |
| |
// public abstract java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName, |
if (interfaceType == "JMPI") |
|
{ |
|
// public java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName, |
// org.pegasus.jmpi.CIMObjectPath pathName, | // org.pegasus.jmpi.CIMObjectPath pathName, |
// java.lang.String resultClass, | // java.lang.String resultClass, |
// java.lang.String role, | // java.lang.String role, |
|
|
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"associatorNames", | "associatorNames", |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"); | "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"); |
//@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath; Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;" |
|
| |
if (id != NULL) | 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) | if (id == NULL) |
{ | { |
env->ExceptionClear(); | env->ExceptionClear(); |
| |
// public abstract java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName, |
// public org.pegasus.jmpi.CIMObjectPath[] associatorNames (org.pegasus.jmpi.CIMObjectPath assocName, |
|
// org.pegasus.jmpi.CIMObjectPath pathName, |
// java.lang.String resultClass, | // java.lang.String resultClass, |
// java.lang.String role, | // java.lang.String role, |
// java.lang.String resultRole) | // java.lang.String resultRole) |
// throws org.pegasus.jmpi.CIMException | // throws org.pegasus.jmpi.CIMException |
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"associatorNames", | "associatorNames", |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"); |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;"); |
//@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;" |
|
| |
if (id != NULL) | if (id != NULL) |
{ | { |
eMethodFound = METHOD_PEGASUS_24; |
eMethodFound = METHOD_CIMASSOCIATORPROVIDER; |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl)); |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl)); |
|
} |
|
} |
|
} |
|
else if (interfaceType == "JMPIExperimental") |
|
{ |
|
// public java.util.Vector associatorNames (org.pegasus.jmpi.OperationContext oc, |
|
// org.pegasus.jmpi.CIMObjectPath assocName, |
|
// org.pegasus.jmpi.CIMObjectPath pathName, |
|
// java.lang.String resultClass, |
|
// java.lang.String role, |
|
// java.lang.String resultRole) |
|
// throws org.pegasus.jmpi.CIMException |
|
id = env->GetMethodID((jclass)pr.jProviderClass, |
|
"associatorNames", |
|
"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"); |
|
|
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_ASSOCIATORPROVIDER2; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl)); |
|
} |
|
|
|
if (id == NULL) |
|
{ |
|
env->ExceptionClear(); |
|
|
|
// public org.pegasus.jmpi.CIMObjectPath[] associatorNames (org.pegasus.jmpi.OperationContext oc, |
|
// org.pegasus.jmpi.CIMObjectPath assocName, |
|
// org.pegasus.jmpi.CIMObjectPath pathName, |
|
// java.lang.String resultClass, |
|
// java.lang.String role, |
|
// java.lang.String resultRole) |
|
// throws org.pegasus.jmpi.CIMException |
|
id = env->GetMethodID((jclass)pr.jProviderClass, |
|
"associatorNames", |
|
"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;"); |
|
|
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_CIMASSOCIATORPROVIDER2; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl)); |
|
} |
} | } |
} | } |
| |
if (id == NULL) | if (id == NULL) |
{ | { |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found no method!"<<PEGASUS_STD(endl)); | DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found no method!"<<PEGASUS_STD(endl)); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
|
} |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
switch (eMethodFound) |
|
{ |
|
case METHOD_CIMASSOCIATORPROVIDER: |
|
{ |
|
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
|
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString()); |
|
jstring jRole = env->NewStringUTF(request->role.getCString()); |
|
jstring jResultRole = env->NewStringUTF(request->resultRole.getCString()); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
#ifdef PEGASUS_DEBUG |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl)); |
|
#endif |
|
|
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jAssociationName, |
|
jPathName, |
|
jResultClass, |
|
jRole, |
|
jResultRole); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
if (jAr) { |
|
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jcopRet = env->GetObjectArrayElement(jAr,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
|
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
handler.deliver(*copRet); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_CIMASSOCIATORPROVIDER2: |
|
{ |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
|
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString()); |
|
jstring jRole = env->NewStringUTF(request->role.getCString()); |
|
jstring jResultRole = env->NewStringUTF(request->resultRole.getCString()); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
#ifdef PEGASUS_DEBUG |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl)); |
|
#endif |
|
|
|
jobjectArray 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); |
|
|
|
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
|
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
handler.deliver(*copRet); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
} | } |
| |
JMPIjvm::checkException(env); |
case METHOD_ASSOCIATORPROVIDER: |
|
|
switch (eMethodFound) |
|
{ |
|
case METHOD_PEGASUS_24: |
|
{ | { |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); | jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); | jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString()); | jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString()); |
jstring jRole = env->NewStringUTF(request->role.getCString()); | jstring jRole = env->NewStringUTF(request->role.getCString()); |
jstring jResultRole = env->NewStringUTF(request->resultRole.getCString()); | jstring jResultRole = env->NewStringUTF(request->resultRole.getCString()); |
|
|
| |
#ifdef PEGASUS_DEBUG | #ifdef PEGASUS_DEBUG |
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl)); | 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: resultClass = "<<request->resultClass<<PEGASUS_STD(endl)); |
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<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)); | DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl)); |
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jAssociationName, | jAssociationName, |
|
jPathName, |
jResultClass, | jResultClass, |
jRole, | jRole, |
jResultRole); | jResultRole); |
|
|
| |
handler.processing(); | handler.processing(); |
if (jVec) { | 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); | JMPIjvm::checkException(env); |
| |
jobject jcopRet = env->GetObjectArrayElement(jVec,i); |
jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); | jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRet); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
break; | break; |
} | } |
| |
case METHOD_SNIA_PROVIDER20: |
case METHOD_ASSOCIATORPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); | jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); | jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
| |
|
|
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jAssociationName, | jAssociationName, |
jPathName, | jPathName, |
jResultClass, | jResultClass, |
|
|
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | handler.processing(); |
if (jVec) { | if (jVec) { |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { | for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
|
|
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
METHOD_PEGASUS_24, |
METHOD_CIMASSOCIATORPROVIDER, |
METHOD_SNIA_PROVIDER20, |
METHOD_CIMASSOCIATORPROVIDER2, |
|
METHOD_ASSOCIATORPROVIDER, |
|
METHOD_ASSOCIATORPROVIDER2, |
} METHOD_VERSION; | } METHOD_VERSION; |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; | METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env = NULL; | JNIEnv *env = NULL; |
|
|
request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // 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 | // convert arguments |
OperationContext context; | OperationContext context; |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | 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, | // org.pegasus.jmpi.CIMObjectPath pathName, |
// java.lang.String role, | // java.lang.String role, |
// boolean includeQualifiers, | // boolean includeQualifiers, |
|
|
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"references", | "references", |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"); | "(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) | 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) | if (id == NULL) |
{ | { |
env->ExceptionClear(); | 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, | // java.lang.String role, |
// boolean includeQualifiers, | // boolean includeQualifiers, |
// boolean includeClassOrigin, | // boolean includeClassOrigin, |
|
|
// throws org.pegasus.jmpi.CIMException | // throws org.pegasus.jmpi.CIMException |
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"references", | "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) | 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) | if (id == NULL) |
{ | { |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found no method!"<<PEGASUS_STD(endl)); | DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found no method!"<<PEGASUS_STD(endl)); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | switch (eMethodFound) |
{ | { |
case METHOD_PEGASUS_24: |
case METHOD_CIMASSOCIATORPROVIDER: |
{ | { |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); | jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); | jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
jstring jRole = env->NewStringUTF(request->role.getCString()); | jstring jRole = env->NewStringUTF(request->role.getCString()); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
|
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl)); |
#endif | #endif |
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jAssociationName, | jAssociationName, |
|
jPathName, |
jRole, | jRole, |
JMPI_INCLUDE_QUALIFIERS, | JMPI_INCLUDE_QUALIFIERS, |
request->includeClassOrigin, | request->includeClassOrigin, |
|
|
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
handler.processing(); | 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(jAr,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
|
CIMClass cls; |
|
|
|
try |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl)); |
|
AutoMutex lock (pr._cimomMutex); |
|
|
|
cls = pr._cimom_handle->getClass(context, |
|
request->nameSpace, |
|
ciRet->getClassName(), |
|
false, |
|
true, |
|
true, |
|
CIMPropertyList()); |
|
DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl)); |
|
} |
|
catch (CIMException e) |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl)); |
|
throw; |
|
} |
|
|
|
const CIMObjectPath& op = ciRet->getPath(); |
|
CIMObjectPath iop = ciRet->buildPath(cls); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
iop.setNameSpace(op.getNameSpace()); |
|
ciRet->setPath(iop); |
|
|
|
handler.deliver(*ciRet); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_CIMASSOCIATORPROVIDER2: |
|
{ |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
|
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
|
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jstring jRole = env->NewStringUTF(request->role.getCString()); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
|
|
|
#ifdef PEGASUS_DEBUG |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl)); |
|
#endif |
|
|
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
joc, |
|
jAssociationName, |
|
jPathName, |
|
jRole, |
|
JMPI_INCLUDE_QUALIFIERS, |
|
request->includeClassOrigin, |
|
jPropertyList); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
|
handler.processing(); |
|
if (jAr) { |
|
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jciRet = env->GetObjectArrayElement(jAr,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
|
CIMClass cls; |
|
|
|
try |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl)); |
|
AutoMutex lock (pr._cimomMutex); |
|
|
|
cls = pr._cimom_handle->getClass(context, |
|
request->nameSpace, |
|
ciRet->getClassName(), |
|
false, |
|
true, |
|
true, |
|
CIMPropertyList()); |
|
DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl)); |
|
} |
|
catch (CIMException e) |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl)); |
|
throw; |
|
} |
|
|
|
const CIMObjectPath& op = ciRet->getPath(); |
|
CIMObjectPath iop = ciRet->buildPath(cls); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
iop.setNameSpace(op.getNameSpace()); |
|
ciRet->setPath(iop); |
|
|
|
handler.deliver(*ciRet); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_ASSOCIATORPROVIDER: |
|
{ |
|
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
|
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jstring jRole = env->NewStringUTF(request->role.getCString()); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
|
|
|
#ifdef PEGASUS_DEBUG |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl)); |
|
#endif |
|
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jAssociationName, |
|
jPathName, |
|
jRole, |
|
JMPI_INCLUDE_QUALIFIERS, |
|
request->includeClassOrigin, |
|
jPropertyList); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobject jciRet = env->GetObjectArrayElement(jVec,i); |
STAT_PMS_PROVIDEREND; |
| |
|
handler.processing(); |
|
if (jVec) { |
|
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); | CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMClass cls; | CIMClass cls; |
| |
|
|
break; | break; |
} | } |
| |
case METHOD_SNIA_PROVIDER20: |
case METHOD_ASSOCIATORPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); | jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); | jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
| |
|
|
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jAssociationName, | jAssociationName, |
jPathName, | jPathName, |
jRole, | jRole, |
|
|
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | handler.processing(); |
if (jVec) { | if (jVec) { |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { | for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
|
|
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
METHOD_PEGASUS_24, |
METHOD_CIMASSOCIATORPROVIDER, |
METHOD_SNIA_PROVIDER20, |
METHOD_CIMASSOCIATORPROVIDER2, |
|
METHOD_ASSOCIATORPROVIDER, |
|
METHOD_ASSOCIATORPROVIDER2, |
} METHOD_VERSION; | } METHOD_VERSION; |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; | METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env = NULL; | JNIEnv *env = NULL; |
|
|
request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // 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(); | JMPIProvider &pr = ph.GetProvider(); |
| |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | jmethodID id = NULL; |
|
String interfaceType; |
|
String interfaceVersion; |
| |
// public abstract java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName, |
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, | // org.pegasus.jmpi.CIMObjectPath pathName, |
// java.lang.String role) | // java.lang.String role) |
// throws org.pegasus.jmpi.CIMException | // throws org.pegasus.jmpi.CIMException |
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"referenceNames", | "referenceNames", |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;"); | "(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) | if (id != NULL) |
{ | { |
eMethodFound = METHOD_SNIA_PROVIDER20; |
eMethodFound = METHOD_ASSOCIATORPROVIDER; |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl)); |
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) | if (id == NULL) |
{ | { |
env->ExceptionClear(); | env->ExceptionClear(); |
| |
// public abstract java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName, |
// 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) | // java.lang.String role) |
// throws org.pegasus.jmpi.CIMException | // throws org.pegasus.jmpi.CIMException |
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"referenceNames", | "referenceNames", |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;"); |
"(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;"); |
//@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;" |
|
| |
if (id != NULL) | if (id != NULL) |
{ | { |
eMethodFound = METHOD_PEGASUS_24; |
eMethodFound = METHOD_CIMASSOCIATORPROVIDER2; |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl)); |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl)); |
|
} |
} | } |
} | } |
| |
if (id == NULL) | if (id == NULL) |
{ | { |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found no method!"<<PEGASUS_STD(endl)); | DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found no method!"<<PEGASUS_STD(endl)); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | switch (eMethodFound) |
{ | { |
case METHOD_PEGASUS_24: |
case METHOD_CIMASSOCIATORPROVIDER: |
|
{ |
|
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
|
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jstring jRole = env->NewStringUTF(request->role.getCString()); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
#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 |
|
|
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jPathName, |
|
jAssociationName, |
|
jRole); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
if (jAr) { |
|
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jcopRet = env->GetObjectArrayElement(jAr,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
|
|
|
handler.deliver(*copRet); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_CIMASSOCIATORPROVIDER2: |
|
{ |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
|
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
|
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jstring jRole = env->NewStringUTF(request->role.getCString()); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
#ifdef PEGASUS_DEBUG |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl)); |
|
#endif |
|
|
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
joc, |
|
jPathName, |
|
jAssociationName, |
|
jRole); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
|
handler.processing(); |
|
if (jAr) { |
|
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jcopRet = env->GetObjectArrayElement(jAr,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
|
|
|
handler.deliver(*copRet); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_ASSOCIATORPROVIDER: |
{ | { |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); | jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); | jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
jstring jRole = env->NewStringUTF(request->role.getCString()); | jstring jRole = env->NewStringUTF(request->role.getCString()); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
#ifdef PEGASUS_DEBUG | #ifdef PEGASUS_DEBUG |
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl)); | 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)); | DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl)); |
#endif | #endif |
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jAssociationName, | jAssociationName, |
|
jPathName, |
jRole); | jRole); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
|
|
| |
handler.processing(); | handler.processing(); |
if (jVec) { | 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); | JMPIjvm::checkException(env); |
| |
jobject jcopRet = env->GetObjectArrayElement(jVec,i); |
jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
break; | break; |
} | } |
| |
case METHOD_SNIA_PROVIDER20: |
case METHOD_ASSOCIATORPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); | jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); | jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
| |
|
|
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jAssociationName, | jAssociationName, |
jPathName, | jPathName, |
jRole); | jRole); |
|
|
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | handler.processing(); |
if (jVec) { | if (jVec) { |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { | for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
|
|
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
METHOD_SNIA_PROVIDER20, |
METHOD_PROPERTYPROVIDER, |
|
METHOD_PROPERTYPROVIDER2, |
} METHOD_VERSION; | } METHOD_VERSION; |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; | METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env = NULL; | JNIEnv *env = NULL; |
|
|
request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // 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 | // forward request |
JMPIProvider &pr = ph.GetProvider(); | JMPIProvider &pr = ph.GetProvider(); |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | 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, | // public abstract org.pegasus.jmpi.CIMValue getPropertyValue (org.pegasus.jmpi.CIMObjectPath cop, |
// java.lang.String oclass, | // java.lang.String oclass, |
// java.lang.String pName) | // java.lang.String pName) |
|
|
| |
if (id != NULL) | 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) | if (id == NULL) |
{ | { |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found no method!"<<PEGASUS_STD(endl)); | DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found no method!"<<PEGASUS_STD(endl)); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | switch (eMethodFound) |
{ | { |
case METHOD_SNIA_PROVIDER20: |
case METHOD_PROPERTYPROVIDER: |
|
{ |
|
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString()); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString()); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_GETSTARTTIME; |
|
|
|
jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider, |
|
id, |
|
jcop, |
|
joclass, |
|
jpName); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
|
|
if (jvalRet) |
|
{ |
|
jint jvalRetRef = env->CallIntMethod(jvalRet,JMPIjvm::jv.CIMValueCInst); |
|
CIMValue *valRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jvalRetRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
handler.deliver(*valRet); |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_PROPERTYPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
| |
|
|
| |
jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider, | jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jcop, | jcop, |
joclass, | joclass, |
jpName); | jpName); |
|
|
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | handler.processing(); |
| |
if (jvalRet) | if (jvalRet) |
|
|
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
METHOD_SNIA_PROVIDER20, |
METHOD_PROPERTYPROVIDER, |
|
METHOD_PROPERTYPROVIDER2, |
} METHOD_VERSION; | } METHOD_VERSION; |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; | METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env = NULL; | JNIEnv *env = NULL; |
|
|
request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // 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 | // forward request |
JMPIProvider &pr = ph.GetProvider(); | JMPIProvider &pr = ph.GetProvider(); |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | 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, | // public abstract void setPropertyValue (org.pegasus.jmpi.CIMObjectPath cop, |
// java.lang.String oclass, | // java.lang.String oclass, |
// java.lang.String pName, | // java.lang.String pName, |
|
|
| |
if (id != NULL) | 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) | if (id == NULL) |
{ | { |
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found no method!"<<PEGASUS_STD(endl)); | DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found no method!"<<PEGASUS_STD(endl)); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | switch (eMethodFound) |
{ | { |
case METHOD_SNIA_PROVIDER20: |
case METHOD_PROPERTYPROVIDER: |
|
{ |
|
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString()); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString()); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
CIMValue *val = new CIMValue (request->newValue); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jvalref = DEBUG_ConvertCToJava (CIMValue*, jint, val); |
|
jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewI, jvalref); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_GETSTARTTIME; |
|
|
|
env->CallVoidMethod ((jobject)pr.jProvider, |
|
id, |
|
jcop, |
|
joclass, |
|
jpName, |
|
jval); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
break; |
|
} |
|
|
|
case METHOD_PROPERTYPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
| |
|
|
| |
env->CallVoidMethod ((jobject)pr.jProvider, | env->CallVoidMethod ((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jcop, | jcop, |
joclass, | joclass, |
jpName, | jpName, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
break; | break; |
} | } |
|
|
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
METHOD_PEGASUS_24, |
METHOD_CIMMETHODPROVIDER, |
METHOD_SNIA_PROVIDER20, |
METHOD_CIMMETHODPROVIDER2, |
|
METHOD_METHODPROVIDER, |
|
METHOD_METHODPROVIDER2, |
} METHOD_VERSION; | } METHOD_VERSION; |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; | METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env = NULL; | JNIEnv *env = NULL; |
|
|
request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // 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(); | JMPIProvider &pr=ph.GetProvider(); |
| |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | 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, | // public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath cop, |
// java.lang.String name, | // java.lang.String name, |
// java.util.Vector in, | // java.util.Vector in, |
|
|
| |
if (id != NULL) | 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) | if (id == NULL) |
|
|
| |
if (id != NULL) | 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(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | switch (eMethodFound) |
{ | { |
case METHOD_PEGASUS_24: |
case METHOD_CIMMETHODPROVIDER: |
|
{ |
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,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]); |
|
jint jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm); |
|
jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jArgRef); |
|
|
|
env->SetObjectArrayElement(jArIn,i,jArg); |
|
} |
|
|
|
jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL); |
|
|
|
jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jcop, |
|
jMethod, |
|
jArIn, |
|
jArOut); |
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
|
|
jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); |
|
CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, 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; |
|
|
|
jint jpRef = env->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst); |
|
CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jpRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
handler.deliverParamValue(*p); |
|
} |
|
|
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_CIMMETHODPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
| |
|
|
| |
jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, | jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jcop, | jcop, |
jMethod, | jMethod, |
jArIn, | jArIn, |
|
|
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | handler.processing(); |
| |
jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); | jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); |
|
|
break; | break; |
} | } |
| |
case METHOD_SNIA_PROVIDER20: |
case METHOD_METHODPROVIDER: |
|
{ |
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
|
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,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()); |
|
jint jpRef = DEBUG_ConvertCToJava (CIMProperty*, jint, p); |
|
jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jpRef); |
|
|
|
env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp); |
|
} |
|
|
|
jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew); |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jcop, |
|
jMethod, |
|
jVecIn, |
|
jVecOut); |
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
|
|
jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); |
|
CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, 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); |
|
|
|
jint jpRef = env->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst); |
|
CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jpRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue())); |
|
} |
|
|
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_METHODPROVIDER2: |
{ | { |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); | jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
| |
|
|
| |
jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, | jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
joc, |
jcop, | jcop, |
jMethod, | jMethod, |
jVecIn, | jVecIn, |
|
|
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
|
if (joc) |
|
{ |
|
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
|
JMPIjvm::checkException(env); |
|
} |
|
|
handler.processing(); | handler.processing(); |
| |
jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); | jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); |
|
|
return 0; | 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() | Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleCreateSubscriptionRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleCreateSubscriptionRequest"); |
|
|
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
METHOD_SNIA_PROVIDER20, |
METHOD_EVENTPROVIDER, |
|
METHOD_EVENTPROVIDER2, |
} METHOD_VERSION; | } METHOD_VERSION; |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; | METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env = NULL; | JNIEnv *env = NULL; |
| |
try { | try { |
String providerName, |
String fileName, |
|
providerName, |
providerLocation; | providerLocation; |
CIMInstance req_provider, | CIMInstance req_provider, |
req_providerModule; | req_providerModule; |
|
|
ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME); | ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME); |
| |
req_provider = pidc.getProvider(); | req_provider = pidc.getProvider(); |
req_providerModule = pidc.getModule(); | 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::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2", | "JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2", |
System::getHostName(), | System::getHostName(), |
request->nameSpace.getString(), | request->nameSpace.getString(), |
providerName); | providerName); |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl)); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: 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 | // 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; |
|
|
|
provTab.lookup(providerName,prec); |
|
|
|
if (prec) |
|
{ |
|
prec->count++; |
|
} |
|
else |
|
{ |
|
prec=new indProvRecord(); |
|
provTab.insert(providerName,prec); |
|
} |
|
| |
// | // |
// Save the provider instance from the request | // Save the provider instance from the request |
// | // |
ph.GetProvider ().setProviderInstance (req_provider); | ph.GetProvider ().setProviderInstance (req_provider); |
| |
indSelectRecord *srec = new indSelectRecord(); |
JMPIProvider &pr = ph.GetProvider (); |
const CIMObjectPath &sPath = request->subscriptionInstance.getPath(); |
|
| |
selxTab.insert(sPath.toString(),srec); |
// |
|
// Increment count of current subscriptions for this provider |
|
// |
|
pr.testIfZeroAndIncrementSubscriptions (); |
| |
// convert arguments |
SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get (SubscriptionFilterConditionContainer::NAME); |
OperationContext *context=new OperationContext(); |
indProvRecord *prec = NULL; |
|
bool fNewPrec = false; |
| |
if (prec->ctx==NULL) |
|
{ | { |
prec->ctx=context; |
AutoMutex lock (mutexProvTab); |
} |
|
| |
context->insert(request->operationContext.get(IdentityContainer::NAME)); |
provTab.lookup (providerName, prec); |
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(SubscriptionFilterConditionContainer::NAME)); |
|
| |
CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); |
if (!prec) |
|
{ |
|
fNewPrec = true; |
| |
SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get |
prec = new indProvRecord (); |
(SubscriptionFilterConditionContainer::NAME); |
|
| |
JMPIProvider &pr = ph.GetProvider(); |
// convert arguments |
|
prec->ctx = new OperationContext (); |
| |
CIMOMHandleQueryContext *qcontext=new CIMOMHandleQueryContext(CIMNamespaceName(request->nameSpace.getString()), |
prec->ctx->insert (request->operationContext.get (IdentityContainer::NAME)); |
*pr._cimom_handle); |
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)); |
| |
CMPI_SelectExp *eSelx = new CMPI_SelectExp(*context, |
prec->enabled = true; |
qcontext, |
|
request->query, |
|
sub_cntr.getQueryLanguage()); |
|
| |
srec->eSelx=eSelx; |
prec->handler = new EnableIndicationsResponseHandler (0, |
srec->qContext=qcontext; |
0, |
|
req_provider, |
|
_indicationCallback, |
|
_responseChunkCallback); |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createSubscriptionRequest: " + pr.getName()); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Adding to provTab "<<providerName<<PEGASUS_STD(endl)); |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Calling provider createSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl)); |
provTab.insert (providerName, prec); |
|
} |
|
} |
| |
for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) { |
{ |
CIMObjectPath className( |
AutoMutex lock (prec->mutex); |
System::getHostName(), |
|
request->nameSpace, |
prec->count++; |
request->classNames[i]); |
|
eSelx->classNames.append(className); |
|
} | } |
| |
CIMPropertyList propertyList = request->propertyList; |
// Add a selection record for JNI CIMOMHandle deliverEvent calls |
|
indSelectRecord *srec = new indSelectRecord (); |
| |
if (!propertyList.isNull()) |
|
{ | { |
Array<CIMName> p = propertyList.getPropertyNameArray(); |
srec->query = request->query; |
int pCount = p.size(); |
srec->queryLanguage = sub_cntr.getQueryLanguage (); |
|
srec->propertyList = request->propertyList; |
| |
eSelx->props=(const char**)malloc((1+pCount)*sizeof(char*)); |
CIMOMHandleQueryContext *qContext = new CIMOMHandleQueryContext (CIMNamespaceName (request->nameSpace.getString ()), |
|
*pr._cimom_handle); |
|
srec->qContext = qContext; |
| |
for (int i=0; i<pCount; i++) |
CIMObjectPath sPath (request->subscriptionInstance.getPath ().getClassName ().getString ()); |
{ |
|
eSelx->props[i]=strdup(p[i].getString().getCString()); |
sPath.setNameSpace (request->subscriptionInstance.getPath ().getNameSpace ()); |
} |
|
eSelx->props[pCount]=NULL; |
AutoMutex lock (mutexSelxTab); |
|
|
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Adding to selxTab "<<sPath.toString ()<<PEGASUS_STD(endl)); |
|
|
|
selxTab.insert (sPath.toString (), srec); |
|
|
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: For selxTab "<<sPath.toString ()<<", srec = "<<PEGASUS_STD(hex)<<(int)srec<<PEGASUS_STD(dec)<<", qContext = "<<PEGASUS_STD(hex)<<(int)qContext<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
} | } |
| |
|
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)); |
|
|
JvmVector *jv = 0; | JvmVector *jv = 0; |
| |
env = JMPIjvm::attachThread(&jv); | env = JMPIjvm::attachThread(&jv); |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | jmethodID id = NULL; |
|
String interfaceType; |
|
String interfaceVersion; |
|
|
|
getInterfaceType (pidc, |
|
interfaceType, |
|
interfaceVersion); |
| |
|
if (interfaceType == "JMPI") |
|
{ |
// public void activateFilter (org.pegasus.jmpi.SelectExp filter, | // public void activateFilter (org.pegasus.jmpi.SelectExp filter, |
// java.lang.String eventType, | // java.lang.String eventType, |
// org.pegasus.jmpi.CIMObjectPath classPath, | // org.pegasus.jmpi.CIMObjectPath classPath, |
// java.lang.String owner) |
// boolean firstActivation) |
// throws org.pegasus.jmpi.CIMException | // throws org.pegasus.jmpi.CIMException |
id = env->GetMethodID((jclass)pr.jProviderClass, | id = env->GetMethodID((jclass)pr.jProviderClass, |
"activateFilter", | "activateFilter", |
|
|
| |
if (id != NULL) | 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(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | 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); |
|
jint jStmtRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, stmt); |
|
jobject jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jStmtRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString()); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]); |
CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), |
|
request->nameSpace, |
|
request->classNames[0]); |
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); | jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
env->CallVoidMethod ((jobject)pr.jProvider, |
|
id, |
|
jSelectExp, |
|
jType, |
|
jcop, |
|
(jboolean)fNewPrec); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
break; |
|
} |
|
|
|
case METHOD_EVENTPROVIDER2: |
|
{ |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
|
|
|
WQLSelectStatement *stmt = newSelectExp (srec->query, |
|
srec->queryLanguage); |
|
jint jStmtRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, stmt); |
|
jobject jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jStmtRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString()); | jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString()); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), |
|
request->nameSpace, |
|
request->classNames[0]); |
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
|
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
env->CallVoidMethod((jobject)pr.jProvider, | env->CallVoidMethod((jobject)pr.jProvider, |
id, | id, |
jSel, |
joc, |
|
jSelectExp, |
jType, | jType, |
jcop, | jcop, |
(jboolean)0); |
(jboolean)fNewPrec); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
// |
if (joc) |
// Increment count of current subscriptions for this provider |
|
// |
|
if (ph.GetProvider ().testIfZeroAndIncrementSubscriptions ()) |
|
{ | { |
// |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
// If there were no current subscriptions before the increment, |
|
// the first subscription has been created |
JMPIjvm::checkException(env); |
// Call the provider's enableIndications method |
|
// |
|
if (_subscriptionInitComplete) |
|
{ |
|
prec->enabled = true; |
|
CIMRequestMessage * request = 0; |
|
CIMResponseMessage * response = 0; |
|
prec->handler = new EnableIndicationsResponseHandler |
|
(request, response, req_provider, _indicationCallback); |
|
} |
|
} | } |
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
|
|
break; | break; |
} | } |
} | } |
|
|
} | } |
HandlerCatch(handler); | HandlerCatch(handler); |
| |
|
|
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
METHOD_SNIA_PROVIDER20, |
METHOD_EVENTPROVIDER, |
|
METHOD_EVENTPROVIDER2, |
} METHOD_VERSION; | } METHOD_VERSION; |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; | METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env = NULL; | JNIEnv *env = NULL; |
|
bool fFreePrec = false; |
|
indProvRecord *prec = NULL; |
|
indSelectRecord *srec = NULL; |
| |
try { | try { |
String providerName, |
String fileName, |
|
providerName, |
providerLocation; | providerLocation; |
CIMInstance req_provider, | CIMInstance req_provider, |
req_providerModule; | req_providerModule; |
|
|
req_provider = pidc.getProvider(); | req_provider = pidc.getProvider(); |
req_providerModule = pidc.getModule(); | 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", | "JMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2", |
System::getHostName(), | System::getHostName(), |
request->nameSpace.getString(), | request->nameSpace.getString(), |
providerName); | 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 | // 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); | provTab.lookup(providerName,prec); |
|
} |
|
|
|
{ |
|
AutoMutex lock (prec->mutex); |
|
|
if (--prec->count <= 0) | if (--prec->count <= 0) |
{ | { |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Removing provTab "<<providerName<<PEGASUS_STD(endl)); |
|
|
provTab.remove(providerName); | provTab.remove(providerName); |
prec=NULL; |
|
|
fFreePrec = true; |
|
} |
} | } |
| |
indSelectRecord *srec = NULL; |
{ |
const CIMObjectPath &sPath = request->subscriptionInstance.getPath(); |
CIMObjectPath sPath (request->subscriptionInstance.getPath ().getClassName ().getString ()); |
String sPathString = sPath.toString(); |
|
| |
selxTab.lookup(sPathString,srec); |
sPath.setNameSpace (request->subscriptionInstance.getPath ().getNameSpace ()); |
| |
CMPI_SelectExp *eSelx = srec->eSelx; |
String sPathString = sPath.toString (); |
CIMOMHandleQueryContext *qContext = srec->qContext; |
|
| |
selxTab.remove(sPathString); |
AutoMutex lock (mutexSelxTab); |
| |
// convert arguments |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Removing selxTab "<<sPathString<<PEGASUS_STD(endl)); |
OperationContext context; |
|
| |
context.insert(request->operationContext.get(IdentityContainer::NAME)); |
selxTab.lookup (sPathString, srec); |
context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
|
context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
|
context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME)); |
|
| |
CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: For selxTab "<<sPathString<<", srec = "<<PEGASUS_STD(hex)<<(int)srec<<PEGASUS_STD(dec)<<", qContext = "<<PEGASUS_STD(hex)<<(int)srec->qContext<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
| |
JMPIProvider & pr=ph.GetProvider(); |
selxTab.remove (sPathString); |
|
} |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteSubscriptionRequest: " + pr.getName()); | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteSubscriptionRequest: " + pr.getName()); |
| |
|
|
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id = NULL; | 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, | // public void deActivateFilter (org.pegasus.jmpi.SelectExp filter, |
// java.lang.String eventType, | // java.lang.String eventType, |
// org.pegasus.jmpi.CIMObjectPath classPath, | // org.pegasus.jmpi.CIMObjectPath classPath, |
|
|
| |
if (id != NULL) | 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(); |
|
|
|
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
|
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
|
"Could not find a method for the provider based on InterfaceType.")); |
} | } |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
switch (eMethodFound) | 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); |
|
jint jStmtRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, stmt); |
|
jobject jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,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]); |
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
|
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
env->CallVoidMethod ((jobject)pr.jProvider, |
|
id, |
|
jSelectExp, |
|
jType, |
|
jcop, |
|
(jboolean)fFreePrec); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]); |
STAT_PMS_PROVIDEREND; |
|
break; |
|
} |
|
|
|
case METHOD_EVENTPROVIDER2: |
|
{ |
|
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
|
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
| |
jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj); |
WQLSelectStatement *stmt = newSelectExp (srec->query, |
|
srec->queryLanguage); |
|
jint jStmtRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, stmt); |
|
jobject jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jStmtRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), |
|
request->nameSpace, |
|
request->classNames[0]); |
|
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
|
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
env->CallVoidMethod((jobject)pr.jProvider, | env->CallVoidMethod((jobject)pr.jProvider, |
id, | id, |
jSel, |
joc, |
|
jSelectExp, |
jType, | jType, |
jRef, |
jcop, |
(jboolean)(prec==NULL)); |
(jboolean)fFreePrec); |
| |
JMPIjvm::checkException(env); | 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; |
JMPIjvm::checkException(env); |
} |
|
} | } |
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
|
|
delete eSelx; |
|
delete qContext; |
|
delete srec; |
|
break; | break; |
} | } |
| |
|
|
break; | break; |
} | } |
} | } |
|
|
|
// |
|
// Decrement count of current subscriptions for this provider |
|
// |
|
pr.decrementSubscriptionsAndTestIfZero (); |
} | } |
HandlerCatch(handler); | HandlerCatch(handler); |
| |
|
if (srec) |
|
{ |
|
delete srec->qContext; |
|
} |
|
delete srec; |
|
|
|
if (fFreePrec) |
|
{ |
|
delete prec->ctx; |
|
delete prec->handler; |
|
delete prec; |
|
} |
|
|
if (env) JMPIjvm::detachThread(); | if (env) JMPIjvm::detachThread(); |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
|
request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| |
// get cached or load new provider module | // 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); | HandlerCatch(handler); |
|
|
// provider's enableIndications method | // provider's enableIndications method |
// | // |
Array <JMPIProvider *> enableProviders; | Array <JMPIProvider *> enableProviders; |
|
|
enableProviders = providerManager.getIndicationProvidersToEnable (); | enableProviders = providerManager.getIndicationProvidersToEnable (); |
| |
Uint32 numProviders = enableProviders.size (); | Uint32 numProviders = enableProviders.size (); |
|
|
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSubscriptionInitCompleteRequest: numProviders = "<<numProviders<<PEGASUS_STD(endl)); |
|
|
|
#if 0 |
for (Uint32 i = 0; i < numProviders; i++) | for (Uint32 i = 0; i < numProviders; i++) |
{ | { |
try | try |
{ | { |
CIMInstance provider; | CIMInstance provider; |
|
|
provider = enableProviders [i]->getProviderInstance (); | provider = enableProviders [i]->getProviderInstance (); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSubscriptionInitCompleteRequest: name = "<<enableProviders[i]->getName ()<<PEGASUS_STD(endl)); |
|
|
// | // |
// Get cached or load new provider module | // 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 ()); | enableProviders [i]->getName ()); |
|
|
indProvRecord * prec = NULL; | 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) | catch (CIMException & e) |
|
|
"Unknown error in handleSubscriptionInitCompleteRequest"); | "Unknown error in handleSubscriptionInitCompleteRequest"); |
} | } |
} | } |
|
#endif |
| |
PEG_METHOD_EXIT (); | PEG_METHOD_EXIT (); |
return (response); | return (response); |