version 1.6, 2004/06/04 02:23:59
|
version 1.24, 2005/05/03 19:01:06
|
|
|
//%2003//////////////////////////////////////////////////////////////////////// |
//%2005//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Development |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// Company, L. P., IBM Corp., The Open Group, Tivoli Systems. |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; | // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; |
// IBM Corp.; EMC Corporation, The Open Group. | // IBM Corp.; EMC Corporation, The Open Group. |
|
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
|
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
// | // |
// Permission is hereby granted, free of charge, to any person obtaining a copy | // Permission is hereby granted, free of charge, to any person obtaining a copy |
// of this software and associated documentation files (the "Software"), to | // of this software and associated documentation files (the "Software"), to |
|
|
// | // |
// Author: Adrian Schuur, schuur@de.ibm.com | // Author: Adrian Schuur, schuur@de.ibm.com |
// | // |
// Modified By: |
// Modified By: Seema Gupta (gseema@in.ibm.com) for PEP135 |
|
// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for PEP#101 |
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
|
|
| |
#include <Pegasus/Common/CIMMessage.h> | #include <Pegasus/Common/CIMMessage.h> |
#include <Pegasus/Common/OperationContext.h> | #include <Pegasus/Common/OperationContext.h> |
#include <Pegasus/Common/Destroyer.h> |
|
#include <Pegasus/Common/Tracer.h> | #include <Pegasus/Common/Tracer.h> |
#include <Pegasus/Common/StatisticalData.h> | #include <Pegasus/Common/StatisticalData.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/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/ProviderManagerService.h> | #include <Pegasus/ProviderManager2/ProviderManagerService.h> |
| |
|
#include <Pegasus/ProviderManager2/CMPI/CMPI_SelectExp.h> |
|
|
| |
PEGASUS_USING_STD; | PEGASUS_USING_STD; |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
int _jmpi_trace=0; |
int JMPIProviderManager::trace=0; |
|
|
|
#ifdef PEGASUS_DEBUG |
|
#define DDD(x) if (JMPIProviderManager::trace) x; |
|
#else |
|
#define DDD(x) |
|
#endif |
|
|
|
#include "Convert.h" |
|
|
|
void JMPIProviderManager::debugPrintMethodPointers (JNIEnv *env, jclass jc) |
|
{ |
|
// cd ${PEGAUSE_HOME}/src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/tests/JMPI_TestPropertyTypes |
|
// javap -s -p JMPI_TestPropertyTypes |
|
static const char *methodNames[][2] = { |
|
// CIMProvider |
|
// cimom-2003-11-24/org/snia/wbem/provider/CIMProvider.java |
|
// src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMProvider.java |
|
{"initialize","(Lorg/pegasus/jmpi/CIMOMHandle;)V"}, |
|
{"cleanup","()V"}, |
|
// InstanceProvider |
|
// cimom-2003-11-24/org/snia/wbem/provider/InstanceProvider.java |
|
// src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMInstanceProvider.java |
|
{"enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"}, |
|
{"enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;"}, |
|
{"getInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;"}, |
|
{"createInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;"}, |
|
{"setInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V"}, |
|
{"deleteInstance","(Lorg/pegasus/jmpi/CIMObjectPath;)V"}, |
|
{"execQuery","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"}, |
|
// MethodProvider |
|
// cimom-2003-11-24/org/snia/wbem/provider/MethodProvider.java |
|
// src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMMethodProvider.java |
|
{"invokeMethod","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;"}, |
|
// PropertyProvider |
|
// cimom-2003-11-24/org/snia/wbem/provider/PropertyProvider.java |
|
// AssociatorProvider |
|
// cimom-2003-11-24/org/snia/wbem/provider20/AssociatorProvider.java |
|
// src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMAssociationProvider.java |
|
// CIMProviderRouter |
|
// cimom-2003-11-24/org/snia/wbem/provider20/CIMProviderRouter.java |
|
// EventProvider |
|
// cimom-2003-11-24/org/snia/wbem/provider20/EventProvider.java |
|
// src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/EventProvider.java |
|
{"authorizeFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)V"}, |
|
{"mustPoll","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;)Z"}, |
|
{"activateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"}, |
|
{"deActivateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"}, |
|
// IndicationHandler |
|
// cimom-2003-11-24/org/snia/wbem/provider20/IndicationHandler.java |
|
// ProviderAdapter |
|
// cimom-2003-11-24/org/snia/wbem/provider20/ProviderAdapter.java |
|
// JMPI_TestPropertyTypes |
|
{"findObjectPath","(Lorg/pegasus/jmpi/CIMObjectPath;)I"}, |
|
{"testPropertyTypesValue","(Lorg/pegasus/jmpi/CIMInstance;)V"} |
|
}; |
|
|
|
if (!env) |
|
{ |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: env is NULL!"<<PEGASUS_STD(endl)); |
|
return; |
|
} |
|
if (!jc) |
|
{ |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: jc is NULL!"<<PEGASUS_STD(endl)); |
|
return; |
|
} |
| |
#define DDD(x) if (_jmpi_trace) x; |
for (int i = 0; i < (int)(sizeof (methodNames)/sizeof (methodNames[0])); i++) |
|
{ |
|
jmethodID id = env->GetMethodID(jc,methodNames[i][0], methodNames[i][1]); |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: "<<methodNames[i][0]<<", id = "<<PEGASUS_STD(hex)<<(int)id<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
|
env->ExceptionClear(); |
|
} |
|
} |
| |
JMPIProviderManager::IndProvTab JMPIProviderManager::provTab; | JMPIProviderManager::IndProvTab JMPIProviderManager::provTab; |
JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab; | JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab; |
|
|
JMPIProviderManager::JMPIProviderManager(Mode m) | JMPIProviderManager::JMPIProviderManager(Mode m) |
{ | { |
mode=m; | mode=m; |
if (getenv("JMPI_TRACE")) _jmpi_trace=1; |
_subscriptionInitComplete = false; |
else _jmpi_trace=0; |
|
|
#ifdef PEGASUS_DEBUG |
|
if (getenv("PEGASUS_JMPI_TRACE")) |
|
JMPIProviderManager::trace = 1; |
|
else |
|
JMPIProviderManager::trace = 0; |
|
#else |
|
JMPIProviderManager::trace = 0; |
|
#endif |
} | } |
| |
JMPIProviderManager::~JMPIProviderManager(void) | JMPIProviderManager::~JMPIProviderManager(void) |
|
|
const String &ns, const String &cn) | const String &ns, const String &cn) |
{ | { |
String key(ns+String("::")+cn+String("::")+CIMValue(name.getCapabilitiesMask()).toString()); | String key(ns+String("::")+cn+String("::")+CIMValue(name.getCapabilitiesMask()).toString()); |
|
|
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::insertProvider: "<<key<<PEGASUS_STD(endl)); |
|
|
return provReg.insert(key,name); | return provReg.insert(key,name); |
} | } |
| |
| |
Message * JMPIProviderManager::processMessage(Message * request) throw() | Message * JMPIProviderManager::processMessage(Message * request) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::processMessage()"); |
"JMPIProviderManager::processMessage()"); |
|
| |
Message * response = 0; | Message * response = 0; |
| |
|
|
response = handleReferenceNamesRequest(request); | response = handleReferenceNamesRequest(request); |
| |
break; | break; |
/* case CIM_INVOKE_METHOD_REQUEST_MESSAGE: |
case CIM_INVOKE_METHOD_REQUEST_MESSAGE: |
response = handleInvokeMethodRequest(request); | response = handleInvokeMethodRequest(request); |
| |
break; | break; |
|
|
response = handleCreateSubscriptionRequest(request); | response = handleCreateSubscriptionRequest(request); |
| |
break; | break; |
case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE: |
/* case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE: |
response = handleModifySubscriptionRequest(request); | response = handleModifySubscriptionRequest(request); |
|
|
break; | break; |
|
*/ |
case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE: | case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE: |
response = handleDeleteSubscriptionRequest(request); | response = handleDeleteSubscriptionRequest(request); |
| |
break; | break; |
case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE: |
/* case CIM_EXPORT_INDICATION_REQUEST_MESSAGE: |
response = handleEnableIndicationsRequest(request); |
response = handleExportIndicationRequest(request); |
|
|
break; |
|
case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE: |
|
response = handleDisableIndicationsRequest(request); |
|
|
|
break; |
|
case CIM_CONSUME_INDICATION_REQUEST_MESSAGE: |
|
response = handleConsumeIndicationRequest(request); |
|
break; | break; |
|
*/ |
case CIM_DISABLE_MODULE_REQUEST_MESSAGE: | case CIM_DISABLE_MODULE_REQUEST_MESSAGE: |
response = handleDisableModuleRequest(request); | response = handleDisableModuleRequest(request); |
| |
|
|
case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE: | case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE: |
response = handleStopAllProvidersRequest(request); | response = handleStopAllProvidersRequest(request); |
| |
break; */ |
break; |
case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE: | case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE: |
response = handleInitializeProviderRequest(request); | response = handleInitializeProviderRequest(request); |
| |
break; | break; |
|
case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE: |
|
response = handleSubscriptionInitCompleteRequest (request); |
|
|
|
break; |
default: | default: |
cout<<"*** Unsupported Request ??"<<request->getType()<<endl; |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
asm("int $3"); |
"*** Unsupported Request "+request->getType()); |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::processMessage: Unsupported request "<<request->getType ()<<PEGASUS_STD(endl)); |
response = handleUnsupportedRequest(request); | response = handleUnsupportedRequest(request); |
| |
break; | break; |
|
|
handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \ | handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \ |
} | } |
| |
|
static jobjectArray getList(JvmVector *jv, JNIEnv *env, CIMPropertyList &list) |
|
{ |
|
Uint32 s=list.size(); |
|
jobjectArray pl=NULL; |
|
if (s) { |
|
jstring initial=env->NewString(NULL,0); |
|
pl=(jobjectArray)env->NewObjectArray(s,jv->StringClassRef,initial); |
|
for (Uint32 i=0; i<s; i++) { |
|
env->SetObjectArrayElement |
|
(pl,i,env->NewStringUTF(list[i].getString().getCString())); |
|
} |
|
} |
|
return pl; |
|
} |
| |
Message * JMPIProviderManager::handleGetInstanceRequest(const Message * message) throw() | Message * JMPIProviderManager::handleGetInstanceRequest(const Message * message) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetInstanceRequest"); |
"JMPIProviderManager::handleGetInstanceRequest"); |
|
| |
HandlerIntro(GetInstance,message,request,response,handler,CIMInstance()); | HandlerIntro(GetInstance,message,request,response,handler,CIMInstance()); |
| |
JNIEnv *env=NULL; | JNIEnv *env=NULL; |
|
Boolean mode24=false; |
|
CIMPropertyList propertyList; |
|
jobjectArray pl=NULL; |
|
|
try { | try { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, | Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"JMPIProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2", | "JMPIProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
|
|
request->nameSpace.getString(), | request->nameSpace.getString(), |
request->instanceName.getClassName().getString()); | request->instanceName.getClassName().getString()); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->instanceName.getClassName().getString()<<PEGASUS_STD(endl)); |
|
|
// make target object path | // make target object path |
CIMObjectPath objectPath( | CIMObjectPath objectPath( |
System::getHostName(), | System::getHostName(), |
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Calling provider.getInstance: " + pr.getName()); | "Calling provider.getInstance: " + pr.getName()); |
| |
DDD(cerr<<"--- JMPIProviderManager::getInstance"<<endl); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: Calling provider getInstance: "<<pr.getName()<<PEGASUS_STD(endl)); |
| |
JvmVector *jv; | JvmVector *jv; |
JNIEnv *env=JMPIjvm::attachThread(&jv); | JNIEnv *env=JMPIjvm::attachThread(&jv); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
|
jv->CIMObjectPathNewI,(jint)&objectPath); |
jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath); |
|
|
|
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace, | CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace, |
request->instanceName.getClassName(), | request->instanceName.getClassName(), |
false,true,true,CIMPropertyList()); | false,true,true,CIMPropertyList()); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
jobject cc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls); |
|
|
jObj = DEBUG_ConvertCToJava (CIMClass*, jint, &cls); |
|
|
|
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jObj); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; |
|
|
|
jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"getInstance", | jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"getInstance", |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;"); | "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;"); |
|
|
|
if (id==NULL) { |
|
env->ExceptionClear(); |
|
id=env->GetMethodID((jclass)pr.jProviderClass,"getInstance", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)" |
|
"Lorg/pegasus/jmpi/CIMInstance;"); |
|
JMPIjvm::checkException(env); |
|
mode24=true; |
|
pl=getList(jv,env,request->propertyList); |
|
} |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
jobject inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,cc,true); |
|
|
STAT_GETSTARTTIME; |
|
|
|
jobject inst=NULL; |
|
if (mode24) |
|
inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef, |
|
request->localOnly,request->includeQualifiers,request->includeClassOrigin,pl,jCc); |
|
else |
|
inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jCc,true); |
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
handler.processing(); | handler.processing(); |
if (inst) { | if (inst) { |
CIMInstance *ci=((CIMInstance*)env->CallIntMethod(inst,JMPIjvm::jv.CIMInstanceCInst)); |
jint jCi = env->CallIntMethod(inst,JMPIjvm::jv.CIMInstanceCInst); |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi); |
|
|
handler.deliver(*ci); | handler.deliver(*ci); |
} | } |
handler.complete(); | handler.complete(); |
|
|
| |
Message * JMPIProviderManager::handleEnumerateInstancesRequest(const Message * message) throw() | Message * JMPIProviderManager::handleEnumerateInstancesRequest(const Message * message) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleEnumerateInstanceRequest"); |
"JMPIProviderManager::handleEnumerateInstanceRequest"); |
|
|
HandlerIntro(EnumerateInstances,message,request,response,handler,Array<CIMInstance>()); |
| |
HandlerIntro(EnumerateInstances,message,request,response, |
|
handler,Array<CIMInstance>()); |
|
JNIEnv *env=NULL; | JNIEnv *env=NULL; |
|
Boolean mode24=false; |
|
CIMPropertyList propertyList; |
|
jobjectArray pl=NULL; |
|
|
try { | try { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, | Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"JMPIProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2", | "JMPIProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2", |
|
|
request->nameSpace.getString(), | request->nameSpace.getString(), |
request->className.getString()); | request->className.getString()); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl)); |
|
|
// make target object path | // make target object path |
CIMObjectPath objectPath( | CIMObjectPath objectPath( |
System::getHostName(), | System::getHostName(), |
|
|
// convert arguments | // convert arguments |
OperationContext context; | OperationContext context; |
| |
context.insert(IdentityContainer(request->userName)); |
context.insert(request->operationContext.get(IdentityContainer::NAME)); |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
CIMPropertyList propertyList(request->propertyList); | CIMPropertyList propertyList(request->propertyList); |
| |
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Calling provider.enumerateInstances: " + pr.getName()); | "Calling provider.enumerateInstances: " + pr.getName()); |
| |
DDD(cerr<<"--- JMPIProviderManager::enumerateInstances"<<endl); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Calling provider enumerateInstances: "<<pr.getName()<<PEGASUS_STD(endl)); |
|
|
| |
JvmVector *jv; | JvmVector *jv; |
env=JMPIjvm::attachThread(&jv); | env=JMPIjvm::attachThread(&jv); |
| |
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath); |
jv->CIMObjectPathNewI,(jint)&objectPath); |
|
|
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace, | CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace, |
request->className, | request->className, |
false,true,true,CIMPropertyList()); | false,true,true,CIMPropertyList()); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls); |
|
|
jObj = DEBUG_ConvertCToJava (CIMClass*, jint, &cls); |
|
|
|
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jObj); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
|
|
| |
jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"enumInstances", | jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"enumInstances", |
"(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;"); | "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;"); |
|
|
|
if (id==NULL) { |
|
env->ExceptionClear(); |
|
id=env->GetMethodID((jclass)pr.jProviderClass,"enumerateInstances", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)" |
|
"[Lorg/pegasus/jmpi/CIMInstance;"); |
|
JMPIjvm::checkException(env); |
|
mode24=true; |
|
pl=getList(jv,env,request->propertyList); |
|
} |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
if (!mode24) { |
jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,false,jCc,true); | jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,false,jCc,true); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
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); |
|
|
jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); | jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst)); |
|
|
jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst); |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
handler.deliver(*ci); |
|
} |
|
} |
|
handler.complete(); |
|
} |
|
else { |
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef, |
|
request->localOnly,request->includeQualifiers,request->includeClassOrigin,pl,jCc); |
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
if (jAr) { |
|
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jInst=env->GetObjectArrayElement(jAr,i); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
// const CIMObjectPath& op=inst.getPath(); |
jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst); |
// CIMObjectPath iop=inst.buildPath(cls); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi); |
// iop.setNameSpace(op.getNameSpace()); |
|
// inst.setPath(iop); |
JMPIjvm::checkException(env); |
| |
handler.deliver(inst); |
handler.deliver(*ci); |
} | } |
} | } |
handler.complete(); | handler.complete(); |
} | } |
|
} |
HandlerCatch(handler); | HandlerCatch(handler); |
| |
if (env) JMPIjvm::detachThread(); | if (env) JMPIjvm::detachThread(); |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest"); |
| |
HandlerIntro(EnumerateInstanceNames,message,request,response, |
HandlerIntro(EnumerateInstanceNames,message,request,response, handler,Array<CIMObjectPath>()); |
handler,Array<CIMObjectPath>()); |
|
JNIEnv *env=NULL; | JNIEnv *env=NULL; |
|
Boolean mode24=false; |
|
CIMPropertyList propertyList; |
|
jobjectArray pl=NULL; |
|
|
try { | try { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, | Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"JMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2", | "JMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2", |
|
|
request->nameSpace.getString(), | request->nameSpace.getString(), |
request->className.getString()); | request->className.getString()); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl)); |
|
|
// make target object path | // make target object path |
CIMObjectPath objectPath( | CIMObjectPath objectPath( |
System::getHostName(), | System::getHostName(), |
|
|
// convert arguments | // convert arguments |
OperationContext context; | OperationContext context; |
| |
context.insert(IdentityContainer(request->userName)); |
context.insert(request->operationContext.get(IdentityContainer::NAME)); |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
JMPIProvider & pr=ph.GetProvider(); | JMPIProvider & pr=ph.GetProvider(); |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Calling provider.enumerateInstanceNames: " + pr.getName()); | "Calling provider.enumerateInstanceNames: " + pr.getName()); |
| |
DDD(cerr<<"--- JMPIProviderManager::enumerateInstanceNames"<<endl); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Calling provider : enumerateInstanceNames"<<pr.getName()<<PEGASUS_STD(endl)); |
|
|
| |
JvmVector *jv; | JvmVector *jv; |
env=JMPIjvm::attachThread(&jv); | env=JMPIjvm::attachThread(&jv); |
| |
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath); |
jv->CIMObjectPathNewI,(jint)&objectPath); |
|
|
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace, | CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace, |
request->className, | request->className, |
false,true,true,CIMPropertyList()); | false,true,true,CIMPropertyList()); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls); |
|
|
jObj = DEBUG_ConvertCToJava (CIMClass*, jint, &cls); |
|
|
|
jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jObj); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
|
|
| |
jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"enumInstances", | jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"enumInstances", |
"(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"); | "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"); |
|
|
|
if (id==NULL) { |
|
env->ExceptionClear(); |
|
id=env->GetMethodID((jclass)pr.jProviderClass,"enumerateInstanceNames", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)" |
|
"[Lorg/pegasus/jmpi/CIMObjectPath;"); |
|
JMPIjvm::checkException(env); |
|
mode24=true; |
|
} |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
if (!mode24) { |
jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,true,jCc); | jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,true,jCc); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
|
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); |
jobject jCop=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
|
jobject inst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
JMPIjvm::checkException(env); |
|
|
|
jint jCop = env->CallIntMethod(inst,JMPIjvm::jv.CIMObjectPathCInst); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
handler.deliver(*cop); |
|
} |
|
} |
|
handler.complete(); |
|
} |
|
else { |
|
jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jCc); |
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
if (jAr) { |
|
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject inst=env->GetObjectArrayElement(jAr,i); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod |
|
(jCop,JMPIjvm::jv.CIMObjectPathCInst)); |
jint jCop = env->CallIntMethod(inst,JMPIjvm::jv.CIMObjectPathCInst); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
|
|
handler.deliver(*cop); | handler.deliver(*cop); |
} | } |
} | } |
handler.complete(); | handler.complete(); |
} | } |
|
} |
HandlerCatch(handler); | HandlerCatch(handler); |
| |
if (env) JMPIjvm::detachThread(); | if (env) JMPIjvm::detachThread(); |
|
|
| |
Message * JMPIProviderManager::handleCreateInstanceRequest(const Message * message) throw() | Message * JMPIProviderManager::handleCreateInstanceRequest(const Message * message) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleCreateInstanceRequest"); |
"JMPIProviderManager::handleCreateInstanceRequest"); |
|
|
HandlerIntro(CreateInstance,message,request,response,handler,CIMObjectPath()); |
| |
HandlerIntro(CreateInstance,message,request,response, |
|
handler,CIMObjectPath()); |
|
JNIEnv *env=NULL; | JNIEnv *env=NULL; |
try { | try { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, | Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
|
request->nameSpace.getString(), | request->nameSpace.getString(), |
request->newInstance.getPath().getClassName().getString()); | request->newInstance.getPath().getClassName().getString()); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->newInstance.getPath().getClassName().getString()<<PEGASUS_STD(endl)); |
|
|
// make target object path | // make target object path |
CIMObjectPath objectPath( | CIMObjectPath objectPath( |
System::getHostName(), | System::getHostName(), |
|
|
// convert arguments | // convert arguments |
OperationContext context; | OperationContext context; |
| |
context.insert(IdentityContainer(request->userName)); |
context.insert(request->operationContext.get(IdentityContainer::NAME)); |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
// forward request | // forward request |
JMPIProvider & pr=ph.GetProvider(); | JMPIProvider & pr=ph.GetProvider(); |
|
|
"Calling provider.createInstance: " + | "Calling provider.createInstance: " + |
ph.GetProvider().getName()); | ph.GetProvider().getName()); |
| |
DDD(cerr<<"--- JMPIProviderManager::createInstances"<<endl); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: Calling provider createInstance: "<<pr.getName()<<PEGASUS_STD(endl)); |
| |
JvmVector *jv; | JvmVector *jv; |
env=JMPIjvm::attachThread(&jv); | env=JMPIjvm::attachThread(&jv); |
| |
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath); |
jv->CIMObjectPathNewI,(jint)&objectPath); |
|
|
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
jobject jInst=env->NewObject(jv->CIMInstanceClassRef, |
|
jv->CIMInstanceNewI,(jint)&request->newInstance); |
jObj = DEBUG_ConvertCToJava (CIMInstance*, jint, &request->newInstance); |
|
|
|
jobject jInst=env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jObj); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
|
|
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;"); | "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;"); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobject jCop=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jInst); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jRef = "<<jRef<<", jInst = "<<jInst<<PEGASUS_STD(endl)); |
|
|
|
jobject inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jInst); |
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
handler.processing(); | handler.processing(); |
if (jCop) { |
if (inst) { |
CIMObjectPath cop=*((CIMObjectPath*)env->CallIntMethod(jCop,JMPIjvm::jv.CIMObjectPathCInst)); |
jint jCop = env->CallIntMethod(inst,JMPIjvm::jv.CIMObjectPathCInst); |
handler.deliver(cop); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
|
|
handler.deliver(*cop); |
} | } |
handler.complete(); | handler.complete(); |
} | } |
|
|
| |
Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw() | Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleModifyInstanceRequest"); |
"JMPIProviderManager::handleModifyInstanceRequest"); |
|
| |
HandlerIntroVoid(ModifyInstance,message,request,response,handler); | HandlerIntroVoid(ModifyInstance,message,request,response,handler); |
|
|
JNIEnv *env=NULL; | JNIEnv *env=NULL; |
|
Boolean mode24=false; |
|
CIMPropertyList propertyList; |
|
jobjectArray pl=NULL; |
|
|
try { | try { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, | Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"DefaultProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
"JMPIProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
System::getHostName(), | System::getHostName(), |
request->nameSpace.getString(), | request->nameSpace.getString(), |
request->modifiedInstance.getPath().getClassName().getString()); | request->modifiedInstance.getPath().getClassName().getString()); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->modifiedInstance.getPath().getClassName().getString()<<PEGASUS_STD(endl)); |
|
|
// make target object path | // make target object path |
CIMObjectPath objectPath( | CIMObjectPath objectPath( |
System::getHostName(), | System::getHostName(), |
|
|
ProviderName name = _resolveProviderName( | ProviderName name = _resolveProviderName( |
request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: provider name physical = "<<name.getPhysicalName()<<", logical = "<<name.getLogicalName()<<PEGASUS_STD(endl)); |
|
|
// get cached or load new provider module | // get cached or load new provider module |
JMPIProvider::OpProviderHolder ph = | JMPIProvider::OpProviderHolder ph = |
providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); | providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
|
|
// convert arguments | // convert arguments |
OperationContext context; | OperationContext context; |
| |
context.insert(IdentityContainer(request->userName)); |
context.insert(request->operationContext.get(IdentityContainer::NAME)); |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
CIMPropertyList propertyList(request->propertyList); | CIMPropertyList propertyList(request->propertyList); |
| |
// forward request | // forward request |
JMPIProvider & pr=ph.GetProvider(); | JMPIProvider & pr=ph.GetProvider(); |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.modifyInstance: " + pr.getName()); |
"Calling provider.modifyInstance: " + pr.getName()); |
|
|
|
DDD(cerr<<"--- JMPIProviderManager::modifyInstance"<<endl); |
|
| |
JvmVector *jv; | JvmVector *jv; |
env=JMPIjvm::attachThread(&jv); | env=JMPIjvm::attachThread(&jv); |
| |
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
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)); |
jv->CIMObjectPathNewI,(jint)&objectPath); |
DDD(debugPrintMethodPointers (env, (jclass)pr.jProviderClass)); |
|
|
|
jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath); |
|
|
|
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
jobject jInst=env->NewObject(jv->CIMInstanceClassRef, |
|
jv->CIMInstanceNewI,(jint)&request->modifiedInstance); |
jObj = DEBUG_ConvertCToJava (CIMInstance*, jint, &request->modifiedInstance); |
|
|
|
jobject jInst=env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jObj); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
|
|
| |
jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"setInstance", | jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"setInstance", |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V"); | "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V"); |
|
|
|
if (id==NULL) { |
|
env->ExceptionClear(); |
|
id=env->GetMethodID((jclass)pr.jProviderClass,"setInstance", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V"); |
|
JMPIjvm::checkException(env); |
|
mode24=true; |
|
pl=getList(jv,env,request->propertyList); |
|
} |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
|
if (!mode24) |
env->CallVoidMethod((jobject)pr.jProvider,id,jRef,jInst); | env->CallVoidMethod((jobject)pr.jProvider,id,jRef,jInst); |
|
else |
|
env->CallVoidMethod((jobject)pr.jProvider,id,jRef,jInst,pl); |
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
JMPIjvm::detachThread(); |
|
} | } |
HandlerCatch(handler); | HandlerCatch(handler); |
| |
|
|
| |
Message * JMPIProviderManager::handleDeleteInstanceRequest(const Message * message) throw() | Message * JMPIProviderManager::handleDeleteInstanceRequest(const Message * message) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleDeleteInstanceRequest"); |
"JMPIProviderManager::handleDeleteInstanceRequest"); |
|
|
HandlerIntroVoid(DeleteInstance,message,request,response,handler); |
| |
HandlerIntroVoid(DeleteInstance,message,request,response, |
|
handler); |
|
JNIEnv *env=NULL; | JNIEnv *env=NULL; |
try { | try { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, | Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"DefaultProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
"JMPIProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
System::getHostName(), | System::getHostName(), |
request->nameSpace.getString(), | request->nameSpace.getString(), |
request->instanceName.getClassName().getString()); | request->instanceName.getClassName().getString()); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->instanceName.getClassName().getString()<<PEGASUS_STD(endl)); |
|
|
// make target object path | // make target object path |
CIMObjectPath objectPath( | CIMObjectPath objectPath( |
System::getHostName(), | System::getHostName(), |
|
|
// convert arguments | // convert arguments |
OperationContext context; | OperationContext context; |
| |
context.insert(IdentityContainer(request->userName)); |
context.insert(request->operationContext.get(IdentityContainer::NAME)); |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
// forward request | // forward request |
JMPIProvider & pr=ph.GetProvider(); | JMPIProvider & pr=ph.GetProvider(); |
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Calling provider.deleteInstance: " + pr.getName()); | "Calling provider.deleteInstance: " + pr.getName()); |
| |
DDD(cerr<<"--- JMPIProviderManager::modifyInstance"<<endl); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: Calling provider deleteInstance: "<<pr.getName()<<PEGASUS_STD(endl)); |
| |
JvmVector *jv; | JvmVector *jv; |
env=JMPIjvm::attachThread(&jv); | env=JMPIjvm::attachThread(&jv); |
| |
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath); |
jv->CIMObjectPathNewI,(jint)&objectPath); |
|
|
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
|
|
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
JMPIjvm::detachThread(); |
|
} | } |
HandlerCatch(handler); | HandlerCatch(handler); |
| |
if (env) JMPIjvm::detachThread(); | if (env) JMPIjvm::detachThread(); |
|
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
return(response); | return(response); |
|
|
| |
Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw() | Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest"); |
"JMPIProviderManager::handleAssociatorsRequest"); |
|
|
HandlerIntro(Associators,message,request,response,handler,Array<CIMObject>()); |
| |
HandlerIntro(Associators,message,request,response, |
typedef enum { |
handler,Array<CIMObject>()); |
METHOD_UNKNOWN = 0, |
|
METHOD_DIRECTOR, |
|
METHOD_SNIA_PROVIDER20, |
|
} METHOD_VERSION; |
|
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env=NULL; | JNIEnv *env=NULL; |
|
CIMPropertyList propertyList; |
|
jobjectArray jPropertyList = NULL; |
|
|
try { | try { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, | Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2", | "JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2", |
|
|
request->nameSpace.getString(), | request->nameSpace.getString(), |
request->objectName.getClassName().getString()); | request->objectName.getClassName().getString()); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<PEGASUS_STD(endl)); |
|
|
// make target object path | // make target object path |
CIMObjectPath objectPath( | CIMObjectPath objectPath( |
System::getHostName(), | System::getHostName(), |
|
|
// convert arguments | // convert arguments |
OperationContext context; | OperationContext context; |
| |
context.insert(IdentityContainer(request->userName)); |
context.insert(request->operationContext.get(IdentityContainer::NAME)); |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
// forward request | // forward request |
JMPIProvider & pr=ph.GetProvider(); | JMPIProvider & pr=ph.GetProvider(); |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associators: " + pr.getName()); |
"Calling provider.associators: " + pr.getName()); |
|
| |
DDD(cerr<<"--- JMPIProviderManager::associators"<< |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Calling provider associators: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl)); |
" role: >"<<request->role<<"< aCls "<< |
|
request->assocClass<<endl); |
JvmVector *jv = 0; |
| |
JvmVector *jv; |
|
env=JMPIjvm::attachThread(&jv); | env=JMPIjvm::attachThread(&jv); |
| |
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath); |
jv->CIMObjectPathNewI,(jint)&objectPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jstring rClass=env->NewStringUTF(request->resultClass.getString().getCString()); |
jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString()); |
jstring rRole=env->NewStringUTF(request->role.getCString()); |
jstring jRole = env->NewStringUTF(request->role.getCString()); |
jstring resRole=env->NewStringUTF(request->resultRole.getCString()); |
jstring jResultRole = env->NewStringUTF(request->resultRole.getCString()); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"associators", |
jmethodID id = NULL; |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;" |
|
"Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"); |
// public abstract java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName, |
|
// java.lang.String resultClass, |
|
// java.lang.String role, |
|
// java.lang.String resultRole, |
|
// boolean includeQualifiers, |
|
// boolean includeClassOrigin, |
|
// java.lang.String[] propertyList) |
|
// throws org.pegasus.jmpi.CIMException; |
|
// |
|
id = env->GetMethodID((jclass)pr.jProviderClass, |
|
"associators", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"); |
|
|
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_DIRECTOR; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_DIRECTOR."<<PEGASUS_STD(endl)); |
|
} |
|
|
|
if (id == NULL) |
|
{ |
|
env->ExceptionClear(); |
|
|
|
// public abstract java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName, |
|
// org.pegasus.jmpi.CIMObjectPath pathName, |
|
// java.lang.String resultClass, |
|
// java.lang.String role, |
|
// java.lang.String resultRole, |
|
// boolean includeQualifiers, |
|
// boolean includeClassOrigin, |
|
// java.lang.String[] propertyList) |
|
// throws org.pegasus.jmpi.CIMException; |
|
// |
|
id = env->GetMethodID((jclass)pr.jProviderClass, |
|
"associators", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"); |
|
|
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_SNIA_PROVIDER20; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl)); |
|
} |
|
} |
|
|
|
if (id == NULL) |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl)); |
|
} |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef, |
jPropertyList = getList(jv,env,request->propertyList); |
rClass,rRole,resRole,false,false,NULL); |
|
|
switch (eMethodFound) |
|
{ |
|
case METHOD_DIRECTOR: |
|
{ |
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jAssociationName, |
|
jResultClass, |
|
jRole, |
|
jResultRole, |
|
false, |
|
false, |
|
jPropertyList); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; | 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->GetArrayLength(jVec); i<m; i++) { |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
|
jobject jInst=env->GetObjectArrayElement(jVec,i); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst)); |
|
|
jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace, |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi); |
inst.getClassName(),false,true,true,CIMPropertyList()); |
CIMClass cls = pr._cimom_handle->getClass(context,request->nameSpace,ci->getClassName(),false,true,true,CIMPropertyList()); |
const CIMObjectPath& op=inst.getPath(); |
const CIMObjectPath& op = ci->getPath(); |
CIMObjectPath iop=inst.buildPath(cls); |
CIMObjectPath iop = ci->buildPath(cls); |
|
|
|
iop.setNameSpace(op.getNameSpace()); |
|
ci->setPath(iop); |
|
|
|
handler.deliver(*ci); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_SNIA_PROVIDER20: |
|
{ |
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &assocPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jAssociationName, |
|
jPathName, |
|
jResultClass, |
|
jRole, |
|
jResultRole, |
|
false, |
|
false, |
|
jPropertyList); |
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
if (jVec) { |
|
for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jInst=env->GetObjectArrayElement(jVec,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi); |
|
CIMClass cls = pr._cimom_handle->getClass(context,request->nameSpace,ci->getClassName(),false,true,true,CIMPropertyList()); |
|
const CIMObjectPath& op = ci->getPath(); |
|
CIMObjectPath iop = ci->buildPath(cls); |
|
|
iop.setNameSpace(op.getNameSpace()); | iop.setNameSpace(op.getNameSpace()); |
inst.setPath(iop); |
ci->setPath(iop); |
| |
handler.deliver(inst); |
handler.deliver(*ci); |
} | } |
} | } |
handler.complete(); | handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_UNKNOWN: |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl)); |
|
break; |
|
} |
|
} |
} | } |
HandlerCatch(handler); | HandlerCatch(handler); |
| |
|
|
return(response); | return(response); |
} | } |
| |
|
|
|
|
Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw() | Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorNamesRequest"); |
"JMPIProviderManager::handleAssociatorNamesRequest"); |
|
|
HandlerIntro(AssociatorNames,message,request,response,handler,Array<CIMObjectPath>()); |
| |
HandlerIntro(AssociatorNames,message,request,response, |
typedef enum { |
handler,Array<CIMObjectPath>()); |
METHOD_UNKNOWN = 0, |
|
METHOD_DIRECTOR, |
|
METHOD_SNIA_PROVIDER20 |
|
} METHOD_VERSION; |
|
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env=NULL; | JNIEnv *env=NULL; |
|
|
try { | try { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, | Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2", | "JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2", |
|
|
request->nameSpace.getString(), | request->nameSpace.getString(), |
request->objectName.getClassName().getString()); | request->objectName.getClassName().getString()); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<PEGASUS_STD(endl)); |
|
|
// make target object path | // make target object path |
CIMObjectPath objectPath( | CIMObjectPath objectPath( |
System::getHostName(), | System::getHostName(), |
|
|
// convert arguments | // convert arguments |
OperationContext context; | OperationContext context; |
| |
context.insert(IdentityContainer(request->userName)); |
context.insert(request->operationContext.get(IdentityContainer::NAME)); |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
// forward request | // forward request |
JMPIProvider & pr=ph.GetProvider(); | JMPIProvider & pr=ph.GetProvider(); |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associatorNames: " + pr.getName()); |
"Calling provider.associatorNames: " + pr.getName()); |
|
| |
DDD(cerr<<"--- JMPIProviderManager::associatorNames"<< |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: Calling provider associatorNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl)); |
" role: >"<<request->role<<"< aCls "<< |
|
request->assocClass<<endl); |
JvmVector *jv = 0; |
| |
JvmVector *jv; |
|
env=JMPIjvm::attachThread(&jv); | env=JMPIjvm::attachThread(&jv); |
| |
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath); |
jv->CIMObjectPathNewI,(jint)&objectPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jstring rClass=env->NewStringUTF(request->resultClass.getString().getCString()); |
jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString()); |
jstring rRole=env->NewStringUTF(request->role.getCString()); |
jstring jRole = env->NewStringUTF(request->role.getCString()); |
jstring resRole=env->NewStringUTF(request->resultRole.getCString()); |
jstring jResultRole = env->NewStringUTF(request->resultRole.getCString()); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"associatorNames", |
jmethodID id = NULL; |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;" |
|
"Ljava/lang/String;)Ljava/util/Vector;"); |
// public abstract java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName, |
|
// java.lang.String resultClass, |
|
// java.lang.String role, |
|
// java.lang.String resultRole) |
|
// throws org.pegasus.jmpi.CIMException |
|
id = env->GetMethodID((jclass)pr.jProviderClass, |
|
"associatorNames", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"); |
|
|
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_DIRECTOR; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_DIRECTOR."<<PEGASUS_STD(endl)); |
|
} |
|
|
|
if (id == NULL) |
|
{ |
|
env->ExceptionClear(); |
|
|
|
// public abstract java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName, |
|
// org.pegasus.jmpi.CIMObjectPath pathName, |
|
// java.lang.String resultClass, |
|
// java.lang.String role, |
|
// java.lang.String resultRole) |
|
// throws org.pegasus.jmpi.CIMException |
|
id = env->GetMethodID((jclass)pr.jProviderClass, |
|
"associatorNames", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"); |
|
|
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_SNIA_PROVIDER20; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl)); |
|
} |
|
} |
|
|
|
if (id == NULL) |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found no method!"<<PEGASUS_STD(endl)); |
|
} |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef, |
switch (eMethodFound) |
rClass,rRole,resRole); |
{ |
|
case METHOD_DIRECTOR: |
|
{ |
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jAssociationName, |
|
jResultClass, |
|
jRole, |
|
jResultRole); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; | 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->GetArrayLength(jVec); i<m; i++) { |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
jobject jCop=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
|
jobject jInst=env->GetObjectArrayElement(jVec,i); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod |
|
(jCop,JMPIjvm::jv.CIMObjectPathCInst)); |
jint jCop = env->CallIntMethod(jInst,JMPIjvm::jv.CIMObjectPathCInst); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
|
|
handler.deliver(*cop); | handler.deliver(*cop); |
} | } |
} | } |
handler.complete(); | handler.complete(); |
|
break; |
} | } |
HandlerCatch(handler); |
|
| |
if (env) JMPIjvm::detachThread(); |
case METHOD_SNIA_PROVIDER20: |
|
{ |
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &assocPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jAssociationName, |
|
jPathNameRef, |
|
jResultClass, |
|
jRole, |
|
jResultRole); |
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
if (jVec) { |
|
for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jInst=env->GetObjectArrayElement(jVec,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jCop = env->CallIntMethod(jInst,JMPIjvm::jv.CIMObjectPathCInst); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
handler.deliver(*cop); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_UNKNOWN: |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: should not be here!"<<PEGASUS_STD(endl)); |
|
break; |
|
} |
|
} |
|
} |
|
HandlerCatch(handler); |
|
|
|
if (env) JMPIjvm::detachThread(); |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
return(response); | return(response); |
} | } |
| |
|
|
Message * JMPIProviderManager::handleReferencesRequest(const Message * message) throw() | Message * JMPIProviderManager::handleReferencesRequest(const Message * message) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferencesRequest"); |
"JMPIProviderManager::handleReferencesRequest"); |
|
|
HandlerIntro(References,message,request,response,handler,Array<CIMObject>()); |
| |
HandlerIntro(References,message,request,response, |
typedef enum { |
handler,Array<CIMObject>()); |
METHOD_UNKNOWN = 0, |
|
METHOD_DIRECTOR, |
|
METHOD_SNIA_PROVIDER20, |
|
} METHOD_VERSION; |
|
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env=NULL; | JNIEnv *env=NULL; |
|
CIMPropertyList propertyList; |
|
jobjectArray jPropertyList = NULL; |
|
|
try { | try { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, | Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"DefaultProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2", |
"JMPIProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2", |
System::getHostName(), | System::getHostName(), |
request->nameSpace.getString(), | request->nameSpace.getString(), |
request->objectName.getClassName().getString()); | request->objectName.getClassName().getString()); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<PEGASUS_STD(endl)); |
|
|
// make target object path | // make target object path |
CIMObjectPath objectPath( | CIMObjectPath objectPath( |
System::getHostName(), | System::getHostName(), |
|
|
// convert arguments | // convert arguments |
OperationContext context; | OperationContext context; |
| |
context.insert(IdentityContainer(request->userName)); |
context.insert(request->operationContext.get(IdentityContainer::NAME)); |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
// forward request | // forward request |
JMPIProvider & pr=ph.GetProvider(); | JMPIProvider & pr=ph.GetProvider(); |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.references: " + pr.getName()); |
"Calling provider.references: " + pr.getName()); |
|
| |
DDD(cerr<<"--- JMPIProviderManager::references"<<" role: >"<<request->role<<"< aCls "<< |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Calling provider references: "<<pr.getName()<<", role: "<<request->role<<" aCls: "<<request->resultClass<<PEGASUS_STD(endl)); |
request->resultClass<<endl); |
|
|
JvmVector *jv = 0; |
| |
JvmVector *jv; |
|
env=JMPIjvm::attachThread(&jv); | env=JMPIjvm::attachThread(&jv); |
| |
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath); |
jv->CIMObjectPathNewI,(jint)&objectPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jstring rRole=env->NewStringUTF(request->role.getCString()); |
jstring jRole = env->NewStringUTF(request->role.getCString()); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"references", |
jmethodID id = NULL; |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
|
"ZZ[Ljava/lang/String;)Ljava/util/Vector;"); |
// public abstract java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName, |
|
// java.lang.String role, |
|
// boolean includeQualifiers, |
|
// boolean includeClassOrigin, |
|
// java.lang.String[] propertyList) |
|
// throws org.pegasus.jmpi.CIMException |
|
id = env->GetMethodID((jclass)pr.jProviderClass, |
|
"references", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"); |
|
|
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_DIRECTOR; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_DIRECTOR."<<PEGASUS_STD(endl)); |
|
} |
|
|
|
if (id == NULL) |
|
{ |
|
env->ExceptionClear(); |
|
|
|
// public abstract java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName, |
|
// org.pegasus.jmpi.CIMObjectPath pathName, |
|
// java.lang.String role, |
|
// boolean includeQualifiers, |
|
// boolean includeClassOrigin, |
|
// java.lang.String[] propertyList) |
|
// throws org.pegasus.jmpi.CIMException |
|
id = env->GetMethodID((jclass)pr.jProviderClass, |
|
"references", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"); |
|
|
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_SNIA_PROVIDER20; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl)); |
|
} |
|
} |
|
|
|
if (id == NULL) |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl)); |
|
} |
| |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef, |
jPropertyList = getList(jv,env,request->propertyList); |
rRole,false,false,NULL); |
|
|
switch (eMethodFound) |
|
{ |
|
case METHOD_DIRECTOR: |
|
{ |
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jAssociationName, |
|
jRole, |
|
false, |
|
false, |
|
jPropertyList); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; | 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->GetArrayLength(jVec); i<m; i++) { |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
|
jobject jInst=env->GetObjectArrayElement(jVec,i); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst)); |
|
|
jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace, |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi); |
inst.getClassName(),false,true,true,CIMPropertyList()); |
CIMClass cls = pr._cimom_handle->getClass(context, |
const CIMObjectPath& op=inst.getPath(); |
request->nameSpace, |
CIMObjectPath iop=inst.buildPath(cls); |
ci->getClassName(), |
|
false, |
|
true, |
|
true, |
|
CIMPropertyList()); |
|
const CIMObjectPath& op = ci->getPath(); |
|
CIMObjectPath iop = ci->buildPath(cls); |
|
|
|
iop.setNameSpace(op.getNameSpace()); |
|
ci->setPath(iop); |
|
|
|
handler.deliver(*ci); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_SNIA_PROVIDER20: |
|
{ |
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &resultPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jAssociationName, |
|
jPathName, |
|
jRole, |
|
false, |
|
false, |
|
jPropertyList); |
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
if (jVec) { |
|
for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jInst=env->GetObjectArrayElement(jVec,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi); |
|
CIMClass cls = pr._cimom_handle->getClass(context, |
|
request->nameSpace, |
|
ci->getClassName(), |
|
false, |
|
true, |
|
true, |
|
CIMPropertyList()); |
|
const CIMObjectPath& op = ci->getPath(); |
|
CIMObjectPath iop = ci->buildPath(cls); |
|
|
iop.setNameSpace(op.getNameSpace()); | iop.setNameSpace(op.getNameSpace()); |
inst.setPath(iop); |
ci->setPath(iop); |
| |
handler.deliver(inst); |
handler.deliver(*ci); |
} | } |
} | } |
handler.complete(); | handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_UNKNOWN: |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl)); |
|
break; |
|
} |
|
} |
} | } |
HandlerCatch(handler); | HandlerCatch(handler); |
| |
|
|
return(response); | return(response); |
} | } |
| |
|
|
Message * JMPIProviderManager::handleReferenceNamesRequest(const Message * message) throw() | Message * JMPIProviderManager::handleReferenceNamesRequest(const Message * message) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferenceNamesRequest"); |
"JMPIProviderManager::handleReferenceNamesRequest"); |
|
|
HandlerIntro(ReferenceNames,message,request,response,handler,Array<CIMObjectPath>()); |
| |
HandlerIntro(ReferenceNames,message,request,response, |
typedef enum { |
handler,Array<CIMObjectPath>()); |
METHOD_UNKNOWN = 0, |
|
METHOD_DIRECTOR, |
|
METHOD_SNIA_PROVIDER20, |
|
} METHOD_VERSION; |
|
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
JNIEnv *env=NULL; | JNIEnv *env=NULL; |
|
|
try { | try { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, | Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"JMPIProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2", | "JMPIProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2", |
|
|
request->nameSpace.getString(), | request->nameSpace.getString(), |
request->objectName.getClassName().getString()); | request->objectName.getClassName().getString()); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<PEGASUS_STD(endl)); |
|
|
// make target object path | // make target object path |
CIMObjectPath objectPath( | CIMObjectPath objectPath( |
System::getHostName(), | System::getHostName(), |
|
|
// convert arguments | // convert arguments |
OperationContext context; | OperationContext context; |
| |
context.insert(IdentityContainer(request->userName)); |
context.insert(request->operationContext.get(IdentityContainer::NAME)); |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
JMPIProvider & pr=ph.GetProvider(); | JMPIProvider & pr=ph.GetProvider(); |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.referenceNames: " + pr.getName()); |
"Calling provider.referenceNames: " + pr.getName()); |
|
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: Calling provider referenceNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->resultClass<<PEGASUS_STD(endl)); |
| |
DDD(cerr<<"--- JMPIProviderManager::referenceNames"<<" role: >"<<request->role<<"< aCls "<< |
JvmVector *jv = 0; |
request->resultClass<<endl); |
|
| |
JvmVector *jv; |
|
env=JMPIjvm::attachThread(&jv); | env=JMPIjvm::attachThread(&jv); |
| |
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath); |
jv->CIMObjectPathNewI,(jint)&objectPath); |
jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jstring rRole=env->NewStringUTF(request->role.getCString()); |
jstring jRole = env->NewStringUTF(request->role.getCString()); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"referenceNames", |
jmethodID id = NULL; |
|
|
|
// public abstract java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName, |
|
// java.lang.String role) |
|
// throws org/pegasus/jmpi/CIMException |
|
id = env->GetMethodID((jclass)pr.jProviderClass, |
|
"referenceNames", |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;"); | "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;"); |
| |
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_DIRECTOR; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_DIRECTOR."<<PEGASUS_STD(endl)); |
|
} |
|
|
|
if (id == NULL) |
|
{ |
|
env->ExceptionClear(); |
|
|
|
// public abstract java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName, |
|
// org.pegasus.jmpi.CIMObjectPath pathName, |
|
// java.lang.String role) |
|
// throws org/pegasus/jmpi/CIMException |
|
id = env->GetMethodID((jclass)pr.jProviderClass, |
|
"referenceNames", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;"); |
|
|
|
if (id != NULL) |
|
{ |
|
eMethodFound = METHOD_SNIA_PROVIDER20; |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl)); |
|
} |
|
} |
|
|
|
if (id == NULL) |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl)); |
|
} |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,rRole); |
switch (eMethodFound) |
|
{ |
|
case METHOD_DIRECTOR: |
|
{ |
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jAssociationName, |
|
jRole); |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; | 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->GetArrayLength(jVec); i<m; i++) { |
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
jobject jCop=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
|
jobject jInst=env->GetObjectArrayElement(jVec,i); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod |
|
(jCop,JMPIjvm::jv.CIMObjectPathCInst)); |
jint jCop = env->CallIntMethod(jInst,JMPIjvm::jv.CIMObjectPathCInst); |
|
|
JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
|
|
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
|
handler.deliver(*cop); | handler.deliver(*cop); |
} | } |
} | } |
handler.complete(); | handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_SNIA_PROVIDER20: |
|
{ |
|
jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &resultPath); |
|
jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider, |
|
id, |
|
jAssociationName, |
|
jPathName, |
|
jRole); |
|
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
if (jVec) { |
|
for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jInst=env->GetObjectArrayElement(jVec,i); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
jint jCop = env->CallIntMethod(jInst,JMPIjvm::jv.CIMObjectPathCInst); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
|
|
handler.deliver(*cop); |
|
} |
|
} |
|
handler.complete(); |
|
break; |
|
} |
|
|
|
case METHOD_UNKNOWN: |
|
{ |
|
DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl)); |
|
break; |
|
} |
|
} |
} | } |
HandlerCatch(handler); | HandlerCatch(handler); |
| |
|
|
return(response); | return(response); |
} | } |
| |
|
|
/* |
|
Message * JMPIProviderManager::handleInvokeMethodRequest(const Message * message) throw() | Message * JMPIProviderManager::handleInvokeMethodRequest(const Message * message) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleInvokeMethodRequest"); |
"JMPIProviderManager::handleInvokeMethodRequest"); |
|
|
HandlerIntroMethod(InvokeMethod,message,request,response,handler); |
|
|
|
JNIEnv *env=NULL; |
|
Boolean mode24=false; |
| |
HandlerIntroMethod(InvokeMethod,message,request,response, |
|
handler); |
|
try { | try { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, | Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"JMPIProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2", | "JMPIProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2", |
|
|
request->nameSpace.getString(), | request->nameSpace.getString(), |
request->instanceName.getClassName().getString()); | request->instanceName.getClassName().getString()); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->instanceName.getClassName().getString()<<PEGASUS_STD(endl)); |
|
|
// make target object path | // make target object path |
CIMObjectPath objectPath( | CIMObjectPath objectPath( |
System::getHostName(), | System::getHostName(), |
|
|
// convert arguments | // convert arguments |
OperationContext context; | OperationContext context; |
| |
context.insert(IdentityContainer(request->userName)); |
context.insert(request->operationContext.get(IdentityContainer::NAME)); |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
|
|
CIMObjectPath instanceReference(request->instanceName); |
|
|
|
// ATTN: propagate namespace |
|
instanceReference.setNameSpace(request->nameSpace); |
|
| |
// forward request |
|
JMPIProvider & pr=ph.GetProvider(); | JMPIProvider & pr=ph.GetProvider(); |
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Calling provider.invokeMethod: " + pr.getName()); | "Calling provider.invokeMethod: " + pr.getName()); |
| |
CMPIStatus rc={CMPI_RC_OK,NULL}; |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: Calling provider invokeMethod: "<<pr.getName()<<PEGASUS_STD(endl)); |
CMPI_ContextOnStack eCtx(context); |
JvmVector *jv; |
CMPI_ObjectPathOnStack eRef(objectPath); |
env=JMPIjvm::attachThread(&jv); |
CMPI_ResultOnStack eRes(handler,&pr.broker); |
|
CMPI_ThreadContext thr(&pr.broker,&eCtx); |
|
CMPI_ArgsOnStack eArgsIn(request->inParameters); |
|
Array<CIMParamValue> outArgs; |
|
CMPI_ArgsOnStack eArgsOut(outArgs); |
|
CString mName=request->methodName.getString().getCString(); |
|
| |
CMPIFlags flgs=0; |
jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath); |
eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32); |
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj); |
|
JMPIjvm::checkException(env); |
|
|
|
jstring jMethod=env->NewStringUTF(request->methodName.getString().getCString()); |
|
JMPIjvm::checkException(env); |
| |
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
rc=pr.miVector.methMI->ft->invokeMethod( |
jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"invokeMethod", |
pr.miVector.methMI,&eCtx,&eRes,&eRef,CHARS(mName),&eArgsIn,&eArgsOut); |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
|
"Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;"); |
|
|
|
if (id==NULL) { |
|
env->ExceptionClear(); |
|
id=env->GetMethodID((jclass)pr.jProviderClass,"invokeMethod", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
|
"[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;"); |
|
JMPIjvm::checkException(env); |
|
mode24=true; |
|
} |
|
JMPIjvm::checkException(env); |
|
|
|
if (!mode24) { |
|
jobject jVecIn=env->NewObject(jv->VectorClassRef,jv->VectorNew); |
|
JMPIjvm::checkException(env); |
|
for (int i=0,m=request->inParameters.size(); i<m; i++) { |
|
const CIMParamValue &parm = request->inParameters[i]; |
|
const CIMValue v = parm.getValue(); |
|
CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize()); |
|
jint jObj = DEBUG_ConvertCToJava (CIMProperty*, jint, p); |
|
|
|
jobject prop=env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jObj); |
|
|
|
env->CallVoidMethod(jVecIn,jv->VectorAddElement,prop); |
|
} |
|
|
|
jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew); |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jValue=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jMethod,jVecIn,jVecOut); |
|
JMPIjvm::checkException(env); |
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
if (rc.rc!=CMPI_RC_OK) |
handler.processing(); |
throw CIMException((CIMStatusCode)rc.rc); |
|
|
jint jv = env->CallIntMethod(jValue,JMPIjvm::jv.CIMValueCInst); |
|
CIMValue *v = DEBUG_ConvertJavaToC (jint, CIMValue*, jv); |
|
|
|
handler.deliver(*v); |
|
|
|
for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); i<m; i++) { |
|
JMPIjvm::checkException(env); |
|
|
|
jobject jProp=env->CallObjectMethod(jVecOut,JMPIjvm::jv.VectorElementAt,i); |
|
JMPIjvm::checkException(env); |
|
|
|
jint jp = env->CallIntMethod(jProp,JMPIjvm::jv.PropertyCInst); |
|
CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue())); |
|
} |
| |
for (int i=0,s=outArgs.size(); i<s; i++) |
|
handler.deliverParamValue(outArgs[i]); |
|
handler.complete(); | handler.complete(); |
} | } |
HandlerCatch(handler); |
else { |
|
Uint32 m=request->inParameters.size(); |
| |
PEG_METHOD_EXIT(); |
jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL); |
|
for (Uint32 i=0; i<m; i++) { |
|
CIMParamValue *parm = new CIMParamValue(request->inParameters[i]); |
|
jint jObj = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm); |
|
jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jObj); |
| |
return(response); |
env->SetObjectArrayElement(jArIn,i,jArg); |
} | } |
*//* |
|
struct indProvRecord { |
|
indProvRecord() : enabled(false), count(1), handler(NULL) {} |
|
Boolean enabled; |
|
int count; |
|
EnableIndicationsResponseHandler* handler; |
|
}; |
|
| |
struct indSelectRecord { |
jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL); |
indSelectRecord() : eSelx(NULL) {} |
|
CMPI_SelectExp *eSelx; |
jobject jValue=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jMethod,jArIn,jArOut); |
}; |
JMPIjvm::checkException(env); |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
handler.processing(); |
|
|
|
jint jv = env->CallIntMethod(jValue,JMPIjvm::jv.CIMValueCInst); |
|
CIMValue *v = DEBUG_ConvertJavaToC (jint, CIMValue*, jv); |
|
|
|
handler.deliver(*v); |
|
|
|
for (int i=0; i<24; i++) { |
|
jobject jArg=env->GetObjectArrayElement(jArOut,i); |
|
JMPIjvm::checkException(env); |
|
|
|
if (jArg==NULL) break; |
|
|
|
jint jp = env->CallIntMethod(jArg,JMPIjvm::jv.ArgumentCInst); |
|
CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp); |
|
|
|
JMPIjvm::checkException(env); |
|
|
|
handler.deliverParamValue(*p); |
|
} |
|
|
|
handler.complete(); |
|
} |
|
} |
|
HandlerCatch(handler); |
|
|
|
if (env) JMPIjvm::detachThread(); |
| |
|
PEG_METHOD_EXIT(); |
| |
typedef HashTable<String,indProvRecord*,EqualFunc<String>,HashFunc<String> > IndProvTab; |
return(response); |
typedef HashTable<String,indSelectRecord*,EqualFunc<String>,HashFunc<String> > IndSelectTab; |
} |
| |
IndProvTab provTab; |
|
IndSelectTab selxTab; |
|
*//* |
|
int LocateIndicationProviderNames(const CIMInstance& pInstance, const CIMInstance& pmInstance, | int LocateIndicationProviderNames(const CIMInstance& pInstance, const CIMInstance& pmInstance, |
String& providerName, String& location) | String& providerName, String& location) |
{ | { |
|
|
| |
Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw() | Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateSubscriptionRequest"); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleCreateSubscriptionRequest"); |
| |
HandlerIntroInd(CreateSubscription,message,request,response, |
HandlerIntroInd(CreateSubscription,message,request,response,handler); |
handler); |
|
|
JNIEnv *env=NULL; |
try { | try { |
const CIMObjectPath &x=request->subscriptionInstance.getPath(); | const CIMObjectPath &x=request->subscriptionInstance.getPath(); |
| |
String providerName,providerLocation; | String providerName,providerLocation; |
LocateIndicationProviderNames(request->provider, request->providerModule, |
CIMInstance req_provider, req_providerModule; |
providerName,providerLocation); |
ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME); |
|
req_provider = pidc.getProvider(); |
|
req_providerModule = pidc.getModule(); |
|
LocateIndicationProviderNames(req_provider, req_providerModule,providerName,providerLocation); |
| |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, | Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2", | "JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2", |
|
|
request->nameSpace.getString(), | request->nameSpace.getString(), |
providerName); | providerName); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl)); |
|
|
String fileName = resolveFileName(providerLocation); | String fileName = resolveFileName(providerLocation); |
| |
// get cached or load new provider module | // get cached or load new provider module |
|
|
| |
indProvRecord *prec=NULL; | indProvRecord *prec=NULL; |
provTab.lookup(providerName,prec); | provTab.lookup(providerName,prec); |
if (prec) prec->count++; |
if (prec) |
|
prec->count++; |
else { | else { |
prec=new indProvRecord(); | prec=new indProvRecord(); |
provTab.insert(providerName,prec); | provTab.insert(providerName,prec); |
} | } |
| |
|
// |
|
// Save the provider instance from the request |
|
// |
|
ph.GetProvider ().setProviderInstance (req_provider); |
|
|
indSelectRecord *srec=new indSelectRecord(); | indSelectRecord *srec=new indSelectRecord(); |
const CIMObjectPath &sPath=request->subscriptionInstance.getPath(); | const CIMObjectPath &sPath=request->subscriptionInstance.getPath(); |
selxTab.insert(sPath.toString(),srec); | selxTab.insert(sPath.toString(),srec); |
|
|
// convert arguments | // convert arguments |
OperationContext *context=new OperationContext(); | OperationContext *context=new OperationContext(); |
| |
context->insert(IdentityContainer(request->userName)); |
if (prec->ctx==NULL) { |
context->insert(SubscriptionInstanceContainer |
prec->ctx=context; |
(request->subscriptionInstance)); |
} |
context->insert(SubscriptionFilterConditionContainer |
|
(request->condition, request->queryLanguage)); |
context->insert(request->operationContext.get(IdentityContainer::NAME)); |
|
context->insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
context->insert(SubscriptionLanguageListContainer |
context->insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
(request->acceptLanguages)); |
context->insert(request->operationContext.get(SubscriptionInstanceContainer::NAME)); |
context->insert(AcceptLanguageListContainer(request->acceptLanguages)); |
context->insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME)); |
context->insert(ContentLanguageListContainer(request->contentLanguages)); |
context->insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME)); |
| |
CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); | CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); |
| |
|
SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get |
|
(SubscriptionFilterConditionContainer::NAME); |
|
|
JMPIProvider & pr=ph.GetProvider(); | JMPIProvider & pr=ph.GetProvider(); |
| |
CMPIStatus rc={CMPI_RC_OK,NULL}; |
CIMOMHandleQueryContext *qcontext=new CIMOMHandleQueryContext(CIMNamespaceName(request->nameSpace.getString()), |
CMPI_ContextOnStack eCtx(*context); |
*pr._cimom_handle); |
|
|
CMPI_SelectExp *eSelx=new CMPI_SelectExp(*context, | CMPI_SelectExp *eSelx=new CMPI_SelectExp(*context, |
|
qcontext, |
request->query, | request->query, |
request->queryLanguage); |
sub_cntr.getQueryLanguage()); |
|
|
srec->eSelx=eSelx; | srec->eSelx=eSelx; |
CMPI_ThreadContext thr(&pr.broker,&eCtx); |
srec->qContext=qcontext; |
|
|
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Calling provider.createSubscriptionRequest: " + pr.getName()); | "Calling provider.createSubscriptionRequest: " + pr.getName()); |
| |
DDD(cerr<<"--- JMPIProviderManager::createSubscriptionRequest"<<endl); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Calling provider createSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl)); |
| |
for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) { | for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) { |
CIMObjectPath className( | CIMObjectPath className( |
|
|
request->classNames[i]); | request->classNames[i]); |
eSelx->classNames.append(className); | eSelx->classNames.append(className); |
} | } |
CMPI_ObjectPathOnStack eRef(eSelx->classNames[0]); |
|
| |
CIMPropertyList propertyList = request->propertyList; | CIMPropertyList propertyList = request->propertyList; |
if (!propertyList.isNull()) { | if (!propertyList.isNull()) { |
|
|
eSelx->props[pCount]=NULL; | eSelx->props[pCount]=NULL; |
} | } |
| |
Uint16 repeatNotificationPolicy = request->repeatNotificationPolicy; |
JvmVector *jv; |
|
env=JMPIjvm::attachThread(&jv); |
|
|
|
jint jObj = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx); |
|
|
|
jobject jSel=env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jObj); |
|
JMPIjvm::checkException(env); |
|
|
|
jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]); |
|
|
|
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj); |
|
JMPIjvm::checkException(env); |
|
|
|
jstring jType=env->NewStringUTF(request->nameSpace.getString().getCString()); |
|
JMPIjvm::checkException(env); |
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
rc=pr.miVector.indMI->ft->activateFilter( |
jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"activateFilter", |
pr.miVector.indMI,&eCtx,NULL,eSelx, |
"(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;" |
CHARS(request->nameSpace.getString().getCString()),&eRef,false); |
"Lorg/pegasus/jmpi/CIMObjectPath;Z)V"); |
|
JMPIjvm::checkException(env); |
|
|
|
env->CallVoidMethod((jobject)pr.jProvider,id,jSel,jType, |
|
jRef,(jboolean)0); |
|
JMPIjvm::checkException(env); |
|
|
|
// |
|
// Increment count of current subscriptions for this provider |
|
// |
|
if (ph.GetProvider ().testIfZeroAndIncrementSubscriptions ()) |
|
{ |
|
// |
|
// If there were no current subscriptions before the increment, |
|
// the first subscription has been created |
|
// Call the provider's enableIndications method |
|
// |
|
if (_subscriptionInitComplete) |
|
{ |
|
prec->enabled = true; |
|
CIMRequestMessage * request = 0; |
|
CIMResponseMessage * response = 0; |
|
prec->handler = new EnableIndicationsResponseHandler |
|
(request, response, req_provider, _indicationCallback); |
|
} |
|
} |
| |
STAT_PMS_PROVIDEREND; | STAT_PMS_PROVIDEREND; |
| |
if (rc.rc!=CMPI_RC_OK) |
|
throw CIMException((CIMStatusCode)rc.rc); |
|
} | } |
HandlerCatch(handler); | HandlerCatch(handler); |
| |
|
if (env) JMPIjvm::detachThread(); |
|
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
return(response); | return(response); |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDeleteSubscriptionRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDeleteSubscriptionRequest"); |
| |
HandlerIntroInd(DeleteSubscription,message,request,response, |
HandlerIntroInd(DeleteSubscription,message,request,response,handler); |
handler); |
|
|
JNIEnv *env=NULL; |
try { | try { |
String providerName,providerLocation; | String providerName,providerLocation; |
LocateIndicationProviderNames(request->provider, request->providerModule, |
CIMInstance req_provider, req_providerModule; |
|
ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME); |
|
req_provider = pidc.getProvider(); |
|
req_providerModule = pidc.getModule(); |
|
|
|
LocateIndicationProviderNames(req_provider, req_providerModule, |
providerName,providerLocation); | providerName,providerLocation); |
| |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, | Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
|
request->nameSpace.getString(), | request->nameSpace.getString(), |
providerName); | providerName); |
| |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl)); |
|
|
String fileName = resolveFileName(providerLocation); | String fileName = resolveFileName(providerLocation); |
| |
// get cached or load new provider module | // get cached or load new provider module |
JMPIProvider::OpProviderHolder ph = | JMPIProvider::OpProviderHolder ph = |
providerManager.getProvider(fileName, providerName, String::EMPTY); | providerManager.getProvider(fileName, providerName, String::EMPTY); |
| |
|
|
indProvRecord *prec=NULL; | indProvRecord *prec=NULL; |
provTab.lookup(providerName,prec); | provTab.lookup(providerName,prec); |
if (--prec->count<=0) { | if (--prec->count<=0) { |
|
|
selxTab.lookup(sPathString,srec); | selxTab.lookup(sPathString,srec); |
| |
CMPI_SelectExp *eSelx=srec->eSelx; | CMPI_SelectExp *eSelx=srec->eSelx; |
CMPI_ObjectPathOnStack eRef(eSelx->classNames[0]); |
CIMOMHandleQueryContext *qContext=srec->qContext; |
|
|
selxTab.remove(sPathString); | selxTab.remove(sPathString); |
| |
// convert arguments | // convert arguments |
OperationContext context; | OperationContext context; |
| |
context.insert(IdentityContainer(request->userName)); |
context.insert(request->operationContext.get(IdentityContainer::NAME)); |
context.insert(SubscriptionInstanceContainer |
context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
(request->subscriptionInstance)); |
context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
|
context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME)); |
context.insert(SubscriptionLanguageListContainer |
context.insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME)); |
(request->acceptLanguages)); |
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
| |
CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); | CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); |
| |
JMPIProvider & pr=ph.GetProvider(); | JMPIProvider & pr=ph.GetProvider(); |
| |
CMPIStatus rc={CMPI_RC_OK,NULL}; |
|
CMPI_ContextOnStack eCtx(context); |
|
CMPI_ThreadContext thr(&pr.broker,&eCtx); |
|
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
"Calling provider.deleteSubscriptionRequest: " + pr.getName()); | "Calling provider.deleteSubscriptionRequest: " + pr.getName()); |
| |
DDD(cerr<<"--- JMPIProviderManager::deleteSubscriptionRequest"<<endl); |
DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Calling provider deleteSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl)); |
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
JvmVector *jv; |
|
env=JMPIjvm::attachThread(&jv); |
STAT_GETSTARTTIME; |
|
|
|
rc=pr.miVector.indMI->ft->deActivateFilter( |
|
pr.miVector.indMI,&eCtx,NULL,eSelx, |
|
CHARS(request->nameSpace.getString().getCString()),&eRef,prec==NULL); |
|
|
|
delete eSelx; |
|
|
|
STAT_PMS_PROVIDEREND; |
|
|
|
if (rc.rc!=CMPI_RC_OK) |
|
throw CIMException((CIMStatusCode)rc.rc); |
|
} |
|
HandlerCatch(handler); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
return(response); |
|
} |
|
|
|
Message * JMPIProviderManager::handleEnableIndicationsRequest(const Message * message) throw() |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager:: handleEnableIndicationsRequest"); |
|
|
|
HandlerIntroInd(EnableIndications,message,request,response, |
|
handler); |
|
try { |
|
String providerName,providerLocation; |
|
LocateIndicationProviderNames(request->provider, request->providerModule, |
|
providerName,providerLocation); |
|
|
|
indProvRecord *provRec; |
|
if (provTab.lookup(providerName,provRec)) { |
|
provRec->enabled=true; |
|
provRec->handler=new EnableIndicationsResponseHandler( |
|
request, response, request->provider, _indicationCallback); |
|
} |
|
|
|
String fileName = resolveFileName(providerLocation); |
|
|
|
// get cached or load new provider module |
|
JMPIProvider::OpProviderHolder ph = |
|
providerManager.getProvider(fileName, providerName, String::EMPTY); |
|
|
|
// convert arguments |
|
OperationContext context; |
|
| |
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
jint jObj = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx); |
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
| |
JMPIProvider & pr=ph.GetProvider(); |
jobject jSel=env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jObj); |
|
JMPIjvm::checkException(env); |
| |
CMPIStatus rc={CMPI_RC_OK,NULL}; |
jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]); |
CMPI_ContextOnStack eCtx(context); |
|
CMPI_ThreadContext thr(&pr.broker,&eCtx); |
|
| |
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj); |
"Calling provider.EnableIndicationRequest: " + pr.getName()); |
JMPIjvm::checkException(env); |
| |
DDD(cerr<<"--- JMPIProviderManager::enableIndicationRequest"<<endl); |
jstring jType=env->NewStringUTF(request->nameSpace.getString().getCString()); |
|
JMPIjvm::checkException(env); |
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
STAT_GETSTARTTIME; | STAT_GETSTARTTIME; |
| |
pr.miVector.indMI->ft->enableIndications( |
jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"deActivateFilter", |
pr.miVector.indMI); |
"(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;" |
|
"Lorg/pegasus/jmpi/CIMObjectPath;Z)V"); |
STAT_PMS_PROVIDEREND; |
JMPIjvm::checkException(env); |
} |
|
HandlerCatch(handler); |
|
|
|
PEG_METHOD_EXIT(); |
|
| |
return(response); |
env->CallVoidMethod((jobject)pr.jProvider,id,jSel,jType, |
} |
jRef,(jboolean)(prec==NULL)); |
|
JMPIjvm::checkException(env); |
| |
Message * JMPIProviderManager::handleDisableIndicationsRequest(const Message * message) throw() |
// |
|
// Decrement count of current subscriptions for this provider |
|
// |
|
if (ph.GetProvider ().decrementSubscriptionsAndTestIfZero ()) |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager:: handleDisableIndicationsRequest"); |
// |
|
// If there are no current subscriptions after the decrement, |
HandlerIntroInd(DisableIndications,message,request,response, |
// the last subscription has been deleted |
handler); |
// Call the provider's disableIndications method |
try { |
// |
String providerName,providerLocation; |
if (_subscriptionInitComplete) |
LocateIndicationProviderNames(request->provider, request->providerModule, |
{ |
providerName,providerLocation); |
prec->enabled = false; |
|
if (prec->handler) delete prec->handler; |
indProvRecord *provRec; |
prec->handler = NULL; |
if (provTab.lookup(providerName,provRec)) { |
} |
provRec->enabled=false; |
|
if (provRec->handler) delete provRec->handler; |
|
provRec->handler=NULL; |
|
} | } |
| |
String fileName = resolveFileName(providerLocation); |
STAT_PMS_PROVIDEREND; |
|
|
// get cached or load new provider module |
|
JMPIProvider::OpProviderHolder ph = |
|
providerManager.getProvider(fileName, providerName, String::EMPTY); |
|
|
|
// convert arguments |
|
OperationContext context; |
|
|
|
context.insert(AcceptLanguageListContainer(request->acceptLanguages)); |
|
context.insert(ContentLanguageListContainer(request->contentLanguages)); |
|
|
|
JMPIProvider & pr=ph.GetProvider(); |
|
|
|
CMPIStatus rc={CMPI_RC_OK,NULL}; |
|
CMPI_ContextOnStack eCtx(context); |
|
CMPI_ThreadContext thr(&pr.broker,&eCtx); |
|
|
|
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Calling provider.DisableIndicationRequest: " + pr.getName()); |
|
|
|
DDD(cerr<<"--- JMPIProviderManager::disableIndicationRequest"<<endl); |
|
|
|
JMPIProvider::pm_service_op_lock op_lock(&pr); |
|
|
|
STAT_GETSTARTTIME; |
|
| |
pr.miVector.indMI->ft->disableIndications( |
delete eSelx; |
pr.miVector.indMI); |
delete qContext; |
|
delete srec; |
| |
STAT_PMS_PROVIDEREND; |
|
} | } |
HandlerCatch(handler); | HandlerCatch(handler); |
| |
|
if (env) JMPIjvm::detachThread(); |
|
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| |
return(response); | return(response); |
}*/ |
} |
// |
|
// Provider module status |
|
// |
|
static const Uint16 _MODULE_OK = 2; |
|
static const Uint16 _MODULE_STOPPING = 9; |
|
static const Uint16 _MODULE_STOPPED = 10; |
|
| |
Message * JMPIProviderManager::handleDisableModuleRequest(const Message * message) throw() | Message * JMPIProviderManager::handleDisableModuleRequest(const Message * message) throw() |
{ | { |
|
|
| |
Array<Uint16> operationalStatus; | Array<Uint16> operationalStatus; |
// Assume success. | // Assume success. |
operationalStatus.append(_MODULE_STOPPED); |
operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED); |
| |
// | // |
// Unload providers | // Unload providers |
// | // |
Array<CIMInstance> _pInstances = request->providers; | Array<CIMInstance> _pInstances = request->providers; |
| |
for(Uint32 i = 0, n = _pInstances.size(); i < n; i++) |
|
{ |
|
/* temp disabled by Chip |
|
// get the provider file name and logical name |
|
Triad<String, String, String> triad = |
|
getProviderRegistrar()->_getProviderRegPair(_pInstances[i], mInstance); |
|
|
|
providerManager.unloadProvider(triad.first, triad.second); |
|
*/ |
|
} |
|
|
|
CIMDisableModuleResponseMessage * response = | CIMDisableModuleResponseMessage * response = |
new CIMDisableModuleResponseMessage( | new CIMDisableModuleResponseMessage( |
request->messageId, | request->messageId, |
|
|
PEGASUS_ASSERT(request != 0); | PEGASUS_ASSERT(request != 0); |
| |
Array<Uint16> operationalStatus; | Array<Uint16> operationalStatus; |
operationalStatus.append(_MODULE_OK); |
operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK); |
| |
CIMEnableModuleResponseMessage * response = | CIMEnableModuleResponseMessage * response = |
new CIMEnableModuleResponseMessage( | new CIMEnableModuleResponseMessage( |
|
|
return(response); | return(response); |
} | } |
| |
|
Message * JMPIProviderManager::handleSubscriptionInitCompleteRequest |
|
(const Message * message) |
|
{ |
|
PEG_METHOD_ENTER (TRC_PROVIDERMANAGER, |
|
"JMPIProviderManager::handleSubscriptionInitCompleteRequest"); |
|
|
|
CIMSubscriptionInitCompleteRequestMessage * request = |
|
dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *> |
|
(const_cast <Message *> (message)); |
|
|
|
PEGASUS_ASSERT (request != 0); |
|
|
|
CIMSubscriptionInitCompleteResponseMessage * response = |
|
dynamic_cast <CIMSubscriptionInitCompleteResponseMessage *> |
|
(request->buildResponse ()); |
|
|
|
PEGASUS_ASSERT (response != 0); |
|
|
|
// |
|
// Set indicator |
|
// |
|
_subscriptionInitComplete = true; |
|
|
|
// |
|
// For each provider that has at least one subscription, call |
|
// provider's enableIndications method |
|
// |
|
Array <JMPIProvider *> enableProviders; |
|
enableProviders = providerManager.getIndicationProvidersToEnable (); |
|
|
|
Uint32 numProviders = enableProviders.size (); |
|
for (Uint32 i = 0; i < numProviders; i++) |
|
{ |
|
try |
|
{ |
|
CIMInstance provider; |
|
provider = enableProviders [i]->getProviderInstance (); |
|
|
|
// |
|
// Get cached or load new provider module |
|
// |
|
JMPIProvider::OpProviderHolder ph = providerManager.getProvider |
|
(enableProviders [i]->getModule ()->getFileName (), |
|
enableProviders [i]->getName ()); |
|
|
|
indProvRecord * prec = NULL; |
|
provTab.lookup (enableProviders [i]->getName (), prec); |
|
if (prec) |
|
{ |
|
prec->enabled = true; |
|
CIMRequestMessage * request = 0; |
|
CIMResponseMessage * response = 0; |
|
prec->handler = new EnableIndicationsResponseHandler |
|
(request, response, provider, _indicationCallback); |
|
} |
|
} |
|
catch (CIMException & e) |
|
{ |
|
PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
|
"CIMException: " + e.getMessage ()); |
|
} |
|
catch (Exception & e) |
|
{ |
|
PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
|
"Exception: " + e.getMessage ()); |
|
} |
|
catch(...) |
|
{ |
|
PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
|
"Unknown error in handleSubscriptionInitCompleteRequest"); |
|
} |
|
} |
|
|
|
PEG_METHOD_EXIT (); |
|
return (response); |
|
} |
|
|
Message * JMPIProviderManager::handleUnsupportedRequest(const Message * message) throw() | Message * JMPIProviderManager::handleUnsupportedRequest(const Message * message) throw() |
{ | { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleUnsupportedRequest"); | PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleUnsupportedRequest"); |
| |
PEG_METHOD_EXIT(); |
CIMRequestMessage* request = |
|
dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message)); |
|
PEGASUS_ASSERT(request != 0 ); |
| |
// a null response implies unsupported or unknown operation |
CIMResponseMessage* response = request->buildResponse(); |
return(0); |
response->cimException = |
|
PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY); |
|
|
|
PEG_METHOD_EXIT(); |
|
return response; |
} | } |
| |
ProviderName JMPIProviderManager::_resolveProviderName( | ProviderName JMPIProviderManager::_resolveProviderName( |
|
|
providerId.getModule().findProperty("InterfaceType")).getValue(); | providerId.getModule().findProperty("InterfaceType")).getValue(); |
genericValue.get(interfaceName); | genericValue.get(interfaceName); |
| |
// Check if the provider module is blocked |
|
Array<Uint16> operationalStatus; |
|
Uint32 pos = providerId.getModule().findProperty( |
|
CIMName("OperationalStatus")); |
|
PEGASUS_ASSERT(pos != PEG_NOT_FOUND); |
|
providerId.getModule().getProperty(pos).getValue().get(operationalStatus); |
|
|
|
for(Uint32 i = 0; i < operationalStatus.size(); i++) |
|
{ |
|
if(operationalStatus[i] == _MODULE_STOPPED || |
|
operationalStatus[i] == _MODULE_STOPPING) |
|
{ |
|
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED, |
|
MessageLoaderParms( |
|
"ProviderManager.ProviderManagerService.PROVIDER_BLOCKED", |
|
"provider blocked.")); |
|
} |
|
} |
|
|
|
return ProviderName(providerName, fileName, interfaceName, 0); | return ProviderName(providerName, fileName, interfaceName, 0); |
} | } |
| |