|
version 1.10, 2004/06/24 21:10:27
|
version 1.80, 2009/12/15 11:39:40
|
|
|
|
| //%2003//////////////////////////////////////////////////////////////////////// |
//%LICENSE//////////////////////////////////////////////////////////////// |
| // | // |
| // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Development |
// Licensed to The Open Group (TOG) under one or more contributor license |
| // Company, L. P., IBM Corp., The Open Group, Tivoli Systems. |
// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with |
| // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; |
// this work for additional information regarding copyright ownership. |
| // IBM Corp.; EMC Corporation, The Open Group. |
// Each contributor licenses this file to you under the OpenPegasus Open |
| |
// Source License; you may not use this file except in compliance with the |
| |
// License. |
| // | // |
| // 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 |
| // of this software and associated documentation files (the "Software"), to |
// copy of this software and associated documentation files (the "Software"), |
| // deal in the Software without restriction, including without limitation the |
// to deal in the Software without restriction, including without limitation |
| // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
// the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| // sell copies of the Software, and to permit persons to whom the Software is |
// and/or sell copies of the Software, and to permit persons to whom the |
| // furnished to do so, subject to the following conditions: |
// Software is furnished to do so, subject to the following conditions: |
| // | // |
| // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN |
// The above copyright notice and this permission notice shall be included |
| // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED |
// in all copies or substantial portions of the Software. |
| // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT |
|
| // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
|
| // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
|
| // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
| // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
|
| // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
| // | // |
| //============================================================================== |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| |
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| |
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| |
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| |
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| |
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| |
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| // | // |
| // Author: Adrian Schuur, schuur@de.ibm.com |
////////////////////////////////////////////////////////////////////////// |
| // |
|
| // Modified By: Seema Gupta (gseema@in.ibm.com) for PEP135 |
|
| // | // |
| //%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
|
| #include "JMPIProviderManager.h" | #include "JMPIProviderManager.h" |
| | |
| #include "JMPIImpl.h" | #include "JMPIImpl.h" |
| | |
| #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/MessageLoader.h> //l10n | #include <Pegasus/Common/MessageLoader.h> //l10n |
| #include <Pegasus/Common/Constants.h> | #include <Pegasus/Common/Constants.h> |
| |
#include <Pegasus/Common/FileSystem.h> |
| |
#include <Pegasus/Common/ArrayInternal.h> |
| | |
| #include <Pegasus/Config/ConfigManager.h> | #include <Pegasus/Config/ConfigManager.h> |
| | |
| #include <Pegasus/ProviderManager2/ProviderName.h> | #include <Pegasus/ProviderManager2/ProviderName.h> |
| #include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h> | #include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h> |
| #include <Pegasus/ProviderManager2/ProviderManagerService.h> |
#include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.h> |
| |
|
| | |
| PEGASUS_USING_STD; | PEGASUS_USING_STD; |
| PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| | |
| int _jmpi_trace=0; |
// request->localOnly is replaced with JMPI_LOCALONLY for |
| |
// getInstance () and enumerateInstances () |
| |
#define JMPI_LOCALONLY false |
| |
|
| |
/* Fix for 4092 */ |
| |
// request->includeQualifiers is replaced with JMPI_INCLUDE_QUALIFIERS |
| |
// for getInstance (), setInstance (), enumerateInstances (), associators () |
| |
// and references () |
| |
#define JMPI_INCLUDE_QUALIFIERS false |
| |
|
| |
#include "Convert.h" |
| |
|
| |
|
| |
// |
| |
// The following tests were added to allow the provider to supply a |
| |
// CIMObjectPath in the response. Before this, the path was always |
| |
// rebuild by the response functions from the instance. This resulted |
| |
// in cases where the key properties were not in the returned instance |
| |
// (ex. excluded by the property list) so that the path could not be built. |
| |
// The preferred behavior is for the provider to build the path on response. |
| |
// However, to cover existing providers the alternate of allowing the |
| |
// ProviderManager has been kept if the path in the instance is not considered |
| |
// to exist. |
| |
// PLEASE: provider writers build/set a proper path into returned objects |
| |
// See bug 8062 |
| |
|
| |
/* |
| |
local function to implement the CIMObjectPath required for a response |
| |
object. |
| |
If there is a path defined in the instance, we simply return this path. |
| |
If not, we use the class to build a path from the instance. |
| |
Note that we are depending on some value in the keybindings to determine |
| |
if we have a path. |
| |
*/ |
| |
|
| |
void _fixCIMObjectPath(CIMInstance* instance, CIMClass& cls) |
| |
{ |
| |
CIMObjectPath op = instance->getPath(); |
| |
const Array<CIMKeyBinding> kb = op.getKeyBindings(); |
| |
if (kb.size() == 0) |
| |
{ |
| |
CIMObjectPath iop = instance->buildPath(cls); |
| |
/* Fix for 4237*/ |
| |
iop.setNameSpace(op.getNameSpace()); |
| |
instance->setPath(iop); |
| |
} |
| |
} |
| |
|
| |
void JMPIProviderManager::debugPrintMethodPointers (JNIEnv *env, jclass jc) |
| |
{ |
| |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::debugPrintMethodPointers"); |
| |
|
| |
static const char *methodNames[][3] = { |
| |
// CIMProvider |
| |
{"snia 2.0", |
| |
"initialize", |
| |
"(Lorg/pegasus/jmpi/CIMOMHandle;)V"}, |
| |
{"snia 2.0", |
| |
"cleanup", |
| |
"()V"}, |
| |
// InstanceProvider |
| |
{"snia 2.0", |
| |
"enumInstances", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;" |
| |
"Z)Ljava/util/Vector;"}, |
| |
{"pegasus 2.4", |
| |
"enumInstances", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;" |
| |
"Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;"}, |
| |
/* Begin Fix for 4189 */ |
| |
{"pegasus 2.5", |
| |
"enumerateInstances", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;" |
| |
"ZZ[Ljava/lang/String;)Ljava/util/Vector;"}, |
| |
/* End Fix for 4189 */ |
| |
{"snia 2.0", |
| |
"enumInstances", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)" |
| |
"Ljava/util/Vector;"}, |
| |
{"pegasus 2.4", |
| |
"enumerateInstanceNames", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)" |
| |
"[Lorg/pegasus/jmpi/CIMObjectPath;"}, |
| |
{"pegasus 2.5", |
| |
"enumerateInstanceNames", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)" |
| |
"Ljava/util/Vector;"}, |
| |
{"snia 2.0", |
| |
"getInstance", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)" |
| |
"Lorg/pegasus/jmpi/CIMInstance;"}, |
| |
{"pegasus 2.4", |
| |
"getInstance", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;" |
| |
"Lorg/pegasus/jmpi/CIMClass;)Lorg/pegasus/jmpi/CIMInstance;"}, |
| |
/* Begin Fix for 4238 */ |
| |
{"pegasus 2.5", |
| |
"getInstance", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;" |
| |
"ZZ[Ljava/lang/String;)Lorg/pegasus/jmpi/CIMInstance;"}, |
| |
/* End Fix for 4238 */ |
| |
{"snia 2.0", |
| |
"createInstance", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;"}, |
| |
{"snia 2.0", |
| |
"setInstance", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V"}, |
| |
{"pegasus 2.4", |
| |
"setInstance", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V"}, |
| |
{"snia 2.0", |
| |
"deleteInstance", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;)V"}, |
| |
{"snia 2.0", |
| |
"execQuery", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"}, |
| |
{"pegasus 2.4", |
| |
"execQuery", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)" |
| |
"[Lorg/pegasus/jmpi/CIMInstance;"}, |
| |
{"pegasus 2.5", |
| |
"execQuery", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;" |
| |
"Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"}, |
| |
// MethodProvider |
| |
{"snia 2.0", |
| |
"invokeMethod", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;"}, |
| |
{"pegasus 2.4", |
| |
"invokeMethod", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)" |
| |
"Lorg/pegasus/jmpi/CIMValue;"}, |
| |
// PropertyProvider |
| |
{"snia 2.0", |
| |
"getPropertyValue", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)" |
| |
"Lorg/pegasus/jmpi/CIMValue;"}, |
| |
{"snia 2.0", |
| |
"setPropertyValue", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;" |
| |
"Lorg/pegasus/jmpi/CIMValue;)V"}, |
| |
// AssociatorProvider |
| |
{"snia 2.0", |
| |
"associators", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;" |
| |
"ZZ[Ljava/lang/String;)Ljava/util/Vector;"}, |
| |
{"pegasus 2.4", |
| |
"associators", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;" |
| |
"Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"}, |
| |
{"snia 2.0", |
| |
"associatorNames", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)" |
| |
"Ljava/util/Vector;"}, |
| |
{"pegasus 2.4", |
| |
"associatorNames", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;" |
| |
"Ljava/lang/String;)Ljava/util/Vector;"}, |
| |
{"snia 2.0", |
| |
"references", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"}, |
| |
{"pegasus 2.4", |
| |
"references", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"ZZ[Ljava/lang/String;)Ljava/util/Vector;"}, |
| |
{"snia 2.0", |
| |
"referenceNames", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Ljava/lang/String;)Ljava/util/Vector;"}, |
| |
{"pegasus 2.4", |
| |
"referenceNames", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)" |
| |
"Ljava/util/Vector;"}, |
| |
// CIMProviderRouter |
| |
// EventProvider |
| |
{"snia 2.0", |
| |
"activateFilter", |
| |
"(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Z)V"}, |
| |
{"snia 2.0", |
| |
"deActivateFilter", |
| |
"(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Z)V"}, |
| |
// IndicationHandler |
| |
// ProviderAdapter |
| |
// JMPI_TestPropertyTypes |
| |
{"JMPI_TestPropertyTypes", |
| |
"findObjectPath", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;)I"}, |
| |
{"JMPI_TestPropertyTypes", |
| |
"testPropertyTypesValue", |
| |
"(Lorg/pegasus/jmpi/CIMInstance;)V"} |
| |
}; |
| |
|
| |
if (!env) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"No JNI environment specified. (JNIEnv==NULL)"); |
| |
PEG_METHOD_EXIT(); |
| |
return; |
| |
} |
| |
if (!jc) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"No Java class specified. (jc==NULL)"); |
| |
PEG_METHOD_EXIT(); |
| |
return; |
| |
} |
| |
|
| |
for (int i = 0; i < (int)(sizeof (methodNames)/sizeof (methodNames[0])); i++) |
| |
{ |
| |
jmethodID id = env->GetMethodID(jc,methodNames[i][1], methodNames[i][2]); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"Method: %s, %s, id = %p", |
| |
methodNames[i][0],methodNames[i][1],id)); |
| |
|
| |
env->ExceptionClear(); |
| |
} |
| |
|
| |
env->ExceptionClear(); |
| |
PEG_METHOD_EXIT(); |
| |
return; |
| |
} |
| |
|
| |
void debugIntrospectJavaObject (JNIEnv *env, jobject jInst) |
| |
{ |
| |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::debugIntrospectJavaObject"); |
| |
|
| |
jclass jInstClass = env->GetObjectClass(jInst); |
| |
jclass jInstSuperClass = env->GetSuperclass(jInstClass); |
| |
jmethodID jmidGetDeclaredMethods = env->GetMethodID( |
| |
jInstClass, |
| |
"getDeclaredMethods", |
| |
"()[Ljava/lang/reflect/Method;"); |
| |
|
| |
if (!jmidGetDeclaredMethods) |
| |
{ |
| |
env->ExceptionClear(); |
| |
jmidGetDeclaredMethods = env->GetMethodID( |
| |
jInstSuperClass, |
| |
"getDeclaredMethods", |
| |
"()[Ljava/lang/reflect/Method;"); |
| |
} |
| |
|
| |
if (jmidGetDeclaredMethods) |
| |
{ |
| |
jobjectArray jarrayDeclaredMethods = (jobjectArray)env->CallObjectMethod( |
| |
jInstClass, |
| |
jmidGetDeclaredMethods); |
| |
|
| |
if (jarrayDeclaredMethods) |
| |
{ |
| |
for (int i=0,iLen=env->GetArrayLength(jarrayDeclaredMethods); |
| |
i < iLen; |
| |
i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jDeclaredMethod = env->GetObjectArrayElement( |
| |
jarrayDeclaredMethods, |
| |
i); |
| |
jclass jDeclaredMethodClass = env->GetObjectClass(jDeclaredMethod); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jmethodID jmidToString = env->GetMethodID( |
| |
jDeclaredMethodClass, |
| |
"toString", |
| |
"()Ljava/lang/String;"); |
| |
jstring jstringResult = (jstring)env->CallObjectMethod( |
| |
jDeclaredMethod, |
| |
jmidToString); |
| |
const char *pszResult = env->GetStringUTFChars(jstringResult, 0); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"Introspect java object: %s",pszResult)); |
| |
|
| |
env->ReleaseStringUTFChars (jstringResult, pszResult); |
| |
} |
| |
} |
| |
} |
| |
|
| |
env->ExceptionClear(); |
| |
PEG_METHOD_EXIT(); |
| |
return; |
| |
} |
| |
|
| |
void debugDumpJavaObject (JNIEnv *env, jobject jInst) |
| |
{ |
| |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::debugDumpJavaObject"); |
| |
jclass jInstClass = env->GetObjectClass(jInst); |
| |
jclass jInstSuperClass = env->GetSuperclass(jInstClass); |
| |
jmethodID jmidToString1 = env->GetMethodID( |
| |
jInstClass, |
| |
"toString", |
| |
"()Ljava/lang/String;"); |
| |
jmethodID jmidToString2 = env->GetMethodID( |
| |
jInstSuperClass, |
| |
"toString", |
| |
"()Ljava/lang/String;"); |
| |
if (!jmidToString1 || !jmidToString2) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"No class or super class description."); |
| |
env->ExceptionClear(); |
| |
PEG_METHOD_EXIT(); |
| |
return; |
| |
} |
| |
jstring jstringResult1 = (jstring)env->CallObjectMethod( |
| |
jInstClass, |
| |
jmidToString1); |
| |
jstring jstringResult2 = (jstring)env->CallObjectMethod( |
| |
jInstSuperClass, |
| |
jmidToString2); |
| |
jstring jstringResult3 = (jstring)env->CallObjectMethod( |
| |
jInst, |
| |
jmidToString1); |
| |
const char *pszResult1 = env->GetStringUTFChars(jstringResult1, 0); |
| |
const char *pszResult2 = env->GetStringUTFChars(jstringResult2, 0); |
| |
const char *pszResult3 = env->GetStringUTFChars(jstringResult3, 0); |
| |
|
| |
jmethodID jmidCInst = env->GetMethodID( |
| |
env->GetObjectClass(jInst), |
| |
JMPIjvm::jv.instanceMethodNames[22].methodName, |
| |
JMPIjvm::jv.instanceMethodNames[22].signature); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"Dumping class %p:\n " |
| |
" jInstSuperClass = %p\n" |
| |
" jClassShouldBe = %p\n" |
| |
" jmidCInst = %p\n" |
| |
" pszResult1 = %s\n" |
| |
" pszResult2 = %s\n" |
| |
" pszResult3 = %s", |
| |
jInstClass,jInstSuperClass,JMPIjvm::jv.classRefs[18],jmidCInst, |
| |
pszResult1,pszResult2,pszResult3 )); |
| |
|
| |
env->ReleaseStringUTFChars (jstringResult1, pszResult1); |
| |
env->ReleaseStringUTFChars (jstringResult2, pszResult2); |
| |
env->ReleaseStringUTFChars (jstringResult3, pszResult3); |
| |
|
| |
env->ExceptionClear(); |
| |
PEG_METHOD_EXIT(); |
| |
return; |
| |
} |
| |
|
| |
bool JMPIProviderManager::getInterfaceType( |
| |
ProviderIdContainer pidc, |
| |
String& interfaceType, |
| |
String& interfaceVersion) |
| |
{ |
| |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::getInterfaceType"); |
| |
|
| |
CIMInstance ciProviderModule = pidc.getModule (); |
| |
Uint32 idx; |
| |
bool fRet = true; |
| |
|
| |
idx = ciProviderModule.findProperty ("InterfaceType"); |
| |
|
| |
if (idx != PEG_NOT_FOUND) |
| |
{ |
| |
CIMValue itValue; |
| |
|
| |
itValue = ciProviderModule.getProperty (idx).getValue (); |
| |
|
| |
itValue.get (interfaceType); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"interfaceType = %s",(const char*)interfaceType.getCString())); |
| |
} |
| |
else |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"inferfaceType not found."); |
| |
fRet = false; |
| |
} |
| |
|
| |
idx = ciProviderModule.findProperty ("InterfaceVersion"); |
| |
|
| |
if (idx != PEG_NOT_FOUND) |
| |
{ |
| |
CIMValue itValue; |
| |
|
| |
itValue = ciProviderModule.getProperty (idx).getValue (); |
| |
|
| |
itValue.get (interfaceVersion); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"interfaceVersion = %s",(const char*)interfaceVersion.getCString())); |
| |
} |
| |
else |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"inferfaceVersion not found."); |
| |
fRet = false; |
| |
} |
| |
PEG_METHOD_EXIT(); |
| |
return fRet; |
| |
} |
| |
|
| |
bool JMPIProviderManager::interfaceIsUsed (JNIEnv *env, |
| |
jobject jObject, |
| |
String searchInterfaceName) |
| |
{ |
| |
jobjectArray jInterfaces = 0; |
| |
jsize jInterfacesLength = 0; |
| |
bool fFound = false; |
| |
|
| |
if (!jObject) |
| |
{ |
| |
return false; |
| |
} |
| |
|
| |
jInterfaces = (jobjectArray)env->CallObjectMethod( |
| |
env->GetObjectClass (jObject), |
| |
JMPIjvm::jv.ClassGetInterfaces); |
| |
|
| |
if (!jInterfaces) |
| |
{ |
| |
return false; |
| |
} |
| |
|
| |
jInterfacesLength = env->GetArrayLength (jInterfaces); |
| |
|
| |
for (jsize i = 0; !fFound && i < jInterfacesLength; i++) |
| |
{ |
| |
jobject jInterface = env->GetObjectArrayElement (jInterfaces, i); |
| |
|
| |
if (jInterface) |
| |
{ |
| |
jstring jInterfaceName = (jstring)env->CallObjectMethod( |
| |
jInterface, |
| |
JMPIjvm::jv.ClassGetName); |
| |
|
| |
if (jInterfaceName) |
| |
{ |
| |
const char *pszInterfaceName = env->GetStringUTFChars( |
| |
jInterfaceName, |
| |
0); |
| |
String interfaceName = pszInterfaceName; |
| |
|
| |
if (String::equal (interfaceName, searchInterfaceName)) |
| |
{ |
| |
fFound = true; |
| |
} |
| | |
| #define DDD(x) if (_jmpi_trace) x; |
env->ReleaseStringUTFChars (jInterfaceName, pszInterfaceName); |
| |
} |
| |
} |
| |
} |
| |
|
| |
return fFound; |
| |
} |
| | |
| JMPIProviderManager::IndProvTab JMPIProviderManager::provTab; | JMPIProviderManager::IndProvTab JMPIProviderManager::provTab; |
| |
Mutex JMPIProviderManager::mutexProvTab; |
| JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab; | JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab; |
| |
Mutex JMPIProviderManager::mutexSelxTab; |
| JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg; | JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg; |
| |
Mutex JMPIProviderManager::mutexProvReg; |
| | |
| JMPIProviderManager::JMPIProviderManager(Mode m) |
JMPIProviderManager::JMPIProviderManager() |
| { | { |
| mode=m; |
_subscriptionInitComplete = false; |
| if (getenv("JMPI_TRACE")) _jmpi_trace=1; |
|
| else _jmpi_trace=0; |
|
| } | } |
| | |
| JMPIProviderManager::~JMPIProviderManager(void) | JMPIProviderManager::~JMPIProviderManager(void) |
|
|
|
| Boolean JMPIProviderManager::insertProvider(const ProviderName & name, | Boolean JMPIProviderManager::insertProvider(const ProviderName & name, |
| const String &ns, const String &cn) | const String &ns, const String &cn) |
| { | { |
| String key(ns+String("::")+cn+String("::")+CIMValue(name.getCapabilitiesMask()).toString()); |
PEG_METHOD_ENTER( TRC_PROVIDERMANAGER, |
| return provReg.insert(key,name); |
"JMPIProviderManager::insertProvider"); |
| |
|
| |
String key(ns + String("::") + cn); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"insertProvider: %s",(const char*)key.getCString())); |
| |
|
| |
Boolean ret = false; |
| |
|
| |
{ |
| |
AutoMutex lock (mutexProvReg); |
| |
|
| |
ret = provReg.insert(key,name); |
| } | } |
| | |
| |
PEG_METHOD_EXIT(); |
| |
return ret; |
| |
} |
| | |
| 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; |
|
|
|
| { | { |
| case CIM_GET_INSTANCE_REQUEST_MESSAGE: | case CIM_GET_INSTANCE_REQUEST_MESSAGE: |
| response = handleGetInstanceRequest(request); | response = handleGetInstanceRequest(request); |
| |
|
| break; | break; |
| |
|
| case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE: | case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE: |
| response = handleEnumerateInstancesRequest(request); | response = handleEnumerateInstancesRequest(request); |
| |
|
| break; | break; |
| |
|
| case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE: | case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE: |
| response = handleEnumerateInstanceNamesRequest(request); | response = handleEnumerateInstanceNamesRequest(request); |
| |
|
| break; | break; |
| |
|
| case CIM_CREATE_INSTANCE_REQUEST_MESSAGE: | case CIM_CREATE_INSTANCE_REQUEST_MESSAGE: |
| response = handleCreateInstanceRequest(request); | response = handleCreateInstanceRequest(request); |
| |
|
| break; | break; |
| |
|
| case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE: | case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE: |
| response = handleModifyInstanceRequest(request); | response = handleModifyInstanceRequest(request); |
| |
|
| break; | break; |
| |
|
| case CIM_DELETE_INSTANCE_REQUEST_MESSAGE: | case CIM_DELETE_INSTANCE_REQUEST_MESSAGE: |
| response = handleDeleteInstanceRequest(request); | response = handleDeleteInstanceRequest(request); |
| |
break; |
| | |
| |
case CIM_EXEC_QUERY_REQUEST_MESSAGE: |
| |
response = handleExecQueryRequest(request); |
| break; | break; |
| /* case CIM_EXEC_QUERY_REQUEST_MESSAGE: |
|
| response = handleExecuteQueryRequest(request); |
|
| | |
| */ break; |
|
| case CIM_ASSOCIATORS_REQUEST_MESSAGE: | case CIM_ASSOCIATORS_REQUEST_MESSAGE: |
| response = handleAssociatorsRequest(request); | response = handleAssociatorsRequest(request); |
| |
|
| break; | break; |
| |
|
| case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE: | case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE: |
| response = handleAssociatorNamesRequest(request); | response = handleAssociatorNamesRequest(request); |
| |
|
| break; | break; |
| |
|
| case CIM_REFERENCES_REQUEST_MESSAGE: | case CIM_REFERENCES_REQUEST_MESSAGE: |
| response = handleReferencesRequest(request); | response = handleReferencesRequest(request); |
| |
|
| break; | break; |
| |
|
| case CIM_REFERENCE_NAMES_REQUEST_MESSAGE: | case CIM_REFERENCE_NAMES_REQUEST_MESSAGE: |
| response = handleReferenceNamesRequest(request); | response = handleReferenceNamesRequest(request); |
| |
break; |
| | |
| |
case CIM_GET_PROPERTY_REQUEST_MESSAGE: |
| |
response = handleGetPropertyRequest(request); |
| |
break; |
| |
|
| |
case CIM_SET_PROPERTY_REQUEST_MESSAGE: |
| |
response = handleSetPropertyRequest(request); |
| break; | break; |
| /* case CIM_INVOKE_METHOD_REQUEST_MESSAGE: |
|
| response = handleInvokeMethodRequest(request); |
|
| | |
| |
case CIM_INVOKE_METHOD_REQUEST_MESSAGE: |
| |
response = handleInvokeMethodRequest(request); |
| break; | break; |
| |
|
| case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE: | case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE: |
| response = handleCreateSubscriptionRequest(request); | response = handleCreateSubscriptionRequest(request); |
| |
|
| break; | break; |
| case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE: |
|
| response = handleModifySubscriptionRequest(request); |
|
| | |
| |
/* case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE: |
| |
response = handleModifySubscriptionRequest(request); |
| break; | break; |
| |
*/ |
| case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE: | case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE: |
| response = handleDeleteSubscriptionRequest(request); | response = handleDeleteSubscriptionRequest(request); |
| |
|
| break; |
|
| case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE: |
|
| response = handleEnableIndicationsRequest(request); |
|
| |
|
| break; | break; |
| case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE: |
|
| response = handleDisableIndicationsRequest(request); |
|
| | |
| break; |
/* case CIM_EXPORT_INDICATION_REQUEST_MESSAGE: |
| case CIM_EXPORT_INDICATION_REQUEST_MESSAGE: |
|
| response = handleExportIndicationRequest(request); | response = handleExportIndicationRequest(request); |
| break; | break; |
| |
*/ |
| case CIM_DISABLE_MODULE_REQUEST_MESSAGE: | case CIM_DISABLE_MODULE_REQUEST_MESSAGE: |
| response = handleDisableModuleRequest(request); | response = handleDisableModuleRequest(request); |
| |
|
| break; | break; |
| |
|
| case CIM_ENABLE_MODULE_REQUEST_MESSAGE: | case CIM_ENABLE_MODULE_REQUEST_MESSAGE: |
| response = handleEnableModuleRequest(request); | response = handleEnableModuleRequest(request); |
| |
|
| break; | break; |
| |
|
| case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE: | case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE: |
| response = handleStopAllProvidersRequest(request); | response = handleStopAllProvidersRequest(request); |
| |
break; |
| | |
| break; */ |
case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE: |
| case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE: |
response = handleSubscriptionInitCompleteRequest (request); |
| response = handleInitializeProviderRequest(request); |
break; |
| | |
| |
case CIM_INDICATION_SERVICE_DISABLED_REQUEST_MESSAGE: |
| |
response = handleIndicationServiceDisabledRequest (request); |
| break; | break; |
| |
|
| default: | default: |
| cout<<"*** Unsupported Request ??"<<request->getType()<<endl; |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| asm("int $3"); |
"Unsupported Request %d", |
| response = handleUnsupportedRequest(request); |
request->getType() |
| |
)); |
| | |
| |
response = handleUnsupportedRequest(request); |
| break; | break; |
| } | } |
| | |
|
|
|
| #define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL) | #define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL) |
| | |
| | |
| #define HandlerIntroBase(type,type1,message,request,response,handler,respType) \ |
#define HandlerIntroBase(type,type1,message,request,response,handler) \ |
| CIM##type##RequestMessage * request = \ | CIM##type##RequestMessage * request = \ |
| dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *>(message)); \ |
dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *> \ |
| |
(message)); \ |
| PEGASUS_ASSERT(request != 0); \ | PEGASUS_ASSERT(request != 0); \ |
| CIM##type##ResponseMessage * response = \ | CIM##type##ResponseMessage * response = \ |
| new CIM##type##ResponseMessage( \ |
dynamic_cast<CIM##type##ResponseMessage*>(request->buildResponse()); \ |
| request->messageId, \ |
|
| CIMException(), \ |
|
| request->queueIds.copyAndPop() \ |
|
| respType \ |
|
| PEGASUS_ASSERT(response != 0); \ | PEGASUS_ASSERT(response != 0); \ |
| response->setKey(request->getKey()); \ |
type1##ResponseHandler handler(request, response, _responseChunkCallback); |
| response->setHttpMethod(request->getHttpMethod()); \ |
|
| type1##ResponseHandler handler(request, response); |
|
| |
|
| #define VOIDINTRO ); |
|
| #define NOVOIDINTRO(type) ,type); |
|
| #define METHODINTRO ,CIMValue(), Array<CIMParamValue>(), request->methodName ); |
|
| |
|
| |
|
| #define HandlerIntroVoid(type,message,request,response,handler) \ |
|
| HandlerIntroBase(type,type,message,request,response,handler,VOIDINTRO) |
|
| |
|
| #define HandlerIntroMethod(type,message,request,response,handler) \ |
|
| HandlerIntroBase(type,type,message,request,response,handler,METHODINTRO) |
|
| | |
| #define HandlerIntroInd(type,message,request,response,handler) \ | #define HandlerIntroInd(type,message,request,response,handler) \ |
| HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO) |
HandlerIntroBase(type,Operation,message,request,response,handler) |
| | |
| #define HandlerIntroInit(type,message,request,response,handler) \ | #define HandlerIntroInit(type,message,request,response,handler) \ |
| HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO) |
HandlerIntroBase(type,Operation,message,request,response,handler) |
| | |
| #define HandlerIntro(type,message,request,response,handler,respType) \ |
#define HandlerIntro(type,message,request,response,handler) \ |
| HandlerIntroBase(type,type,message,request,response,handler,NOVOIDINTRO(respType)) |
HandlerIntroBase(type,type,message,request,response,handler) |
| | |
| #define HandlerCatch(handler) \ | #define HandlerCatch(handler) \ |
| catch(CIMException & e) \ | catch(CIMException & e) \ |
| { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \ |
{ PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,"CIMException: %s", \ |
| "Exception: " + e.getMessage()); \ |
(const char*)e.getMessage().getCString())); \ |
| handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); \ |
handler.setStatus(e.getCode(), e.getContentLanguages(), \ |
| |
e.getMessage()); \ |
| } \ | } \ |
| catch(Exception & e) \ | catch(Exception & e) \ |
| { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \ |
{ PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,"Exception: %s", \ |
| "Exception: " + e.getMessage()); \ |
(const char*)e.getMessage().getCString())); \ |
| handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); \ |
handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), \ |
| |
e.getMessage()); \ |
| } \ | } \ |
| catch(...) \ | catch(...) \ |
| { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \ |
{ PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, \ |
| "Exception: Unknown"); \ | "Exception: Unknown"); \ |
| handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \ | handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \ |
| } | } |
| | |
| |
static jobjectArray getList(JvmVector *jv, JNIEnv *env, CIMPropertyList &list) |
| |
{ |
| |
jobjectArray pl= NULL; |
| |
if (!list.isNull()) |
| |
{ |
| |
Uint32 s=list.size(); |
| |
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); |
| | |
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_CIMINSTANCEPROVIDER, |
| |
METHOD_INSTANCEPROVIDER, |
| |
METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2 |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| JNIEnv *env=NULL; | JNIEnv *env=NULL; |
| try { |
|
| Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
try |
| "JMPIProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
{ |
| System::getHostName(), |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| request->nameSpace.getString(), |
"handleGetInstanceRequest: " |
| request->instanceName.getClassName().getString()); |
"name space = %s class name = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)request-> |
| |
instanceName.getClassName().getString().getCString() |
| |
)); |
| | |
| // make target object path | // make target object path |
| CIMObjectPath objectPath( |
CIMObjectPath *objectPath = new CIMObjectPath( |
| System::getHostName(), | System::getHostName(), |
| request->nameSpace, | request->nameSpace, |
| request->instanceName.getClassName(), | request->instanceName.getClassName(), |
|
|
|
| request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| | |
| // get cached or load new provider module | // get cached or load new provider module |
| JMPIProvider::OpProviderHolder ph = providerManager.getProvider(name.getPhysicalName(), |
JMPIProvider::OpProviderHolder ph = providerManager.getProvider( |
| |
name.getPhysicalName(), |
| name.getLogicalName()); | name.getLogicalName()); |
| OperationContext context; | OperationContext context; |
| | |
| |
context.insert( |
| |
request->operationContext.get(IdentityContainer::NAME)); |
| |
context.insert( |
| |
request->operationContext.get(AcceptLanguageListContainer::NAME)); |
| |
context.insert( |
| |
request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
|
| // forward request | // forward request |
| JMPIProvider & pr=ph.GetProvider(); | JMPIProvider & pr=ph.GetProvider(); |
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
PEG_TRACE(( TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| "Calling provider.getInstance: " + pr.getName()); |
"handleGetInstanceRequest:Calling provider instance: %s" , |
| |
(const char*)pr.getName().getCString())); |
| | |
| DDD(cerr<<"--- JMPIProviderManager::getInstance"<<endl); |
JvmVector *jv = 0; |
| | |
| JvmVector *jv; |
env = JMPIjvm::attachThread(&jv); |
| JNIEnv *env=JMPIjvm::attachThread(&jv); |
|
| JMPIjvm::checkException(env); |
|
| jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
|
| jv->CIMObjectPathNewI,(jint)&objectPath); |
|
| JMPIjvm::checkException(env); |
|
| | |
| CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace, |
if (!env) |
| request->instanceName.getClassName(), |
{ |
| false,true,true,CIMPropertyList()); |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| JMPIjvm::checkException(env); |
"handleGetInstanceRequest:" |
| jobject cc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls); |
"Could not initialize the JVM (Java Virtual Machine) " |
| JMPIjvm::checkException(env); |
"runtime environment."); |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); |
PEG_METHOD_EXIT(); |
| | |
| STAT_GETSTARTTIME; |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| | |
| jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"getInstance", |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;"); |
|
| JMPIjvm::checkException(env); |
|
| jobject inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,cc,true); |
|
| | |
| STAT_PMS_PROVIDEREND; |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get(ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| | |
| JMPIjvm::checkException(env); |
if (interfaceType == "JMPI") |
| handler.processing(); |
{ |
| if (inst) { |
id = env->GetMethodID( |
| CIMInstance *ci=((CIMInstance*)env->CallIntMethod(inst,JMPIjvm::jv.CIMInstanceCInst)); |
(jclass)pr.jProviderClass, |
| handler.deliver(*ci); |
"getInstance", |
| } |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| handler.complete(); |
"Lorg/pegasus/jmpi/CIMClass;Z)" |
| |
"Lorg/pegasus/jmpi/CIMInstance;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_INSTANCEPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleGetInstanceRequest: " |
| |
"Found METHOD_INSTANCEPROVIDER."); |
| } | } |
| HandlerCatch(handler); |
|
| | |
| if (env) JMPIjvm::detachThread(); |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| | |
| PEG_METHOD_EXIT(); |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"getInstance", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[" |
| |
"Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)" |
| |
"Lorg/pegasus/jmpi/CIMInstance;"); |
| | |
| return(response); |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMINSTANCEPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleGetInstanceRequest: " |
| |
"Found METHOD_CIMINSTANCEPROVIDER."); |
| |
} |
| |
} |
| } | } |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"getInstance", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)" |
| |
"Lorg/pegasus/jmpi/CIMInstance;"); |
| | |
| Message * JMPIProviderManager::handleEnumerateInstancesRequest(const Message * message) throw() |
if (id != NULL) |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
eMethodFound = METHOD_INSTANCEPROVIDER2; |
| "JMPIProviderManager::handleEnumerateInstanceRequest"); |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleGetInstanceRequest: " |
| |
"Found METHOD_INSTANCEPROVIDER2."); |
| |
} |
| |
/* Fix for 4238 */ |
| |
} |
| | |
| HandlerIntro(EnumerateInstances,message,request,response, |
if (id == NULL) |
| handler,Array<CIMInstance>()); |
{ |
| JNIEnv *env=NULL; |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| try { |
"handleGetInstanceRequest: No method provider found!"); |
| Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
| "JMPIProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2", |
|
| System::getHostName(), |
|
| request->nameSpace.getString(), |
|
| request->className.getString()); |
|
| | |
| // make target object path |
PEG_METHOD_EXIT(); |
| CIMObjectPath objectPath( |
|
| System::getHostName(), |
|
| request->nameSpace, |
|
| request->className); |
|
| | |
| // resolve provider name |
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, |
| ProviderName name = _resolveProviderName( |
MessageLoaderParms( |
| request->operationContext.get(ProviderIdContainer::NAME)); |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| |
} |
| | |
| // get cached or load new provider module |
JMPIjvm::checkException(env); |
| JMPIProvider::OpProviderHolder ph = |
|
| providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), |
|
| String::EMPTY); |
|
| | |
| // convert arguments |
switch (eMethodFound) |
| OperationContext context; |
{ |
| |
case METHOD_CIMINSTANCEPROVIDER: |
| |
{ |
| |
jlong jopRef=DEBUG_ConvertCToJava(CIMObjectPath*,jlong,objectPath); |
| |
jobject jop=env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jopRef); |
| | |
| context.insert(request->operationContext.get(IdentityContainer::NAME)); |
JMPIjvm::checkException(env); |
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
|
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
|
| | |
| CIMPropertyList propertyList(request->propertyList); |
CIMClass cls; |
| | |
| // forward request |
try |
| JMPIProvider & pr=ph.GetProvider(); |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleGetInstanceRequest: " |
| |
"enter(METHOD_CIMINSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request-> |
| |
instanceName.getClassName().getString().getCString() |
| |
)); |
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
AutoMutex lock (pr._cimomMutex); |
| "Calling provider.enumerateInstances: " + pr.getName()); |
|
| | |
| DDD(cerr<<"--- JMPIProviderManager::enumerateInstances"<<endl); |
cls = pr._cimom_handle->getClass( |
| |
context, |
| |
request->nameSpace, |
| |
request->instanceName.getClassName(), |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleGetInstanceRequest: " |
| |
"exit(METHOD_CIMINSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request-> |
| |
instanceName.getClassName().getString().getCString() |
| |
)); |
| | |
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleGetInstanceRequest: " |
| |
"Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request-> |
| |
instanceName.getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| | |
| JvmVector *jv; |
PEG_METHOD_EXIT(); |
| env=JMPIjvm::attachThread(&jv); |
throw; |
| |
} |
| | |
| jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
CIMClass *pcls = new CIMClass (cls); |
| jv->CIMObjectPathNewI,(jint)&objectPath); |
|
| JMPIjvm::checkException(env); |
|
| | |
| CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace, |
|
| request->className, |
|
| false,true,true,CIMPropertyList()); |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls); |
|
| |
jlong jcimClassRef = DEBUG_ConvertCToJava( |
| |
CIMClass*, |
| |
jlong, |
| |
pcls); |
| |
jobject jcimClass = env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jcimClassRef); |
| |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| | |
| STAT_GETSTARTTIME; |
StatProviderTimeMeasurement providerTime(response); |
| | |
| jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"enumInstances", |
jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider, |
| "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;"); |
id, |
| JMPIjvm::checkException(env); |
jop, |
| |
JMPI_LOCALONLY, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
request->includeClassOrigin, |
| |
jPropertyList, |
| |
jcimClass); |
| | |
| jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,false,jCc,true); |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| STAT_PMS_PROVIDEREND; |
|
| |
|
| handler.processing(); | handler.processing(); |
| if (jVec) { |
|
| for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
|
| JMPIjvm::checkException(env); |
|
| jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
| JMPIjvm::checkException(env); |
|
| CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst)); |
|
| JMPIjvm::checkException(env); |
|
| | |
| // const CIMObjectPath& op=inst.getPath(); |
if (jciRet) { |
| // CIMObjectPath iop=inst.buildPath(cls); |
jlong jciRetRef = env->CallLongMethod( |
| // iop.setNameSpace(op.getNameSpace()); |
jciRet, |
| // inst.setPath(iop); |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| | |
| handler.deliver(inst); |
handler.deliver(*ciRet); |
| } |
|
| } | } |
| handler.complete(); | handler.complete(); |
| |
break; |
| } | } |
| HandlerCatch(handler); |
|
| | |
| if (env) JMPIjvm::detachThread(); |
/* Fix for 4238 */ |
| |
case METHOD_INSTANCEPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jopRef); |
| | |
| PEG_METHOD_EXIT(); |
JMPIjvm::checkException(env); |
| | |
| return(response); |
CIMClass cls; |
| } |
|
| | |
| Message * JMPIProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw() |
try |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest"); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleGetInstanceRequest: " |
| |
"enter(METHOD_INSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request-> |
| |
instanceName.getClassName().getString().getCString() |
| |
)); |
| | |
| HandlerIntro(EnumerateInstanceNames,message,request,response, |
AutoMutex lock (pr._cimomMutex); |
| handler,Array<CIMObjectPath>()); |
|
| JNIEnv *env=NULL; |
|
| try { |
|
| Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
| "JMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2", |
|
| System::getHostName(), |
|
| request->nameSpace.getString(), |
|
| request->className.getString()); |
|
| | |
| // make target object path |
cls = pr._cimom_handle->getClass( |
| CIMObjectPath objectPath( |
context, |
| System::getHostName(), |
|
| request->nameSpace, | request->nameSpace, |
| request->className); |
request->instanceName.getClassName(), |
| |
false, |
| // resolve provider name |
true, |
| ProviderName name = _resolveProviderName( |
true, |
| request->operationContext.get(ProviderIdContainer::NAME)); |
CIMPropertyList()); |
| |
|
| // get cached or load new provider module |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| JMPIProvider::OpProviderHolder ph = |
"handleGetInstanceRequest: " |
| providerManager.getProvider(name.getPhysicalName(), name.getLogicalName()); |
"exit(METHOD_INSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| // convert arguments |
(const char*)request-> |
| OperationContext context; |
instanceName.getClassName().getString().getCString() |
| |
)); |
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleGetInstanceRequest: " |
| |
"Caught CIMExcetion (METHOD_INSTANCEPROVIDER2) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request-> |
| |
instanceName.getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| | |
| context.insert(request->operationContext.get(IdentityContainer::NAME)); |
CIMClass *pcls = new CIMClass (cls); |
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
|
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
|
| | |
| JMPIProvider & pr=ph.GetProvider(); |
JMPIjvm::checkException(env); |
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
jlong jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| "Calling provider.enumerateInstanceNames: " + pr.getName()); |
jobject jcimClass = env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jcimClassRef); |
| | |
| DDD(cerr<<"--- JMPIProviderManager::enumerateInstanceNames"<<endl); |
JMPIjvm::checkException(env); |
| | |
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| | |
| JvmVector *jv; |
StatProviderTimeMeasurement providerTime(response); |
| env=JMPIjvm::attachThread(&jv); |
|
| | |
| jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
jobject jciRet = env->CallObjectMethod( |
| jv->CIMObjectPathNewI,(jint)&objectPath); |
(jobject)pr.jProvider, |
| JMPIjvm::checkException(env); |
id, |
| |
joc, |
| |
jop, |
| |
jcimClass, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
request->includeClassOrigin, |
| |
jPropertyList); |
| | |
| CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace, |
|
| request->className, |
|
| false,true,true,CIMPropertyList()); |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls); |
|
| JMPIjvm::checkException(env); |
|
| |
|
| JMPIProvider::pm_service_op_lock op_lock(&pr); |
|
| | |
| STAT_GETSTARTTIME; |
if (joc) |
| |
{ |
| |
env->CallVoidMethod( |
| |
joc, |
| |
JMPIjvm::jv.OperationContextUnassociate); |
| | |
| jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"enumInstances", |
|
| "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"); |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| |
} |
| | |
| jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,true,jCc); |
handler.processing(); |
| JMPIjvm::checkException(env); |
|
| | |
| STAT_PMS_PROVIDEREND; |
if (jciRet) { |
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| | |
| handler.processing(); |
handler.deliver(*ciRet); |
| if (jVec) { |
|
| for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
|
| JMPIjvm::checkException(env); |
|
| jobject jCop=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
| JMPIjvm::checkException(env); |
|
| CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod |
|
| (jCop,JMPIjvm::jv.CIMObjectPathCInst)); |
|
| JMPIjvm::checkException(env); |
|
| handler.deliver(*cop); |
|
| } |
|
| } | } |
| handler.complete(); | handler.complete(); |
| |
break; |
| } | } |
| HandlerCatch(handler); |
/* Fix for 4238 */ |
| | |
| if (env) JMPIjvm::detachThread(); |
case METHOD_INSTANCEPROVIDER: |
| |
{ |
| |
jlong jopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ,jopRef); |
| | |
| PEG_METHOD_EXIT(); |
JMPIjvm::checkException(env); |
| | |
| return(response); |
CIMClass cls; |
| } |
|
| | |
| Message * JMPIProviderManager::handleCreateInstanceRequest(const Message * message) throw() |
try |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| "JMPIProviderManager::handleCreateInstanceRequest"); |
"handleGetInstanceRequest: " |
| |
"enter(METHOD_INSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request-> |
| |
instanceName.getClassName().getString().getCString() |
| |
)); |
| | |
| HandlerIntro(CreateInstance,message,request,response, |
AutoMutex lock (pr._cimomMutex); |
| handler,CIMObjectPath()); |
|
| JNIEnv *env=NULL; |
|
| try { |
|
| Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
| "JMPIProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
|
| System::getHostName(), |
|
| request->nameSpace.getString(), |
|
| request->newInstance.getPath().getClassName().getString()); |
|
| | |
| // make target object path |
cls = pr._cimom_handle->getClass( |
| CIMObjectPath objectPath( |
context, |
| System::getHostName(), |
|
| request->nameSpace, | request->nameSpace, |
| request->newInstance.getPath().getClassName(), |
request->instanceName.getClassName(), |
| request->newInstance.getPath().getKeyBindings()); |
false, |
| |
true, |
| // resolve provider name |
true, |
| ProviderName name = _resolveProviderName( |
CIMPropertyList()); |
| request->operationContext.get(ProviderIdContainer::NAME)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleGetInstanceRequest: " |
| // get cached or load new provider module |
"exit(METHOD_INSTANCEPROVIDER): " |
| JMPIProvider::OpProviderHolder ph = |
"cimom_handle->getClass(%s).", |
| providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), |
(const char*)request-> |
| String::EMPTY); |
instanceName.getClassName().getString().getCString() |
| |
)); |
| // convert arguments |
} |
| OperationContext context; |
catch (CIMException e) |
| |
{ |
| context.insert(request->operationContext.get(IdentityContainer::NAME)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
"handleGetInstanceRequest: " |
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
"Caught CIMExcetion (METHOD_INSTANCEPROVIDER) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request-> |
| |
instanceName.getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| | |
| // forward request |
PEG_METHOD_EXIT(); |
| JMPIProvider & pr=ph.GetProvider(); |
throw; |
| |
} |
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
CIMClass *pcls = new CIMClass (cls); |
| "Calling provider.createInstance: " + |
|
| ph.GetProvider().getName()); |
|
| | |
| DDD(cerr<<"--- JMPIProviderManager::createInstances"<<endl); |
JMPIjvm::checkException(env); |
| | |
| JvmVector *jv; |
jlong jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| env=JMPIjvm::attachThread(&jv); |
jobject jcimClass = env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jcimClassRef); |
| | |
| jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
|
| jv->CIMObjectPathNewI,(jint)&objectPath); |
|
| JMPIjvm::checkException(env); |
|
| jobject jInst=env->NewObject(jv->CIMInstanceClassRef, |
|
| jv->CIMInstanceNewI,(jint)&request->newInstance); |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); |
StatProviderTimeMeasurement providerTime(response); |
| | |
| STAT_GETSTARTTIME; |
// Modified for Bugzilla# 3679 |
| |
jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider, |
| |
id, |
| |
jop, |
| |
jcimClass, |
| |
JMPI_LOCALONLY); |
| | |
| jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"createInstance", |
|
| "(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); |
handler.processing(); |
| | |
| STAT_PMS_PROVIDEREND; |
if (jciRet) { |
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| | |
| JMPIjvm::checkException(env); |
handler.deliver(*ciRet); |
| handler.processing(); |
|
| if (jCop) { |
|
| CIMObjectPath cop=*((CIMObjectPath*)env->CallIntMethod(jCop,JMPIjvm::jv.CIMObjectPathCInst)); |
|
| handler.deliver(cop); |
|
| } | } |
| handler.complete(); | handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleGetInstanceRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| } | } |
| HandlerCatch(handler); | HandlerCatch(handler); |
| | |
|
|
|
| return(response); | return(response); |
| } | } |
| | |
| Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw() |
Message * JMPIProviderManager::handleEnumerateInstancesRequest( |
| |
const Message * message) throw() |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_METHOD_ENTER( |
| "JMPIProviderManager::handleModifyInstanceRequest"); |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleEnumerateInstanceRequest"); |
| |
|
| |
HandlerIntro(EnumerateInstances,message,request,response,handler); |
| | |
| HandlerIntroVoid(ModifyInstance,message,request,response,handler); |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_CIMINSTANCEPROVIDER, |
| |
METHOD_CIMINSTANCEPROVIDER2, |
| |
METHOD_INSTANCEPROVIDER, |
| |
METHOD_INSTANCEPROVIDER2, |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| JNIEnv *env=NULL; | JNIEnv *env=NULL; |
| try { |
|
| Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
try |
| "DefaultProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
{ |
| System::getHostName(), |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| request->nameSpace.getString(), |
"handleEnumerateInstanceRequest: " |
| request->modifiedInstance.getPath().getClassName().getString()); |
"name space = %s class name = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| | |
| // make target object path | // make target object path |
| CIMObjectPath objectPath( |
CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(), |
| System::getHostName(), |
|
| request->nameSpace, | request->nameSpace, |
| request->modifiedInstance.getPath ().getClassName(), |
request->className); |
| request->modifiedInstance.getPath ().getKeyBindings()); |
|
| | |
| // resolve provider name | // resolve provider name |
| ProviderName name = _resolveProviderName( | ProviderName name = _resolveProviderName( |
| request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| | |
| // get cached or load new provider module | // get cached or load new provider module |
| JMPIProvider::OpProviderHolder ph = |
JMPIProvider::OpProviderHolder ph = providerManager.getProvider( |
| providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
name.getPhysicalName(), |
| |
name.getLogicalName(), |
| |
String::EMPTY); |
| | |
| // convert arguments | // convert arguments |
| OperationContext context; | OperationContext context; |
| | |
| context.insert(request->operationContext.get(IdentityContainer::NAME)); |
context.insert( |
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
request->operationContext.get(IdentityContainer::NAME)); |
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
context.insert( |
| |
request->operationContext.get(AcceptLanguageListContainer::NAME)); |
| CIMPropertyList propertyList(request->propertyList); |
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((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| "Calling provider.modifyInstance: " + pr.getName()); |
"handleEnumerateInstanceRequest: " |
| |
"Calling provider: %s", (const char*)pr.getName().getCString())); |
| | |
| DDD(cerr<<"--- JMPIProviderManager::modifyInstance"<<endl); |
JvmVector *jv = 0; |
| | |
| JvmVector *jv; |
|
| env=JMPIjvm::attachThread(&jv); | env=JMPIjvm::attachThread(&jv); |
| | |
| jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
if (!env) |
| jv->CIMObjectPathNewI,(jint)&objectPath); |
{ |
| JMPIjvm::checkException(env); |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| jobject jInst=env->NewObject(jv->CIMInstanceClassRef, |
"handleEnumerateInstanceRequest: " |
| jv->CIMInstanceNewI,(jint)&request->modifiedInstance); |
"Could not initialize the JVM (Java Virtual Machine) " |
| JMPIjvm::checkException(env); |
"runtime environment."); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| | |
| STAT_GETSTARTTIME; |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get (ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| | |
| jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"setInstance", |
if (interfaceType == "JMPI") |
| "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V"); |
{ |
| JMPIjvm::checkException(env); |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"enumInstances", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Z" |
| |
"Lorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_INSTANCEPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstances: Found METHOD_INSTANCEPROVIDER."); |
| |
} |
| | |
| env->CallVoidMethod((jobject)pr.jProvider,id,jRef,jInst); |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| | |
| STAT_PMS_PROVIDEREND; |
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); |
if (id != NULL) |
| JMPIjvm::detachThread(); |
{ |
| |
eMethodFound = METHOD_CIMINSTANCEPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstances: " |
| |
"Found METHOD_CIMINSTANCEPROVIDER."); |
| } | } |
| HandlerCatch(handler); |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"enumerateInstances", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)" |
| |
"Ljava/util/Vector;"); |
| | |
| if (env) JMPIjvm::detachThread(); |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_INSTANCEPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstances: " |
| |
"Found METHOD_INSTANCEPROVIDER2."); |
| |
} |
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"enumerateInstances", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMClass;ZZ[" |
| |
"Ljava/lang/String;)[" |
| |
"Lorg/pegasus/jmpi/CIMInstance;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMINSTANCEPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstances: " |
| |
"Found METHOD_CIMINSTANCEPROVIDER2."); |
| |
} |
| |
} |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstances: No method provider found!"); |
| | |
| PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| | |
| return(response); |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| } | } |
| | |
| Message * JMPIProviderManager::handleDeleteInstanceRequest(const Message * message) throw() |
JMPIjvm::checkException(env); |
| |
|
| |
switch (eMethodFound) |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
case METHOD_CIMINSTANCEPROVIDER: |
| "JMPIProviderManager::handleDeleteInstanceRequest"); |
{ |
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| | |
| HandlerIntroVoid(DeleteInstance,message,request,response, |
JMPIjvm::checkException(env); |
| handler); |
|
| JNIEnv *env=NULL; |
|
| try { |
|
| Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
| "DefaultProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2", |
|
| System::getHostName(), |
|
| request->nameSpace.getString(), |
|
| request->instanceName.getClassName().getString()); |
|
| | |
| // make target object path |
CIMClass cls; |
| CIMObjectPath objectPath( |
|
| System::getHostName(), |
|
| request->nameSpace, |
|
| request->instanceName.getClassName(), |
|
| request->instanceName.getKeyBindings()); |
|
| | |
| // resolve provider name |
try |
| ProviderName name = _resolveProviderName( |
{ |
| request->operationContext.get(ProviderIdContainer::NAME)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstances: " |
| |
"enter(METHOD_CIMINSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| | |
| // get cached or load new provider module |
AutoMutex lock (pr._cimomMutex); |
| JMPIProvider::OpProviderHolder ph = |
|
| providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
|
| | |
| // convert arguments |
cls = pr._cimom_handle->getClass(context, |
| OperationContext context; |
request->nameSpace, |
| |
request->className, |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstances: " |
| |
"exit(METHOD_CIMINSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| | |
| context.insert(request->operationContext.get(IdentityContainer::NAME)); |
} |
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
catch (CIMException e) |
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstances: " |
| |
"Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request->className.getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| | |
| // forward request |
PEG_METHOD_EXIT(); |
| JMPIProvider & pr=ph.GetProvider(); |
throw; |
| |
} |
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
CIMClass *pcls = new CIMClass (cls); |
| "Calling provider.deleteInstance: " + pr.getName()); |
|
| | |
| DDD(cerr<<"--- JMPIProviderManager::modifyInstance"<<endl); |
JMPIjvm::checkException(env); |
| | |
| JvmVector *jv; |
jlong jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| env=JMPIjvm::attachThread(&jv); |
jobject jcc = env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jccRef); |
| | |
| jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
|
| jv->CIMObjectPathNewI,(jint)&objectPath); |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| | |
| STAT_GETSTARTTIME; |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jAr = (jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
jcop, |
| |
JMPI_LOCALONLY, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
request->includeClassOrigin, |
| |
jPropertyList, |
| |
jcc); |
| | |
| jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"deleteInstance", |
|
| "(Lorg/pegasus/jmpi/CIMObjectPath;)V"); |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| env->CallVoidMethod((jobject)pr.jProvider,id,jRef); |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| | |
| STAT_PMS_PROVIDEREND; |
jobject jciRet = env->GetObjectArrayElement(jAr,i); |
| | |
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| JMPIjvm::detachThread(); |
|
| } |
|
| HandlerCatch(handler); |
|
| |
|
| if (env) JMPIjvm::detachThread(); |
|
| PEG_METHOD_EXIT(); |
|
| | |
| return(response); |
jlong jciRetRef = env->CallLongMethod( |
| } |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| | |
| |
/* Fix for 4237 */ |
| |
CIMClass cls; |
| | |
| Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw() |
try |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| "JMPIProviderManager::handleAssociatorsRequest"); |
"handleEnumerateInstances: " |
| |
"enter: cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| | |
| HandlerIntro(Associators,message,request,response, |
AutoMutex lock (pr._cimomMutex); |
| handler,Array<CIMObject>()); |
|
| JNIEnv *env=NULL; |
|
| try { |
|
| Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
| "JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2", |
|
| System::getHostName(), |
|
| request->nameSpace.getString(), |
|
| request->objectName.getClassName().getString()); |
|
| | |
| // make target object path |
cls = pr._cimom_handle->getClass(context, |
| CIMObjectPath objectPath( |
|
| System::getHostName(), |
|
| request->nameSpace, | request->nameSpace, |
| request->objectName.getClassName()); |
ciRet->getClassName(), |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstances: " |
| |
"exit: cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| | |
| objectPath.setKeyBindings(request->objectName.getKeyBindings()); |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstances: " |
| |
"Caught CIMExcetion " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| | |
| CIMObjectPath assocPath( |
PEG_METHOD_EXIT(); |
| System::getHostName(), |
throw; |
| request->nameSpace, |
} |
| request->assocClass.getString()); |
|
| | |
| // resolve provider name |
JMPIjvm::checkException(env); |
| ProviderName name = _resolveProviderName( |
|
| request->operationContext.get(ProviderIdContainer::NAME)); |
|
| | |
| // get cached or load new provider module |
handler.deliver(*ciRet); |
| JMPIProvider::OpProviderHolder ph = |
} |
| providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| | |
| // convert arguments |
case METHOD_CIMINSTANCEPROVIDER2: |
| OperationContext context; |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| | |
| context.insert(request->operationContext.get(IdentityContainer::NAME)); |
CIMClass cls; |
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
|
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
|
| | |
| // forward request |
try |
| JMPIProvider & pr=ph.GetProvider(); |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstances: " |
| |
"enter(METHOD_CIMINSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
AutoMutex lock (pr._cimomMutex); |
| "Calling provider.associators: " + pr.getName()); |
|
| | |
| DDD(cerr<<"--- JMPIProviderManager::associators"<< |
cls = pr._cimom_handle->getClass(context, |
| " role: >"<<request->role<<"< aCls "<< |
request->nameSpace, |
| request->assocClass<<endl); |
request->className, |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstances: " |
| |
"exit(METHOD_CIMINSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstances: " |
| |
"Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request->className.getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| | |
| JvmVector *jv; |
PEG_METHOD_EXIT(); |
| env=JMPIjvm::attachThread(&jv); |
throw; |
| |
} |
| |
|
| |
CIMClass *pcls = new CIMClass (cls); |
| | |
| jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
|
| jv->CIMObjectPathNewI,(jint)&objectPath); |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| jstring rClass=env->NewStringUTF(request->resultClass.getString().getCString()); |
jlong jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| jstring rRole=env->NewStringUTF(request->role.getCString()); |
jobject jcc = env->NewObject( |
| jstring resRole=env->NewStringUTF(request->resultRole.getCString()); |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jccRef); |
| |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| | |
| STAT_GETSTARTTIME; |
StatProviderTimeMeasurement providerTime(response); |
| | |
| jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"associators", |
jobjectArray jAr = (jobjectArray)env->CallObjectMethod( |
| "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;" |
(jobject)pr.jProvider, |
| "Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"); |
id, |
| |
joc, |
| |
jcop, |
| |
jcc, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
request->includeClassOrigin, |
| |
jPropertyList); |
| | |
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef, |
if (joc) |
| rClass,rRole,resRole,false,false,NULL); |
{ |
| JMPIjvm::checkException(env); |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| | |
| STAT_PMS_PROVIDEREND; |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->GetObjectArrayElement(jAr,i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
|
| |
/* Fix for 4237 */ |
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstancesRequest: " |
| |
"enter: cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
ciRet->getClassName(), |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstancesRequest: " |
| |
"exit: cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstancesRequest: " |
| |
"Caught CIMExcetion " |
| |
"cimom_handle->getClass(%s): %s ", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*ciRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
/* Fix for 4189 */ |
| |
case METHOD_INSTANCEPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstancesRequest: " |
| |
"enter(METHOD_INSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass (context, |
| |
request->nameSpace, |
| |
request->className, |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstancesRequest: " |
| |
"enter(METHOD_INSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstancesRequest: " |
| |
"Caught CIMExcetion(METHOD_INSTANCEPROVIDER2) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request->className.getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
CIMClass *pcls = new CIMClass (cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| |
jobject jcc = env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jccRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jcop, |
| |
jcc, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
request->includeClassOrigin, |
| |
jPropertyList); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
if (jVec) { |
| |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i<m; |
| |
i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
|
| |
/* Fix for 4237 */ |
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstancesRequest: " |
| |
"enter: cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
ciRet->getClassName(), |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstancesRequest: " |
| |
"exit: cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstancesRequest: " |
| |
"Caught CIMExcetion " |
| |
"cimom_handle->getClass(%s): %s ", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
_fixCIMObjectPath(ciRet, cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*ciRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
/* Fix for 4189 */ |
| |
|
| |
case METHOD_INSTANCEPROVIDER: |
| |
{ |
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstancesRequest: " |
| |
"enter(METHOD_INSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
request->className, |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstancesRequest: " |
| |
"exit(METHOD_INSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstancesRequest: " |
| |
"Caught CIMExcetion(METHOD_INSTANCEPROVIDER) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request->className.getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
CIMClass *pcls = new CIMClass (cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| |
jobject jcc = env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jccRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
// Modified for Bugzilla# 3679 |
| |
jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, |
| |
id, |
| |
jcop, |
| |
request->deepInheritance, |
| |
jcc, |
| |
JMPI_LOCALONLY); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
if (jVec) { |
| |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i<m; |
| |
i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
|
| |
/* Fix for 4237 */ |
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstancesRequest: " |
| |
"enter: cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
ciRet->getClassName(), |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstancesRequest: " |
| |
"exit: cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstancesRequest: " |
| |
"Caught CIMExcetion " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
_fixCIMObjectPath(ciRet, cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*ciRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstancesRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| |
} |
| |
HandlerCatch(handler); |
| |
|
| |
if (env) JMPIjvm::detachThread(); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
return(response); |
| |
} |
| |
|
| |
Message * JMPIProviderManager::handleEnumerateInstanceNamesRequest( |
| |
const Message * message) throw() |
| |
{ |
| |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleEnumerateInstanceNamesRequest"); |
| |
|
| |
HandlerIntro(EnumerateInstanceNames,message,request,response, handler); |
| |
|
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_CIMINSTANCEPROVIDER, |
| |
METHOD_CIMINSTANCEPROVIDER2, |
| |
METHOD_INSTANCEPROVIDER, |
| |
METHOD_INSTANCEPROVIDER2, |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| |
JNIEnv *env = NULL; |
| |
|
| |
try { |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"name space = %s class name = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)request->className.getString().getCString())); |
| |
|
| |
// make target object path |
| |
CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(), |
| |
request->nameSpace, |
| |
request->className); |
| |
|
| |
// resolve provider name |
| |
ProviderName name = _resolveProviderName( |
| |
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
|
| |
// get cached or load new provider module |
| |
JMPIProvider::OpProviderHolder ph = providerManager.getProvider( |
| |
name.getPhysicalName(), |
| |
name.getLogicalName()); |
| |
|
| |
// convert arguments |
| |
OperationContext context; |
| |
|
| |
context.insert( |
| |
request->operationContext.get(IdentityContainer::NAME)); |
| |
context.insert( |
| |
request->operationContext.get(AcceptLanguageListContainer::NAME)); |
| |
context.insert( |
| |
request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
|
| |
JMPIProvider &pr = ph.GetProvider(); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"Calling provider: %s",(const char*)pr.getName().getCString())); |
| |
|
| |
JvmVector *jv = 0; |
| |
|
| |
env = JMPIjvm::attachThread(&jv); |
| |
|
| |
if (!env) |
| |
{ |
| |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| |
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
|
| |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get(ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| |
|
| |
if (interfaceType == "JMPI") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"enumInstances", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_INSTANCEPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"Found METHOD_INSTANCEPROVIDER."); |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
|
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"enumerateInstanceNames", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMClass;)[" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMINSTANCEPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"Found METHOD_CIMINSTANCEPROVIDER."); |
| |
} |
| |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"enumerateInstanceNames", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_INSTANCEPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"Found METHOD_INSTANCEPROVIDER2."); |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
|
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"enumerateInstanceNames", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMClass;)" |
| |
"[Lorg/pegasus/jmpi/CIMObjectPath;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMINSTANCEPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"Found METHOD_CIMINSTANCEPROVIDER2."); |
| |
} |
| |
} |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"No method provider found!"); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| |
} |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
switch (eMethodFound) |
| |
{ |
| |
case METHOD_CIMINSTANCEPROVIDER: |
| |
{ |
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"enter(METHOD_CIMINSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
request->className, |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"exit(METHOD_CIMINSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request->className.getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
CIMClass *pcls = new CIMClass (cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcimClassRef = DEBUG_ConvertCToJava( |
| |
CIMClass*, |
| |
jlong, |
| |
pcls); |
| |
jobject jcimClass = env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jcimClassRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jAr = (jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
jcop, |
| |
jcimClass); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jcopRet = env->GetObjectArrayElement(jAr,i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jcopRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*copRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_CIMINSTANCEPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"enter(METHOD_CIMINSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
request->className, |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"exit(METHOD_CIMINSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER2) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request->className.getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
CIMClass *pcls = new CIMClass (cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcimClassRef = DEBUG_ConvertCToJava(CIMClass*, jlong, pcls); |
| |
jobject jcimClass = env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jcimClassRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jAr = (jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jcop, |
| |
jcimClass); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jcopRet = env->GetObjectArrayElement(jAr,i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jcopRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*copRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_INSTANCEPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"enter(METHOD_INSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
request->className, |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"exit(METHOD_INSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"Caught CIMExcetion(METHOD_INSTANCEPROVIDER2) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request->className.getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
CIMClass *pcls = new CIMClass (cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcimClassRef = DEBUG_ConvertCToJava( |
| |
CIMClass*, |
| |
jlong, |
| |
pcls); |
| |
jobject jcimClass = env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jcimClassRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jcop, |
| |
jcimClass); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
if (jVec) { |
| |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i<m; |
| |
i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jcopRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jcopRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*copRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_INSTANCEPROVIDER: |
| |
{ |
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"exit(METHOD_INSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
request->className, |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"exit(METHOD_INSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"Caught CIMExcetion(METHOD_INSTANCEPROVIDER) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request->className.getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
CIMClass *pcls = new CIMClass (cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcimClassRef = DEBUG_ConvertCToJava( |
| |
CIMClass*, |
| |
jlong, |
| |
pcls); |
| |
jobject jcimClass = env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jcimClassRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, |
| |
id, |
| |
jcop, |
| |
true, |
| |
jcimClass); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
if (jVec) { |
| |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i<m; |
| |
i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jcopRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jcopRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*copRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleEnumerateInstanceNamesRequest: " |
| |
"Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| |
} |
| |
HandlerCatch(handler); |
| |
|
| |
if (env) JMPIjvm::detachThread(); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
return(response); |
| |
} |
| |
|
| |
Message * JMPIProviderManager::handleCreateInstanceRequest( |
| |
const Message * message) throw() |
| |
{ |
| |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleCreateInstanceRequest"); |
| |
|
| |
HandlerIntro(CreateInstance,message,request,response,handler); |
| |
|
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER |
| |
METHOD_INSTANCEPROVIDER2 // same as METHOD_CIMINSTANCEPROVIDER2 |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| |
JNIEnv *env = NULL; |
| |
|
| |
try { |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"handleCreateInstanceRequest: " |
| |
"name space = %s class name = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)request-> |
| |
newInstance.getPath().getClassName().getString().getCString() |
| |
)); |
| |
|
| |
// make target object path |
| |
CIMObjectPath *objectPath = |
| |
new CIMObjectPath( |
| |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->newInstance.getPath().getClassName(), |
| |
request->newInstance.getPath().getKeyBindings()); |
| |
|
| |
// resolve provider name |
| |
ProviderName name = _resolveProviderName( |
| |
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
|
| |
// get cached or load new provider module |
| |
JMPIProvider::OpProviderHolder ph = |
| |
providerManager.getProvider( |
| |
name.getPhysicalName(), |
| |
name.getLogicalName(), |
| |
String::EMPTY); |
| |
|
| |
// forward request |
| |
JMPIProvider &pr = ph.GetProvider(); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| |
"handleCreateInstanceRequest: " |
| |
"Calling provider: %s", (const char*)pr.getName().getCString())); |
| |
|
| |
JvmVector *jv = 0; |
| |
|
| |
env = JMPIjvm::attachThread(&jv); |
| |
|
| |
if (!env) |
| |
{ |
| |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleCreateInstanceRequest: " |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| |
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
|
| |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get( |
| |
ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| |
|
| |
if (interfaceType == "JMPI") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"createInstance", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMInstance;)" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_INSTANCEPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleCreateInstanceRequest: " |
| |
"Found METHOD_INSTANCEPROVIDER."); |
| |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"createInstance", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMInstance;)" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_INSTANCEPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleCreateInstanceRequest: " |
| |
"Found METHOD_INSTANCEPROVIDER2."); |
| |
} |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleCreateInstanceRequest: No method provider found!"); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| |
} |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
switch (eMethodFound) |
| |
{ |
| |
case METHOD_INSTANCEPROVIDER: |
| |
{ |
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMInstance *ci = new CIMInstance (request->newInstance); |
| |
jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci); |
| |
jobject jci = env->NewObject( |
| |
jv->CIMInstanceClassRef, |
| |
jv->CIMInstanceNewJ, |
| |
jciRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleCreateInstanceRequest: " |
| |
"id = %p, jcop = %p, jci = %p", |
| |
id,jcop,jci)); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider, |
| |
id, |
| |
jcop, |
| |
jci); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
|
| |
if (jcopRet) { |
| |
jlong jCopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jCopRetRef); |
| |
|
| |
handler.deliver(*copRet); |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_INSTANCEPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMInstance *ci = new CIMInstance (request->newInstance); |
| |
jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci); |
| |
jobject jci = env->NewObject( |
| |
jv->CIMInstanceClassRef, |
| |
jv->CIMInstanceNewJ, |
| |
jciRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleCreateInstanceRequest: " |
| |
"id = %p, jcop = %p, jci = %p", |
| |
id,jcop,jci)); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jcop, |
| |
jci); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
|
| |
if (jcopRet) { |
| |
jlong jCopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jCopRetRef); |
| |
|
| |
handler.deliver(*copRet); |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleCreateInstanceRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| |
} |
| |
HandlerCatch(handler); |
| |
|
| |
if (env) JMPIjvm::detachThread(); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
return(response); |
| |
} |
| |
|
| |
Message * JMPIProviderManager::handleModifyInstanceRequest( |
| |
const Message * message) throw() |
| |
{ |
| |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleModifyInstanceRequest"); |
| |
|
| |
HandlerIntro(ModifyInstance,message,request,response,handler); |
| |
|
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_CIMINSTANCEPROVIDER, |
| |
METHOD_INSTANCEPROVIDER, |
| |
METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2 |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| |
JNIEnv *env = NULL; |
| |
|
| |
try { |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"handleModifyInstanceRequest: " |
| |
"name space = %s class name = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)request->modifiedInstance.getPath().getClassName() |
| |
.getString().getCString() |
| |
)); |
| |
|
| |
// make target object path |
| |
CIMObjectPath *objectPath = |
| |
new CIMObjectPath( |
| |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->modifiedInstance.getPath().getClassName(), |
| |
request->modifiedInstance.getPath ().getKeyBindings()); |
| |
|
| |
// resolve provider name |
| |
ProviderName name = _resolveProviderName( |
| |
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleModifyInstanceRequest: " |
| |
"provider name physical = %s, logical = %s", |
| |
(const char*)name.getPhysicalName().getCString(), |
| |
(const char*)name.getLogicalName().getCString() |
| |
)); |
| |
|
| |
// get cached or load new provider module |
| |
JMPIProvider::OpProviderHolder ph = |
| |
providerManager.getProvider( |
| |
name.getPhysicalName(), |
| |
name.getLogicalName(), |
| |
String::EMPTY); |
| |
|
| |
// forward request |
| |
JMPIProvider &pr = ph.GetProvider(); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| |
"handleModifyInstanceRequest: " |
| |
"Calling provider: %s", (const char*)pr.getName().getCString())); |
| |
|
| |
JvmVector *jv = 0; |
| |
|
| |
env = JMPIjvm::attachThread(&jv); |
| |
|
| |
if (!env) |
| |
{ |
| |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
| |
"handleModifyInstanceRequest: " |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| |
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
|
| |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get( |
| |
ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| |
|
| |
if (interfaceType == "JMPI") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"setInstance", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMInstance;)V"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_INSTANCEPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleModifyInstanceRequest: " |
| |
"Found METHOD_INSTANCEPROVIDER."); |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
|
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"setInstance", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Z[Ljava/lang/String)V"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMINSTANCEPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleModifyInstanceRequest: " |
| |
"Found METHOD_CIMINSTANCEPROVIDER."); |
| |
} |
| |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"setInstance", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMInstance;)V"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_INSTANCEPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleModifyInstanceRequest: " |
| |
"Found METHOD_INSTANCEPROVIDER2."); |
| |
} |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleModifyInstanceRequest: No method provider found!"); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| |
} |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
switch (eMethodFound) |
| |
{ |
| |
case METHOD_INSTANCEPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
|
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMInstance *ci = new CIMInstance (request->modifiedInstance); |
| |
jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci); |
| |
jobject jci = env->NewObject( |
| |
jv->CIMInstanceClassRef, |
| |
jv->CIMInstanceNewJ, |
| |
jciRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
env->CallVoidMethod((jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jcop, |
| |
jci); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
break; |
| |
} |
| |
|
| |
case METHOD_CIMINSTANCEPROVIDER: |
| |
{ |
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMInstance *ci = new CIMInstance (request->modifiedInstance); |
| |
jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci); |
| |
jobject jci = env->NewObject( |
| |
jv->CIMInstanceClassRef, |
| |
jv->CIMInstanceNewJ, |
| |
jciRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
env->CallVoidMethod((jobject)pr.jProvider, |
| |
id, |
| |
jcop, |
| |
jci, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
jPropertyList); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_INSTANCEPROVIDER: |
| |
{ |
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMInstance *ci = new CIMInstance (request->modifiedInstance); |
| |
jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci); |
| |
jobject jci = env->NewObject( |
| |
jv->CIMInstanceClassRef, |
| |
jv->CIMInstanceNewJ, |
| |
jciRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
env->CallVoidMethod((jobject)pr.jProvider, |
| |
id, |
| |
jcop, |
| |
jci); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleModifyInstanceRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| |
} |
| |
HandlerCatch(handler); |
| |
|
| |
if (env) JMPIjvm::detachThread(); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
return(response); |
| |
} |
| |
|
| |
Message * JMPIProviderManager::handleDeleteInstanceRequest( |
| |
const Message * message) throw() |
| |
{ |
| |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleDeleteInstanceRequest"); |
| |
|
| |
HandlerIntro(DeleteInstance,message,request,response,handler); |
| |
|
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER |
| |
METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2 |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| |
JNIEnv *env = NULL; |
| |
|
| |
try { |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"handleDeleteInstanceRequest: " |
| |
"name space = %s class name = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)request-> |
| |
instanceName.getClassName().getString().getCString() |
| |
)); |
| |
|
| |
// make target object path |
| |
CIMObjectPath *objectPath = new CIMObjectPath( |
| |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->instanceName.getClassName(), |
| |
request->instanceName.getKeyBindings()); |
| |
|
| |
// resolve provider name |
| |
ProviderName name = _resolveProviderName( |
| |
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
|
| |
// get cached or load new provider module |
| |
JMPIProvider::OpProviderHolder ph = |
| |
providerManager.getProvider( |
| |
name.getPhysicalName(), |
| |
name.getLogicalName(), |
| |
String::EMPTY); |
| |
|
| |
// forward request |
| |
JMPIProvider &pr = ph.GetProvider(); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| |
"handleDeleteInstanceRequest: " |
| |
"Calling provider: %s", (const char*)pr.getName().getCString())); |
| |
|
| |
JvmVector *jv = 0; |
| |
|
| |
env = JMPIjvm::attachThread(&jv); |
| |
|
| |
if (!env) |
| |
{ |
| |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleDeleteInstanceRequest: " |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| |
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
|
| |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get(ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| |
|
| |
if (interfaceType == "JMPI") |
| |
{ |
| |
id = env->GetMethodID((jclass)pr.jProviderClass, |
| |
"deleteInstance", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;)V"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_INSTANCEPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleDeleteInstanceRequest: " |
| |
"Found METHOD_INSTANCEPROVIDER."); |
| |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"deleteInstance", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;)V"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_INSTANCEPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleDeleteInstanceRequest: " |
| |
"Found METHOD_INSTANCEPROVIDER2."); |
| |
} |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleDeleteInstanceRequest: No method provider found!"); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| |
} |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
switch (eMethodFound) |
| |
{ |
| |
case METHOD_INSTANCEPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
env->CallVoidMethod((jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jcop); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
break; |
| |
} |
| |
|
| |
case METHOD_INSTANCEPROVIDER: |
| |
{ |
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
env->CallVoidMethod((jobject)pr.jProvider, |
| |
id, |
| |
jcop); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleDeleteInstanceRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| |
} |
| |
HandlerCatch(handler); |
| |
|
| |
if (env) JMPIjvm::detachThread(); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
return(response); |
| |
} |
| |
|
| |
Message * JMPIProviderManager::handleExecQueryRequest( |
| |
const Message * message) throw() |
| |
{ |
| |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleExecQueryRequest"); |
| |
|
| |
HandlerIntro(ExecQuery,message,request,response,handler); |
| |
|
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_CIMINSTANCEPROVIDER, |
| |
METHOD_CIMINSTANCEPROVIDER2, |
| |
METHOD_INSTANCEPROVIDER, |
| |
METHOD_INSTANCEPROVIDER2, |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| |
JNIEnv *env = NULL; |
| |
|
| |
try { |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"handleExecQueryRequest: " |
| |
"name space = %s class name = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
// make target object path |
| |
CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(), |
| |
request->nameSpace, |
| |
request->className); |
| |
|
| |
// resolve provider name |
| |
ProviderName name = _resolveProviderName( |
| |
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
|
| |
// get cached or load new provider module |
| |
JMPIProvider::OpProviderHolder ph = |
| |
providerManager.getProvider( |
| |
name.getPhysicalName(), |
| |
name.getLogicalName(), |
| |
String::EMPTY); |
| |
|
| |
// convert arguments |
| |
OperationContext context; |
| |
|
| |
context.insert( |
| |
request->operationContext.get(IdentityContainer::NAME)); |
| |
context.insert( |
| |
request->operationContext.get(AcceptLanguageListContainer::NAME)); |
| |
context.insert( |
| |
request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
|
| |
// forward request |
| |
JMPIProvider &pr = ph.GetProvider(); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| |
"handleExecQueryRequest: " |
| |
"Calling provider: %s, queryLanguage: %s, query: %s", |
| |
(const char*)pr.getName().getCString(), |
| |
(const char*)request->queryLanguage.getCString(), |
| |
(const char*)request->query.getCString() |
| |
)); |
| |
|
| |
JvmVector *jv = 0; |
| |
|
| |
env = JMPIjvm::attachThread(&jv); |
| |
|
| |
if (!env) |
| |
{ |
| |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleExecQueryRequest: " |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| |
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
|
| |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get( |
| |
ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| |
|
| |
if (interfaceType == "JMPI") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"execQuery", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_INSTANCEPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: Found METHOD_INSTANCEPROVIDER."); |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
|
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"execQuery", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)" |
| |
"[Lorg/pegasus/jmpi/CIMInstance;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMINSTANCEPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: " |
| |
"Found METHOD_CIMINSTANCEPROVIDER."); |
| |
} |
| |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"execQuery", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;" |
| |
"Ljava/lang/String;)Ljava/util/Vector;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_INSTANCEPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: Found METHOD_INSTANCEPROVIDER2."); |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
|
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"execQuery", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;" |
| |
"Ljava/lang/String;)" |
| |
"[Lorg/pegasus/jmpi/CIMInstance;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMINSTANCEPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: " |
| |
"Found METHOD_CIMINSTANCEPROVIDER2."); |
| |
} |
| |
} |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleExecQueryRequest: No method provider found!"); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| |
} |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
switch (eMethodFound) |
| |
{ |
| |
case METHOD_CIMINSTANCEPROVIDER: |
| |
{ |
| |
jlong jcopref = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopref); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jqueryLanguage = env->NewStringUTF( |
| |
request->queryLanguage.getCString()); |
| |
jstring jquery = env->NewStringUTF( |
| |
request->query.getCString()); |
| |
|
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: " |
| |
"enter(METHOD_CIMINSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
request->className, |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: " |
| |
"exit(METHOD_CIMINSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleExecQueryRequest: " |
| |
"Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request->className.getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
CIMClass *pcls = new CIMClass (cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| |
|
| |
jobject jCc=env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jcls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jAr = (jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
jcop, |
| |
jquery, |
| |
jqueryLanguage, |
| |
jCc); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->GetObjectArrayElement(jAr,i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*ciRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_CIMINSTANCEPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jcopref = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopref); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jqueryLanguage = env->NewStringUTF( |
| |
request->queryLanguage.getCString()); |
| |
jstring jquery = env->NewStringUTF( |
| |
request->query.getCString()); |
| |
|
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: " |
| |
"enter(METHOD_CIMINSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
request->className, |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: " |
| |
"exit(METHOD_CIMINSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleExecQueryRequest: " |
| |
"Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER2) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request->className.getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
CIMClass *pcls = new CIMClass (cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| |
|
| |
jobject jCc=env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jcls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jAr = (jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jcop, |
| |
jquery, |
| |
jqueryLanguage, |
| |
jCc); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->GetObjectArrayElement(jAr,i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*ciRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_INSTANCEPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jcopref = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopref); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jqueryLanguage = env->NewStringUTF( |
| |
request->queryLanguage.getCString()); |
| |
jstring jquery = env->NewStringUTF( |
| |
request->query.getCString()); |
| |
|
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: " |
| |
"enter(METHOD_INSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
request->className, |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: " |
| |
"exit(METHOD_INSTANCEPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleExecQueryRequest: " |
| |
"Caught CIMExcetion(METHOD_INSTANCEPROVIDER2) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request->className.getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
CIMClass *pcls = new CIMClass (cls); |
| |
|
| |
jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| |
|
| |
jobject jCc=env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jcls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobject jVec = env->CallObjectMethod ((jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jcop, |
| |
jCc, |
| |
jquery, |
| |
jqueryLanguage); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
if (jVec) |
| |
{ |
| |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i < m; |
| |
i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: jciRet = %p",jciRet)); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*ciRet); |
| |
} |
| |
} |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: done!"); |
| |
|
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_INSTANCEPROVIDER: |
| |
{ |
| |
jlong jcopref = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopref); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jqueryLanguage = env->NewStringUTF( |
| |
request->queryLanguage.getCString()); |
| |
jstring jquery = env->NewStringUTF( |
| |
request->query.getCString()); |
| |
|
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: " |
| |
"enter(METHOD_INSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
request->className, |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleExecQueryRequest: " |
| |
"exit(METHOD_INSTANCEPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)request->className.getString().getCString() |
| |
)); |
| |
|
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleExecQueryRequest: " |
| |
"Caught CIMExcetion(METHOD_INSTANCEPROVIDER) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)request->className.getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
CIMClass *pcls = new CIMClass (cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls); |
| |
|
| |
jobject jCc=env->NewObject( |
| |
jv->CIMClassClassRef, |
| |
jv->CIMClassNewJ, |
| |
jcls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jql = 0; // @BUG - how to convert? |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobject jVec = env->CallObjectMethod((jobject)pr.jProvider, |
| |
id, |
| |
jcop, |
| |
jquery, |
| |
jql, |
| |
jCc); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
if (jVec) { |
| |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i<m; |
| |
i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*ciRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleExecQueryRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| |
} |
| |
HandlerCatch(handler); |
| |
|
| |
if (env) JMPIjvm::detachThread(); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
return(response); |
| |
} |
| |
|
| |
Message * JMPIProviderManager::handleAssociatorsRequest( |
| |
const Message * message) throw() |
| |
{ |
| |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleAssociatorsRequest"); |
| |
|
| |
HandlerIntro(Associators,message,request,response,handler); |
| |
|
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_CIMASSOCIATORPROVIDER, |
| |
METHOD_CIMASSOCIATORPROVIDER2, |
| |
METHOD_ASSOCIATORPROVIDER, |
| |
METHOD_ASSOCIATORPROVIDER2, |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| |
JNIEnv *env = NULL; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"handleAssociatorsRequest: " |
| |
"name space = %s class name = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)request-> |
| |
objectName.getClassName().getString().getCString() |
| |
)); |
| |
|
| |
// make target object path |
| |
CIMObjectPath *objectPath = new CIMObjectPath( |
| |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->objectName.getClassName(), |
| |
request->objectName.getKeyBindings()); |
| |
CIMObjectPath *assocPath = new CIMObjectPath( |
| |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->assocClass.getString()); |
| |
|
| |
// resolve provider name |
| |
ProviderName name = _resolveProviderName( |
| |
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
|
| |
// get cached or load new provider module |
| |
JMPIProvider::OpProviderHolder ph = |
| |
providerManager.getProvider( |
| |
name.getPhysicalName(), |
| |
name.getLogicalName(), |
| |
String::EMPTY); |
| |
|
| |
// convert arguments |
| |
OperationContext context; |
| |
|
| |
context.insert( |
| |
request->operationContext.get(IdentityContainer::NAME)); |
| |
context.insert( |
| |
request->operationContext.get(AcceptLanguageListContainer::NAME)); |
| |
context.insert( |
| |
request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
|
| |
// forward request |
| |
JMPIProvider &pr = ph.GetProvider(); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| |
"handleAssociatorsRequest: " |
| |
"Calling provider: %s, role: %s, aCls: %s", |
| |
(const char*)pr.getName().getCString(), |
| |
(const char*)request->role.getCString(), |
| |
(const char*)request->assocClass.getString().getCString() |
| |
)); |
| |
|
| |
JvmVector *jv = 0; |
| |
|
| |
env = JMPIjvm::attachThread(&jv); |
| |
|
| |
if (!env) |
| |
{ |
| |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleAssociatorsRequest: " |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| |
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
|
| |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get( |
| |
ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| |
|
| |
if (interfaceType == "JMPI") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"associators", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/lang/String;Ljava/lang/String;" |
| |
"ZZ[Ljava/lang/String;)Ljava/util/Vector;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_ASSOCIATORPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: " |
| |
"Found METHOD_ASSOCIATORPROVIDER."); |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
|
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"associators", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/lang/String;Ljava/lang/String;" |
| |
"ZZ[Ljava/lang/String;)" |
| |
"[Lorg/pegasus/jmpi/CIMInstance;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMASSOCIATORPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: " |
| |
"Found METHOD_ASSOCIATORPROVIDER."); |
| |
} |
| |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"associators", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Ljava/lang/String;Ljava/lang/String;" |
| |
"Ljava/lang/String;ZZ[Ljava/lang/String;)" |
| |
"Ljava/util/Vector;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_ASSOCIATORPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: " |
| |
"Found METHOD_ASSOCIATORPROVIDER2."); |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"associators", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Ljava/lang/String;Ljava/lang/String;" |
| |
"Ljava/lang/String;ZZ[Ljava/lang/String;" |
| |
")[Lorg/pegasus/jmpi/CIMInstance;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMASSOCIATORPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: " |
| |
"Found METHOD_CIMASSOCIATORPROVIDER2."); |
| |
} |
| |
} |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleAssociatorsRequest: No method found!"); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| |
} |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
switch (eMethodFound) |
| |
{ |
| |
case METHOD_CIMASSOCIATORPROVIDER: |
| |
{ |
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
assocPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jResultClass = |
| |
env->NewStringUTF( |
| |
request->resultClass.getString().getCString()); |
| |
jstring jRole = |
| |
env->NewStringUTF( |
| |
request->role.getCString()); |
| |
jstring jResultRole = |
| |
env->NewStringUTF( |
| |
request->resultRole.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: assocName = %s ", |
| |
(const char*)assocPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: pathName = %s ", |
| |
(const char*)objectPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: resultClass = %s ", |
| |
(const char*)request->resultClass.getString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: resultRole = %s ", |
| |
(const char*)request->resultRole.getCString())); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: includeQualifiers = false"); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: includeClassOrigin = false"); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jAr=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
jAssociationName, |
| |
jPathName, |
| |
jResultClass, |
| |
jRole, |
| |
jResultRole, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
request->includeClassOrigin, |
| |
jPropertyList); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->GetObjectArrayElement(jAr,i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: " |
| |
"enter(METHOD_CIMASSOCIATORPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
ciRet->getClassName(), |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: " |
| |
"exit(METHOD_CIMASSOCIATORPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleAssociatorsRequest: " |
| |
"Caught CIMExcetion(METHOD_CIMASSOCIATORPROVIDER) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
_fixCIMObjectPath(ciRet, cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*ciRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_CIMASSOCIATORPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
assocPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jResultClass = |
| |
env->NewStringUTF( |
| |
request->resultClass.getString().getCString()); |
| |
jstring jRole = |
| |
env->NewStringUTF(request->role.getCString()); |
| |
jstring jResultRole = |
| |
env->NewStringUTF(request->resultRole.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: assocName = %s ", |
| |
(const char*)assocPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: pathName = %s ", |
| |
(const char*)objectPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: resultClass = %s ", |
| |
(const char*)request->resultClass.getString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: resultRole = %s ", |
| |
(const char*)request->resultRole.getCString())); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: includeQualifiers = false"); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: includeClassOrigin = false"); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jAr=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jAssociationName, |
| |
jPathName, |
| |
jResultClass, |
| |
jRole, |
| |
jResultRole, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
request->includeClassOrigin, |
| |
jPropertyList); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->GetObjectArrayElement(jAr,i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: " |
| |
"enter(METHOD_CIMASSOCIATORPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
ciRet->getClassName(), |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: " |
| |
"exit(METHOD_CIMASSOCIATORPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleAssociatorsRequest: " |
| |
"Caught CIMExcetion(METHOD_CIMASSOCIATORPROVIDER2) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
_fixCIMObjectPath(ciRet, cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*ciRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_ASSOCIATORPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
assocPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jResultClass = |
| |
env->NewStringUTF( |
| |
request->resultClass.getString().getCString()); |
| |
jstring jRole = |
| |
env->NewStringUTF(request->role.getCString()); |
| |
jstring jResultRole = |
| |
env->NewStringUTF(request->resultRole.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: assocName = %s ", |
| |
(const char*)assocPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: pathName = %s ", |
| |
(const char*)objectPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: resultClass = %s ", |
| |
(const char*)request->resultClass.getString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: resultRole = %s ", |
| |
(const char*)request->resultRole.getCString())); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: includeQualifiers = false"); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: includeClassOrigin = false"); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jAssociationName, |
| |
jPathName, |
| |
jResultClass, |
| |
jRole, |
| |
jResultRole, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
request->includeClassOrigin, |
| |
jPropertyList); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
if (jVec) { |
| |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i<m; |
| |
i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: " |
| |
"enter(METHOD_ASSOCIATORPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass( |
| |
context, |
| |
request->nameSpace, |
| |
ciRet->getClassName(), |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: " |
| |
"exit(METHOD_ASSOCIATORPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleAssociatorsRequest: " |
| |
"Caught CIMExcetion(METHOD_ASSOCIATORPROVIDER2) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
_fixCIMObjectPath(ciRet, cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*ciRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_ASSOCIATORPROVIDER: |
| |
{ |
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
assocPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jResultClass = |
| |
env->NewStringUTF( |
| |
request->resultClass.getString().getCString()); |
| |
jstring jRole = |
| |
env->NewStringUTF(request->role.getCString()); |
| |
jstring jResultRole = |
| |
env->NewStringUTF(request->resultRole.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: assocName = %s ", |
| |
(const char*)assocPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: pathName = %s ", |
| |
(const char*)objectPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: resultClass = %s ", |
| |
(const char*)request->resultClass.getString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: resultRole = %s ", |
| |
(const char*)request->resultRole.getCString())); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: includeQualifiers = false"); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: includeClassOrigin = false"); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
jAssociationName, |
| |
jPathName, |
| |
jResultClass, |
| |
jRole, |
| |
jResultRole, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
request->includeClassOrigin, |
| |
jPropertyList); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
if (jVec) { |
| |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i<m; |
| |
i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
jobject jciRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: " |
| |
"enter(METHOD_ASSOCIATORPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
ciRet->getClassName(), |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorsRequest: " |
| |
"exit(METHOD_ASSOCIATORPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleAssociatorsRequest: " |
| |
"Caught CIMExcetion(METHOD_ASSOCIATORPROVIDER) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
_fixCIMObjectPath(ciRet, cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*ciRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleAssociatorsRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| |
} |
| |
HandlerCatch(handler); |
| |
|
| |
if (env) JMPIjvm::detachThread(); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
return(response); |
| |
} |
| |
|
| |
Message * JMPIProviderManager::handleAssociatorNamesRequest( |
| |
const Message * message) throw() |
| |
{ |
| |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleAssociatorNamesRequest"); |
| |
|
| |
HandlerIntro(AssociatorNames,message,request,response,handler); |
| |
|
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_CIMASSOCIATORPROVIDER, |
| |
METHOD_CIMASSOCIATORPROVIDER2, |
| |
METHOD_ASSOCIATORPROVIDER, |
| |
METHOD_ASSOCIATORPROVIDER2 |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| |
JNIEnv *env = NULL; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"handleAssociatorNamesRequest: " |
| |
"name space = %s class name = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)request-> |
| |
objectName.getClassName().getString().getCString() |
| |
)); |
| |
|
| |
// make target object path |
| |
CIMObjectPath *objectPath = new CIMObjectPath( |
| |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->objectName.getClassName(), |
| |
request->objectName.getKeyBindings()); |
| |
CIMObjectPath *assocPath = new CIMObjectPath( |
| |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->assocClass.getString()); |
| |
|
| |
// resolve provider name |
| |
ProviderName name = _resolveProviderName( |
| |
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
|
| |
// get cached or load new provider module |
| |
JMPIProvider::OpProviderHolder ph = |
| |
providerManager.getProvider( |
| |
name.getPhysicalName(), |
| |
name.getLogicalName(), |
| |
String::EMPTY); |
| |
|
| |
// forward request |
| |
JMPIProvider &pr = ph.GetProvider(); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| |
"handleAssociatorNamesRequest: " |
| |
"Calling provider: %s, role: %s, aCls: %s", |
| |
(const char*)pr.getName().getCString(), |
| |
(const char*)request->role.getCString(), |
| |
(const char*)request->assocClass.getString().getCString() |
| |
)); |
| |
|
| |
JvmVector *jv = 0; |
| |
|
| |
env = JMPIjvm::attachThread(&jv); |
| |
|
| |
if (!env) |
| |
{ |
| |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleAssociatorNamesRequest: " |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| |
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
|
| |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get(ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| |
|
| |
if (interfaceType == "JMPI") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"associatorNames", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/lang/String;Ljava/lang/String;)" |
| |
"Ljava/util/Vector;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_ASSOCIATORPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: " |
| |
"Found METHOD_ASSOCIATORPROVIDER."); |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"associatorNames", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/lang/String;Ljava/lang/String;)" |
| |
"[Lorg/pegasus/jmpi/CIMObjectPath;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMASSOCIATORPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: " |
| |
"Found METHOD_CIMASSOCIATORPROVIDER."); |
| |
} |
| |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"associatorNames", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/lang/String;Ljava/lang/String;)" |
| |
"Ljava/util/Vector;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_ASSOCIATORPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: " |
| |
"Found METHOD_ASSOCIATORPROVIDER2."); |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
|
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"associatorNames", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Ljava/lang/String;Ljava/lang/String;" |
| |
"Ljava/lang/String;)[" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMASSOCIATORPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: " |
| |
"Found METHOD_CIMASSOCIATORPROVIDER2."); |
| |
} |
| |
} |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleAssociatorNames: No method found!"); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| |
} |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
switch (eMethodFound) |
| |
{ |
| |
case METHOD_CIMASSOCIATORPROVIDER: |
| |
{ |
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
assocPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jResultClass = |
| |
env->NewStringUTF( |
| |
request->resultClass.getString().getCString()); |
| |
jstring jRole = |
| |
env->NewStringUTF(request->role.getCString()); |
| |
jstring jResultRole = |
| |
env->NewStringUTF(request->resultRole.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: assocName = %s ", |
| |
(const char*)assocPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: resultClass = %s ", |
| |
(const char*)request->resultClass.getString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: resultRole = %s ", |
| |
(const char*)request->resultRole.getCString())); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jAr=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
jAssociationName, |
| |
jPathName, |
| |
jResultClass, |
| |
jRole, |
| |
jResultRole); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jcopRet = env->GetObjectArrayElement(jAr,i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jcopRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*copRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_CIMASSOCIATORPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
assocPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jResultClass = |
| |
env->NewStringUTF( |
| |
request->resultClass.getString().getCString()); |
| |
jstring jRole = |
| |
env->NewStringUTF(request->role.getCString()); |
| |
jstring jResultRole = |
| |
env->NewStringUTF(request->resultRole.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: assocName = %s ", |
| |
(const char*)assocPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: resultClass = %s ", |
| |
(const char*)request->resultClass.getString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: resultRole = %s ", |
| |
(const char*)request->resultRole.getCString())); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jAr=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jAssociationName, |
| |
jPathName, |
| |
jResultClass, |
| |
jRole, |
| |
jResultRole); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jcopRet = env->GetObjectArrayElement(jAr,i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jcopRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*copRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_ASSOCIATORPROVIDER: |
| |
{ |
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
assocPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jResultClass = |
| |
env->NewStringUTF( |
| |
request->resultClass.getString().getCString()); |
| |
jstring jRole = |
| |
env->NewStringUTF(request->role.getCString()); |
| |
jstring jResultRole = |
| |
env->NewStringUTF(request->resultRole.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: assocName = %s ", |
| |
(const char*)assocPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: pathName = %s ", |
| |
(const char*)objectPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: resultClass = %s ", |
| |
(const char*)request->resultClass.getString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: resultRole = %s ", |
| |
(const char*)request->resultRole.getCString())); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
jAssociationName, |
| |
jPathName, |
| |
jResultClass, |
| |
jRole, |
| |
jResultRole); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
if (jVec) { |
| |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i<m; i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jcopRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jcopRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*copRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_ASSOCIATORPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
assocPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jResultClass = |
| |
env->NewStringUTF( |
| |
request->resultClass.getString().getCString()); |
| |
jstring jRole = |
| |
env->NewStringUTF(request->role.getCString()); |
| |
jstring jResultRole = |
| |
env->NewStringUTF(request->resultRole.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: assocName = %s ", |
| |
(const char*)assocPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: pathName = %s ", |
| |
(const char*)objectPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: resultClass = %s ", |
| |
(const char*)request->resultClass.getString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleAssociatorNamesRequest: resultRole = %s ", |
| |
(const char*)request->resultRole.getCString())); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jAssociationName, |
| |
jPathName, |
| |
jResultClass, |
| |
jRole, |
| |
jResultRole); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
if (jVec) { |
| |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i<m; i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jcopRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jcopRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*copRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleAssociatorNamesRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| |
} |
| |
HandlerCatch(handler); |
| |
|
| |
if (env) JMPIjvm::detachThread(); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
return(response); |
| |
} |
| |
|
| |
Message * JMPIProviderManager::handleReferencesRequest( |
| |
const Message * message) throw() |
| |
{ |
| |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleReferencesRequest"); |
| |
|
| |
HandlerIntro(References,message,request,response,handler); |
| |
|
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_CIMASSOCIATORPROVIDER, |
| |
METHOD_CIMASSOCIATORPROVIDER2, |
| |
METHOD_ASSOCIATORPROVIDER, |
| |
METHOD_ASSOCIATORPROVIDER2, |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| |
JNIEnv *env = NULL; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"handleReferencesRequest: " |
| |
"name space = %s class name = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)request-> |
| |
objectName.getClassName().getString().getCString() |
| |
)); |
| |
|
| |
// make target object path |
| |
CIMObjectPath *objectPath = new CIMObjectPath( |
| |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->objectName.getClassName(), |
| |
request->objectName.getKeyBindings()); |
| |
CIMObjectPath *resultPath = new CIMObjectPath( |
| |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->resultClass.getString()); |
| |
|
| |
// resolve provider name |
| |
ProviderName name = _resolveProviderName( |
| |
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
|
| |
// get cached or load new provider module |
| |
JMPIProvider::OpProviderHolder ph = |
| |
providerManager.getProvider( |
| |
name.getPhysicalName(), |
| |
name.getLogicalName(), |
| |
String::EMPTY); |
| |
|
| |
// convert arguments |
| |
OperationContext context; |
| |
|
| |
context.insert( |
| |
request->operationContext.get(IdentityContainer::NAME)); |
| |
context.insert( |
| |
request->operationContext.get(AcceptLanguageListContainer::NAME)); |
| |
context.insert( |
| |
request->operationContext.get(ContentLanguageListContainer::NAME)); |
| |
|
| |
// forward request |
| |
JMPIProvider &pr = ph.GetProvider(); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| |
"handleReferencesRequest: " |
| |
"Calling provider: %s, role: %s, refCls: %s", |
| |
(const char*)pr.getName().getCString(), |
| |
(const char*)request->role.getCString(), |
| |
(const char*)request->resultClass.getString().getCString() |
| |
)); |
| |
|
| |
JvmVector *jv = 0; |
| |
|
| |
env = JMPIjvm::attachThread(&jv); |
| |
|
| |
if (!env) |
| |
{ |
| |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleReferencesRequest: " |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| |
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
|
| |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get(ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| |
|
| |
if (interfaceType == "JMPI") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"references", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"ZZ[Ljava/lang/String;)Ljava/util/Vector;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_ASSOCIATORPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: " |
| |
"Found METHOD_ASSOCIATORPROVIDER."); |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"references", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"ZZ[Ljava/lang/String;)" |
| |
"[Lorg/pegasus/jmpi/CIMInstance;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMASSOCIATORPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: " |
| |
"Found METHOD_CIMASSOCIATORPROVIDER."); |
| |
} |
| |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"references", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"ZZ[Ljava/lang/String;)Ljava/util/Vector;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_ASSOCIATORPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: " |
| |
"Found METHOD_ASSOCIATORPROVIDER2."); |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"references", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Ljava/lang/String;ZZ[Ljava/lang/String;)" |
| |
"[Lorg/pegasus/jmpi/CIMInstance;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMASSOCIATORPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: " |
| |
"Found METHOD_CIMASSOCIATORPROVIDER2."); |
| |
} |
| |
} |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleReferencesRequest: No method provider found!"); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| |
} |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
switch (eMethodFound) |
| |
{ |
| |
case METHOD_CIMASSOCIATORPROVIDER: |
| |
{ |
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
resultPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jRole = env->NewStringUTF(request->role.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: assocName = %s ", |
| |
(const char*)resultPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: includeQualifiers = false"); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: includeClassOrigin = false"); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jAr=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
jAssociationName, |
| |
jPathName, |
| |
jRole, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
request->includeClassOrigin, |
| |
jPropertyList); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->GetObjectArrayElement(jAr,i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: " |
| |
"enter(METHOD_CIMASSOCIATORPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
ciRet->getClassName(), |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: " |
| |
"exit(METHOD_CIMASSOCIATORPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleReferencesRequest: " |
| |
"Caught CIMExcetion(METHOD_CIMASSOCIATORPROVIDER) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
_fixCIMObjectPath(ciRet, cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMObject coRet(*ciRet); |
| |
handler.deliver(coRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_CIMASSOCIATORPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
resultPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jRole = env->NewStringUTF(request->role.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: assocName = %s ", |
| |
(const char*)resultPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: includeQualifiers = false"); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: includeClassOrigin = false"); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jAr=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jAssociationName, |
| |
jPathName, |
| |
jRole, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
request->includeClassOrigin, |
| |
jPropertyList); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->GetObjectArrayElement(jAr,i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: " |
| |
"enter(METHOD_CIMASSOCIATORPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
ciRet->getClassName(), |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: " |
| |
"exit(METHOD_CIMASSOCIATORPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleReferencesRequest: " |
| |
"Caught CIMExcetion(METHOD_CIMASSOCIATORPROVIDER2) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
const CIMObjectPath& op = ciRet->getPath(); |
| |
CIMObjectPath iop = ciRet->buildPath(cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
iop.setNameSpace(op.getNameSpace()); |
| |
ciRet->setPath(iop); |
| |
|
| |
CIMObject coRet(*ciRet); |
| |
handler.deliver(coRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_ASSOCIATORPROVIDER: |
| |
{ |
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
resultPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jRole = env->NewStringUTF(request->role.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: assocName = %s ", |
| |
(const char*)resultPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: pathName = %s ", |
| |
(const char*)objectPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: includeQualifiers = false"); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: includeClassOrigin = false"); |
| |
#endif |
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
jAssociationName, |
| |
jPathName, |
| |
jRole, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
request->includeClassOrigin, |
| |
jPropertyList); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
if (jVec) { |
| |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i<m; i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: " |
| |
"enter(METHOD_ASSOCIATORPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
ciRet->getClassName(), |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: " |
| |
"exit(METHOD_ASSOCIATORPROVIDER): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleReferencesRequest: " |
| |
"Caught CIMExcetion(METHOD_ASSOCIATORPROVIDER) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
const CIMObjectPath& op = ciRet->getPath(); |
| |
CIMObjectPath iop = ciRet->buildPath(cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
iop.setNameSpace(op.getNameSpace()); |
| |
ciRet->setPath(iop); |
| |
|
| |
CIMObject coRet(*ciRet); |
| |
handler.deliver(coRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_ASSOCIATORPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
resultPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jRole = env->NewStringUTF(request->role.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobjectArray jPropertyList = getList(jv,env,request->propertyList); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: assocName = %s ", |
| |
(const char*)resultPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: pathName = %s ", |
| |
(const char*)objectPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: includeQualifiers = false"); |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: includeClassOrigin = false"); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jAssociationName, |
| |
jPathName, |
| |
jRole, |
| |
JMPI_INCLUDE_QUALIFIERS, |
| |
request->includeClassOrigin, |
| |
jPropertyList); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
if (jVec) { |
| |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i<m; i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jciRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jciRetRef = env->CallLongMethod( |
| |
jciRet, |
| |
JMPIjvm::jv.CIMInstanceCInst); |
| |
CIMInstance *ciRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMInstance*, |
| |
jciRetRef); |
| |
CIMClass cls; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: " |
| |
"enter(METHOD_ASSOCIATORPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
AutoMutex lock (pr._cimomMutex); |
| |
|
| |
cls = pr._cimom_handle->getClass(context, |
| |
request->nameSpace, |
| |
ciRet->getClassName(), |
| |
false, |
| |
true, |
| |
true, |
| |
CIMPropertyList()); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: " |
| |
"exit(METHOD_ASSOCIATORPROVIDER2): " |
| |
"cimom_handle->getClass(%s).", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString() |
| |
)); |
| |
|
| |
} |
| |
catch (CIMException e) |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleReferencesRequest: " |
| |
"Caught CIMExcetion(METHOD_ASSOCIATORPROVIDER2) " |
| |
"during cimom_handle->getClass(%s): %s ", |
| |
(const char*)ciRet-> |
| |
getClassName().getString().getCString(), |
| |
(const char*)e.getMessage().getCString() |
| |
)); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
throw; |
| |
} |
| |
|
| |
const CIMObjectPath& op = ciRet->getPath(); |
| |
CIMObjectPath iop = ciRet->buildPath(cls); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
iop.setNameSpace(op.getNameSpace()); |
| |
ciRet->setPath(iop); |
| |
|
| |
CIMObject coRet(*ciRet); |
| |
handler.deliver(coRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleReferencesRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| |
} |
| |
HandlerCatch(handler); |
| |
|
| |
if (env) JMPIjvm::detachThread(); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
return(response); |
| |
} |
| |
|
| |
Message * JMPIProviderManager::handleReferenceNamesRequest( |
| |
const Message * message) throw() |
| |
{ |
| |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleReferenceNamesRequest"); |
| |
|
| |
HandlerIntro(ReferenceNames,message,request,response,handler); |
| |
|
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_CIMASSOCIATORPROVIDER, |
| |
METHOD_CIMASSOCIATORPROVIDER2, |
| |
METHOD_ASSOCIATORPROVIDER, |
| |
METHOD_ASSOCIATORPROVIDER2, |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| |
JNIEnv *env = NULL; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"handleReferenceNamesRequest: " |
| |
"name space = %s class name = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)request-> |
| |
objectName.getClassName().getString().getCString() |
| |
)); |
| |
|
| |
// make target object path |
| |
CIMObjectPath *objectPath = new CIMObjectPath( |
| |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->objectName.getClassName(), |
| |
request->objectName.getKeyBindings()); |
| |
CIMObjectPath *resultPath = new CIMObjectPath( |
| |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->resultClass.getString()); |
| |
|
| |
// resolve provider name |
| |
ProviderName name = _resolveProviderName( |
| |
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
|
| |
// get cached or load new provider module |
| |
JMPIProvider::OpProviderHolder ph = providerManager.getProvider( |
| |
name.getPhysicalName(), |
| |
name.getLogicalName(), |
| |
String::EMPTY); |
| |
|
| |
JMPIProvider &pr = ph.GetProvider(); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| |
"handleReferenceNamesRequest: " |
| |
"Calling provider: %s, role: %s, refCls: %s", |
| |
(const char*)pr.getName().getCString(), |
| |
(const char*)request->role.getCString(), |
| |
(const char*)request->resultClass.getString().getCString() |
| |
)); |
| |
|
| |
JvmVector *jv = 0; |
| |
|
| |
env = JMPIjvm::attachThread(&jv); |
| |
|
| |
if (!env) |
| |
{ |
| |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleReferenceNamesRequest: " |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| |
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
|
| |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get(ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| |
|
| |
if (interfaceType == "JMPI") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"referenceNames", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)" |
| |
"Ljava/util/Vector;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_ASSOCIATORPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferencesRequest: " |
| |
"Found METHOD_ASSOCIATORPROVIDER."); |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
|
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"referenceNames", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
")[Lorg/pegasus/jmpi/CIMObjectPath;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMASSOCIATORPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferenceNamesRequest: " |
| |
"Found METHOD_CIMASSOCIATORPROVIDER."); |
| |
} |
| |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"referenceNames", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
")Ljava/util/Vector;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_ASSOCIATORPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferenceNamesRequest: " |
| |
"Found METHOD_ASSOCIATORPROVIDER2."); |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
env->ExceptionClear(); |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"referenceNames", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Ljava/lang/String;)" |
| |
"[Lorg/pegasus/jmpi/CIMObjectPath;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMASSOCIATORPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferenceNamesRequest: " |
| |
"Found METHOD_CIMASSOCIATORPROVIDER2."); |
| |
} |
| |
} |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleReferenceNames: No method found!"); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| |
} |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
switch (eMethodFound) |
| |
{ |
| |
case METHOD_CIMASSOCIATORPROVIDER: |
| |
{ |
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
resultPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jRole = env->NewStringUTF(request->role.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferenceNamesRequest: assocName = %s ", |
| |
(const char*)objectPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferenceNamesRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jAr=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
jPathName, |
| |
jAssociationName, |
| |
jRole); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jcopRet = env->GetObjectArrayElement(jAr,i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jcopRetRef); |
| |
|
| |
handler.deliver(*copRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_CIMASSOCIATORPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
resultPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jRole = env->NewStringUTF(request->role.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferenceNamesRequest: assocName = %s ", |
| |
(const char*)objectPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferenceNamesRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jAr=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jPathName, |
| |
jAssociationName, |
| |
jRole); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
if (jAr) { |
| |
for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) { |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jcopRet = env->GetObjectArrayElement(jAr,i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jcopRetRef); |
| |
|
| |
handler.deliver(*copRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_ASSOCIATORPROVIDER: |
| |
{ |
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
resultPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jRole = env->NewStringUTF(request->role.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferenceNamesRequest: assocName = %s ", |
| |
(const char*)objectPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferenceNamesRequest: pathName = %s ", |
| |
(const char*)resultPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferenceNamesRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
jAssociationName, |
| |
jPathName, |
| |
jRole); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.processing(); |
| |
if (jVec) { |
| |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i<m; i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
|
| |
jobject jcopRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jcopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jcopRetRef); |
| |
|
| |
handler.deliver(*copRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_ASSOCIATORPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jAssociationNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
resultPath); |
| |
jobject jAssociationName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jAssociationNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jPathNameRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jPathName = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jPathNameRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jRole = env->NewStringUTF(request->role.getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
#ifdef PEGASUS_DEBUG |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferenceNamesRequest: assocName = %s ", |
| |
(const char*)objectPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferenceNamesRequest: pathName = %s ", |
| |
(const char*)resultPath->toString().getCString())); |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleReferenceNamesRequest: role = %s ", |
| |
(const char*)request->role.getCString())); |
| |
#endif |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobjectArray jVec=(jobjectArray)env->CallObjectMethod( |
| |
(jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jAssociationName, |
| |
jPathName, |
| |
jRole); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| | |
| handler.processing(); | handler.processing(); |
| if (jVec) { | if (jVec) { |
| for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); |
| |
i<m; i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| |
jobject jcopRet = env->CallObjectMethod( |
| |
jVec, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
JMPIjvm::checkException(env); |
| |
jlong jcopRetRef = env->CallLongMethod( |
| |
jcopRet, |
| |
JMPIjvm::jv.CIMObjectPathCInst); |
| |
JMPIjvm::checkException(env); |
| |
CIMObjectPath *copRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMObjectPath*, |
| |
jcopRetRef); |
| |
handler.deliver(*copRet); |
| |
} |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleReferenceNamesRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| |
} |
| |
HandlerCatch(handler); |
| |
|
| |
if (env) JMPIjvm::detachThread(); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
return(response); |
| |
} |
| |
|
| |
Message * JMPIProviderManager::handleGetPropertyRequest( |
| |
const Message * message) throw() |
| |
{ |
| |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleGetPropertyRequest"); |
| |
|
| |
HandlerIntro(GetProperty,message,request,response,handler); |
| |
|
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_PROPERTYPROVIDER, |
| |
METHOD_PROPERTYPROVIDER2, |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| |
JNIEnv *env = NULL; |
| |
|
| |
try { |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"handleGetPropertyRequest: " |
| |
"name space = %s class name = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)request-> |
| |
instanceName.getClassName().getString().getCString() |
| |
)); |
| |
|
| |
// make target object path |
| |
CIMObjectPath *objectPath = new CIMObjectPath( |
| |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->instanceName.getClassName(), |
| |
request->instanceName.getKeyBindings()); |
| |
|
| |
// resolve provider name |
| |
ProviderName name = _resolveProviderName( |
| |
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
|
| |
// get cached or load new provider module |
| |
JMPIProvider::OpProviderHolder ph = providerManager.getProvider( |
| |
name.getPhysicalName(), |
| |
name.getLogicalName(), |
| |
String::EMPTY); |
| |
|
| |
// forward request |
| |
JMPIProvider &pr = ph.GetProvider(); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| |
"handleReferenceNamesRequest: " |
| |
"Calling provider: %s", |
| |
(const char*)pr.getName().getCString() |
| |
)); |
| |
|
| |
JvmVector *jv = 0; |
| |
|
| |
env = JMPIjvm::attachThread(&jv); |
| |
|
| |
if (!env) |
| |
{ |
| |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleReferenceNamesRequest: " |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| |
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
|
| |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get(ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| |
|
| |
if (interfaceType == "JMPI") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"getPropertyValue", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_PROPERTYPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleGetPropertyRequest: " |
| |
"Found METHOD_PROPERTYPROVIDER."); |
| |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"getPropertyValue", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_PROPERTYPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleGetPropertyRequest: " |
| |
"Found METHOD_PROPERTYPROVIDER2."); |
| |
} |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleGetPropertyRequest: No method provider found!"); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| |
} |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
switch (eMethodFound) |
| |
{ |
| |
case METHOD_PROPERTYPROVIDER: |
| |
{ |
| |
jlong jcopref = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopref); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring joclass = |
| |
env->NewStringUTF( |
| |
request->instanceName.getClassName().getString().getCString()); |
| |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
| |
jstring jpName = |
| |
env->NewStringUTF( |
| |
request->propertyName.getString().getCString()); |
| |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst)); |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider, |
| |
id, |
| |
jcop, |
| |
joclass, |
| |
jpName); |
| |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace, |
handler.processing(); |
| inst.getClassName(),false,true,true,CIMPropertyList()); |
|
| const CIMObjectPath& op=inst.getPath(); |
if (jvalRet) |
| CIMObjectPath iop=inst.buildPath(cls); |
{ |
| iop.setNameSpace(op.getNameSpace()); |
jlong jvalRetRef = env->CallLongMethod( |
| inst.setPath(iop); |
jvalRet, |
| |
JMPIjvm::jv.CIMValueCInst); |
| |
CIMValue *valRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMValue*, |
| |
jvalRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*valRet); |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_PROPERTYPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jcopref = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopref); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring joclass = env->NewStringUTF( |
| |
request->instanceName.getClassName().getString().getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jpName = env->NewStringUTF( |
| |
request->propertyName.getString().getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jcop, |
| |
joclass, |
| |
jpName); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
|
| |
handler.processing(); |
| |
|
| |
if (jvalRet) |
| |
{ |
| |
jlong jvalRetRef = env->CallLongMethod( |
| |
jvalRet, |
| |
JMPIjvm::jv.CIMValueCInst); |
| |
CIMValue *valRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMValue*, |
| |
jvalRetRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliver(*valRet); |
| |
} |
| |
handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleGetPropertyRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| |
} |
| |
HandlerCatch(handler); |
| |
|
| |
if (env) JMPIjvm::detachThread(); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
return(response); |
| |
} |
| |
|
| |
Message * JMPIProviderManager::handleSetPropertyRequest( |
| |
const Message * message) throw() |
| |
{ |
| |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleSetPropertyRequest"); |
| |
|
| |
HandlerIntro(SetProperty,message,request,response,handler); |
| |
|
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_PROPERTYPROVIDER, |
| |
METHOD_PROPERTYPROVIDER2, |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| |
JNIEnv *env = NULL; |
| |
|
| |
try |
| |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"handleSetPropertyRequest: " |
| |
"name space = %s class name = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)request-> |
| |
instanceName.getClassName().getString().getCString() |
| |
)); |
| |
|
| |
// make target object path |
| |
CIMObjectPath *objectPath = new CIMObjectPath( |
| |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->instanceName.getClassName(), |
| |
request->instanceName.getKeyBindings()); |
| |
|
| |
// resolve provider name |
| |
ProviderName name = _resolveProviderName( |
| |
request->operationContext.get(ProviderIdContainer::NAME)); |
| |
|
| |
// get cached or load new provider module |
| |
JMPIProvider::OpProviderHolder ph = providerManager.getProvider( |
| |
name.getPhysicalName(), |
| |
name.getLogicalName(), |
| |
String::EMPTY); |
| |
|
| |
// forward request |
| |
JMPIProvider &pr = ph.GetProvider(); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| |
"handleSetPropertyRequest: " |
| |
"Calling provider. setPropertyValue: %s", |
| |
(const char*)pr.getName().getCString())); |
| |
|
| |
JvmVector *jv = 0; |
| |
|
| |
env = JMPIjvm::attachThread(&jv); |
| |
|
| |
if (!env) |
| |
{ |
| |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| |
|
| |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| |
|
| |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get(ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| |
|
| |
if (interfaceType == "JMPI") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"setPropertyValue", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_PROPERTYPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleSetPropertyRequest: " |
| |
"Found METHOD_PROPERTYPROVIDER."); |
| |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"setPropertyValue", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_PROPERTYPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleSetPropertyRequest: " |
| |
"Found METHOD_PROPERTYPROVIDER2."); |
| |
} |
| |
} |
| |
|
| |
if (id == NULL) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleSetPropertyRequest: No method provider found!"); |
| |
|
| |
PEG_METHOD_EXIT(); |
| |
|
| |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| |
} |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
switch (eMethodFound) |
| |
{ |
| |
case METHOD_PROPERTYPROVIDER: |
| |
{ |
| |
jlong jcopref = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopref); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring joclass = |
| |
env->NewStringUTF( |
| |
request->instanceName.getClassName().getString().getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jpName = |
| |
env->NewStringUTF( |
| |
request->propertyName.getString().getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMValue *val = new CIMValue (request->newValue); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jvalref = DEBUG_ConvertCToJava(CIMValue*, jlong, val); |
| |
jobject jval = env->NewObject( |
| |
jv->CIMValueClassRef, |
| |
jv->CIMValueNewJ, |
| |
jvalref); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
env->CallVoidMethod ((jobject)pr.jProvider, |
| |
id, |
| |
jcop, |
| |
joclass, |
| |
jpName, |
| |
jval); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_PROPERTYPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jcopref = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopref); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring joclass = |
| |
env->NewStringUTF( |
| |
request->instanceName.getClassName().getString().getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jstring jpName = |
| |
env->NewStringUTF( |
| |
request->propertyName.getString().getCString()); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
CIMValue *val = new CIMValue (request->newValue); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
jlong jvalref = DEBUG_ConvertCToJava (CIMValue*, jlong, val); |
| |
jobject jval = env->NewObject( |
| |
jv->CIMValueClassRef, |
| |
jv->CIMValueNewJ, |
| |
jvalref); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
env->CallVoidMethod ((jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jcop, |
| |
joclass, |
| |
jpName, |
| |
jval); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| |
break; |
| |
} |
| | |
| handler.deliver(inst); |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleSetPropertyRequest: Unknown method provider!"); |
| |
break; |
| } | } |
| } | } |
| handler.complete(); |
|
| } | } |
| HandlerCatch(handler); | HandlerCatch(handler); |
| | |
|
|
|
| return(response); | return(response); |
| } | } |
| | |
| |
Message * JMPIProviderManager::handleInvokeMethodRequest( |
| |
const Message * message) throw() |
| Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw() |
|
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
PEG_METHOD_ENTER( |
| "JMPIProviderManager::handleAssociatorNamesRequest"); |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleInvokeMethodRequest"); |
| |
|
| |
HandlerIntro(InvokeMethod,message,request,response,handler); |
| | |
| HandlerIntro(AssociatorNames,message,request,response, |
typedef enum { |
| handler,Array<CIMObjectPath>()); |
METHOD_UNKNOWN = 0, |
| |
METHOD_CIMMETHODPROVIDER, |
| |
METHOD_CIMMETHODPROVIDER2, |
| |
METHOD_METHODPROVIDER, |
| |
METHOD_METHODPROVIDER2, |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| JNIEnv *env=NULL; | JNIEnv *env=NULL; |
| |
|
| try { | try { |
| Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| "JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2", |
"handleInvokeMethodRequest: " |
| System::getHostName(), |
"name space = %s class name = %s", |
| request->nameSpace.getString(), |
(const char*)request->nameSpace.getString().getCString(), |
| request->objectName.getClassName().getString()); |
(const char*)request-> |
| |
instanceName.getClassName().getString().getCString() |
| |
)); |
| | |
| // make target object path | // make target object path |
| CIMObjectPath objectPath( |
CIMObjectPath *objectPath = new CIMObjectPath( |
| System::getHostName(), |
|
| request->nameSpace, |
|
| request->objectName.getClassName()); |
|
| |
|
| objectPath.setKeyBindings(request->objectName.getKeyBindings()); |
|
| |
|
| CIMObjectPath assocPath( |
|
| System::getHostName(), | System::getHostName(), |
| request->nameSpace, | request->nameSpace, |
| request->assocClass.getString()); |
request->instanceName.getClassName(), |
| |
request->instanceName.getKeyBindings()); |
| | |
| // resolve provider name | // resolve provider name |
| ProviderName name = _resolveProviderName( | ProviderName name = _resolveProviderName( |
| request->operationContext.get(ProviderIdContainer::NAME)); | request->operationContext.get(ProviderIdContainer::NAME)); |
| | |
| // get cached or load new provider module | // get cached or load new provider module |
| JMPIProvider::OpProviderHolder ph = |
JMPIProvider::OpProviderHolder ph = providerManager.getProvider( |
| providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
name.getPhysicalName(), |
| |
name.getLogicalName(), |
| // convert arguments |
String::EMPTY); |
| OperationContext context; |
|
| |
|
| context.insert(request->operationContext.get(IdentityContainer::NAME)); |
|
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
|
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
|
| | |
| // forward request |
|
| JMPIProvider & pr=ph.GetProvider(); | JMPIProvider & pr=ph.GetProvider(); |
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| "Calling provider.associatorNames: " + pr.getName()); |
"handleInvokeMethodRequest: " |
| |
"Calling provider: %s", |
| |
(const char*)pr.getName().getCString() |
| |
)); |
| | |
| DDD(cerr<<"--- JMPIProviderManager::associatorNames"<< |
JvmVector *jv = 0; |
| " role: >"<<request->role<<"< aCls "<< |
|
| request->assocClass<<endl); |
|
| | |
| JvmVector *jv; |
|
| env=JMPIjvm::attachThread(&jv); | env=JMPIjvm::attachThread(&jv); |
| | |
| jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
if (!env) |
| jv->CIMObjectPathNewI,(jint)&objectPath); |
{ |
| JMPIjvm::checkException(env); |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleInvokeMethodRequest: " |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| | |
| jstring rClass=env->NewStringUTF(request->resultClass.getString().getCString()); |
PEG_METHOD_EXIT(); |
| jstring rRole=env->NewStringUTF(request->role.getCString()); |
|
| jstring resRole=env->NewStringUTF(request->resultRole.getCString()); |
throw PEGASUS_CIM_EXCEPTION_L( |
| JMPIjvm::checkException(env); |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| |
} |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); | JMPIProvider::pm_service_op_lock op_lock(&pr); |
| | |
| STAT_GETSTARTTIME; |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType( |
| |
request->operationContext.get(ProviderIdContainer::NAME), |
| |
interfaceType, |
| |
interfaceVersion); |
| | |
| jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"associatorNames", |
if (interfaceType == "JMPI") |
| "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;" |
{ |
| "Ljava/lang/String;)Ljava/util/Vector;"); |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"invokeMethod", |
| |
"(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/util/Vector;Ljava/util/Vector;)" |
| |
"Lorg/pegasus/jmpi/CIMValue;"); |
| | |
| JMPIjvm::checkException(env); |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_METHODPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleInvokeMethodRequest: " |
| |
"Found METHOD_PROPERTYPROVIDER."); |
| |
} |
| | |
| jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef, |
if (id == NULL) |
| rClass,rRole,resRole); |
{ |
| JMPIjvm::checkException(env); |
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;"); |
| | |
| STAT_PMS_PROVIDEREND; |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMMETHODPROVIDER; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleInvokeMethodRequest: " |
| |
"Found METHOD_CIMMETHODPROVIDER."); |
| |
} |
| |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"invokeMethod", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
| |
"Ljava/util/Vector;Ljava/util/Vector;)" |
| |
"Lorg/pegasus/jmpi/CIMValue;"); |
| | |
| handler.processing(); |
if (id != NULL) |
| if (jVec) { |
{ |
| for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
eMethodFound = METHOD_METHODPROVIDER2; |
| JMPIjvm::checkException(env); |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| jobject jCop=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
"handleInvokeMethodRequest: " |
| JMPIjvm::checkException(env); |
"Found METHOD_METHODPROVIDER2."); |
| CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod |
} |
| (jCop,JMPIjvm::jv.CIMObjectPathCInst)); |
|
| JMPIjvm::checkException(env); |
if (id == NULL) |
| handler.deliver(*cop); |
{ |
| |
env->ExceptionClear(); |
| |
|
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"invokeMethod", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;" |
| |
"Ljava/lang/String;" |
| |
"[Lorg/pegasus/jmpi/CIMArgument;[" |
| |
"Lorg/pegasus/jmpi/CIMArgument;)" |
| |
"Lorg/pegasus/jmpi/CIMValue;"); |
| |
|
| |
if (id != NULL) |
| |
{ |
| |
eMethodFound = METHOD_CIMMETHODPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleInvokeMethodRequest: " |
| |
"Found METHOD_CIMMETHODPROVIDER2."); |
| } | } |
| } | } |
| handler.complete(); |
|
| } | } |
| HandlerCatch(handler); |
|
| | |
| if (env) JMPIjvm::detachThread(); |
if (id == NULL) |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleInvokeMethod: No method provider found!"); |
| | |
| PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| | |
| return(response); |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on " |
| |
"InterfaceType.")); |
| } | } |
| | |
| |
JMPIjvm::checkException(env); |
| | |
| Message * JMPIProviderManager::handleReferencesRequest(const Message * message) throw() |
switch (eMethodFound) |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
case METHOD_CIMMETHODPROVIDER: |
| "JMPIProviderManager::handleReferencesRequest"); |
{ |
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| | |
| HandlerIntro(References,message,request,response, |
JMPIjvm::checkException(env); |
| handler,Array<CIMObject>()); |
|
| JNIEnv *env=NULL; |
|
| try { |
|
| Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
| "DefaultProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2", |
|
| System::getHostName(), |
|
| request->nameSpace.getString(), |
|
| request->objectName.getClassName().getString()); |
|
| | |
| // make target object path |
jstring jMethod = |
| CIMObjectPath objectPath( |
env->NewStringUTF( |
| System::getHostName(), |
request->methodName.getString().getCString()); |
| request->nameSpace, |
|
| request->objectName.getClassName()); |
|
| | |
| objectPath.setKeyBindings(request->objectName.getKeyBindings()); |
JMPIjvm::checkException(env); |
| | |
| CIMObjectPath resultPath( |
Uint32 m=request->inParameters.size(); |
| System::getHostName(), |
|
| request->nameSpace, |
|
| request->resultClass.getString()); |
|
| | |
| // resolve provider name |
jobjectArray jArIn=(jobjectArray)env->NewObjectArray( |
| ProviderName name = _resolveProviderName( |
m, |
| request->operationContext.get(ProviderIdContainer::NAME)); |
jv->CIMArgumentClassRef, |
| |
NULL); |
| | |
| // get cached or load new provider module |
for (Uint32 i=0; i<m; i++) { |
| JMPIProvider::OpProviderHolder ph = |
CIMParamValue *parm = new CIMParamValue(request->inParameters[i]); |
| providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
jlong jArgRef = DEBUG_ConvertCToJava(CIMParamValue*, jlong, parm); |
| |
jobject jArg = env->NewObject( |
| |
jv->CIMArgumentClassRef, |
| |
jv->CIMArgumentNewJ, |
| |
jArgRef); |
| | |
| // convert arguments |
env->SetObjectArrayElement(jArIn,i,jArg); |
| OperationContext context; |
} |
| | |
| context.insert(request->operationContext.get(IdentityContainer::NAME)); |
jobjectArray jArOut=(jobjectArray)env->NewObjectArray( |
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
24, |
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
jv->CIMArgumentClassRef, |
| |
NULL); |
| | |
| // forward request |
StatProviderTimeMeasurement providerTime(response); |
| JMPIProvider & pr=ph.GetProvider(); |
|
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, |
| "Calling provider.references: " + pr.getName()); |
id, |
| |
jcop, |
| |
jMethod, |
| |
jArIn, |
| |
jArOut); |
| |
JMPIjvm::checkException(env); |
| | |
| DDD(cerr<<"--- JMPIProviderManager::references"<<" role: >"<<request->role<<"< aCls "<< |
handler.processing(); |
| request->resultClass<<endl); |
|
| | |
| JvmVector *jv; |
jlong jValueRetRef = env->CallLongMethod( |
| env=JMPIjvm::attachThread(&jv); |
jValueRet, |
| |
JMPIjvm::jv.CIMValueCInst); |
| |
CIMValue *valueRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMValue*, |
| |
jValueRetRef); |
| |
|
| |
handler.deliver(*valueRet); |
| |
|
| |
for (int i=0; i<24; i++) { |
| |
jobject jArg = env->GetObjectArrayElement(jArOut,i); |
| | |
| jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
|
| jv->CIMObjectPathNewI,(jint)&objectPath); |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| jstring rRole=env->NewStringUTF(request->role.getCString()); |
if (jArg==NULL) |
| |
break; |
| |
|
| |
jlong jpRef = env->CallLongMethod( |
| |
jArg, |
| |
JMPIjvm::jv.CIMArgumentCInst); |
| |
CIMParamValue *p = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMParamValue*, |
| |
jpRef); |
| |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); |
handler.deliverParamValue(*p); |
| |
} |
| | |
| STAT_GETSTARTTIME; |
handler.complete(); |
| |
break; |
| |
} |
| | |
| jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"references", |
case METHOD_CIMMETHODPROVIDER2: |
| "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;" |
{ |
| "ZZ[Ljava/lang/String;)Ljava/util/Vector;"); |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| |
|
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| | |
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef, |
jstring jMethod = |
| rRole,false,false,NULL); |
env->NewStringUTF(request->methodName.getString().getCString()); |
| |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| STAT_PMS_PROVIDEREND; |
Uint32 m=request->inParameters.size(); |
| | |
| handler.processing(); |
jobjectArray jArIn=(jobjectArray)env->NewObjectArray( |
| if (jVec) { |
m, |
| for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
jv->CIMArgumentClassRef, |
| |
NULL); |
| |
|
| |
for (Uint32 i=0; i<m; i++) { |
| |
CIMParamValue *parm = new CIMParamValue(request->inParameters[i]); |
| |
jlong jArgRef = DEBUG_ConvertCToJava(CIMParamValue*, jlong, parm); |
| |
jobject jArg = env->NewObject( |
| |
jv->CIMArgumentClassRef, |
| |
jv->CIMArgumentNewJ, |
| |
jArgRef); |
| |
|
| |
env->SetObjectArrayElement(jArIn,i,jArg); |
| |
} |
| |
|
| |
jobjectArray jArOut=(jobjectArray)env->NewObjectArray( |
| |
24, |
| |
jv->CIMArgumentClassRef, |
| |
NULL); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jcop, |
| |
jMethod, |
| |
jArIn, |
| |
jArOut); |
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
| |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst)); |
} |
| |
|
| |
handler.processing(); |
| |
|
| |
jlong jValueRetRef = env->CallLongMethod( |
| |
jValueRet, |
| |
JMPIjvm::jv.CIMValueCInst); |
| |
CIMValue *valueRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMValue*, |
| |
jValueRetRef); |
| |
|
| |
handler.deliver(*valueRet); |
| |
|
| |
for (int i=0; i<24; i++) { |
| |
jobject jArg = env->GetObjectArrayElement(jArOut,i); |
| |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace, |
if (jArg==NULL) |
| inst.getClassName(),false,true,true,CIMPropertyList()); |
break; |
| const CIMObjectPath& op=inst.getPath(); |
|
| CIMObjectPath iop=inst.buildPath(cls); |
|
| iop.setNameSpace(op.getNameSpace()); |
|
| inst.setPath(iop); |
|
| | |
| handler.deliver(inst); |
jlong jpRef = env->CallLongMethod( |
| } |
jArg, |
| |
JMPIjvm::jv.CIMArgumentCInst); |
| |
CIMParamValue *p = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMParamValue*, |
| |
jpRef); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
|
| |
handler.deliverParamValue(*p); |
| } | } |
| |
|
| handler.complete(); | handler.complete(); |
| |
break; |
| } | } |
| HandlerCatch(handler); |
|
| |
|
| if (env) JMPIjvm::detachThread(); |
|
| | |
| PEG_METHOD_EXIT(); |
case METHOD_METHODPROVIDER: |
| |
{ |
| |
jlong jcopRef = DEBUG_ConvertCToJava( |
| |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| | |
| return(response); |
JMPIjvm::checkException(env); |
| } |
|
| | |
| |
jstring jMethod = env->NewStringUTF( |
| |
request->methodName.getString().getCString()); |
| | |
| Message * JMPIProviderManager::handleReferenceNamesRequest(const Message * message) throw() |
JMPIjvm::checkException(env); |
| { |
|
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
|
| "JMPIProviderManager::handleReferenceNamesRequest"); |
|
| | |
| HandlerIntro(ReferenceNames,message,request,response, |
jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew); |
| handler,Array<CIMObjectPath>()); |
|
| JNIEnv *env=NULL; |
|
| try { |
|
| Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
|
| "JMPIProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2", |
|
| System::getHostName(), |
|
| request->nameSpace.getString(), |
|
| request->objectName.getClassName().getString()); |
|
| | |
| // make target object path |
JMPIjvm::checkException(env); |
| CIMObjectPath objectPath( |
|
| System::getHostName(), |
|
| request->nameSpace, |
|
| request->objectName.getClassName()); |
|
| | |
| objectPath.setKeyBindings(request->objectName.getKeyBindings()); |
for (int i=0,m=request->inParameters.size(); i<m; i++) |
| |
{ |
| |
const CIMParamValue &parm = request->inParameters[i]; |
| |
const CIMValue v = parm.getValue(); |
| |
CIMProperty *p = new CIMProperty( |
| |
parm.getParameterName(), |
| |
v, |
| |
v.getArraySize()); |
| |
jlong jpRef = DEBUG_ConvertCToJava (CIMProperty*, jlong, p); |
| |
jobject jp = env->NewObject( |
| |
jv->CIMPropertyClassRef, |
| |
jv->CIMPropertyNewJ, |
| |
jpRef); |
| |
|
| |
env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp); |
| |
} |
| |
|
| |
jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew); |
| |
JMPIjvm::checkException(env); |
| |
|
| |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, |
| |
id, |
| |
jcop, |
| |
jMethod, |
| |
jVecIn, |
| |
jVecOut); |
| |
JMPIjvm::checkException(env); |
| | |
| CIMObjectPath resultPath( |
handler.processing(); |
| System::getHostName(), |
|
| request->nameSpace, |
|
| request->resultClass.getString()); |
|
| | |
| // resolve provider name |
jlong jValueRetRef = env->CallLongMethod( |
| ProviderName name = _resolveProviderName( |
jValueRet, |
| request->operationContext.get(ProviderIdContainer::NAME)); |
JMPIjvm::jv.CIMValueCInst); |
| |
CIMValue *valueRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMValue*, |
| |
jValueRetRef); |
| |
|
| |
handler.deliver(*valueRet); |
| |
|
| |
for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); |
| |
i<m; |
| |
i++) |
| |
{ |
| |
JMPIjvm::checkException(env); |
| | |
| // get cached or load new provider module |
jobject jProp = env->CallObjectMethod( |
| JMPIProvider::OpProviderHolder ph = |
jVecOut, |
| providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| | |
| // convert arguments |
JMPIjvm::checkException(env); |
| OperationContext context; |
|
| | |
| context.insert(request->operationContext.get(IdentityContainer::NAME)); |
jlong jpRef = env->CallLongMethod( |
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
jProp, |
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
JMPIjvm::jv.CIMPropertyCInst); |
| |
CIMProperty *p = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMProperty*, |
| |
jpRef); |
| | |
| JMPIProvider & pr=ph.GetProvider(); |
JMPIjvm::checkException(env); |
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
handler.deliverParamValue( |
| "Calling provider.referenceNames: " + pr.getName()); |
CIMParamValue(p->getName().getString(), |
| |
p->getValue())); |
| |
} |
| | |
| |
handler.complete(); |
| |
break; |
| |
} |
| | |
| DDD(cerr<<"--- JMPIProviderManager::referenceNames"<<" role: >"<<request->role<<"< aCls "<< |
case METHOD_METHODPROVIDER2: |
| request->resultClass<<endl); |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ, |
| |
jocRef); |
| | |
| JvmVector *jv; |
jlong jcopRef = DEBUG_ConvertCToJava( |
| env=JMPIjvm::attachThread(&jv); |
CIMObjectPath*, |
| |
jlong, |
| |
objectPath); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ, |
| |
jcopRef); |
| | |
| jobject jRef=env->NewObject(jv->CIMObjectPathClassRef, |
|
| jv->CIMObjectPathNewI,(jint)&objectPath); |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| jstring rRole=env->NewStringUTF(request->role.getCString()); |
jstring jMethod = env->NewStringUTF( |
| |
request->methodName.getString().getCString()); |
| |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); |
jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew); |
| |
|
| |
JMPIjvm::checkException(env); |
| | |
| STAT_GETSTARTTIME; |
for (int i=0,m=request->inParameters.size(); i<m; i++) |
| |
{ |
| |
const CIMParamValue &parm = request->inParameters[i]; |
| |
const CIMValue v = parm.getValue(); |
| |
CIMProperty *p = new CIMProperty( |
| |
parm.getParameterName(), |
| |
v, |
| |
v.getArraySize()); |
| |
jlong jpRef = DEBUG_ConvertCToJava(CIMProperty*, jlong, p); |
| |
jobject jp = env->NewObject( |
| |
jv->CIMPropertyClassRef, |
| |
jv->CIMPropertyNewJ, |
| |
jpRef); |
| | |
| jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"referenceNames", |
env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp); |
| "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;"); |
} |
| | |
| |
jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew); |
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,rRole); |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jcop, |
| |
jMethod, |
| |
jVecIn, |
| |
jVecOut); |
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| | |
| STAT_PMS_PROVIDEREND; |
if (joc) |
| |
{ |
| |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| |
|
| |
JMPIjvm::checkException(env); |
| |
} |
| | |
| handler.processing(); | handler.processing(); |
| if (jVec) { |
|
| for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) { |
jlong jValueRetRef = env->CallLongMethod( |
| |
jValueRet, |
| |
JMPIjvm::jv.CIMValueCInst); |
| |
CIMValue *valueRet = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMValue*, |
| |
jValueRetRef); |
| |
|
| |
handler.deliver(*valueRet); |
| |
|
| |
for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); |
| |
i<m; |
| |
i++) |
| |
{ |
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| jobject jCop=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i); |
|
| |
jobject jProp = env->CallObjectMethod( |
| |
jVecOut, |
| |
JMPIjvm::jv.VectorElementAt, |
| |
i); |
| |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod |
|
| (jCop,JMPIjvm::jv.CIMObjectPathCInst)); |
jlong jpRef = env->CallLongMethod( |
| |
jProp, |
| |
JMPIjvm::jv.CIMPropertyCInst); |
| |
CIMProperty *p = DEBUG_ConvertJavaToC( |
| |
jlong, |
| |
CIMProperty*, |
| |
jpRef); |
| |
|
| JMPIjvm::checkException(env); | JMPIjvm::checkException(env); |
| handler.deliver(*cop); |
|
| } |
handler.deliverParamValue( |
| |
CIMParamValue(p->getName().getString(), |
| |
p->getValue())); |
| } | } |
| |
|
| handler.complete(); | handler.complete(); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleInvokeMethodRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| } | } |
| HandlerCatch(handler); | HandlerCatch(handler); |
| | |
|
|
|
| return(response); | return(response); |
| } | } |
| | |
| |
int LocateIndicationProviderNames( |
| |
const CIMInstance& pInstance, |
| |
const CIMInstance& pmInstance, |
| |
String& providerName, |
| |
String& location) |
| |
{ |
| |
Uint32 pos = pInstance.findProperty(PEGASUS_PROPERTYNAME_NAME); |
| |
pInstance.getProperty(pos).getValue().get(providerName); |
| | |
| /* |
pos = pmInstance.findProperty(CIMName ("Location")); |
| Message * JMPIProviderManager::handleInvokeMethodRequest(const Message * message) throw() |
pmInstance.getProperty(pos).getValue().get(location); |
| |
return 0; |
| |
} |
| |
|
| |
WQLSelectStatement * |
| |
newSelectExp (String& query, |
| |
String& queryLanguage) |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
WQLSelectStatement *stmt = new WQLSelectStatement (queryLanguage, query); |
| "JMPIProviderManager::handleInvokeMethodRequest"); |
|
| |
try |
| |
{ |
| |
WQLParser::parse (query, *stmt); |
| |
} |
| |
catch (const Exception &e) |
| |
{ |
| |
cerr << "Error: newSelectExp caught: " << e.getMessage () << endl; |
| |
} |
| |
|
| |
return stmt; |
| |
} |
| |
|
| |
Message * JMPIProviderManager::handleCreateSubscriptionRequest( |
| |
const Message * message) throw() |
| |
{ |
| |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleCreateSubscriptionRequest"); |
| |
|
| |
HandlerIntroInd(CreateSubscription,message,request,response,handler); |
| |
|
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_EVENTPROVIDER, |
| |
METHOD_EVENTPROVIDER2, |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| |
JNIEnv *env = NULL; |
| | |
| HandlerIntroMethod(InvokeMethod,message,request,response, |
|
| handler); |
|
| try { | try { |
| Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
String fileName, |
| "JMPIProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2", |
providerName, |
| System::getHostName(), |
providerLocation; |
| request->nameSpace.getString(), |
CIMInstance req_provider, |
| request->instanceName.getClassName().getString()); |
req_providerModule; |
| |
ProviderIdContainer pidc = |
| |
(ProviderIdContainer) request->operationContext.get( |
| |
ProviderIdContainer::NAME); |
| | |
| // make target object path |
req_provider = pidc.getProvider (); |
| CIMObjectPath objectPath( |
req_providerModule = pidc.getModule (); |
| System::getHostName(), |
|
| request->nameSpace, |
|
| request->instanceName.getClassName(), |
|
| request->instanceName.getKeyBindings()); |
|
| | |
| // resolve provider name |
LocateIndicationProviderNames( |
| ProviderName name = _resolveProviderName( |
req_provider, |
| request->operationContext.get(ProviderIdContainer::NAME)); |
req_providerModule, |
| |
providerName, |
| |
providerLocation); |
| |
|
| |
fileName = resolveFileName(providerLocation); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"handleCreateSubscriptionRequest: " |
| |
"name space = %s provider name = %s provider filename = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)providerName.getCString(), |
| |
(const char*)fileName.getCString() |
| |
)); |
| |
|
| |
// get cached or load new provider module |
| |
JMPIProvider::OpProviderHolder ph = |
| |
providerManager.getProvider( |
| |
fileName, |
| |
providerName, |
| |
String::EMPTY); |
| |
|
| |
// |
| |
// Save the provider instance from the request |
| |
// |
| |
ph.GetProvider ().setProviderInstance (req_provider); |
| |
|
| |
JMPIProvider &pr = ph.GetProvider (); |
| |
|
| |
// |
| |
// Increment count of current subscriptions for this provider |
| |
// |
| |
pr.testIfZeroAndIncrementSubscriptions (); |
| |
|
| |
SubscriptionFilterConditionContainer sub_cntr = |
| |
request->operationContext.get( |
| |
SubscriptionFilterConditionContainer::NAME); |
| |
indProvRecord *prec = NULL; |
| |
bool fNewPrec = false; |
| |
|
| |
{ |
| |
AutoMutex lock (mutexProvTab); |
| |
|
| |
provTab.lookup (providerName, prec); |
| |
|
| |
if (!prec) |
| |
{ |
| |
fNewPrec = true; |
| | |
| // get cached or load new provider module |
prec = new indProvRecord (); |
| JMPIProvider::OpProviderHolder ph = |
|
| providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); |
|
| | |
| // convert arguments | // convert arguments |
| OperationContext context; |
prec->ctx = new OperationContext (); |
| | |
| context.insert(request->operationContext.get(IdentityContainer::NAME)); |
prec->ctx->insert( |
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
request->operationContext.get( |
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
IdentityContainer::NAME)); |
| |
prec->ctx->insert( |
| |
request->operationContext.get( |
| |
AcceptLanguageListContainer::NAME)); |
| |
prec->ctx->insert( |
| |
request->operationContext.get( |
| |
ContentLanguageListContainer::NAME)); |
| |
prec->ctx->insert( |
| |
request->operationContext.get( |
| |
SubscriptionInstanceContainer::NAME)); |
| |
prec->ctx->insert( |
| |
request->operationContext.get( |
| |
SubscriptionFilterConditionContainer::NAME)); |
| |
|
| |
prec->enabled = true; |
| |
|
| |
prec->handler = new EnableIndicationsResponseHandler( |
| |
0, |
| |
0, |
| |
req_provider, |
| |
_indicationCallback, |
| |
_responseChunkCallback); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleCreateSubscriptionRequest: " |
| |
"Adding %s to provTab.", |
| |
(const char*)providerName.getCString())); |
| | |
| CIMObjectPath instanceReference(request->instanceName); |
provTab.insert (providerName, prec); |
| |
} |
| // ATTN: propagate namespace |
} |
| instanceReference.setNameSpace(request->nameSpace); |
|
| | |
| // forward request |
{ |
| JMPIProvider & pr=ph.GetProvider(); |
AutoMutex lock (prec->mutex); |
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
prec->count++; |
| "Calling provider.invokeMethod: " + pr.getName()); |
} |
| | |
| CMPIStatus rc={CMPI_RC_OK,NULL}; |
// Add a selection record for JNI CIMOMHandle deliverEvent calls |
| CMPI_ContextOnStack eCtx(context); |
indSelectRecord *srec = new indSelectRecord (); |
| CMPI_ObjectPathOnStack eRef(objectPath); |
|
| 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; |
{ |
| eCtx.ft->addEntry(&eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32); |
srec->query = request->query; |
| |
srec->queryLanguage = sub_cntr.getQueryLanguage (); |
| |
srec->propertyList = request->propertyList; |
| |
|
| |
CIMOMHandleQueryContext *qContext = |
| |
new CIMOMHandleQueryContext( |
| |
CIMNamespaceName( |
| |
request->nameSpace.getString()), |
| |
*pr._cimom_handle); |
| |
srec->qContext = qContext; |
| |
|
| |
CIMObjectPath sPath = request->subscriptionInstance.getPath(); |
| |
Array<CIMKeyBinding> kb; |
| |
|
| |
// Technically we only need Name and Handler for uniqueness |
| |
kb = sPath.getKeyBindings (); |
| |
|
| |
// Add an entry for every provider. |
| |
kb.append (CIMKeyBinding ("Provider", |
| |
pr.getName (), |
| |
CIMKeyBinding::STRING)); |
| |
|
| |
sPath.setKeyBindings (kb); |
| |
|
| |
AutoMutex lock (mutexSelxTab); |
| |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleCreateSubscriptionRequest: " |
| |
"Adding %s to selxTab.", |
| |
(const char*)sPath.toString().getCString())); |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); |
selxTab.insert (sPath.toString (), srec); |
| | |
| STAT_GETSTARTTIME; |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleCreateSubscriptionRequest: " |
| |
"For selxTab %s , srec = %p, qContext = %p", |
| |
(const char*)sPath.toString().getCString(), |
| |
srec,qContext)); |
| |
} |
| | |
| rc=pr.miVector.methMI->ft->invokeMethod( |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4, |
| pr.miVector.methMI,&eCtx,&eRes,&eRef,CHARS(mName),&eArgsIn,&eArgsOut); |
"handleCreateSubscriptionRequest: Calling provider: %s", |
| |
(const char*)pr.getName().getCString())); |
| | |
| STAT_PMS_PROVIDEREND; |
JvmVector *jv = 0; |
| | |
| if (rc.rc!=CMPI_RC_OK) |
env = JMPIjvm::attachThread(&jv); |
| throw CIMException((CIMStatusCode)rc.rc); |
|
| | |
| for (int i=0,s=outArgs.size(); i<s; i++) |
if (!env) |
| handler.deliverParamValue(outArgs[i]); |
{ |
| handler.complete(); |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| } |
"handleCreateSubscriptionRequest: " |
| HandlerCatch(handler); |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| | |
| PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| | |
| return(response); |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| } | } |
| *//* |
|
| struct indProvRecord { |
|
| indProvRecord() : enabled(false), count(1), handler(NULL) {} |
|
| Boolean enabled; |
|
| int count; |
|
| EnableIndicationsResponseHandler* handler; |
|
| }; |
|
| | |
| struct indSelectRecord { |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| indSelectRecord() : eSelx(NULL) {} |
|
| CMPI_SelectExp *eSelx; |
|
| }; |
|
| | |
| |
jmethodID id = NULL; |
| |
String interfaceType; |
| |
String interfaceVersion; |
| |
|
| |
getInterfaceType (pidc, |
| |
interfaceType, |
| |
interfaceVersion); |
| | |
| typedef HashTable<String,indProvRecord*,EqualFunc<String>,HashFunc<String> > IndProvTab; |
if (interfaceType == "JMPI") |
| typedef HashTable<String,indSelectRecord*,EqualFunc<String>,HashFunc<String> > IndSelectTab; |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"activateFilter", |
| |
"(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Z)V"); |
| | |
| IndProvTab provTab; |
if (id != NULL) |
| IndSelectTab selxTab; |
|
| *//* |
|
| int LocateIndicationProviderNames(const CIMInstance& pInstance, const CIMInstance& pmInstance, |
|
| String& providerName, String& location) |
|
| { | { |
| Uint32 pos = pInstance.findProperty(CIMName ("Name")); |
eMethodFound = METHOD_EVENTPROVIDER; |
| pInstance.getProperty(pos).getValue().get(providerName); |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleCreateSubscriptionRequest: " |
| |
"Found METHOD_EVENTPROVIDER."); |
| |
} |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"activateFilter", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Z)V"); |
| | |
| pos = pmInstance.findProperty(CIMName ("Location")); |
if (id != NULL) |
| pmInstance.getProperty(pos).getValue().get(location); |
{ |
| return 0; |
eMethodFound = METHOD_EVENTPROVIDER2; |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleCreateSubscriptionRequest: " |
| |
"Found METHOD_EVENTPROVIDER2."); |
| |
} |
| } | } |
| | |
| Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw() |
if (id == NULL) |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateSubscriptionRequest"); |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleCreateSubscriptionRequest: No method provider found!"); |
| | |
| HandlerIntroInd(CreateSubscription,message,request,response, |
PEG_METHOD_EXIT(); |
| handler); |
|
| try { |
|
| const CIMObjectPath &x=request->subscriptionInstance.getPath(); |
|
| | |
| String providerName,providerLocation; |
throw PEGASUS_CIM_EXCEPTION_L( |
| CIMInstance req_provider, req_providerModule; |
CIM_ERR_FAILED, |
| ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME); |
MessageLoaderParms( |
| req_provider = pidc.getProvider(); |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| req_providerModule = pidc.getModule(); |
"Could not find a method for the provider based on" |
| LocateIndicationProviderNames(req_provider, req_providerModule, |
" InterfaceType.")); |
| providerName,providerLocation); |
} |
| | |
| Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
JMPIjvm::checkException(env); |
| "JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2", |
|
| System::getHostName(), |
|
| request->nameSpace.getString(), |
|
| providerName); |
|
| | |
| String fileName = resolveFileName(providerLocation); |
switch (eMethodFound) |
| |
{ |
| |
case METHOD_EVENTPROVIDER: |
| |
{ |
| |
WQLSelectStatement *stmt = newSelectExp( |
| |
srec->query, |
| |
srec->queryLanguage); |
| |
jlong jStmtRef = DEBUG_ConvertCToJava( |
| |
WQLSelectStatement *, |
| |
jlong, |
| |
stmt); |
| |
jobject jSelectExp = env->NewObject( |
| |
jv->SelectExpClassRef, |
| |
jv->SelectExpNewJ, |
| |
jStmtRef); |
| | |
| // get cached or load new provider module |
JMPIjvm::checkException(env); |
| JMPIProvider::OpProviderHolder ph = |
|
| providerManager.getProvider(fileName, providerName, String::EMPTY); |
|
| | |
| indProvRecord *prec=NULL; |
jstring jType = env->NewStringUTF( |
| provTab.lookup(providerName,prec); |
request->nameSpace.getString().getCString()); |
| if (prec) prec->count++; |
|
| else { |
|
| prec=new indProvRecord(); |
|
| provTab.insert(providerName,prec); |
|
| } |
|
| | |
| indSelectRecord *srec=new indSelectRecord(); |
JMPIjvm::checkException(env); |
| const CIMObjectPath &sPath=request->subscriptionInstance.getPath(); |
|
| selxTab.insert(sPath.toString(),srec); |
|
| | |
| // convert arguments |
CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), |
| OperationContext *context=new OperationContext(); |
request->nameSpace, |
| |
request->classNames[0]); |
| |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ,jcopRef); |
| | |
| context.insert(request->operationContext.get(IdentityContainer::NAME)); |
JMPIjvm::checkException(env); |
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
|
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
|
| context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME)); |
|
| context.insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME)); |
|
| context.insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME)); |
|
| | |
| CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
env->CallVoidMethod ((jobject)pr.jProvider, |
| |
id, |
| |
jSelectExp, |
| |
jType, |
| |
jcop, |
| |
(jboolean)fNewPrec); |
| | |
| JMPIProvider & pr=ph.GetProvider(); |
JMPIjvm::checkException(env); |
| |
break; |
| |
} |
| |
|
| |
case METHOD_EVENTPROVIDER2: |
| |
{ |
| |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| |
jlong, |
| |
&request->operationContext); |
| |
jobject joc = env->NewObject( |
| |
jv->OperationContextClassRef, |
| |
jv->OperationContextNewJ,jocRef); |
| | |
| CMPIStatus rc={CMPI_RC_OK,NULL}; |
WQLSelectStatement *stmt = newSelectExp(srec->query, |
| CMPI_ContextOnStack eCtx(*context); |
srec->queryLanguage); |
| CMPI_SelectExp *eSelx=new CMPI_SelectExp(*context, |
jlong jStmtRef = DEBUG_ConvertCToJava( |
| request->query, |
WQLSelectStatement *, |
| request->queryLanguage); |
jlong, |
| srec->eSelx=eSelx; |
stmt); |
| CMPI_ThreadContext thr(&pr.broker,&eCtx); |
jobject jSelectExp = env->NewObject( |
| |
jv->SelectExpClassRef, |
| |
jv->SelectExpNewJ, |
| |
jStmtRef); |
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
JMPIjvm::checkException(env); |
| "Calling provider.createSubscriptionRequest: " + pr.getName()); |
|
| | |
| DDD(cerr<<"--- JMPIProviderManager::createSubscriptionRequest"<<endl); |
jstring jType = env->NewStringUTF( |
| |
request->nameSpace.getString().getCString()); |
| | |
| for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) { |
JMPIjvm::checkException(env); |
| CIMObjectPath className( |
|
| System::getHostName(), |
CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), |
| request->nameSpace, | request->nameSpace, |
| request->classNames[i]); |
request->classNames[0]); |
| eSelx->classNames.append(className); |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop); |
| } |
jobject jcop = env->NewObject( |
| CMPI_ObjectPathOnStack eRef(eSelx->classNames[0]); |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ,jcopRef); |
| | |
| CIMPropertyList propertyList = request->propertyList; |
JMPIjvm::checkException(env); |
| if (!propertyList.isNull()) { |
|
| Array<CIMName> p=propertyList.getPropertyNameArray(); |
|
| int pCount=p.size(); |
|
| eSelx->props=(const char**)malloc((1+pCount)*sizeof(char*)); |
|
| for (int i=0; i<pCount; i++) { |
|
| eSelx->props[i]=strdup(p[i].getString().getCString()); |
|
| } |
|
| eSelx->props[pCount]=NULL; |
|
| } |
|
| | |
| Uint16 repeatNotificationPolicy = request->repeatNotificationPolicy; |
StatProviderTimeMeasurement providerTime(response); |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); |
env->CallVoidMethod ((jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jSelectExp, |
| |
jType, |
| |
jcop, |
| |
(jboolean)fNewPrec); |
| | |
| STAT_GETSTARTTIME; |
JMPIjvm::checkException(env); |
| | |
| rc=pr.miVector.indMI->ft->activateFilter( |
if (joc) |
| pr.miVector.indMI,&eCtx,NULL,eSelx, |
{ |
| CHARS(request->nameSpace.getString().getCString()),&eRef,false); |
env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate); |
| | |
| STAT_PMS_PROVIDEREND; |
JMPIjvm::checkException(env); |
| |
} |
| |
break; |
| |
} |
| | |
| if (rc.rc!=CMPI_RC_OK) |
case METHOD_UNKNOWN: |
| throw CIMException((CIMStatusCode)rc.rc); |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleCreateSubscriptionRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| } | } |
| HandlerCatch(handler); | HandlerCatch(handler); |
| | |
| |
if (env) JMPIjvm::detachThread(); |
| |
|
| PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| | |
| return(response); | return(response); |
| } | } |
| | |
| Message * JMPIProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw() |
Message * JMPIProviderManager::handleDeleteSubscriptionRequest( |
| |
const Message * message) throw() |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDeleteSubscriptionRequest"); |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleDeleteSubscriptionRequest"); |
| |
|
| |
HandlerIntroInd(DeleteSubscription,message,request,response,handler); |
| |
|
| |
typedef enum { |
| |
METHOD_UNKNOWN = 0, |
| |
METHOD_EVENTPROVIDER, |
| |
METHOD_EVENTPROVIDER2, |
| |
} METHOD_VERSION; |
| |
METHOD_VERSION eMethodFound = METHOD_UNKNOWN; |
| |
JNIEnv *env = NULL; |
| |
bool fFreePrec = false; |
| |
indProvRecord *prec = NULL; |
| |
indSelectRecord *srec = NULL; |
| | |
| HandlerIntroInd(DeleteSubscription,message,request,response, |
|
| handler); |
|
| try { | try { |
| String providerName,providerLocation; |
String fileName, |
| CIMInstance req_provider, req_providerModule; |
providerName, |
| ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME); |
providerLocation; |
| |
CIMInstance req_provider, |
| |
req_providerModule; |
| |
ProviderIdContainer pidc = (ProviderIdContainer) |
| |
request->operationContext.get( |
| |
ProviderIdContainer::NAME); |
| |
|
| req_provider = pidc.getProvider(); | req_provider = pidc.getProvider(); |
| req_providerModule = pidc.getModule(); | req_providerModule = pidc.getModule(); |
| | |
| LocateIndicationProviderNames(req_provider, req_providerModule, |
LocateIndicationProviderNames (req_provider, |
| providerName,providerLocation); |
req_providerModule, |
| |
providerName, |
| Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
providerLocation); |
| "JMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2", |
|
| System::getHostName(), |
fileName = resolveFileName (providerLocation); |
| request->nameSpace.getString(), |
|
| providerName); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
| |
"handleDeleteSubscriptionRequest: " |
| String fileName = resolveFileName(providerLocation); |
"name space = %s provider name = %s provider filename = %s", |
| |
(const char*)request->nameSpace.getString().getCString(), |
| |
(const char*)providerName.getCString(), |
| |
(const char*)fileName.getCString() |
| |
)); |
| | |
| // get cached or load new provider module | // get cached or load new provider module |
| JMPIProvider::OpProviderHolder ph = |
JMPIProvider::OpProviderHolder ph = providerManager.getProvider( |
| providerManager.getProvider(fileName, providerName, String::EMPTY); |
fileName, |
| |
providerName, |
| |
String::EMPTY); |
| |
|
| |
JMPIProvider &pr = ph.GetProvider (); |
| | |
| |
{ |
| |
AutoMutex lock (mutexProvTab); |
| | |
| indProvRecord *prec=NULL; |
|
| provTab.lookup(providerName,prec); | provTab.lookup(providerName,prec); |
| if (--prec->count<=0) { |
|
| provTab.remove(providerName); |
|
| prec=NULL; |
|
| } | } |
| | |
| indSelectRecord *srec=NULL; |
{ |
| const CIMObjectPath &sPath=request->subscriptionInstance.getPath(); |
AutoMutex lock (prec->mutex); |
| String sPathString=sPath.toString(); |
|
| selxTab.lookup(sPathString,srec); |
|
| |
|
| CMPI_SelectExp *eSelx=srec->eSelx; |
|
| CMPI_ObjectPathOnStack eRef(eSelx->classNames[0]); |
|
| selxTab.remove(sPathString); |
|
| | |
| // convert arguments |
if (--prec->count <= 0) |
| OperationContext context; |
{ |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleDeleteSubscriptionRequest: " |
| |
"Removing %s from provTab.", |
| |
(const char*)providerName.getCString())); |
| | |
| context.insert(request->operationContext.get(IdentityContainer::NAME)); |
provTab.remove (providerName); |
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
|
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
|
| context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME)); |
|
| context.insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME)); |
|
| | |
| CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); |
fFreePrec = true; |
| |
} |
| |
} |
| | |
| JMPIProvider & pr=ph.GetProvider(); |
{ |
| |
CIMObjectPath sPath = request->subscriptionInstance.getPath(); |
| |
Array<CIMKeyBinding> kb; |
| | |
| CMPIStatus rc={CMPI_RC_OK,NULL}; |
// Technically we only need Name and Handler for uniqueness |
| CMPI_ContextOnStack eCtx(context); |
kb = sPath.getKeyBindings (); |
| CMPI_ThreadContext thr(&pr.broker,&eCtx); |
|
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
// Add an entry for every provider. |
| "Calling provider.deleteSubscriptionRequest: " + pr.getName()); |
kb.append (CIMKeyBinding ("Provider", |
| |
pr.getName (), |
| |
CIMKeyBinding::STRING)); |
| | |
| DDD(cerr<<"--- JMPIProviderManager::deleteSubscriptionRequest"<<endl); |
sPath.setKeyBindings (kb); |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); |
String sPathString = sPath.toString (); |
| | |
| STAT_GETSTARTTIME; |
AutoMutex lock (mutexSelxTab); |
| | |
| rc=pr.miVector.indMI->ft->deActivateFilter( |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| pr.miVector.indMI,&eCtx,NULL,eSelx, |
"handleDeleteSubscriptionRequest: " |
| CHARS(request->nameSpace.getString().getCString()),&eRef,prec==NULL); |
"Removing %s from selxTab.", |
| |
(const char*)sPathString.getCString())); |
| | |
| delete eSelx; |
if (!selxTab.lookup (sPathString, srec)) |
| |
{ |
| |
PEGASUS_ASSERT(0); |
| |
} |
| | |
| STAT_PMS_PROVIDEREND; |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleDeleteSubscriptionRequest: " |
| |
"For selxTab %s , srec = %p, qContext = %p", |
| |
(const char*)sPathString.getCString(), |
| |
srec,srec->qContext)); |
| | |
| if (rc.rc!=CMPI_RC_OK) |
selxTab.remove (sPathString); |
| throw CIMException((CIMStatusCode)rc.rc); |
|
| } | } |
| HandlerCatch(handler); |
|
| |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3, |
| |
"handleDeleteSubscriptionRequest: " |
| |
"Calling provider: %s", |
| |
(const char*)pr.getName().getCString())); |
| |
|
| |
JvmVector *jv = 0; |
| |
|
| |
env = JMPIjvm::attachThread(&jv); |
| |
|
| |
if (!env) |
| |
{ |
| |
PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleDeleteSubscriptionRequest: " |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment."); |
| | |
| PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| | |
| return(response); |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED", |
| |
"Could not initialize the JVM (Java Virtual Machine) " |
| |
"runtime environment.")); |
| } | } |
| | |
| Message * JMPIProviderManager::handleEnableIndicationsRequest(const Message * message) throw() |
JMPIProvider::pm_service_op_lock op_lock(&pr); |
| { |
|
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager:: handleEnableIndicationsRequest"); |
|
| | |
| HandlerIntroInd(EnableIndications,message,request,response, |
jmethodID id = NULL; |
| handler); |
String interfaceType; |
| try { |
String interfaceVersion; |
| String providerName,providerLocation; |
|
| CIMInstance req_provider, req_providerModule; |
getInterfaceType( |
| ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME); |
request->operationContext.get(ProviderIdContainer::NAME), |
| req_provider = pidc.getProvider(); |
interfaceType, |
| req_providerModule = pidc.getModule(); |
interfaceVersion); |
| | |
| LocateIndicationProviderNames(req_provider, req_providerModule, |
if (interfaceType == "JMPI") |
| providerName,providerLocation); |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"deActivateFilter", |
| |
"(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Z)V"); |
| | |
| indProvRecord *provRec; |
if (id != NULL) |
| if (provTab.lookup(providerName,provRec)) { |
{ |
| provRec->enabled=true; |
eMethodFound = METHOD_EVENTPROVIDER; |
| provRec->handler=new EnableIndicationsResponseHandler( |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| request, response, request->provider, _indicationCallback); |
"handleDeleteSubscriptionRequest: " |
| |
"Found METHOD_EVENTPROVIDER."); |
| } | } |
| |
} |
| |
else if (interfaceType == "JMPIExperimental") |
| |
{ |
| |
id = env->GetMethodID( |
| |
(jclass)pr.jProviderClass, |
| |
"deActivateFilter", |
| |
"(Lorg/pegasus/jmpi/OperationContext;" |
| |
"Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;" |
| |
"Lorg/pegasus/jmpi/CIMObjectPath;Z)V"); |
| | |
| String fileName = resolveFileName(providerLocation); |
if (id != NULL) |
| |
{ |
| // get cached or load new provider module |
eMethodFound = METHOD_EVENTPROVIDER2; |
| JMPIProvider::OpProviderHolder ph = |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| providerManager.getProvider(fileName, providerName, String::EMPTY); |
"handleDeleteSubscriptionRequest: " |
| |
"Found METHOD_EVENTPROVIDER2."); |
| |
} |
| |
} |
| | |
| // convert arguments |
if (id == NULL) |
| OperationContext context; |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleDeleteSubscriptionRequest: No method provider found!"); |
| | |
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
PEG_METHOD_EXIT(); |
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
|
| | |
| JMPIProvider & pr=ph.GetProvider(); |
throw PEGASUS_CIM_EXCEPTION_L( |
| |
CIM_ERR_FAILED, |
| |
MessageLoaderParms( |
| |
"ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND", |
| |
"Could not find a method for the provider based on" |
| |
" InterfaceType.")); |
| |
} |
| | |
| CMPIStatus rc={CMPI_RC_OK,NULL}; |
JMPIjvm::checkException(env); |
| CMPI_ContextOnStack eCtx(context); |
|
| CMPI_ThreadContext thr(&pr.broker,&eCtx); |
|
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
switch (eMethodFound) |
| "Calling provider.EnableIndicationRequest: " + pr.getName()); |
{ |
| |
case METHOD_EVENTPROVIDER: |
| |
{ |
| |
WQLSelectStatement *stmt = newSelectExp( |
| |
srec->query, |
| |
srec->queryLanguage); |
| |
jlong jStmtRef = DEBUG_ConvertCToJava( |
| |
WQLSelectStatement *, |
| |
jlong, |
| |
stmt); |
| |
jobject jSelectExp = env->NewObject( |
| |
jv->SelectExpClassRef, |
| |
jv->SelectExpNewJ,jStmtRef); |
| | |
| DDD(cerr<<"--- JMPIProviderManager::enableIndicationRequest"<<endl); |
JMPIjvm::checkException(env); |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); |
jstring jType = env->NewStringUTF( |
| |
request->nameSpace.getString().getCString()); |
| | |
| STAT_GETSTARTTIME; |
JMPIjvm::checkException(env); |
| | |
| pr.miVector.indMI->ft->enableIndications( |
CIMObjectPath *cop = new CIMObjectPath( |
| pr.miVector.indMI); |
System::getHostName(), |
| |
request->nameSpace, |
| |
request->classNames[0]); |
| |
jlong jcopRef = DEBUG_ConvertCToJava(CIMObjectPath*, jlong, cop); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ,jcopRef); |
| | |
| STAT_PMS_PROVIDEREND; |
JMPIjvm::checkException(env); |
| } |
|
| HandlerCatch(handler); |
|
| | |
| PEG_METHOD_EXIT(); |
StatProviderTimeMeasurement providerTime(response); |
| |
|
| |
env->CallVoidMethod ((jobject)pr.jProvider, |
| |
id, |
| |
jSelectExp, |
| |
jType, |
| |
jcop, |
| |
(jboolean)fFreePrec); |
| | |
| return(response); |
JMPIjvm::checkException(env); |
| |
break; |
| } | } |
| | |
| Message * JMPIProviderManager::handleDisableIndicationsRequest(const Message * message) throw() |
case METHOD_EVENTPROVIDER2: |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager:: handleDisableIndicationsRequest"); |
jlong jocRef = DEBUG_ConvertCToJava( |
| |
OperationContext*, |
| HandlerIntroInd(DisableIndications,message,request,response, |
jlong, |
| handler); |
&request->operationContext); |
| try { |
jobject joc = env->NewObject( |
| String providerName,providerLocation; |
jv->OperationContextClassRef, |
| CIMInstance req_provider, req_providerModule; |
jv->OperationContextNewJ,jocRef); |
| ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME); |
|
| | |
| req_provider = pidc.getProvider(); |
WQLSelectStatement *stmt = newSelectExp (srec->query, |
| req_providerModule = pidc.getModule(); |
srec->queryLanguage); |
| |
jlong jStmtRef = DEBUG_ConvertCToJava( |
| |
WQLSelectStatement *, |
| |
jlong, |
| |
stmt); |
| |
jobject jSelectExp = env->NewObject( |
| |
jv->SelectExpClassRef, |
| |
jv->SelectExpNewJ, |
| |
jStmtRef); |
| | |
| LocateIndicationProviderNames(req_provider, req_providerModule, |
JMPIjvm::checkException(env); |
| providerName,providerLocation); |
|
| | |
| indProvRecord *provRec; |
jstring jType = env->NewStringUTF( |
| if (provTab.lookup(providerName,provRec)) { |
request->nameSpace.getString().getCString()); |
| provRec->enabled=false; |
|
| if (provRec->handler) delete provRec->handler; |
|
| provRec->handler=NULL; |
|
| } |
|
| | |
| String fileName = resolveFileName(providerLocation); |
JMPIjvm::checkException(env); |
| | |
| // get cached or load new provider module |
CIMObjectPath *cop = new CIMObjectPath (System::getHostName(), |
| JMPIProvider::OpProviderHolder ph = |
request->nameSpace, |
| providerManager.getProvider(fileName, providerName, String::EMPTY); |
request->classNames[0]); |
| |
jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop); |
| |
jobject jcop = env->NewObject( |
| |
jv->CIMObjectPathClassRef, |
| |
jv->CIMObjectPathNewJ,jcopRef); |
| | |
| // convert arguments |
JMPIjvm::checkException(env); |
| OperationContext context; |
|
| | |
| context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME)); |
StatProviderTimeMeasurement providerTime(response); |
| context.insert(request->operationContext.get(ContentLanguageListContainer::NAME)); |
|
| | |
| JMPIProvider & pr=ph.GetProvider(); |
env->CallVoidMethod ((jobject)pr.jProvider, |
| |
id, |
| |
joc, |
| |
jSelectExp, |
| |
jType, |
| |
jcop, |
| |
(jboolean)fFreePrec); |
| | |
| CMPIStatus rc={CMPI_RC_OK,NULL}; |
JMPIjvm::checkException(env); |
| CMPI_ContextOnStack eCtx(context); |
|
| CMPI_ThreadContext thr(&pr.broker,&eCtx); |
|
| | |
| PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
if (joc) |
| "Calling provider.DisableIndicationRequest: " + pr.getName()); |
{ |
| |
env->CallVoidMethod( |
| |
joc, |
| |
JMPIjvm::jv.OperationContextUnassociate); |
| | |
| DDD(cerr<<"--- JMPIProviderManager::disableIndicationRequest"<<endl); |
JMPIjvm::checkException(env); |
| |
} |
| |
break; |
| |
} |
| | |
| JMPIProvider::pm_service_op_lock op_lock(&pr); |
case METHOD_UNKNOWN: |
| |
{ |
| |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
| |
"handleDeleteSubscriptionRequest: Unknown method provider!"); |
| |
break; |
| |
} |
| |
} |
| | |
| STAT_GETSTARTTIME; |
// |
| |
// Decrement count of current subscriptions for this provider |
| |
// |
| |
pr.decrementSubscriptionsAndTestIfZero (); |
| |
} |
| |
HandlerCatch(handler); |
| | |
| pr.miVector.indMI->ft->disableIndications( |
if (srec) |
| pr.miVector.indMI); |
{ |
| |
delete srec->qContext; |
| |
} |
| |
delete srec; |
| | |
| STAT_PMS_PROVIDEREND; |
if (fFreePrec) |
| |
{ |
| |
delete prec->ctx; |
| |
delete prec->handler; |
| |
delete prec; |
| } | } |
| HandlerCatch(handler); |
|
| |
if (env) JMPIjvm::detachThread(); |
| | |
| PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| | |
| return(response); | return(response); |
| }*/ |
} |
| | |
| Message * JMPIProviderManager::handleDisableModuleRequest(const Message * message) throw() |
Message * JMPIProviderManager::handleDisableModuleRequest( |
| |
const Message * message) throw() |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDisableModuleRequest"); |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleDisableModuleRequest"); |
| | |
| CIMDisableModuleRequestMessage * request = | CIMDisableModuleRequestMessage * request = |
| dynamic_cast<CIMDisableModuleRequestMessage *>(const_cast<Message *>(message)); |
dynamic_cast<CIMDisableModuleRequestMessage *> |
| |
(const_cast<Message *>(message)); |
| | |
| PEGASUS_ASSERT(request != 0); | PEGASUS_ASSERT(request != 0); |
| | |
| // get provider module name | // get provider module name |
| String moduleName; | String moduleName; |
| CIMInstance mInstance = request->providerModule; | CIMInstance mInstance = request->providerModule; |
| Uint32 pos = mInstance.findProperty(CIMName ("Name")); |
Uint32 pos = mInstance.findProperty(PEGASUS_PROPERTYNAME_NAME); |
| | |
| if(pos != PEG_NOT_FOUND) | if(pos != PEG_NOT_FOUND) |
| { | { |
|
|
|
| // | // |
| 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( |
dynamic_cast<CIMDisableModuleResponseMessage*>( |
| request->messageId, |
request->buildResponse()); |
| CIMException(), |
|
| request->queueIds.copyAndPop(), |
|
| operationalStatus); |
|
| |
|
| PEGASUS_ASSERT(response != 0); | PEGASUS_ASSERT(response != 0); |
| |
response->operationalStatus = operationalStatus; |
| // preserve message key |
|
| response->setKey(request->getKey()); |
|
| |
|
| // |
|
| // Set HTTP method in response from request |
|
| // |
|
| response->setHttpMethod (request->getHttpMethod ()); |
|
| | |
| PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| | |
| return(response); | return(response); |
| } | } |
| | |
| Message * JMPIProviderManager::handleEnableModuleRequest(const Message * message) throw() |
Message * JMPIProviderManager::handleEnableModuleRequest( |
| |
const Message * message) throw() |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnableModuleRequest"); |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleEnableModuleRequest"); |
| | |
| CIMEnableModuleRequestMessage * request = | CIMEnableModuleRequestMessage * request = |
| dynamic_cast<CIMEnableModuleRequestMessage *>(const_cast<Message *>(message)); |
dynamic_cast<CIMEnableModuleRequestMessage *> |
| |
(const_cast<Message *>(message)); |
| | |
| PEGASUS_ASSERT(request != 0); | PEGASUS_ASSERT(request != 0); |
| | |
| Array<Uint16> operationalStatus; | Array<Uint16> operationalStatus; |
| operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK); |
operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED); |
| | |
| CIMEnableModuleResponseMessage * response = | CIMEnableModuleResponseMessage * response = |
| new CIMEnableModuleResponseMessage( |
dynamic_cast<CIMEnableModuleResponseMessage*>( |
| request->messageId, |
request->buildResponse()); |
| CIMException(), |
|
| request->queueIds.copyAndPop(), |
|
| operationalStatus); |
|
| |
|
| PEGASUS_ASSERT(response != 0); | PEGASUS_ASSERT(response != 0); |
| |
response->operationalStatus = operationalStatus; |
| // preserve message key |
|
| response->setKey(request->getKey()); |
|
| |
|
| // Set HTTP method in response from request |
|
| response->setHttpMethod (request->getHttpMethod ()); |
|
| | |
| PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
| | |
| return(response); | return(response); |
| } | } |
| | |
| Message * JMPIProviderManager::handleStopAllProvidersRequest(const Message * message) throw() |
Message * JMPIProviderManager::handleStopAllProvidersRequest( |
| |
const Message * message) throw() |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleStopAllProvidersRequest"); |
PEG_METHOD_ENTER( |
| |
TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::handleStopAllProvidersRequest"); |
| | |
| CIMStopAllProvidersRequestMessage * request = | CIMStopAllProvidersRequestMessage * request = |
| dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message)); |
dynamic_cast<CIMStopAllProvidersRequestMessage *> |
| |
(const_cast<Message *>(message)); |
| | |
| PEGASUS_ASSERT(request != 0); | PEGASUS_ASSERT(request != 0); |
| | |
| CIMStopAllProvidersResponseMessage * response = | CIMStopAllProvidersResponseMessage * response = |
| new CIMStopAllProvidersResponseMessage( |
dynamic_cast<CIMStopAllProvidersResponseMessage*>( |
| request->messageId, |
request->buildResponse()); |
| CIMException(), |
|
| request->queueIds.copyAndPop()); |
|
| |
|
| PEGASUS_ASSERT(response != 0); | PEGASUS_ASSERT(response != 0); |
| | |
| // preserve message key |
|
| response->setKey(request->getKey()); |
|
| |
|
| // Set HTTP method in response from request |
|
| response->setHttpMethod (request->getHttpMethod ()); |
|
| |
|
| // tell the provider manager to shutdown all the providers | // tell the provider manager to shutdown all the providers |
| providerManager.shutdownAllProviders(); | providerManager.shutdownAllProviders(); |
| | |
|
|
|
| return(response); | return(response); |
| } | } |
| | |
| Message * JMPIProviderManager::handleInitializeProviderRequest(const Message * message) |
Message* JMPIProviderManager::handleIndicationServiceDisabledRequest( |
| |
Message* message) |
| { | { |
| PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleInitializeProviderRequest"); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, |
| |
"JMPIProviderManager::_handleIndicationServiceDisabledRequest"); |
| | |
| HandlerIntroInit(InitializeProvider,message,request,response,handler); |
CIMIndicationServiceDisabledRequestMessage* request = |
| |
dynamic_cast<CIMIndicationServiceDisabledRequestMessage*>(message); |
| |
PEGASUS_ASSERT(request != 0); |
| | |
| try |
CIMIndicationServiceDisabledResponseMessage* response = |
| { |
dynamic_cast<CIMIndicationServiceDisabledResponseMessage*>( |
| // resolve provider name |
request->buildResponse()); |
| ProviderName name = _resolveProviderName( |
PEGASUS_ASSERT(response != 0); |
| request->operationContext.get(ProviderIdContainer::NAME)); |
|
| | |
| // get cached or load new provider module |
_subscriptionInitComplete = false; |
| JMPIProvider::OpProviderHolder ph = |
|
| providerManager.getProvider(name.getPhysicalName(), |
|
| name.getLogicalName(), String::EMPTY); |
|
| | |
| |
PEG_METHOD_EXIT (); |
| |
return response; |
| } | } |
| HandlerCatch(handler); |
|
| | |
| PEG_METHOD_EXIT(); |
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 (); |
| | |
| |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
| |
"handleSubscriptionInitCompleteRequest: numProviders = %d ", |
| |
numProviders)); |
| |
|
| |
PEG_METHOD_EXIT (); |
| return(response); | 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( |
|
|
|
| { | { |
| String providerName; | String providerName; |
| String fileName; | String fileName; |
| String interfaceName; |
String moduleName; |
| CIMValue genericValue; | CIMValue genericValue; |
| | |
| |
genericValue = providerId.getModule().getProperty( |
| |
providerId.getModule().findProperty( |
| |
PEGASUS_PROPERTYNAME_NAME)).getValue(); |
| |
genericValue.get(moduleName); |
| |
|
| genericValue = providerId.getProvider().getProperty( | genericValue = providerId.getProvider().getProperty( |
| providerId.getProvider().findProperty("Name")).getValue(); |
providerId.getProvider().findProperty( |
| |
PEGASUS_PROPERTYNAME_NAME)).getValue(); |
| genericValue.get(providerName); | genericValue.get(providerName); |
| | |
| genericValue = providerId.getModule().getProperty( | genericValue = providerId.getModule().getProperty( |
|
|
|
| genericValue.get(fileName); | genericValue.get(fileName); |
| fileName = resolveFileName(fileName); | fileName = resolveFileName(fileName); |
| | |
| // ATTN: This attribute is probably not required |
return ProviderName(moduleName, providerName, fileName); |
| genericValue = providerId.getModule().getProperty( |
|
| providerId.getModule().findProperty("InterfaceType")).getValue(); |
|
| genericValue.get(interfaceName); |
|
| |
|
| return ProviderName(providerName, fileName, interfaceName, 0); |
|
| } | } |
| | |
| String JMPIProviderManager::resolveFileName(String fileName) | String JMPIProviderManager::resolveFileName(String fileName) |
| { | { |
| String name; |
String name = ConfigManager::getHomedPath( |
| #if defined(PEGASUS_OS_TYPE_WINDOWS) |
ConfigManager::getInstance()->getCurrentValue("providerDir")); |
| name = fileName; // + String(".dll"); |
// physfilename = everything up to the delimiter pointing at class start |
| #elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) |
// in case there is no delimiter anymore, it takes the entire filename |
| name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir")); |
String physfilename = fileName.subString(0, fileName.find(":")); |
| name.append(String("/") + fileName); // + String(".sl")); |
// look in all(multiple) homed pathes for the physical file |
| #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC) |
name = FileSystem::getAbsoluteFileName(name, physfilename); |
| name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir")); |
// construct back the fully specified jar:<classname> provider name |
| name.append(String("/") + fileName); // + String(".so")); |
name = FileSystem::extractFilePath(name) + fileName; |
| #elif defined(PEGASUS_OS_OS400) |
|
| name = filrName; |
|
| #else |
|
| name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir")); |
|
| name.append(String("/") + fileName); // + String(".so")); |
|
| #endif |
|
| return name; | return name; |
| } | } |
| | |
Return to
JMPIProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI