version 1.46, 2006/05/09 16:14:26
|
version 1.59.4.2, 2007/07/07 01:35:43
|
|
|
// | // |
//============================================================================== | //============================================================================== |
// | // |
// Author: Adrian Schuur, schuur@de.ibm.com |
|
// |
|
// Modified By: Seema Gupta (gseema@in.ibm.com) for PEP135 |
|
// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for PEP#101 |
|
// |
|
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
|
// NOCHKSRC |
| |
#include "JMPIProviderManager.h" | #include "JMPIProviderManager.h" |
| |
|
|
#include <Pegasus/Common/Logger.h> | #include <Pegasus/Common/Logger.h> |
#include <Pegasus/Common/MessageLoader.h> //l10n | #include <Pegasus/Common/MessageLoader.h> //l10n |
#include <Pegasus/Common/Constants.h> | #include <Pegasus/Common/Constants.h> |
|
#include <Pegasus/Common/FileSystem.h> |
|
#include <Pegasus/Common/ArrayInternal.h> |
| |
#include <Pegasus/Config/ConfigManager.h> | #include <Pegasus/Config/ConfigManager.h> |
| |
#include <Pegasus/ProviderManager2/ProviderName.h> | #include <Pegasus/ProviderManager2/ProviderName.h> |
#include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h> | #include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h> |
#include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.h> | #include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.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 |
|
|
for (int i = 0; i < (int)(sizeof (methodNames)/sizeof (methodNames[0])); i++) | for (int i = 0; i < (int)(sizeof (methodNames)/sizeof (methodNames[0])); i++) |
{ | { |
jmethodID id = env->GetMethodID(jc,methodNames[i][1], methodNames[i][2]); | jmethodID id = env->GetMethodID(jc,methodNames[i][1], methodNames[i][2]); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: "<<methodNames[i][0]<<", "<<methodNames[i][1]<<", id = "<<PEGASUS_STD(hex)<<(int)id<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: "<<methodNames[i][0]<<", "<<methodNames[i][1]<<", id = "<<PEGASUS_STD(hex)<<(long)id<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
env->ExceptionClear(); | env->ExceptionClear(); |
} | } |
| |
|
|
JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg; | JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg; |
Mutex JMPIProviderManager::mutexProvReg; | Mutex JMPIProviderManager::mutexProvReg; |
| |
JMPIProviderManager::JMPIProviderManager(Mode m) |
JMPIProviderManager::JMPIProviderManager() |
{ | { |
mode=m; |
|
_subscriptionInitComplete = false; | _subscriptionInitComplete = false; |
| |
#ifdef PEGASUS_DEBUG | #ifdef PEGASUS_DEBUG |
|
|
#define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL) | #define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL) |
| |
| |
#define HandlerIntroBase(type,type1,message,request,response,handler,respType) \ |
#define HandlerIntroBase(type,type1,message,request,response,handler) \ |
CIM##type##RequestMessage * request = \ | CIM##type##RequestMessage * request = \ |
dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *>(message)); \ | dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *>(message)); \ |
PEGASUS_ASSERT(request != 0); \ | PEGASUS_ASSERT(request != 0); \ |
CIM##type##ResponseMessage * response = \ | CIM##type##ResponseMessage * response = \ |
new CIM##type##ResponseMessage( \ |
dynamic_cast<CIM##type##ResponseMessage*>(request->buildResponse()); \ |
request->messageId, \ |
|
CIMException(), \ |
|
request->queueIds.copyAndPop() \ |
|
respType \ |
|
PEGASUS_ASSERT(response != 0); \ | PEGASUS_ASSERT(response != 0); \ |
response->setKey(request->getKey()); \ |
|
response->setHttpMethod(request->getHttpMethod()); \ |
|
type1##ResponseHandler handler(request, response, _responseChunkCallback); | type1##ResponseHandler handler(request, response, _responseChunkCallback); |
| |
#define VOIDINTRO ); |
|
#define NOVOIDINTRO(type) ,type); |
|
#define METHODINTRO ,CIMValue(), Array<CIMParamValue>(), request->methodName ); |
|
|
|
|
|
#define HandlerIntroVoid(type,message,request,response,handler) \ |
|
HandlerIntroBase(type,type,message,request,response,handler,VOIDINTRO) |
|
|
|
#define HandlerIntroMethod(type,message,request,response,handler) \ |
|
HandlerIntroBase(type,type,message,request,response,handler,METHODINTRO) |
|
|
|
#define HandlerIntroInd(type,message,request,response,handler) \ | #define HandlerIntroInd(type,message,request,response,handler) \ |
HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO) |
HandlerIntroBase(type,Operation,message,request,response,handler) |
| |
#define HandlerIntroInit(type,message,request,response,handler) \ | #define HandlerIntroInit(type,message,request,response,handler) \ |
HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO) |
HandlerIntroBase(type,Operation,message,request,response,handler) |
| |
#define HandlerIntro(type,message,request,response,handler,respType) \ |
#define HandlerIntro(type,message,request,response,handler) \ |
HandlerIntroBase(type,type,message,request,response,handler,NOVOIDINTRO(respType)) |
HandlerIntroBase(type,type,message,request,response,handler) |
| |
#define HandlerCatch(handler) \ | #define HandlerCatch(handler) \ |
catch(CIMException & e) \ | catch(CIMException & e) \ |
|
|
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); \ | handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); \ |
} \ | } \ |
catch(...) \ | catch(...) \ |
{ PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \ |
{ PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \ |
"Exception: Unknown"); \ | "Exception: Unknown"); \ |
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \ | handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \ |
} | } |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetInstanceRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetInstanceRequest"); |
| |
HandlerIntro(GetInstance,message,request,response,handler,CIMInstance()); |
HandlerIntro(GetInstance,message,request,response,handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_CIMINSTANCEPROVIDER: | case METHOD_CIMINSTANCEPROVIDER: |
{ | { |
jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef); |
jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); | jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider, | jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jop, | jop, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); | handler.processing(); |
| |
if (jciRet) { | if (jciRet) { |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
| |
handler.deliver(*ciRet); | handler.deliver(*ciRet); |
} | } |
|
|
/* Fix for 4238 */ | /* Fix for 4238 */ |
case METHOD_INSTANCEPROVIDER2: | case METHOD_INSTANCEPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef); |
jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); | jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
|
|
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider, | jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
handler.processing(); | handler.processing(); |
| |
if (jciRet) { | if (jciRet) { |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
| |
handler.deliver(*ciRet); | handler.deliver(*ciRet); |
} | } |
|
|
| |
case METHOD_INSTANCEPROVIDER: | case METHOD_INSTANCEPROVIDER: |
{ | { |
jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef); |
jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
// Modified for Bugzilla# 3679 | // Modified for Bugzilla# 3679 |
jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider, | jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); | handler.processing(); |
| |
if (jciRet) { | if (jciRet) { |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
| |
handler.deliver(*ciRet); | handler.deliver(*ciRet); |
} | } |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleEnumerateInstanceRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleEnumerateInstanceRequest"); |
| |
HandlerIntro(EnumerateInstances,message,request,response,handler,Array<CIMInstance>()); |
HandlerIntro(EnumerateInstances,message,request,response,handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_CIMINSTANCEPROVIDER: | case METHOD_CIMINSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef); |
jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jccRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); | jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
|
|
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jcop, | jcop, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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++) { |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
| |
/* Fix for 4237 */ | /* Fix for 4237 */ |
CIMClass cls; | CIMClass cls; |
|
|
| |
case METHOD_CIMINSTANCEPROVIDER2: | case METHOD_CIMINSTANCEPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef); |
jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jccRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); | jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
|
|
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
| |
/* Fix for 4237 */ | /* Fix for 4237 */ |
CIMClass cls; | CIMClass cls; |
|
|
/* Fix for 4189 */ | /* Fix for 4189 */ |
case METHOD_INSTANCEPROVIDER2: | case METHOD_INSTANCEPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef); |
jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jccRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); | jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
|
|
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, | jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
| |
/* Fix for 4237 */ | /* Fix for 4237 */ |
CIMClass cls; | CIMClass cls; |
|
|
| |
case METHOD_INSTANCEPROVIDER: | case METHOD_INSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef); |
jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jccRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
// Modified for Bugzilla# 3679 | // Modified for Bugzilla# 3679 |
jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, | jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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++) { |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
| |
/* Fix for 4237 */ | /* Fix for 4237 */ |
CIMClass cls; | CIMClass cls; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest"); |
| |
HandlerIntro(EnumerateInstanceNames,message,request,response, handler,Array<CIMObjectPath>()); |
HandlerIntro(EnumerateInstanceNames,message,request,response, handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_CIMINSTANCEPROVIDER: | case METHOD_CIMINSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jcop, | jcop, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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++) { |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
case METHOD_CIMINSTANCEPROVIDER2: | case METHOD_CIMINSTANCEPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
case METHOD_INSTANCEPROVIDER2: | case METHOD_INSTANCEPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, | jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
case METHOD_INSTANCEPROVIDER: | case METHOD_INSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef); |
jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcimClassRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, | jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jcop, | jcop, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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++) { |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleCreateInstanceRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleCreateInstanceRequest"); |
| |
HandlerIntro(CreateInstance,message,request,response,handler,CIMObjectPath()); |
HandlerIntro(CreateInstance,message,request,response,handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_INSTANCEPROVIDER: | case METHOD_INSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMInstance *ci = new CIMInstance (request->newInstance); | CIMInstance *ci = new CIMInstance (request->newInstance); |
jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci); |
jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci); |
jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef); |
jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewJ,jciRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl)); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider, | jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jcop, | jcop, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); | handler.processing(); |
| |
if (jcopRet) { | if (jcopRet) { |
jint jCopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jCopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCopRetRef); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCopRetRef); |
| |
handler.deliver(*copRet); | handler.deliver(*copRet); |
} | } |
|
|
| |
case METHOD_INSTANCEPROVIDER2: | case METHOD_INSTANCEPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMInstance *ci = new CIMInstance (request->newInstance); | CIMInstance *ci = new CIMInstance (request->newInstance); |
jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci); |
jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci); |
jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef); |
jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewJ,jciRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl)); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider, | jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
handler.processing(); | handler.processing(); |
| |
if (jcopRet) { | if (jcopRet) { |
jint jCopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jCopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCopRetRef); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCopRetRef); |
| |
handler.deliver(*copRet); | handler.deliver(*copRet); |
} | } |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleModifyInstanceRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleModifyInstanceRequest"); |
| |
HandlerIntroVoid(ModifyInstance,message,request,response,handler); |
HandlerIntro(ModifyInstance,message,request,response,handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.modifyInstance: " + pr.getName()); | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.modifyInstance: " + pr.getName()); |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: Calling provider "<<PEGASUS_STD(hex)<<(int)&pr<<PEGASUS_STD(dec)<<", name = "<<pr.getName ()<<", module = "<<pr.getModule()<<" modifyInstance: "<<pr.getName()<<PEGASUS_STD(endl)); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: Calling provider "<<PEGASUS_STD(hex)<<(long)&pr<<PEGASUS_STD(dec)<<", name = "<<pr.getName ()<<", module = "<<pr.getModule()<<" modifyInstance: "<<pr.getName()<<PEGASUS_STD(endl)); |
| |
JvmVector *jv = 0; | JvmVector *jv = 0; |
| |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_INSTANCEPROVIDER2: | case METHOD_INSTANCEPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMInstance *ci = new CIMInstance (request->modifiedInstance); | CIMInstance *ci = new CIMInstance (request->modifiedInstance); |
jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci); |
jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci); |
jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef); |
jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewJ,jciRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); | jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
env->CallVoidMethod((jobject)pr.jProvider, | env->CallVoidMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
case METHOD_CIMINSTANCEPROVIDER: | case METHOD_CIMINSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMInstance *ci = new CIMInstance (request->modifiedInstance); | CIMInstance *ci = new CIMInstance (request->modifiedInstance); |
jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci); |
jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci); |
jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef); |
jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewJ,jciRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); | jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
env->CallVoidMethod((jobject)pr.jProvider, | env->CallVoidMethod((jobject)pr.jProvider, |
id, | id, |
jcop, | jcop, |
|
|
jPropertyList); | jPropertyList); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
|
|
STAT_PMS_PROVIDEREND; |
|
break; | break; |
} | } |
| |
case METHOD_INSTANCEPROVIDER: | case METHOD_INSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMInstance *ci = new CIMInstance (request->modifiedInstance); | CIMInstance *ci = new CIMInstance (request->modifiedInstance); |
jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci); |
jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci); |
jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef); |
jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewJ,jciRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
env->CallVoidMethod((jobject)pr.jProvider, | env->CallVoidMethod((jobject)pr.jProvider, |
id, | id, |
jcop, | jcop, |
jci); | jci); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
|
|
STAT_PMS_PROVIDEREND; |
|
break; | break; |
} | } |
| |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleDeleteInstanceRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleDeleteInstanceRequest"); |
| |
HandlerIntroVoid(DeleteInstance,message,request,response,handler); |
HandlerIntro(DeleteInstance,message,request,response,handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_INSTANCEPROVIDER2: | case METHOD_INSTANCEPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
env->CallVoidMethod((jobject)pr.jProvider, | env->CallVoidMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
case METHOD_INSTANCEPROVIDER: | case METHOD_INSTANCEPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
env->CallVoidMethod((jobject)pr.jProvider, | env->CallVoidMethod((jobject)pr.jProvider, |
id, | id, |
jcop); | jcop); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
|
|
STAT_PMS_PROVIDEREND; |
|
break; | break; |
} | } |
| |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleExecQueryRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleExecQueryRequest"); |
| |
HandlerIntro(ExecQuery,message,request,response,handler,Array<CIMObject>()); |
HandlerIntro(ExecQuery,message,request,response,handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_CIMINSTANCEPROVIDER: | case METHOD_CIMINSTANCEPROVIDER: |
{ | { |
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| |
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls); |
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcls); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jcop, | jcop, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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++) { |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
case METHOD_CIMINSTANCEPROVIDER2: | case METHOD_CIMINSTANCEPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| |
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls); |
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcls); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
case METHOD_INSTANCEPROVIDER2: | case METHOD_INSTANCEPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
CIMClass *pcls = new CIMClass (cls); | CIMClass *pcls = new CIMClass (cls); |
| |
JMPIjvm::checkException(env); |
jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| |
jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcls); |
|
|
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls); |
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
StatProviderTimeMeasurement providerTime(response); |
|
|
|
jobject jVec = env->CallObjectMethod ((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
jcop, | jcop, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
} | } |
| |
handler.processing(); | handler.processing(); |
if (jAr) { |
if (jVec) |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
{ |
|
for (int i = 0, m = env->CallIntMethod (jVec, JMPIjvm::jv.VectorSize); i < m; i++) |
|
{ |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobject jciRet = env->GetObjectArrayElement(jAr,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); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
| |
JMPIjvm::checkException(env); | 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_INSTANCEPROVIDER: | case METHOD_INSTANCEPROVIDER: |
{ | { |
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls); |
jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| |
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls); |
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewJ,jcls); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jql = 0; // @BUG - how to convert? |
jlong jql = 0; // @BUG - how to convert? |
| |
jobjectArray jVec = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
StatProviderTimeMeasurement providerTime(response); |
|
|
|
jobject jVec = env->CallObjectMethod ((jobject)pr.jProvider, |
id, | id, |
jcop, | jcop, |
jquery, | jquery, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest"); |
| |
HandlerIntro(Associators,message,request,response,handler,Array<CIMObject>()); |
HandlerIntro(Associators,message,request,response,handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_CIMASSOCIATORPROVIDER: | case METHOD_CIMASSOCIATORPROVIDER: |
{ | { |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
#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 |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jAssociationName, | jAssociationName, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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++) { |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
CIMClass cls; | CIMClass cls; |
| |
try | try |
|
|
| |
case METHOD_CIMASSOCIATORPROVIDER2: | case METHOD_CIMASSOCIATORPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
#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 |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
CIMClass cls; | CIMClass cls; |
| |
try | try |
|
|
| |
case METHOD_ASSOCIATORPROVIDER2: | case METHOD_ASSOCIATORPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl)); |
#endif | #endif |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
CIMClass cls; | CIMClass cls; |
| |
try | try |
|
|
| |
case METHOD_ASSOCIATORPROVIDER: | case METHOD_ASSOCIATORPROVIDER: |
{ | { |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl)); |
#endif | #endif |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jAssociationName, | jAssociationName, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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++) { |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
CIMClass cls; | CIMClass cls; |
| |
try | try |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorNamesRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorNamesRequest"); |
| |
HandlerIntro(AssociatorNames,message,request,response,handler,Array<CIMObjectPath>()); |
HandlerIntro(AssociatorNames,message,request,response,handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_CIMASSOCIATORPROVIDER: | case METHOD_CIMASSOCIATORPROVIDER: |
{ | { |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl)); |
#endif | #endif |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jAssociationName, | jAssociationName, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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++) { |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRet); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
case METHOD_CIMASSOCIATORPROVIDER2: | case METHOD_CIMASSOCIATORPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl)); |
#endif | #endif |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRet); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
case METHOD_ASSOCIATORPROVIDER: | case METHOD_ASSOCIATORPROVIDER: |
{ | { |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl)); |
#endif | #endif |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jAssociationName, | jAssociationName, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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++) { |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
case METHOD_ASSOCIATORPROVIDER2: | case METHOD_ASSOCIATORPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, assocPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl)); |
#endif | #endif |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferencesRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferencesRequest"); |
| |
HandlerIntro(References,message,request,response,handler,Array<CIMObject>()); |
HandlerIntro(References,message,request,response,handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_CIMASSOCIATORPROVIDER: | case METHOD_CIMASSOCIATORPROVIDER: |
{ | { |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | 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 |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jAssociationName, | jAssociationName, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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++) { |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
CIMClass cls; | CIMClass cls; |
| |
try | try |
|
|
| |
case METHOD_CIMASSOCIATORPROVIDER2: | case METHOD_CIMASSOCIATORPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | 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 |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
CIMClass cls; | CIMClass cls; |
| |
try | try |
|
|
| |
case METHOD_ASSOCIATORPROVIDER: | case METHOD_ASSOCIATORPROVIDER: |
{ | { |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | 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 |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jAssociationName, | jAssociationName, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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++) { |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
CIMClass cls; | CIMClass cls; |
| |
try | try |
|
|
| |
case METHOD_ASSOCIATORPROVIDER2: | case METHOD_ASSOCIATORPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | 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 |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
jlong jciRetRef = env->CallLongMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef); |
CIMInstance *ciRet = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciRetRef); |
CIMClass cls; | CIMClass cls; |
| |
try | try |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferenceNamesRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferenceNamesRequest"); |
| |
HandlerIntro(ReferenceNames,message,request,response,handler,Array<CIMObjectPath>()); |
HandlerIntro(ReferenceNames,message,request,response,handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_CIMASSOCIATORPROVIDER: | case METHOD_CIMASSOCIATORPROVIDER: |
{ | { |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
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 |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jPathName, | jPathName, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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++) { |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef); |
| |
handler.deliver(*copRet); | handler.deliver(*copRet); |
} | } |
|
|
| |
case METHOD_CIMASSOCIATORPROVIDER2: | case METHOD_CIMASSOCIATORPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
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 |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef); |
| |
handler.deliver(*copRet); | handler.deliver(*copRet); |
} | } |
|
|
| |
case METHOD_ASSOCIATORPROVIDER: | case METHOD_ASSOCIATORPROVIDER: |
{ | { |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
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 |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jAssociationName, | jAssociationName, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
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++) { |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef); |
| |
handler.deliver(*copRet); | handler.deliver(*copRet); |
} | } |
|
|
| |
case METHOD_ASSOCIATORPROVIDER2: | case METHOD_ASSOCIATORPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath); |
jlong jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, resultPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jAssociationNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jPathNameRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
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 |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, | jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
jlong jcopRetRef = env->CallLongMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef); |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jcopRetRef); |
| |
handler.deliver(*copRet); | handler.deliver(*copRet); |
} | } |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetPropertyRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetPropertyRequest"); |
| |
HandlerIntro(GetProperty,message,request,response,handler,CIMValue()); |
HandlerIntro(GetProperty,message,request,response,handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_PROPERTYPROVIDER: | case METHOD_PROPERTYPROVIDER: |
{ | { |
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_GETSTARTTIME; |
StatProviderTimeMeasurement providerTime(response); |
| |
jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider, | jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider, |
id, | id, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); | handler.processing(); |
| |
if (jvalRet) | if (jvalRet) |
{ | { |
jint jvalRetRef = env->CallIntMethod(jvalRet,JMPIjvm::jv.CIMValueCInst); |
jlong jvalRetRef = env->CallLongMethod(jvalRet,JMPIjvm::jv.CIMValueCInst); |
CIMValue *valRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jvalRetRef); |
CIMValue *valRet = DEBUG_ConvertJavaToC (jlong, CIMValue*, jvalRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
case METHOD_PROPERTYPROVIDER2: | case METHOD_PROPERTYPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_GETSTARTTIME; |
StatProviderTimeMeasurement providerTime(response); |
| |
jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider, | jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider, |
id, | id, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
if (jvalRet) | if (jvalRet) |
{ | { |
jint jvalRetRef = env->CallIntMethod(jvalRet,JMPIjvm::jv.CIMValueCInst); |
jlong jvalRetRef = env->CallLongMethod(jvalRet,JMPIjvm::jv.CIMValueCInst); |
CIMValue *valRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jvalRetRef); |
CIMValue *valRet = DEBUG_ConvertJavaToC (jlong, CIMValue*, jvalRetRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleSetPropertyRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleSetPropertyRequest"); |
| |
HandlerIntroVoid(SetProperty,message,request,response,handler); |
HandlerIntro(SetProperty,message,request,response,handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_PROPERTYPROVIDER: | case METHOD_PROPERTYPROVIDER: |
{ | { |
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jvalref = DEBUG_ConvertCToJava (CIMValue*, jint, val); |
jlong jvalref = DEBUG_ConvertCToJava (CIMValue*, jlong, val); |
jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewI, jvalref); |
jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewJ, jvalref); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_GETSTARTTIME; |
StatProviderTimeMeasurement providerTime(response); |
| |
env->CallVoidMethod ((jobject)pr.jProvider, | env->CallVoidMethod ((jobject)pr.jProvider, |
id, | id, |
|
|
jval); | jval); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
|
|
STAT_PMS_PROVIDEREND; |
|
break; | break; |
} | } |
| |
case METHOD_PROPERTYPROVIDER2: | case METHOD_PROPERTYPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewJ, jcopref); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jvalref = DEBUG_ConvertCToJava (CIMValue*, jint, val); |
jlong jvalref = DEBUG_ConvertCToJava (CIMValue*, jlong, val); |
jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewI, jvalref); |
jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewJ, jvalref); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_GETSTARTTIME; |
StatProviderTimeMeasurement providerTime(response); |
| |
env->CallVoidMethod ((jobject)pr.jProvider, | env->CallVoidMethod ((jobject)pr.jProvider, |
id, | id, |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
} | } |
|
|
STAT_PMS_PROVIDEREND; |
|
break; | break; |
} | } |
| |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleInvokeMethodRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleInvokeMethodRequest"); |
| |
HandlerIntroMethod(InvokeMethod,message,request,response,handler); |
HandlerIntro(InvokeMethod,message,request,response,handler); |
| |
typedef enum { | typedef enum { |
METHOD_UNKNOWN = 0, | METHOD_UNKNOWN = 0, |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_CIMMETHODPROVIDER: | case METHOD_CIMMETHODPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
for (Uint32 i=0; i<m; i++) { | for (Uint32 i=0; i<m; i++) { |
CIMParamValue *parm = new CIMParamValue(request->inParameters[i]); | CIMParamValue *parm = new CIMParamValue(request->inParameters[i]); |
jint jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm); |
jlong jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jlong, parm); |
jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jArgRef); |
jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewJ,jArgRef); |
| |
env->SetObjectArrayElement(jArIn,i,jArg); | env->SetObjectArrayElement(jArIn,i,jArg); |
} | } |
| |
jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL); | jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, | jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jcop, | jcop, |
|
|
jArOut); | jArOut); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); | handler.processing(); |
| |
jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); |
jlong jValueRetRef = env->CallLongMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); |
CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef); |
CIMValue *valueRet = DEBUG_ConvertJavaToC (jlong, CIMValue*, jValueRetRef); |
| |
handler.deliver(*valueRet); | handler.deliver(*valueRet); |
| |
|
|
if (jArg==NULL) | if (jArg==NULL) |
break; | break; |
| |
jint jpRef = env->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst); |
jlong jpRef = env->CallLongMethod(jArg,JMPIjvm::jv.CIMArgumentCInst); |
CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jpRef); |
CIMParamValue *p = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jpRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
case METHOD_CIMMETHODPROVIDER2: | case METHOD_CIMMETHODPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
for (Uint32 i=0; i<m; i++) { | for (Uint32 i=0; i<m; i++) { |
CIMParamValue *parm = new CIMParamValue(request->inParameters[i]); | CIMParamValue *parm = new CIMParamValue(request->inParameters[i]); |
jint jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm); |
jlong jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jlong, parm); |
jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jArgRef); |
jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewJ,jArgRef); |
| |
env->SetObjectArrayElement(jArIn,i,jArg); | env->SetObjectArrayElement(jArIn,i,jArg); |
} | } |
| |
jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL); | jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, | jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
jArOut); | jArOut); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
handler.processing(); | handler.processing(); |
| |
jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); |
jlong jValueRetRef = env->CallLongMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); |
CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef); |
CIMValue *valueRet = DEBUG_ConvertJavaToC (jlong, CIMValue*, jValueRetRef); |
| |
handler.deliver(*valueRet); | handler.deliver(*valueRet); |
| |
|
|
if (jArg==NULL) | if (jArg==NULL) |
break; | break; |
| |
jint jpRef = env->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst); |
jlong jpRef = env->CallLongMethod(jArg,JMPIjvm::jv.CIMArgumentCInst); |
CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jpRef); |
CIMParamValue *p = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jpRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
case METHOD_METHODPROVIDER: | case METHOD_METHODPROVIDER: |
{ | { |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
const CIMParamValue &parm = request->inParameters[i]; | const CIMParamValue &parm = request->inParameters[i]; |
const CIMValue v = parm.getValue(); | const CIMValue v = parm.getValue(); |
CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize()); | CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize()); |
jint jpRef = DEBUG_ConvertCToJava (CIMProperty*, jint, p); |
jlong jpRef = DEBUG_ConvertCToJava (CIMProperty*, jlong, p); |
jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jpRef); |
jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewJ,jpRef); |
| |
env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp); | env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp); |
} | } |
|
|
jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew); | jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, | jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
jcop, | jcop, |
|
|
jVecOut); | jVecOut); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); | handler.processing(); |
| |
jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); |
jlong jValueRetRef = env->CallLongMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); |
CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef); |
CIMValue *valueRet = DEBUG_ConvertJavaToC (jlong, CIMValue*, jValueRetRef); |
| |
handler.deliver(*valueRet); | handler.deliver(*valueRet); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jpRef = env->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst); |
jlong jpRef = env->CallLongMethod(jProp,JMPIjvm::jv.CIMPropertyCInst); |
CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jpRef); |
CIMProperty *p = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jpRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
case METHOD_METHODPROVIDER2: | case METHOD_METHODPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, objectPath); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
const CIMParamValue &parm = request->inParameters[i]; | const CIMParamValue &parm = request->inParameters[i]; |
const CIMValue v = parm.getValue(); | const CIMValue v = parm.getValue(); |
CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize()); | CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize()); |
jint jpRef = DEBUG_ConvertCToJava (CIMProperty*, jint, p); |
jlong jpRef = DEBUG_ConvertCToJava (CIMProperty*, jlong, p); |
jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jpRef); |
jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewJ,jpRef); |
| |
env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp); | env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp); |
} | } |
|
|
jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew); | jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, | jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
|
|
jVecOut); | jVecOut); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; |
|
|
|
if (joc) | if (joc) |
{ | { |
env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); | env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate); |
|
|
| |
handler.processing(); | handler.processing(); |
| |
jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); |
jlong jValueRetRef = env->CallLongMethod(jValueRet,JMPIjvm::jv.CIMValueCInst); |
CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef); |
CIMValue *valueRet = DEBUG_ConvertJavaToC (jlong, CIMValue*, jValueRetRef); |
| |
handler.deliver(*valueRet); | handler.deliver(*valueRet); |
| |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jint jpRef = env->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst); |
jlong jpRef = env->CallLongMethod(jProp,JMPIjvm::jv.CIMPropertyCInst); |
CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jpRef); |
CIMProperty *p = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jpRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
return 0; | return 0; |
} | } |
| |
CMPI_SelectExp * |
WQLSelectStatement * |
newSelectExp (CIMOMHandleQueryContext *qContext, |
newSelectExp (String& query, |
OperationContext *ctx, |
String& queryLanguage) |
String& query, |
|
String& queryLanguage, |
|
CIMNamespaceName& nameSpace, |
|
Array<CIMName>& classNames, |
|
CIMPropertyList& propertyList) |
|
{ |
|
CMPI_SelectExp *eSelx = NULL; |
|
|
|
eSelx = new CMPI_SelectExp (*ctx, |
|
qContext, |
|
query, |
|
queryLanguage); |
|
|
|
if (!eSelx) |
|
{ | { |
return eSelx; |
WQLSelectStatement *stmt = new WQLSelectStatement (queryLanguage, query); |
} |
|
| |
for (Uint32 i = 0, n = classNames.size (); i < n; i++) |
try |
{ | { |
CIMObjectPath className (System::getHostName(), |
WQLParser::parse (query, *stmt); |
nameSpace, |
|
classNames[i]); |
|
|
|
eSelx->classNames.append (className); |
|
} | } |
|
catch (const Exception &e) |
if (!propertyList.isNull ()) |
|
{ |
|
Array<CIMName> p = propertyList.getPropertyNameArray (); |
|
int pCount = p.size (); |
|
|
|
eSelx->props = (const char**)malloc ((1 + pCount) * sizeof (char*)); |
|
|
|
for (int i = 0; i < pCount; i++) |
|
{ | { |
eSelx->props[i] = strdup (p[i].getString ().getCString ()); |
cerr << "Error: newSelectExp caught: " << e.getMessage () << endl; |
} |
|
|
|
eSelx->props[pCount] = NULL; |
|
} | } |
| |
return eSelx; |
return stmt; |
} | } |
| |
Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw() | Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw() |
|
|
| |
CIMOMHandleQueryContext *qContext = new CIMOMHandleQueryContext (CIMNamespaceName (request->nameSpace.getString ()), | CIMOMHandleQueryContext *qContext = new CIMOMHandleQueryContext (CIMNamespaceName (request->nameSpace.getString ()), |
*pr._cimom_handle); | *pr._cimom_handle); |
CMPI_SelectExp *eSelx = newSelectExp (qContext, |
|
prec->ctx, |
|
srec->query, |
|
srec->queryLanguage, |
|
request->nameSpace, |
|
request->classNames, |
|
srec->propertyList); |
|
|
|
srec->eSelx = eSelx; |
|
srec->qContext = qContext; | srec->qContext = qContext; |
| |
CIMObjectPath sPath (request->subscriptionInstance.getPath ().getClassName ().getString ()); |
CIMObjectPath sPath = request->subscriptionInstance.getPath (); |
|
Array<CIMKeyBinding> kb; |
|
|
|
// Technically we only need Name and Handler for uniqueness |
|
kb = sPath.getKeyBindings (); |
|
|
|
// Add an entry for every provider. |
|
kb.append (CIMKeyBinding ("Provider", |
|
pr.getName (), |
|
CIMKeyBinding::STRING)); |
| |
sPath.setNameSpace (request->subscriptionInstance.getPath ().getNameSpace ()); |
sPath.setKeyBindings (kb); |
| |
AutoMutex lock (mutexSelxTab); | AutoMutex lock (mutexSelxTab); |
| |
|
|
| |
selxTab.insert (sPath.toString (), srec); | selxTab.insert (sPath.toString (), srec); |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: For selxTab "<<sPath.toString ()<<", srec = "<<PEGASUS_STD(hex)<<(int)srec<<PEGASUS_STD(dec)<<", eSelx = "<<PEGASUS_STD(hex)<<(int)eSelx<<PEGASUS_STD(dec)<<", qContext = "<<PEGASUS_STD(hex)<<(int)qContext<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: For selxTab "<<sPath.toString ()<<", srec = "<<PEGASUS_STD(hex)<<(long)srec<<PEGASUS_STD(dec)<<", qContext = "<<PEGASUS_STD(hex)<<(long)qContext<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
} | } |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createSubscriptionRequest: " + pr.getName()); | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createSubscriptionRequest: " + pr.getName()); |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_EVENTPROVIDER: | case METHOD_EVENTPROVIDER: |
{ | { |
CMPI_SelectExp *eSelx = newSelectExp (srec->qContext, |
WQLSelectStatement *stmt = newSelectExp (srec->query, |
prec->ctx, |
srec->queryLanguage); |
srec->query, |
jlong jStmtRef = DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, stmt); |
srec->queryLanguage, |
jobject jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewJ,jStmtRef); |
request->nameSpace, |
|
request->classNames, |
|
srec->propertyList); |
|
jint jEselxRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx); |
|
jobject jEselx = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jEselxRef); |
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), | CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), |
request->nameSpace, | request->nameSpace, |
request->classNames[0]); | request->classNames[0]); |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
env->CallVoidMethod ((jobject)pr.jProvider, | env->CallVoidMethod ((jobject)pr.jProvider, |
id, | id, |
jEselx, |
jSelectExp, |
jType, | jType, |
jcop, | jcop, |
(jboolean)fNewPrec); | (jboolean)fNewPrec); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
|
|
STAT_PMS_PROVIDEREND; |
|
break; | break; |
} | } |
| |
case METHOD_EVENTPROVIDER2: | case METHOD_EVENTPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
CMPI_SelectExp *eSelx = newSelectExp (srec->qContext, |
WQLSelectStatement *stmt = newSelectExp (srec->query, |
prec->ctx, |
srec->queryLanguage); |
srec->query, |
jlong jStmtRef = DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, stmt); |
srec->queryLanguage, |
jobject jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewJ,jStmtRef); |
request->nameSpace, |
|
request->classNames, |
|
srec->propertyList); |
|
jint jEselxRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx); |
|
jobject jEselx = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jEselxRef); |
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), | CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), |
request->nameSpace, | request->nameSpace, |
request->classNames[0]); | request->classNames[0]); |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
env->CallVoidMethod ((jobject)pr.jProvider, | env->CallVoidMethod ((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
jEselx, |
jSelectExp, |
jType, | jType, |
jcop, | jcop, |
(jboolean)fNewPrec); | (jboolean)fNewPrec); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
} | } |
|
|
STAT_PMS_PROVIDEREND; |
|
break; | break; |
} | } |
| |
|
|
} | } |
| |
{ | { |
CIMObjectPath sPath (request->subscriptionInstance.getPath ().getClassName ().getString ()); |
CIMObjectPath sPath = request->subscriptionInstance.getPath (); |
|
Array<CIMKeyBinding> kb; |
| |
sPath.setNameSpace (request->subscriptionInstance.getPath ().getNameSpace ()); |
// Technically we only need Name and Handler for uniqueness |
|
kb = sPath.getKeyBindings (); |
|
|
|
// Add an entry for every provider. |
|
kb.append (CIMKeyBinding ("Provider", |
|
pr.getName (), |
|
CIMKeyBinding::STRING)); |
|
|
|
sPath.setKeyBindings (kb); |
| |
String sPathString = sPath.toString (); | String sPathString = sPath.toString (); |
| |
|
|
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Removing selxTab "<<sPathString<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Removing selxTab "<<sPathString<<PEGASUS_STD(endl)); |
| |
selxTab.lookup (sPathString, srec); |
if (!selxTab.lookup (sPathString, srec)) |
|
{ |
|
PEGASUS_ASSERT(0); |
|
} |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: For selxTab "<<sPathString<<", srec = "<<PEGASUS_STD(hex)<<(int)srec<<PEGASUS_STD(dec)<<", eSelx = "<<PEGASUS_STD(hex)<<(int)srec->eSelx<<PEGASUS_STD(dec)<<", qContext = "<<PEGASUS_STD(hex)<<(int)srec->qContext<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: For selxTab "<<sPathString<<", srec = "<<PEGASUS_STD(hex)<<(long)srec<<PEGASUS_STD(dec)<<", qContext = "<<PEGASUS_STD(hex)<<(long)srec->qContext<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
| |
selxTab.remove (sPathString); | selxTab.remove (sPathString); |
} | } |
|
|
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", | MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED", |
"Could not initialize the JVM (Java Virtual Machine) runtime environment.")); | "Could not initialize the JVM (Java Virtual Machine) runtime environment.")); |
|
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id = NULL; | jmethodID id = NULL; |
String interfaceType; | String interfaceType; |
String interfaceVersion; | String interfaceVersion; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, | throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, |
MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", | MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND", |
"Could not find a method for the provider based on InterfaceType.")); | "Could not find a method for the provider based on InterfaceType.")); |
|
|
{ | { |
case METHOD_EVENTPROVIDER: | case METHOD_EVENTPROVIDER: |
{ | { |
CMPI_SelectExp *eSelx = newSelectExp (srec->qContext, |
WQLSelectStatement *stmt = newSelectExp (srec->query, |
prec->ctx, |
srec->queryLanguage); |
srec->query, |
jlong jStmtRef = DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, stmt); |
srec->queryLanguage, |
jobject jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewJ,jStmtRef); |
request->nameSpace, |
|
request->classNames, |
|
srec->propertyList); |
|
jint jEselxRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx); |
|
jobject jEselx = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jEselxRef); |
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), | CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), |
request->nameSpace, | request->nameSpace, |
request->classNames[0]); | request->classNames[0]); |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
env->CallVoidMethod ((jobject)pr.jProvider, | env->CallVoidMethod ((jobject)pr.jProvider, |
id, | id, |
jEselx, |
jSelectExp, |
jType, | jType, |
jcop, | jcop, |
(jboolean)fFreePrec); | (jboolean)fFreePrec); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
|
|
STAT_PMS_PROVIDEREND; |
|
break; | break; |
} | } |
| |
case METHOD_EVENTPROVIDER2: | case METHOD_EVENTPROVIDER2: |
{ | { |
jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext); |
jlong jocRef = DEBUG_ConvertCToJava (OperationContext*, jlong, &request->operationContext); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef); |
jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewJ,jocRef); |
| |
CMPI_SelectExp *eSelx = newSelectExp (srec->qContext, |
WQLSelectStatement *stmt = newSelectExp (srec->query, |
prec->ctx, |
srec->queryLanguage); |
srec->query, |
jlong jStmtRef = DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, stmt); |
srec->queryLanguage, |
jobject jSelectExp = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewJ,jStmtRef); |
request->nameSpace, |
|
request->classNames, |
|
srec->propertyList); |
|
jint jEselxRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx); |
|
jobject jEselx = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jEselxRef); |
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), | CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), |
request->nameSpace, | request->nameSpace, |
request->classNames[0]); | request->classNames[0]); |
jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef); |
jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewJ,jcopRef); |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
StatProviderTimeMeasurement providerTime(response); |
|
|
env->CallVoidMethod ((jobject)pr.jProvider, | env->CallVoidMethod ((jobject)pr.jProvider, |
id, | id, |
joc, | joc, |
jEselx, |
jSelectExp, |
jType, | jType, |
jcop, | jcop, |
(jboolean)fFreePrec); | (jboolean)fFreePrec); |
|
|
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
} | } |
|
|
STAT_PMS_PROVIDEREND; |
|
break; | break; |
} | } |
| |
|
|
| |
if (srec) | if (srec) |
{ | { |
if ( srec->eSelx |
|
&& srec->eSelx->props |
|
) |
|
{ |
|
const char **props = srec->eSelx->props; |
|
|
|
while (*props) |
|
{ |
|
const char *prop = *props; |
|
|
|
props++; |
|
|
|
if (prop) |
|
{ |
|
free ((void *)prop); |
|
} |
|
} |
|
|
|
free ((void *)srec->eSelx->props); |
|
} |
|
delete srec->eSelx; |
|
delete srec->qContext; | delete srec->qContext; |
} | } |
delete srec; | delete srec; |
|
|
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
STAT_COPYDISPATCHER |
|
|
|
return(response); | return(response); |
} | } |
| |
|
|
| |
PEGASUS_ASSERT(response != 0); | PEGASUS_ASSERT(response != 0); |
| |
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// | // |
// Set HTTP method in response from request | // Set HTTP method in response from request |
// | // |
|
|
| |
PEGASUS_ASSERT(response != 0); | PEGASUS_ASSERT(response != 0); |
| |
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request | // Set HTTP method in response from request |
response->setHttpMethod (request->getHttpMethod ()); | response->setHttpMethod (request->getHttpMethod ()); |
| |
|
|
| |
PEGASUS_ASSERT(response != 0); | PEGASUS_ASSERT(response != 0); |
| |
// preserve message key |
|
response->setKey(request->getKey()); |
|
|
|
// Set HTTP method in response from request | // Set HTTP method in response from request |
response->setHttpMethod (request->getHttpMethod ()); | response->setHttpMethod (request->getHttpMethod ()); |
| |
|
|
} | } |
catch(...) | catch(...) |
{ | { |
PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
PEG_TRACE_CSTRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
"Unknown error in handleSubscriptionInitCompleteRequest"); | "Unknown error in handleSubscriptionInitCompleteRequest"); |
} | } |
} | } |
|
|
| |
String JMPIProviderManager::resolveFileName(String fileName) | String JMPIProviderManager::resolveFileName(String fileName) |
{ | { |
String name; |
String name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir")); |
#if defined(PEGASUS_OS_TYPE_WINDOWS) |
// physfilename = everything up to the delimiter pointing at class start |
name = fileName; // + String(".dll"); |
// in case there is no delimiter anymore, it takes the entire filename |
#elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) |
String physfilename = fileName.subString(0, fileName.find(":")); |
name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir")); |
// look in all(multiple) homed pathes for the physical file |
name.append(String("/") + fileName); // + String(".sl")); |
name = FileSystem::getAbsoluteFileName(name, physfilename); |
#elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) |
// construct back the fully specified jar:<classname> provider name |
name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir")); |
name = FileSystem::extractFilePath(name) + fileName; |
name.append(String("/") + fileName); // + String(".so")); |
|
#elif defined(PEGASUS_OS_OS400) |
|
name = filrName; |
|
#else |
|
name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir")); |
|
name.append(String("/") + fileName); // + String(".so")); |
|
#endif |
|
return name; | return name; |
} | } |
| |