1 karl 1.17 //%2004////////////////////////////////////////////////////////////////////////
|
2 schuur 1.1 //
|
3 karl 1.17 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 schuur 1.1 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.17 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 schuur 1.1 //
10 // Permission is hereby granted, free of charge, to any person obtaining a copy
11 // of this software and associated documentation files (the "Software"), to
12 // deal in the Software without restriction, including without limitation the
13 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
14 // sell copies of the Software, and to permit persons to whom the Software is
15 // furnished to do so, subject to the following conditions:
|
16 karl 1.17 //
|
17 schuur 1.1 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
18 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
19 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
20 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
21 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
22 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
23 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
24 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 //
26 //==============================================================================
27 //
28 // Author: Adrian Schuur, schuur@de.ibm.com
29 //
|
30 se.gupta 1.9 // Modified By: Seema Gupta (gseema@in.ibm.com) for PEP135
|
31 schuur 1.1 //
32 //%/////////////////////////////////////////////////////////////////////////////
33
34 #include "JMPIProviderManager.h"
35
36 #include "JMPIImpl.h"
37
38 #include <Pegasus/Common/CIMMessage.h>
39 #include <Pegasus/Common/OperationContext.h>
40 #include <Pegasus/Common/Destroyer.h>
41 #include <Pegasus/Common/Tracer.h>
42 #include <Pegasus/Common/StatisticalData.h>
43 #include <Pegasus/Common/Logger.h>
44 #include <Pegasus/Common/MessageLoader.h> //l10n
|
45 kumpf 1.10 #include <Pegasus/Common/Constants.h>
|
46 schuur 1.1
47 #include <Pegasus/Config/ConfigManager.h>
48
49 #include <Pegasus/ProviderManager2/ProviderName.h>
50 #include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h>
51 #include <Pegasus/ProviderManager2/ProviderManagerService.h>
52
|
53 schuur 1.12 #include <Pegasus/ProviderManager2/CMPI/CMPI_SelectExp.h>
54
|
55 schuur 1.1
56 PEGASUS_USING_STD;
57 PEGASUS_NAMESPACE_BEGIN
58
59 int _jmpi_trace=0;
60
61 #define DDD(x) if (_jmpi_trace) x;
62
63 JMPIProviderManager::IndProvTab JMPIProviderManager::provTab;
64 JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab;
65 JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg;
66
67 JMPIProviderManager::JMPIProviderManager(Mode m)
68 {
69 mode=m;
70 if (getenv("JMPI_TRACE")) _jmpi_trace=1;
71 else _jmpi_trace=0;
72 }
73
74 JMPIProviderManager::~JMPIProviderManager(void)
75 {
76 schuur 1.1 }
77
|
78 schuur 1.12 Boolean JMPIProviderManager::insertProvider(const ProviderName & name,
|
79 schuur 1.1 const String &ns, const String &cn)
80 {
81 String key(ns+String("::")+cn+String("::")+CIMValue(name.getCapabilitiesMask()).toString());
82 return provReg.insert(key,name);
83 }
84
85
86 Message * JMPIProviderManager::processMessage(Message * request) throw()
87 {
88 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
89 "JMPIProviderManager::processMessage()");
90
91 Message * response = 0;
92
93 // pass the request message to a handler method based on message type
94 switch(request->getType())
95 {
96 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
97 response = handleGetInstanceRequest(request);
98
99 break;
100 schuur 1.1 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
101 response = handleEnumerateInstancesRequest(request);
102
103 break;
104 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
105 response = handleEnumerateInstanceNamesRequest(request);
106
107 break;
108 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
109 response = handleCreateInstanceRequest(request);
110
111 break;
112 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
113 response = handleModifyInstanceRequest(request);
114
115 break;
116 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
117 response = handleDeleteInstanceRequest(request);
118
119 break;
120 /* case CIM_EXEC_QUERY_REQUEST_MESSAGE:
121 schuur 1.1 response = handleExecuteQueryRequest(request);
122
123 */ break;
124 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
125 response = handleAssociatorsRequest(request);
126
127 break;
128 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
129 response = handleAssociatorNamesRequest(request);
130
131 break;
132 case CIM_REFERENCES_REQUEST_MESSAGE:
133 response = handleReferencesRequest(request);
134
135 break;
136 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
137 response = handleReferenceNamesRequest(request);
138
139 break;
|
140 schuur 1.11 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
|
141 schuur 1.1 response = handleInvokeMethodRequest(request);
142
143 break;
|
144 schuur 1.12 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
|
145 schuur 1.1 response = handleCreateSubscriptionRequest(request);
146
147 break;
|
148 schuur 1.12 /* case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
|
149 schuur 1.1 response = handleModifySubscriptionRequest(request);
150 break;
|
151 schuur 1.12 */
|
152 schuur 1.1 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
153 response = handleDeleteSubscriptionRequest(request);
154
155 break;
156 case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE:
157 response = handleEnableIndicationsRequest(request);
158
159 break;
160 case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE:
161 response = handleDisableIndicationsRequest(request);
162
163 break;
|
164 schuur 1.12 /* case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
|
165 kumpf 1.7 response = handleExportIndicationRequest(request);
|
166 schuur 1.1 break;
|
167 schuur 1.12 */
|
168 schuur 1.1 case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
169 response = handleDisableModuleRequest(request);
170
171 break;
172 case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
173 response = handleEnableModuleRequest(request);
174
175 break;
176 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
177 response = handleStopAllProvidersRequest(request);
178
|
179 schuur 1.12 break;
|
180 kumpf 1.4 case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
181 response = handleInitializeProviderRequest(request);
182
183 break;
|
184 schuur 1.1 default:
|
185 konrad.r 1.14 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
186 "*** Unsupported Request "+request->getType());
|
187 schuur 1.1 response = handleUnsupportedRequest(request);
188
189 break;
190 }
191
192 PEG_METHOD_EXIT();
193
194 return(response);
195 }
196
|
197 kumpf 1.6 Boolean JMPIProviderManager::hasActiveProviders()
198 {
199 return providerManager.hasActiveProviders();
200 }
201
202 void JMPIProviderManager::unloadIdleProviders()
|
203 schuur 1.1 {
|
204 kumpf 1.6 providerManager.unloadIdleProviders();
|
205 schuur 1.1 }
206
207 #define STRDUPA(s,o) \
208 if (s) { \
209 o=(const char*)alloca(strlen(s)); \
210 strcpy((char*)(o),(s)); \
211 } \
212 else o=NULL;
213
214 #define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL)
215
216
217 #define HandlerIntroBase(type,type1,message,request,response,handler,respType) \
218 CIM##type##RequestMessage * request = \
219 dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *>(message)); \
220 PEGASUS_ASSERT(request != 0); \
221 CIM##type##ResponseMessage * response = \
222 new CIM##type##ResponseMessage( \
223 request->messageId, \
224 CIMException(), \
225 request->queueIds.copyAndPop() \
226 schuur 1.1 respType \
227 PEGASUS_ASSERT(response != 0); \
228 response->setKey(request->getKey()); \
229 response->setHttpMethod(request->getHttpMethod()); \
230 type1##ResponseHandler handler(request, response);
231
232 #define VOIDINTRO );
233 #define NOVOIDINTRO(type) ,type);
234 #define METHODINTRO ,CIMValue(), Array<CIMParamValue>(), request->methodName );
235
236
237 #define HandlerIntroVoid(type,message,request,response,handler) \
238 HandlerIntroBase(type,type,message,request,response,handler,VOIDINTRO)
239
240 #define HandlerIntroMethod(type,message,request,response,handler) \
241 HandlerIntroBase(type,type,message,request,response,handler,METHODINTRO)
242
243 #define HandlerIntroInd(type,message,request,response,handler) \
244 HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)
245
|
246 kumpf 1.4 #define HandlerIntroInit(type,message,request,response,handler) \
247 HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)
248
|
249 schuur 1.1 #define HandlerIntro(type,message,request,response,handler,respType) \
250 HandlerIntroBase(type,type,message,request,response,handler,NOVOIDINTRO(respType))
251
252 #define HandlerCatch(handler) \
253 catch(CIMException & e) \
254 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
255 "Exception: " + e.getMessage()); \
256 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); \
257 } \
258 catch(Exception & e) \
259 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
260 "Exception: " + e.getMessage()); \
261 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); \
262 } \
263 catch(...) \
264 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
265 "Exception: Unknown"); \
266 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \
267 }
268
|
269 schuur 1.13 static jobjectArray getList(JvmVector *jv, JNIEnv *env, CIMPropertyList &list)
270 {
271 Uint32 s=list.size();
272 jobjectArray pl=NULL;
273 if (s) {
274 jstring initial=env->NewString(NULL,0);
275 pl=env->NewObjectArray(s,jv->StringClassRef,initial);
276 for (Uint32 i=0; i<s; i++) {
277 env->SetObjectArrayElement
278 (pl,i,env->NewStringUTF(list[i].getString().getCString()));
279 }
280 }
281 return pl;
282 }
|
283 schuur 1.1
284 Message * JMPIProviderManager::handleGetInstanceRequest(const Message * message) throw()
285 {
286 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
287 "JMPIProviderManager::handleGetInstanceRequest");
288
289 HandlerIntro(GetInstance,message,request,response,handler,CIMInstance());
290
291 JNIEnv *env=NULL;
|
292 schuur 1.13 Boolean mode24=false;
293 CIMPropertyList propertyList;
294 jobjectArray pl=NULL;
295
|
296 schuur 1.1 try {
297 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
298 "JMPIProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
299 System::getHostName(),
300 request->nameSpace.getString(),
301 request->instanceName.getClassName().getString());
302
303 // make target object path
304 CIMObjectPath objectPath(
305 System::getHostName(),
306 request->nameSpace,
307 request->instanceName.getClassName(),
308 request->instanceName.getKeyBindings());
309
310 // resolve provider name
|
311 kumpf 1.2 ProviderName name = _resolveProviderName(
312 request->operationContext.get(ProviderIdContainer::NAME));
|
313 schuur 1.1
314 // get cached or load new provider module
315 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(name.getPhysicalName(),
316 name.getLogicalName());
317 OperationContext context;
318
319 // forward request
320 JMPIProvider & pr=ph.GetProvider();
321
322 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
323 "Calling provider.getInstance: " + pr.getName());
324
|
325 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::getInstance"<<endl);
|
326 schuur 1.1
327 JvmVector *jv;
328 JNIEnv *env=JMPIjvm::attachThread(&jv);
329 JMPIjvm::checkException(env);
330 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
331 jv->CIMObjectPathNewI,(jint)&objectPath);
332 JMPIjvm::checkException(env);
333
334 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
335 request->instanceName.getClassName(),
336 false,true,true,CIMPropertyList());
337 JMPIjvm::checkException(env);
|
338 schuur 1.13 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls);
|
339 schuur 1.1 JMPIjvm::checkException(env);
340
341 JMPIProvider::pm_service_op_lock op_lock(&pr);
342
|
343 schuur 1.13 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"getInstance",
344 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;");
345
346 if (id==NULL) {
347 env->ExceptionClear();
348 id=env->GetMethodID((jclass)pr.jProviderClass,"getInstance",
349 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)"
350 "Lorg/pegasus/jmpi/CIMInstance;");
351 JMPIjvm::checkException(env);
352 mode24=true;
353 pl=getList(jv,env,request->propertyList);
354 }
355 JMPIjvm::checkException(env);
356
|
357 schuur 1.1 STAT_GETSTARTTIME;
358
|
359 schuur 1.13 jobject inst=NULL;
360 if (mode24) inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
361 request->localOnly,request->includeQualifiers,request->includeClassOrigin,pl,jCc);
362 else inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jCc,true);
363
|
364 schuur 1.1 STAT_PMS_PROVIDEREND;
|
365 schuur 1.13
|
366 schuur 1.1 JMPIjvm::checkException(env);
|
367 schuur 1.13 handler.processing();
|
368 schuur 1.1 if (inst) {
|
369 schuur 1.11 CIMInstance *ci=((CIMInstance*)env->CallIntMethod(inst,JMPIjvm::jv.CIMInstanceCInst));
|
370 schuur 1.1 handler.deliver(*ci);
371 }
372 handler.complete();
|
373 schuur 1.13 }
|
374 schuur 1.1 HandlerCatch(handler);
|
375 schuur 1.13
|
376 schuur 1.1 if (env) JMPIjvm::detachThread();
|
377 schuur 1.13
|
378 schuur 1.1 PEG_METHOD_EXIT();
379
380 return(response);
381 }
382
383 Message * JMPIProviderManager::handleEnumerateInstancesRequest(const Message * message) throw()
384 {
385 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
386 "JMPIProviderManager::handleEnumerateInstanceRequest");
387
388 HandlerIntro(EnumerateInstances,message,request,response,
389 handler,Array<CIMInstance>());
390 JNIEnv *env=NULL;
|
391 schuur 1.13 Boolean mode24=false;
392 CIMPropertyList propertyList;
393 jobjectArray pl=NULL;
394
395 try {
|
396 schuur 1.1 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
397 "JMPIProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2",
398 System::getHostName(),
399 request->nameSpace.getString(),
400 request->className.getString());
401
402 // make target object path
403 CIMObjectPath objectPath(
404 System::getHostName(),
405 request->nameSpace,
406 request->className);
407
408 // resolve provider name
|
409 kumpf 1.2 ProviderName name = _resolveProviderName(
410 request->operationContext.get(ProviderIdContainer::NAME));
|
411 schuur 1.1
412 // get cached or load new provider module
413 JMPIProvider::OpProviderHolder ph =
414 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),
415 String::EMPTY);
416
|
417 schuur 1.12 // convert arguments
|
418 schuur 1.1 OperationContext context;
419
|
420 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
421 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
422 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
423 schuur 1.1
424 CIMPropertyList propertyList(request->propertyList);
425
426 // forward request
|
427 schuur 1.12 JMPIProvider & pr=ph.GetProvider();
|
428 schuur 1.1
429 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
430 "Calling provider.enumerateInstances: " + pr.getName());
431
|
432 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::enumerateInstances"<<endl);
|
433 schuur 1.1
|
434 schuur 1.12
435 JvmVector *jv;
|
436 schuur 1.1 env=JMPIjvm::attachThread(&jv);
437
438 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
|
439 schuur 1.12 jv->CIMObjectPathNewI,(jint)&objectPath);
440 JMPIjvm::checkException(env);
441
|
442 schuur 1.1 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
|
443 schuur 1.12 request->className,
|
444 schuur 1.1 false,true,true,CIMPropertyList());
|
445 schuur 1.12 JMPIjvm::checkException(env);
|
446 schuur 1.1 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls);
447 JMPIjvm::checkException(env);
448
|
449 schuur 1.12 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
450 schuur 1.1
|
451 schuur 1.12 STAT_GETSTARTTIME;
|
452 schuur 1.1
453 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"enumInstances",
454 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;");
|
455 schuur 1.13
456 if (id==NULL) {
457 env->ExceptionClear();
458 id=env->GetMethodID((jclass)pr.jProviderClass,"enumerateInstances",
459 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)"
460 "[Lorg/pegasus/jmpi/CIMInstance;");
461 JMPIjvm::checkException(env);
462 mode24=true;
463 pl=getList(jv,env,request->propertyList);
464 }
|
465 schuur 1.1 JMPIjvm::checkException(env);
466
|
467 schuur 1.13 if (!mode24) {
468 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,false,jCc,true);
469 JMPIjvm::checkException(env);
470
471 STAT_PMS_PROVIDEREND;
472
473 handler.processing();
474 if (jVec) {
475 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
476 JMPIjvm::checkException(env);
477 jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
478 JMPIjvm::checkException(env);
479 CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));
480 JMPIjvm::checkException(env);
481
482 handler.deliver(inst);
483 }
484 }
485 handler.complete();
486 }
|
487 schuur 1.12
|
488 schuur 1.13 else {
489 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
490 request->localOnly,request->includeQualifiers,request->includeClassOrigin,pl,jCc);
491 JMPIjvm::checkException(env);
|
492 schuur 1.12
|
493 schuur 1.13 STAT_PMS_PROVIDEREND;
|
494 schuur 1.12
|
495 schuur 1.13 handler.processing();
496 if (jAr) {
497 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
498 JMPIjvm::checkException(env);
499 jobject jInst=env->GetObjectArrayElement(jAr,i);
500 JMPIjvm::checkException(env);
501 CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));
502 JMPIjvm::checkException(env);
|
503 schuur 1.12
|
504 schuur 1.13 handler.deliver(inst);
505 }
506 }
507 handler.complete();
|
508 schuur 1.1 }
509 }
510 HandlerCatch(handler);
|
511 schuur 1.12
|
512 schuur 1.11 if (env) JMPIjvm::detachThread();
|
513 schuur 1.12
|
514 schuur 1.1 PEG_METHOD_EXIT();
515
516 return(response);
517 }
518
519 Message * JMPIProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw()
520 {
521 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest");
522
523 HandlerIntro(EnumerateInstanceNames,message,request,response,
524 handler,Array<CIMObjectPath>());
525 JNIEnv *env=NULL;
|
526 schuur 1.13 Boolean mode24=false;
527 CIMPropertyList propertyList;
528 jobjectArray pl=NULL;
529
|
530 schuur 1.1 try {
531 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
532 "JMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
533 System::getHostName(),
534 request->nameSpace.getString(),
535 request->className.getString());
536
537 // make target object path
538 CIMObjectPath objectPath(
539 System::getHostName(),
540 request->nameSpace,
541 request->className);
542
543 // resolve provider name
|
544 kumpf 1.2 ProviderName name = _resolveProviderName(
545 request->operationContext.get(ProviderIdContainer::NAME));
|
546 schuur 1.1
547 // get cached or load new provider module
548 JMPIProvider::OpProviderHolder ph =
549 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
550
551 // convert arguments
552 OperationContext context;
553
|
554 se.gupta 1.9 context.insert(request->operationContext.get(IdentityContainer::NAME));
555 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
556 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
557 schuur 1.1
558 JMPIProvider & pr=ph.GetProvider();
559
560 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
561 "Calling provider.enumerateInstanceNames: " + pr.getName());
562
|
563 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::enumerateInstanceNames"<<endl);
|
564 schuur 1.1
|
565 schuur 1.12
|
566 schuur 1.1 JvmVector *jv;
567 env=JMPIjvm::attachThread(&jv);
568
569 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
570 jv->CIMObjectPathNewI,(jint)&objectPath);
571 JMPIjvm::checkException(env);
|
572 schuur 1.12
|
573 schuur 1.1 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
574 request->className,
575 false,true,true,CIMPropertyList());
576 JMPIjvm::checkException(env);
577 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls);
578 JMPIjvm::checkException(env);
579
580 JMPIProvider::pm_service_op_lock op_lock(&pr);
581
582 STAT_GETSTARTTIME;
583
584 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"enumInstances",
585 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
|
586 schuur 1.13
587 if (id==NULL) {
588 env->ExceptionClear();
589 id=env->GetMethodID((jclass)pr.jProviderClass,"enumerateInstanceNames",
590 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)"
591 "[Lorg/pegasus/jmpi/CIMObjectPath;");
592 JMPIjvm::checkException(env);
593 mode24=true;
594 }
|
595 schuur 1.1 JMPIjvm::checkException(env);
596
|
597 schuur 1.13 if (!mode24) {
598 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,true,jCc);
599 JMPIjvm::checkException(env);
600
601 STAT_PMS_PROVIDEREND;
602
603 handler.processing();
604 if (jVec) {
605 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
606 JMPIjvm::checkException(env);
607 jobject jCop=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
608 JMPIjvm::checkException(env);
609 CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod
610 (jCop,JMPIjvm::jv.CIMObjectPathCInst));
611 JMPIjvm::checkException(env);
612 handler.deliver(*cop);
613 }
|
614 schuur 1.1 }
|
615 schuur 1.13 handler.complete();
616 }
617 else {
618 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jCc);
619 JMPIjvm::checkException(env);
620
621 STAT_PMS_PROVIDEREND;
622
623 handler.processing();
624 if (jAr) {
625 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
626 JMPIjvm::checkException(env);
627 jobject jCop=env->GetObjectArrayElement(jAr,i);
628 JMPIjvm::checkException(env);
629 CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod
630 (jCop,JMPIjvm::jv.CIMObjectPathCInst));
631 JMPIjvm::checkException(env);
632 handler.deliver(*cop);
633 }
634 }
635 handler.complete();
|
636 schuur 1.1 }
637 }
638 HandlerCatch(handler);
639
640 if (env) JMPIjvm::detachThread();
641
642 PEG_METHOD_EXIT();
643
644 return(response);
645 }
646
647 Message * JMPIProviderManager::handleCreateInstanceRequest(const Message * message) throw()
648 {
649 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
650 "JMPIProviderManager::handleCreateInstanceRequest");
651
652 HandlerIntro(CreateInstance,message,request,response,
653 handler,CIMObjectPath());
654 JNIEnv *env=NULL;
655 try {
656 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
657 schuur 1.1 "JMPIProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
658 System::getHostName(),
659 request->nameSpace.getString(),
660 request->newInstance.getPath().getClassName().getString());
661
662 // make target object path
663 CIMObjectPath objectPath(
664 System::getHostName(),
665 request->nameSpace,
666 request->newInstance.getPath().getClassName(),
667 request->newInstance.getPath().getKeyBindings());
668
669 // resolve provider name
|
670 kumpf 1.2 ProviderName name = _resolveProviderName(
671 request->operationContext.get(ProviderIdContainer::NAME));
|
672 schuur 1.1
673 // get cached or load new provider module
674 JMPIProvider::OpProviderHolder ph =
675 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),
676 String::EMPTY);
677
678 // convert arguments
679 OperationContext context;
680
|
681 se.gupta 1.9 context.insert(request->operationContext.get(IdentityContainer::NAME));
682 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
683 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
684 schuur 1.1
685 // forward request
686 JMPIProvider & pr=ph.GetProvider();
687
688 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
689 "Calling provider.createInstance: " +
690 ph.GetProvider().getName());
691
|
692 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::createInstances"<<endl);
|
693 schuur 1.12
|
694 schuur 1.1 JvmVector *jv;
695 env=JMPIjvm::attachThread(&jv);
696
697 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
698 jv->CIMObjectPathNewI,(jint)&objectPath);
699 JMPIjvm::checkException(env);
700 jobject jInst=env->NewObject(jv->CIMInstanceClassRef,
701 jv->CIMInstanceNewI,(jint)&request->newInstance);
702 JMPIjvm::checkException(env);
703
704 JMPIProvider::pm_service_op_lock op_lock(&pr);
705
706 STAT_GETSTARTTIME;
707
708 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"createInstance",
709 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;");
710 JMPIjvm::checkException(env);
711
712 jobject jCop=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jInst);
713
714 STAT_PMS_PROVIDEREND;
715 schuur 1.1
716 JMPIjvm::checkException(env);
717 handler.processing();
718 if (jCop) {
719 CIMObjectPath cop=*((CIMObjectPath*)env->CallIntMethod(jCop,JMPIjvm::jv.CIMObjectPathCInst));
720 handler.deliver(cop);
721 }
722 handler.complete();
723 }
724 HandlerCatch(handler);
725
726 if (env) JMPIjvm::detachThread();
727
728 PEG_METHOD_EXIT();
729
730 return(response);
731 }
732
733 Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw()
734 {
735 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
736 schuur 1.1 "JMPIProviderManager::handleModifyInstanceRequest");
737
738 HandlerIntroVoid(ModifyInstance,message,request,response,handler);
739 JNIEnv *env=NULL;
|
740 schuur 1.13 Boolean mode24=false;
741 CIMPropertyList propertyList;
742 jobjectArray pl=NULL;
743
|
744 schuur 1.1 try {
745 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
746 konrad.r 1.15 "JMPIProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
|
747 schuur 1.1 System::getHostName(),
748 request->nameSpace.getString(),
749 request->modifiedInstance.getPath().getClassName().getString());
750
751 // make target object path
752 CIMObjectPath objectPath(
753 System::getHostName(),
754 request->nameSpace,
755 request->modifiedInstance.getPath ().getClassName(),
756 request->modifiedInstance.getPath ().getKeyBindings());
757
758 // resolve provider name
|
759 kumpf 1.2 ProviderName name = _resolveProviderName(
760 request->operationContext.get(ProviderIdContainer::NAME));
|
761 schuur 1.1
762 // get cached or load new provider module
763 JMPIProvider::OpProviderHolder ph =
764 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
765
766 // convert arguments
767 OperationContext context;
768
|
769 se.gupta 1.9 context.insert(request->operationContext.get(IdentityContainer::NAME));
770 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
771 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
772 schuur 1.1
773 CIMPropertyList propertyList(request->propertyList);
774
775 // forward request
776 JMPIProvider & pr=ph.GetProvider();
777
778 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
779 "Calling provider.modifyInstance: " + pr.getName());
780
|
781 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::modifyInstance"<<endl);
|
782 schuur 1.1
783 JvmVector *jv;
784 env=JMPIjvm::attachThread(&jv);
785
786 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
|
787 schuur 1.12 jv->CIMObjectPathNewI,(jint)&objectPath);
|
788 schuur 1.1 JMPIjvm::checkException(env);
789 jobject jInst=env->NewObject(jv->CIMInstanceClassRef,
790 jv->CIMInstanceNewI,(jint)&request->modifiedInstance);
791 JMPIjvm::checkException(env);
792
793 JMPIProvider::pm_service_op_lock op_lock(&pr);
794
795 STAT_GETSTARTTIME;
796
797 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"setInstance",
798 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V");
|
799 schuur 1.13
800 if (id==NULL) {
801 env->ExceptionClear();
802 id=env->GetMethodID((jclass)pr.jProviderClass,"setInstance",
803 "(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V");
804 JMPIjvm::checkException(env);
805 mode24=true;
806 pl=getList(jv,env,request->propertyList);
807 }
|
808 schuur 1.1 JMPIjvm::checkException(env);
809
|
810 schuur 1.13 if (!mode24) env->CallVoidMethod((jobject)pr.jProvider,id,jRef,jInst);
811 else env->CallVoidMethod((jobject)pr.jProvider,id,jRef,jInst,pl);
812
|
813 schuur 1.1 STAT_PMS_PROVIDEREND;
814
815 JMPIjvm::checkException(env);
816 JMPIjvm::detachThread();
817 }
818 HandlerCatch(handler);
819
820 if (env) JMPIjvm::detachThread();
821
822 PEG_METHOD_EXIT();
823
824 return(response);
825 }
826
827 Message * JMPIProviderManager::handleDeleteInstanceRequest(const Message * message) throw()
828 {
829 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
830 "JMPIProviderManager::handleDeleteInstanceRequest");
831
832 HandlerIntroVoid(DeleteInstance,message,request,response,
833 handler);
834 schuur 1.1 JNIEnv *env=NULL;
835 try {
836 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
837 konrad.r 1.15 "JMPIProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
|
838 schuur 1.1 System::getHostName(),
839 request->nameSpace.getString(),
840 request->instanceName.getClassName().getString());
841
842 // make target object path
843 CIMObjectPath objectPath(
844 System::getHostName(),
845 request->nameSpace,
846 request->instanceName.getClassName(),
847 request->instanceName.getKeyBindings());
848
849 // resolve provider name
|
850 kumpf 1.2 ProviderName name = _resolveProviderName(
851 request->operationContext.get(ProviderIdContainer::NAME));
|
852 schuur 1.1
853 // get cached or load new provider module
854 JMPIProvider::OpProviderHolder ph =
855 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
856
857 // convert arguments
858 OperationContext context;
859
|
860 se.gupta 1.9 context.insert(request->operationContext.get(IdentityContainer::NAME));
861 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
862 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
863 schuur 1.1
864 // forward request
865 JMPIProvider & pr=ph.GetProvider();
866
867 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
868 "Calling provider.deleteInstance: " + pr.getName());
869
|
870 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::modifyInstance"<<endl);
|
871 schuur 1.1
872 JvmVector *jv;
873 env=JMPIjvm::attachThread(&jv);
874
875 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
876 jv->CIMObjectPathNewI,(jint)&objectPath);
877 JMPIjvm::checkException(env);
878
879 JMPIProvider::pm_service_op_lock op_lock(&pr);
880
881 STAT_GETSTARTTIME;
882
883 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"deleteInstance",
884 "(Lorg/pegasus/jmpi/CIMObjectPath;)V");
885 JMPIjvm::checkException(env);
886
887 env->CallVoidMethod((jobject)pr.jProvider,id,jRef);
888
889 STAT_PMS_PROVIDEREND;
890
891 JMPIjvm::checkException(env);
892 schuur 1.1 JMPIjvm::detachThread();
893 }
894 HandlerCatch(handler);
895
896 if (env) JMPIjvm::detachThread();
897 PEG_METHOD_EXIT();
898
899 return(response);
900 }
901
902
903 Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw()
904 {
905 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
906 "JMPIProviderManager::handleAssociatorsRequest");
907
908 HandlerIntro(Associators,message,request,response,
909 handler,Array<CIMObject>());
910 JNIEnv *env=NULL;
|
911 schuur 1.13 Boolean mode24=false;
912 CIMPropertyList propertyList;
913 jobjectArray pl=NULL;
914
|
915 schuur 1.1 try {
916 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
917 "JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2",
918 System::getHostName(),
919 request->nameSpace.getString(),
920 request->objectName.getClassName().getString());
921
922 // make target object path
923 CIMObjectPath objectPath(
924 System::getHostName(),
925 request->nameSpace,
926 request->objectName.getClassName());
927
928 objectPath.setKeyBindings(request->objectName.getKeyBindings());
929
930 CIMObjectPath assocPath(
931 System::getHostName(),
932 request->nameSpace,
933 request->assocClass.getString());
934
935 // resolve provider name
|
936 kumpf 1.2 ProviderName name = _resolveProviderName(
937 request->operationContext.get(ProviderIdContainer::NAME));
|
938 schuur 1.1
939 // get cached or load new provider module
940 JMPIProvider::OpProviderHolder ph =
941 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
942
943 // convert arguments
944 OperationContext context;
945
|
946 se.gupta 1.9 context.insert(request->operationContext.get(IdentityContainer::NAME));
947 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
948 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
949 schuur 1.1
950 // forward request
951 JMPIProvider & pr=ph.GetProvider();
952
953 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
954 "Calling provider.associators: " + pr.getName());
955
|
956 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::associators"<<
|
957 schuur 1.1 " role: >"<<request->role<<"< aCls "<<
|
958 kumpf 1.2 request->assocClass<<endl);
|
959 schuur 1.1
960 JvmVector *jv;
961 env=JMPIjvm::attachThread(&jv);
962
963 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
|
964 schuur 1.12 jv->CIMObjectPathNewI,(jint)&objectPath);
|
965 schuur 1.1 JMPIjvm::checkException(env);
966
967 jstring rClass=env->NewStringUTF(request->resultClass.getString().getCString());
968 jstring rRole=env->NewStringUTF(request->role.getCString());
969 jstring resRole=env->NewStringUTF(request->resultRole.getCString());
970 JMPIjvm::checkException(env);
971
972 JMPIProvider::pm_service_op_lock op_lock(&pr);
973
974 STAT_GETSTARTTIME;
975
976 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"associators",
977 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"
978 "Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
|
979 schuur 1.12
|
980 schuur 1.13 if (id==NULL) {
981 env->ExceptionClear();
982 id=env->GetMethodID((jclass)pr.jProviderClass,"associators",
983 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"
984 "Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
985 JMPIjvm::checkException(env);
986 mode24=true;
987 }
|
988 schuur 1.1 JMPIjvm::checkException(env);
989
|
990 schuur 1.13 pl=getList(jv,env,request->propertyList);
991
992 if (!mode24) {
993 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
994 rClass,rRole,resRole,false,false,pl);
995 JMPIjvm::checkException(env);
996
997 STAT_PMS_PROVIDEREND;
|
998 schuur 1.1
|
999 schuur 1.13 handler.processing();
1000 if (jVec) {
1001 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
1002 JMPIjvm::checkException(env);
1003 jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1004 JMPIjvm::checkException(env);
1005 CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));
1006 JMPIjvm::checkException(env);
|
1007 schuur 1.1
|
1008 schuur 1.13 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
|
1009 schuur 1.1 inst.getClassName(),false,true,true,CIMPropertyList());
|
1010 schuur 1.13 const CIMObjectPath& op=inst.getPath();
1011 CIMObjectPath iop=inst.buildPath(cls);
1012 iop.setNameSpace(op.getNameSpace());
1013 inst.setPath(iop);
1014
1015 handler.deliver(inst);
1016 }
1017 }
|
1018 schuur 1.1 }
|
1019 schuur 1.13
1020 else {
1021 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
1022 rClass,rRole,resRole,false,false,pl);
1023 JMPIjvm::checkException(env);
1024
1025 STAT_PMS_PROVIDEREND;
1026
1027 handler.processing();
1028 if (jAr) {
1029 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
1030 JMPIjvm::checkException(env);
1031 jobject jInst=env->GetObjectArrayElement(jAr,i);
1032 JMPIjvm::checkException(env);
1033 CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));
1034 JMPIjvm::checkException(env);
1035
1036 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
1037 inst.getClassName(),false,true,true,CIMPropertyList());
1038 const CIMObjectPath& op=inst.getPath();
1039 CIMObjectPath iop=inst.buildPath(cls);
1040 schuur 1.13 iop.setNameSpace(op.getNameSpace());
1041 inst.setPath(iop);
1042
1043 handler.deliver(inst);
1044 }
1045 }
1046 }
|
1047 schuur 1.1 handler.complete();
1048 }
1049 HandlerCatch(handler);
|
1050 schuur 1.13
1051 if (env) JMPIjvm::detachThread();
1052
|
1053 schuur 1.1 PEG_METHOD_EXIT();
1054
1055 return(response);
1056 }
|
1057 schuur 1.13
|
1058 schuur 1.1
1059
1060 Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw()
1061 {
1062 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1063 "JMPIProviderManager::handleAssociatorNamesRequest");
1064
1065 HandlerIntro(AssociatorNames,message,request,response,
1066 handler,Array<CIMObjectPath>());
1067 JNIEnv *env=NULL;
|
1068 schuur 1.13 Boolean mode24=false;
1069 CIMPropertyList propertyList;
1070 jobjectArray pl=NULL;
1071
|
1072 schuur 1.1 try {
1073 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1074 "JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2",
1075 System::getHostName(),
1076 request->nameSpace.getString(),
1077 request->objectName.getClassName().getString());
1078
1079 // make target object path
1080 CIMObjectPath objectPath(
1081 System::getHostName(),
1082 request->nameSpace,
1083 request->objectName.getClassName());
1084
1085 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1086
1087 CIMObjectPath assocPath(
1088 System::getHostName(),
1089 request->nameSpace,
1090 request->assocClass.getString());
1091
1092 // resolve provider name
|
1093 kumpf 1.2 ProviderName name = _resolveProviderName(
1094 request->operationContext.get(ProviderIdContainer::NAME));
|
1095 schuur 1.1
1096 // get cached or load new provider module
1097 JMPIProvider::OpProviderHolder ph =
1098 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1099
1100 // convert arguments
1101 OperationContext context;
1102
|
1103 se.gupta 1.9 context.insert(request->operationContext.get(IdentityContainer::NAME));
1104 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1105 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1106 schuur 1.1
1107 // forward request
1108 JMPIProvider & pr=ph.GetProvider();
1109
1110 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1111 "Calling provider.associatorNames: " + pr.getName());
1112
|
1113 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::associatorNames"<<
|
1114 schuur 1.1 " role: >"<<request->role<<"< aCls "<<
|
1115 kumpf 1.2 request->assocClass<<endl);
|
1116 schuur 1.1
1117 JvmVector *jv;
1118 env=JMPIjvm::attachThread(&jv);
1119
1120 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
1121 jv->CIMObjectPathNewI,(jint)&objectPath);
1122 JMPIjvm::checkException(env);
1123
1124 jstring rClass=env->NewStringUTF(request->resultClass.getString().getCString());
1125 jstring rRole=env->NewStringUTF(request->role.getCString());
1126 jstring resRole=env->NewStringUTF(request->resultRole.getCString());
1127 JMPIjvm::checkException(env);
1128
1129 JMPIProvider::pm_service_op_lock op_lock(&pr);
1130
1131 STAT_GETSTARTTIME;
1132
1133 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"associatorNames",
1134 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"
1135 "Ljava/lang/String;)Ljava/util/Vector;");
|
1136 schuur 1.13
1137 if (id==NULL) {
1138 env->ExceptionClear();
1139 id=env->GetMethodID((jclass)pr.jProviderClass,"associatorNames",
1140 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"
1141 "Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
1142 JMPIjvm::checkException(env);
1143 mode24=true;
1144 }
|
1145 schuur 1.1 JMPIjvm::checkException(env);
1146
|
1147 schuur 1.13 if (!mode24) {
1148 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
1149 rClass,rRole,resRole);
1150 JMPIjvm::checkException(env);
1151
1152 STAT_PMS_PROVIDEREND;
1153
1154 handler.processing();
1155 if (jVec) {
1156 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
1157 JMPIjvm::checkException(env);
1158 jobject jCop=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1159 JMPIjvm::checkException(env);
1160 CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod
1161 (jCop,JMPIjvm::jv.CIMObjectPathCInst));
1162 JMPIjvm::checkException(env);
1163 handler.deliver(*cop);
1164 }
1165 }
1166 handler.complete();
1167 }
1168 schuur 1.13
1169 else {
1170 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
|
1171 schuur 1.1 rClass,rRole,resRole);
|
1172 schuur 1.13 JMPIjvm::checkException(env);
|
1173 schuur 1.1
|
1174 schuur 1.13 STAT_PMS_PROVIDEREND;
|
1175 schuur 1.1
|
1176 schuur 1.13 handler.processing();
1177 if (jAr) {
1178 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
1179 JMPIjvm::checkException(env);
1180 jobject jCop=env->GetObjectArrayElement(jAr,i);
1181 JMPIjvm::checkException(env);
1182 CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod
1183 (jCop,JMPIjvm::jv.CIMObjectPathCInst));
1184 JMPIjvm::checkException(env);
1185 handler.deliver(*cop);
1186 }
1187 }
1188 handler.complete();
1189 }
|
1190 schuur 1.1 }
1191 HandlerCatch(handler);
|
1192 schuur 1.12
|
1193 schuur 1.1 if (env) JMPIjvm::detachThread();
|
1194 schuur 1.12
|
1195 schuur 1.1 PEG_METHOD_EXIT();
1196
1197 return(response);
1198 }
1199
1200
1201 Message * JMPIProviderManager::handleReferencesRequest(const Message * message) throw()
1202 {
1203 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1204 "JMPIProviderManager::handleReferencesRequest");
1205
1206 HandlerIntro(References,message,request,response,
1207 handler,Array<CIMObject>());
1208 JNIEnv *env=NULL;
|
1209 schuur 1.13 Boolean mode24=false;
1210 CIMPropertyList propertyList;
1211 jobjectArray pl=NULL;
1212
|
1213 schuur 1.1 try {
1214 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
1215 konrad.r 1.15 "JMPIProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2",
|
1216 schuur 1.1 System::getHostName(),
1217 request->nameSpace.getString(),
1218 request->objectName.getClassName().getString());
1219
1220 // make target object path
1221 CIMObjectPath objectPath(
1222 System::getHostName(),
1223 request->nameSpace,
1224 request->objectName.getClassName());
1225
1226 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1227
1228 CIMObjectPath resultPath(
1229 System::getHostName(),
1230 request->nameSpace,
1231 request->resultClass.getString());
1232
1233 // resolve provider name
|
1234 kumpf 1.2 ProviderName name = _resolveProviderName(
1235 request->operationContext.get(ProviderIdContainer::NAME));
|
1236 schuur 1.1
1237 // get cached or load new provider module
1238 JMPIProvider::OpProviderHolder ph =
1239 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1240
1241 // convert arguments
1242 OperationContext context;
1243
|
1244 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
1245 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1246 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1247 schuur 1.1
1248 // forward request
|
1249 schuur 1.12 JMPIProvider & pr=ph.GetProvider();
|
1250 schuur 1.1
1251 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1252 "Calling provider.references: " + pr.getName());
1253
|
1254 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::references"<<" role: >"<<request->role<<"< aCls "<<
|
1255 schuur 1.12 request->resultClass<<endl);
|
1256 schuur 1.1
|
1257 schuur 1.12 JvmVector *jv;
|
1258 schuur 1.1 env=JMPIjvm::attachThread(&jv);
1259
1260 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
|
1261 schuur 1.12 jv->CIMObjectPathNewI,(jint)&objectPath);
1262 JMPIjvm::checkException(env);
|
1263 schuur 1.1
1264 jstring rRole=env->NewStringUTF(request->role.getCString());
|
1265 schuur 1.12 JMPIjvm::checkException(env);
|
1266 schuur 1.1
1267 JMPIProvider::pm_service_op_lock op_lock(&pr);
1268
1269 STAT_GETSTARTTIME;
1270
1271 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"references",
1272 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
|
1273 schuur 1.12 "ZZ[Ljava/lang/String;)Ljava/util/Vector;");
1274
|
1275 schuur 1.13 if (id==NULL) {
1276 env->ExceptionClear();
1277 id=env->GetMethodID((jclass)pr.jProviderClass,"references",
1278 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
1279 "ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
1280 JMPIjvm::checkException(env);
1281 mode24=true;
1282 }
|
1283 schuur 1.1 JMPIjvm::checkException(env);
1284
|
1285 schuur 1.13 pl=getList(jv,env,request->propertyList);
1286
1287 if (!mode24) {
1288 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
1289 rRole,false,false,pl);
1290 JMPIjvm::checkException(env);
1291
1292 STAT_PMS_PROVIDEREND;
1293
1294 handler.processing();
1295 if (jVec) {
1296 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
1297 JMPIjvm::checkException(env);
1298 jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1299 JMPIjvm::checkException(env);
1300 CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));
1301 JMPIjvm::checkException(env);
1302
1303 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
1304 inst.getClassName(),false,true,true,CIMPropertyList());
1305 const CIMObjectPath& op=inst.getPath();
1306 schuur 1.13 CIMObjectPath iop=inst.buildPath(cls);
1307 iop.setNameSpace(op.getNameSpace());
1308 inst.setPath(iop);
1309
1310 handler.deliver(inst);
1311 }
1312 }
1313 handler.complete();
1314 }
1315
1316 else {
1317 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
1318 rRole,false,false,pl);
1319 JMPIjvm::checkException(env);
|
1320 schuur 1.1
|
1321 schuur 1.13 STAT_PMS_PROVIDEREND;
|
1322 schuur 1.1
|
1323 schuur 1.13 handler.processing();
1324 if (jAr) {
1325 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
1326 JMPIjvm::checkException(env);
1327 jobject jInst=env->GetObjectArrayElement(jAr,i);
1328 JMPIjvm::checkException(env);
1329 CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));
1330 JMPIjvm::checkException(env);
|
1331 schuur 1.12
|
1332 schuur 1.13 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
|
1333 schuur 1.12 inst.getClassName(),false,true,true,CIMPropertyList());
|
1334 schuur 1.13 const CIMObjectPath& op=inst.getPath();
1335 CIMObjectPath iop=inst.buildPath(cls);
1336 iop.setNameSpace(op.getNameSpace());
1337 inst.setPath(iop);
|
1338 schuur 1.12
|
1339 schuur 1.13 handler.deliver(inst);
1340 }
|
1341 schuur 1.12 }
|
1342 schuur 1.13 handler.complete();
1343 }
1344
|
1345 schuur 1.1 }
1346 HandlerCatch(handler);
|
1347 schuur 1.12
1348 if (env) JMPIjvm::detachThread();
1349
|
1350 schuur 1.1 PEG_METHOD_EXIT();
1351
1352 return(response);
1353 }
1354
1355
1356 Message * JMPIProviderManager::handleReferenceNamesRequest(const Message * message) throw()
1357 {
1358 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1359 "JMPIProviderManager::handleReferenceNamesRequest");
1360
1361 HandlerIntro(ReferenceNames,message,request,response,
1362 handler,Array<CIMObjectPath>());
1363 JNIEnv *env=NULL;
|
1364 schuur 1.13 Boolean mode24=false;
1365 CIMPropertyList propertyList;
1366 jobjectArray pl=NULL;
1367
|
1368 schuur 1.1 try {
1369 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1370 "JMPIProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
1371 System::getHostName(),
1372 request->nameSpace.getString(),
1373 request->objectName.getClassName().getString());
1374
1375 // make target object path
1376 CIMObjectPath objectPath(
1377 System::getHostName(),
1378 request->nameSpace,
1379 request->objectName.getClassName());
1380
1381 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1382
1383 CIMObjectPath resultPath(
1384 System::getHostName(),
1385 request->nameSpace,
1386 request->resultClass.getString());
1387
1388 // resolve provider name
|
1389 kumpf 1.2 ProviderName name = _resolveProviderName(
1390 request->operationContext.get(ProviderIdContainer::NAME));
|
1391 schuur 1.1
1392 // get cached or load new provider module
1393 JMPIProvider::OpProviderHolder ph =
1394 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1395
1396 // convert arguments
1397 OperationContext context;
1398
|
1399 schuur 1.11 context.insert(request->operationContext.get(IdentityContainer::NAME));
1400 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1401 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1402 schuur 1.1
1403 JMPIProvider & pr=ph.GetProvider();
1404
1405 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1406 "Calling provider.referenceNames: " + pr.getName());
1407
|
1408 schuur 1.12
|
1409 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::referenceNames"<<" role: >"<<request->role<<"< aCls "<<
1410 request->resultClass<<endl);
|
1411 schuur 1.1
1412 JvmVector *jv;
1413 env=JMPIjvm::attachThread(&jv);
1414
1415 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
|
1416 schuur 1.11 jv->CIMObjectPathNewI,(jint)&objectPath);
|
1417 schuur 1.1 JMPIjvm::checkException(env);
|
1418 schuur 1.11
|
1419 schuur 1.1 jstring rRole=env->NewStringUTF(request->role.getCString());
1420 JMPIjvm::checkException(env);
1421
1422 JMPIProvider::pm_service_op_lock op_lock(&pr);
1423
1424 STAT_GETSTARTTIME;
1425
1426 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"referenceNames",
1427 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
|
1428 schuur 1.11
|
1429 schuur 1.13 if (id==NULL) {
1430 env->ExceptionClear();
1431 id=env->GetMethodID((jclass)pr.jProviderClass,"referenceNames",
1432 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
1433 JMPIjvm::checkException(env);
1434 mode24=true;
1435 }
|
1436 schuur 1.1 JMPIjvm::checkException(env);
1437
|
1438 schuur 1.13 if (!mode24) {
1439 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,rRole);
1440 JMPIjvm::checkException(env);
1441
1442 STAT_PMS_PROVIDEREND;
1443
1444 handler.processing();
1445 if (jVec) {
1446 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
1447 JMPIjvm::checkException(env);
1448 jobject jCop=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1449 JMPIjvm::checkException(env);
1450 CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod
1451 (jCop,JMPIjvm::jv.CIMObjectPathCInst));
1452 JMPIjvm::checkException(env);
1453 handler.deliver(*cop);
1454 }
1455 }
1456 handler.complete();
1457 }
1458
1459 schuur 1.13 else {
1460 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,rRole);
1461 JMPIjvm::checkException(env);
|
1462 schuur 1.1
|
1463 schuur 1.13 STAT_PMS_PROVIDEREND;
|
1464 schuur 1.1
|
1465 schuur 1.13 handler.processing();
1466 if (jAr) {
1467 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
1468 JMPIjvm::checkException(env);
1469 jobject jCop=env->GetObjectArrayElement(jAr,i);
1470 JMPIjvm::checkException(env);
1471 CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod
1472 (jCop,JMPIjvm::jv.CIMObjectPathCInst));
1473 JMPIjvm::checkException(env);
1474 handler.deliver(*cop);
1475 }
1476 }
1477 handler.complete();
1478 }
|
1479 schuur 1.1 }
1480 HandlerCatch(handler);
|
1481 schuur 1.11
1482 if (env) JMPIjvm::detachThread();
1483
|
1484 schuur 1.1 PEG_METHOD_EXIT();
1485
1486 return(response);
1487 }
1488
1489
1490 Message * JMPIProviderManager::handleInvokeMethodRequest(const Message * message) throw()
1491 {
1492 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1493 "JMPIProviderManager::handleInvokeMethodRequest");
1494
1495 HandlerIntroMethod(InvokeMethod,message,request,response,
1496 handler);
|
1497 schuur 1.11 JNIEnv *env=NULL;
|
1498 schuur 1.13 Boolean mode24=false;
1499
|
1500 schuur 1.1 try {
1501 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1502 "JMPIProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2",
1503 System::getHostName(),
1504 request->nameSpace.getString(),
1505 request->instanceName.getClassName().getString());
1506
1507 // make target object path
1508 CIMObjectPath objectPath(
1509 System::getHostName(),
1510 request->nameSpace,
1511 request->instanceName.getClassName(),
1512 request->instanceName.getKeyBindings());
1513
1514 // resolve provider name
|
1515 kumpf 1.2 ProviderName name = _resolveProviderName(
1516 request->operationContext.get(ProviderIdContainer::NAME));
|
1517 schuur 1.1
1518 // get cached or load new provider module
1519 JMPIProvider::OpProviderHolder ph =
1520 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1521
1522 // convert arguments
1523 OperationContext context;
1524
|
1525 schuur 1.11 context.insert(request->operationContext.get(IdentityContainer::NAME));
1526 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1527 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1528 schuur 1.1
1529 JMPIProvider & pr=ph.GetProvider();
1530
1531 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1532 "Calling provider.invokeMethod: " + pr.getName());
1533
|
1534 schuur 1.11 JvmVector *jv;
1535 env=JMPIjvm::attachThread(&jv);
1536
1537 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
1538 jv->CIMObjectPathNewI,(jint)&objectPath);
1539 JMPIjvm::checkException(env);
1540
1541 jstring jMethod=env->NewStringUTF(request->methodName.getString().getCString());
1542 JMPIjvm::checkException(env);
1543
|
1544 schuur 1.1 STAT_GETSTARTTIME;
1545
|
1546 schuur 1.11 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"invokeMethod",
1547 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
1548 "Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;");
|
1549 schuur 1.13
1550 if (id==NULL) {
1551 env->ExceptionClear();
1552 id=env->GetMethodID((jclass)pr.jProviderClass,"invokeMethod",
1553 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
1554 "[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");
1555 JMPIjvm::checkException(env);
1556 mode24=true;
1557 }
|
1558 schuur 1.11 JMPIjvm::checkException(env);
1559
|
1560 schuur 1.13 if (!mode24) {
1561 jobject jVecIn=env->NewObject(jv->VectorClassRef,jv->VectorNew);
1562 JMPIjvm::checkException(env);
1563 for (int i=0,m=request->inParameters.size(); i<m; i++) {
1564 const CIMParamValue & parm=request->inParameters[i];
1565 const CIMValue v=parm.getValue();
1566 CIMProperty *p=new CIMProperty(parm.getParameterName(),v,v.getArraySize());
1567 jobject prop=env->NewObject(jv->CIMPropertyClassRef,
1568 jv->CIMPropertyNewI,(jint)p);
1569 env->CallVoidMethod(jVecIn,jv->VectorAddElement,prop);
1570 }
1571
1572 jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
1573 JMPIjvm::checkException(env);
1574
1575 jobject jValue=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jMethod,jVecIn,jVecOut);
1576 JMPIjvm::checkException(env);
1577
1578 STAT_PMS_PROVIDEREND;
1579
1580 handler.processing();
|
1581 schuur 1.1
|
1582 schuur 1.13 CIMValue *v=((CIMValue*)env->CallIntMethod(jValue,JMPIjvm::jv.CIMValueCInst));
1583 handler.deliver(*v);
|
1584 schuur 1.1
|
1585 schuur 1.13 for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); i<m; i++) {
1586 JMPIjvm::checkException(env);
1587 jobject jProp=env->CallObjectMethod(jVecOut,JMPIjvm::jv.VectorElementAt,i);
1588 JMPIjvm::checkException(env);
1589 CIMProperty *p=((CIMProperty*)env->CallIntMethod(jProp,JMPIjvm::jv.PropertyCInst));
1590 JMPIjvm::checkException(env);
1591 handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));
1592 }
1593 handler.complete();
1594 }
1595 else {
1596 Uint32 m=request->inParameters.size();
|
1597 schuur 1.11
|
1598 schuur 1.13 jobjectArray jArIn=env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);
1599 for (Uint32 i=0; i<m; i++) {
1600 CIMParamValue *parm=new CIMParamValue(request->inParameters[i]);
1601 jobject jArg=env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,(jint)parm);
1602 env->SetObjectArrayElement(jArIn,i,jArg);
1603 }
1604 jobjectArray jArOut=env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);
|
1605 schuur 1.1
|
1606 schuur 1.13 jobject jValue=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jMethod,jArIn,jArOut);
|
1607 schuur 1.11 JMPIjvm::checkException(env);
|
1608 schuur 1.13
1609 STAT_PMS_PROVIDEREND;
1610
1611 handler.processing();
1612
1613 CIMValue *v=((CIMValue*)env->CallIntMethod(jValue,JMPIjvm::jv.CIMValueCInst));
1614 handler.deliver(*v);
1615
1616 for (int i=0; i<24; i++) {
1617 jobject jArg=env->GetObjectArrayElement(jArOut,i);
1618 JMPIjvm::checkException(env);
1619 if (jArg==NULL) break;
1620 CIMParamValue *p=((CIMParamValue*)env->CallIntMethod(jArg,JMPIjvm::jv.ArgumentCInst));
1621 JMPIjvm::checkException(env);
1622 handler.deliverParamValue(*p);
1623 }
1624 handler.complete();
1625 }
|
1626 schuur 1.1 }
1627 HandlerCatch(handler);
|
1628 schuur 1.11
1629 if (env) JMPIjvm::detachThread();
1630
|
1631 schuur 1.1 PEG_METHOD_EXIT();
1632
|
1633 schuur 1.11 return(response);
|
1634 schuur 1.1 }
|
1635 schuur 1.12
|
1636 schuur 1.1 int LocateIndicationProviderNames(const CIMInstance& pInstance, const CIMInstance& pmInstance,
1637 String& providerName, String& location)
1638 {
1639 Uint32 pos = pInstance.findProperty(CIMName ("Name"));
1640 pInstance.getProperty(pos).getValue().get(providerName);
1641
1642 pos = pmInstance.findProperty(CIMName ("Location"));
1643 pmInstance.getProperty(pos).getValue().get(location);
1644 return 0;
1645 }
1646
1647 Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw()
1648 {
|
1649 konrad.r 1.15 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleCreateSubscriptionRequest");
|
1650 schuur 1.1
1651 HandlerIntroInd(CreateSubscription,message,request,response,
1652 handler);
|
1653 schuur 1.12 JNIEnv *env=NULL;
|
1654 schuur 1.1 try {
1655 const CIMObjectPath &x=request->subscriptionInstance.getPath();
1656
|
1657 schuur 1.12 String providerName,providerLocation;
1658 CIMInstance req_provider, req_providerModule;
1659 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
1660 req_provider = pidc.getProvider();
1661 req_providerModule = pidc.getModule();
1662 LocateIndicationProviderNames(req_provider, req_providerModule,providerName,providerLocation);
|
1663 schuur 1.1
1664 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1665 "JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
1666 System::getHostName(),
1667 request->nameSpace.getString(),
1668 providerName);
1669
1670 String fileName = resolveFileName(providerLocation);
1671
1672 // get cached or load new provider module
1673 JMPIProvider::OpProviderHolder ph =
1674 providerManager.getProvider(fileName, providerName, String::EMPTY);
1675
1676 indProvRecord *prec=NULL;
|
1677 schuur 1.12 provTab.lookup(providerName,prec);
1678 if (prec) prec->count++;
|
1679 schuur 1.1 else {
|
1680 schuur 1.12 prec=new indProvRecord();
1681 provTab.insert(providerName,prec);
1682 }
|
1683 schuur 1.1
1684 indSelectRecord *srec=new indSelectRecord();
1685 const CIMObjectPath &sPath=request->subscriptionInstance.getPath();
|
1686 schuur 1.12 selxTab.insert(sPath.toString(),srec);
|
1687 schuur 1.1
1688 // convert arguments
1689 OperationContext *context=new OperationContext();
1690
|
1691 schuur 1.12 if (prec->ctx==NULL) {
1692 prec->ctx=context;
1693 }
1694
1695 context->insert(request->operationContext.get(IdentityContainer::NAME));
1696 context->insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1697 context->insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1698 context->insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
1699 context->insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME));
1700 context->insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME));
|
1701 schuur 1.1
1702 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
1703
|
1704 schuur 1.12 SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get
1705 (SubscriptionFilterConditionContainer::NAME);
1706
1707 CMPI_SelectExp *eSelx=new CMPI_SelectExp(*context,request->query,
1708 sub_cntr.getQueryLanguage());
1709 srec->eSelx=eSelx;
|
1710 schuur 1.1
|
1711 schuur 1.12 JMPIProvider & pr=ph.GetProvider();
|
1712 schuur 1.1
1713 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1714 "Calling provider.createSubscriptionRequest: " + pr.getName());
1715
|
1716 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::createSubscriptionRequest"<<endl);
|
1717 schuur 1.1
1718 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) {
1719 CIMObjectPath className(
1720 System::getHostName(),
1721 request->nameSpace,
1722 request->classNames[i]);
1723 eSelx->classNames.append(className);
1724 }
1725
1726 CIMPropertyList propertyList = request->propertyList;
|
1727 schuur 1.12 if (!propertyList.isNull()) {
|
1728 schuur 1.1 Array<CIMName> p=propertyList.getPropertyNameArray();
1729 int pCount=p.size();
1730 eSelx->props=(const char**)malloc((1+pCount)*sizeof(char*));
1731 for (int i=0; i<pCount; i++) {
1732 eSelx->props[i]=strdup(p[i].getString().getCString());
1733 }
1734 eSelx->props[pCount]=NULL;
1735 }
1736
|
1737 schuur 1.12 JvmVector *jv;
1738 env=JMPIjvm::attachThread(&jv);
1739
1740 jobject jSel=env->NewObject(jv->SelectExpClassRef,
1741 jv->SelectExpNewI,(jint)eSelx);
1742 JMPIjvm::checkException(env);
1743
1744 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
1745 jv->CIMObjectPathNewI,(jint)&eSelx->classNames[0]);
1746 JMPIjvm::checkException(env);
1747
1748 jstring jType=env->NewStringUTF(request->nameSpace.getString().getCString());
1749 JMPIjvm::checkException(env);
|
1750 schuur 1.1
1751 JMPIProvider::pm_service_op_lock op_lock(&pr);
1752
1753 STAT_GETSTARTTIME;
1754
|
1755 schuur 1.12 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"activateFilter",
1756 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
1757 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
1758 JMPIjvm::checkException(env);
1759
1760 env->CallVoidMethod((jobject)pr.jProvider,id,jSel,jType,
1761 jRef,(jboolean)0);
1762 JMPIjvm::checkException(env);
|
1763 schuur 1.1
1764 STAT_PMS_PROVIDEREND;
1765
1766 }
1767 HandlerCatch(handler);
|
1768 schuur 1.12
|
1769 schuur 1.1 PEG_METHOD_EXIT();
1770
1771 return(response);
1772 }
1773
1774 Message * JMPIProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw()
1775 {
1776 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDeleteSubscriptionRequest");
1777
1778 HandlerIntroInd(DeleteSubscription,message,request,response,
1779 handler);
|
1780 schuur 1.12 JNIEnv *env=NULL;
|
1781 schuur 1.1 try {
|
1782 schuur 1.12 String providerName,providerLocation;
1783 CIMInstance req_provider, req_providerModule;
1784 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
1785 req_provider = pidc.getProvider();
1786 req_providerModule = pidc.getModule();
|
1787 se.gupta 1.9
|
1788 schuur 1.12 LocateIndicationProviderNames(req_provider, req_providerModule,
1789 providerName,providerLocation);
|
1790 schuur 1.1
1791 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1792 "JMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
1793 System::getHostName(),
1794 request->nameSpace.getString(),
1795 providerName);
1796
1797 String fileName = resolveFileName(providerLocation);
1798
1799 // get cached or load new provider module
1800 JMPIProvider::OpProviderHolder ph =
1801 providerManager.getProvider(fileName, providerName, String::EMPTY);
1802
1803
1804 indProvRecord *prec=NULL;
|
1805 schuur 1.12 provTab.lookup(providerName,prec);
1806 if (--prec->count<=0) {
1807 provTab.remove(providerName);
1808 prec=NULL;
1809 }
|
1810 schuur 1.1
1811 indSelectRecord *srec=NULL;
1812 const CIMObjectPath &sPath=request->subscriptionInstance.getPath();
|
1813 schuur 1.12 String sPathString=sPath.toString();
1814 selxTab.lookup(sPathString,srec);
|
1815 schuur 1.1
1816 CMPI_SelectExp *eSelx=srec->eSelx;
|
1817 schuur 1.12 selxTab.remove(sPathString);
|
1818 schuur 1.1
|
1819 schuur 1.12 // convert arguments
|
1820 schuur 1.1 OperationContext context;
1821
|
1822 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
1823 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1824 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1825 context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
1826 context.insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME));
1827
|
1828 schuur 1.1 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
1829
|
1830 schuur 1.12 JMPIProvider & pr=ph.GetProvider();
|
1831 schuur 1.1
1832 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1833 "Calling provider.deleteSubscriptionRequest: " + pr.getName());
1834
|
1835 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::deleteSubscriptionRequest"<<endl);
|
1836 schuur 1.1
|
1837 schuur 1.12 JvmVector *jv;
1838 env=JMPIjvm::attachThread(&jv);
1839
1840 jobject jSel=env->NewObject(jv->SelectExpClassRef,
1841 jv->SelectExpNewI,(jint)eSelx);
1842 JMPIjvm::checkException(env);
1843
1844 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
1845 jv->CIMObjectPathNewI,(jint)&eSelx->classNames[0]);
1846 JMPIjvm::checkException(env);
1847
1848 jstring jType=env->NewStringUTF(request->nameSpace.getString().getCString());
1849 JMPIjvm::checkException(env);
1850
|
1851 schuur 1.1 JMPIProvider::pm_service_op_lock op_lock(&pr);
1852
1853 STAT_GETSTARTTIME;
1854
|
1855 schuur 1.12 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"deActivateFilter",
1856 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
1857 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
1858 JMPIjvm::checkException(env);
|
1859 schuur 1.1
|
1860 schuur 1.12 env->CallVoidMethod((jobject)pr.jProvider,id,jSel,jType,
1861 jRef,(jboolean)(prec==NULL));
1862 JMPIjvm::checkException(env);
|
1863 schuur 1.1
1864 STAT_PMS_PROVIDEREND;
1865
|
1866 schuur 1.12 delete eSelx;
1867
|
1868 schuur 1.1 }
1869 HandlerCatch(handler);
|
1870 schuur 1.12
|
1871 schuur 1.1 PEG_METHOD_EXIT();
1872
1873 return(response);
1874 }
1875
1876 Message * JMPIProviderManager::handleEnableIndicationsRequest(const Message * message) throw()
1877 {
1878 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager:: handleEnableIndicationsRequest");
1879
1880 HandlerIntroInd(EnableIndications,message,request,response,
1881 handler);
1882 try {
1883 String providerName,providerLocation;
|
1884 se.gupta 1.9 CIMInstance req_provider, req_providerModule;
1885 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
1886 req_provider = pidc.getProvider();
1887 req_providerModule = pidc.getModule();
1888
1889 LocateIndicationProviderNames(req_provider, req_providerModule,
|
1890 schuur 1.1 providerName,providerLocation);
1891
1892 indProvRecord *provRec;
1893 if (provTab.lookup(providerName,provRec)) {
1894 provRec->enabled=true;
|
1895 kumpf 1.3 provRec->handler=new EnableIndicationsResponseHandler(
|
1896 schuur 1.12 request, response, req_provider, _indicationCallback);
|
1897 schuur 1.1 }
1898
1899 String fileName = resolveFileName(providerLocation);
1900
1901 // get cached or load new provider module
1902 JMPIProvider::OpProviderHolder ph =
1903 providerManager.getProvider(fileName, providerName, String::EMPTY);
1904
1905 }
1906 HandlerCatch(handler);
|
1907 schuur 1.12
|
1908 schuur 1.1 PEG_METHOD_EXIT();
1909
1910 return(response);
1911 }
1912
1913 Message * JMPIProviderManager::handleDisableIndicationsRequest(const Message * message) throw()
1914 {
1915 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager:: handleDisableIndicationsRequest");
1916
1917 HandlerIntroInd(DisableIndications,message,request,response,
1918 handler);
1919 try {
1920 String providerName,providerLocation;
|
1921 se.gupta 1.9 CIMInstance req_provider, req_providerModule;
1922 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
1923
1924 req_provider = pidc.getProvider();
1925 req_providerModule = pidc.getModule();
1926
1927 LocateIndicationProviderNames(req_provider, req_providerModule,
|
1928 schuur 1.1 providerName,providerLocation);
1929
1930 indProvRecord *provRec;
1931 if (provTab.lookup(providerName,provRec)) {
1932 provRec->enabled=false;
1933 if (provRec->handler) delete provRec->handler;
1934 provRec->handler=NULL;
1935 }
1936
1937 String fileName = resolveFileName(providerLocation);
1938
1939 // get cached or load new provider module
1940 JMPIProvider::OpProviderHolder ph =
1941 providerManager.getProvider(fileName, providerName, String::EMPTY);
1942 }
1943 HandlerCatch(handler);
|
1944 schuur 1.12
|
1945 schuur 1.1 PEG_METHOD_EXIT();
1946
1947 return(response);
|
1948 schuur 1.12 }
|
1949 schuur 1.1
1950 Message * JMPIProviderManager::handleDisableModuleRequest(const Message * message) throw()
1951 {
1952 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDisableModuleRequest");
1953
1954 CIMDisableModuleRequestMessage * request =
1955 dynamic_cast<CIMDisableModuleRequestMessage *>(const_cast<Message *>(message));
1956
1957 PEGASUS_ASSERT(request != 0);
1958
1959 // get provider module name
1960 String moduleName;
1961 CIMInstance mInstance = request->providerModule;
1962 Uint32 pos = mInstance.findProperty(CIMName ("Name"));
1963
1964 if(pos != PEG_NOT_FOUND)
1965 {
1966 mInstance.getProperty(pos).getValue().get(moduleName);
1967 }
1968
1969 Boolean disableProviderOnly = request->disableProviderOnly;
1970 schuur 1.1
1971 Array<Uint16> operationalStatus;
|
1972 kumpf 1.2 // Assume success.
|
1973 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
|
1974 schuur 1.1
|
1975 kumpf 1.2 //
|
1976 schuur 1.1 // Unload providers
|
1977 kumpf 1.2 //
|
1978 schuur 1.1 Array<CIMInstance> _pInstances = request->providers;
1979
1980 CIMDisableModuleResponseMessage * response =
1981 new CIMDisableModuleResponseMessage(
1982 request->messageId,
1983 CIMException(),
1984 request->queueIds.copyAndPop(),
1985 operationalStatus);
1986
1987 PEGASUS_ASSERT(response != 0);
1988
1989 // preserve message key
1990 response->setKey(request->getKey());
1991
1992 //
1993 // Set HTTP method in response from request
1994 //
1995 response->setHttpMethod (request->getHttpMethod ());
1996
1997 PEG_METHOD_EXIT();
1998
1999 schuur 1.1 return(response);
2000 }
2001
2002 Message * JMPIProviderManager::handleEnableModuleRequest(const Message * message) throw()
2003 {
2004 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnableModuleRequest");
2005
2006 CIMEnableModuleRequestMessage * request =
2007 dynamic_cast<CIMEnableModuleRequestMessage *>(const_cast<Message *>(message));
2008
2009 PEGASUS_ASSERT(request != 0);
2010
2011 Array<Uint16> operationalStatus;
|
2012 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
|
2013 schuur 1.1
2014 CIMEnableModuleResponseMessage * response =
2015 new CIMEnableModuleResponseMessage(
2016 request->messageId,
2017 CIMException(),
2018 request->queueIds.copyAndPop(),
2019 operationalStatus);
2020
2021 PEGASUS_ASSERT(response != 0);
2022
2023 // preserve message key
2024 response->setKey(request->getKey());
2025
2026 // Set HTTP method in response from request
2027 response->setHttpMethod (request->getHttpMethod ());
2028
2029 PEG_METHOD_EXIT();
2030
2031 return(response);
2032 }
2033
2034 schuur 1.1 Message * JMPIProviderManager::handleStopAllProvidersRequest(const Message * message) throw()
2035 {
2036 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleStopAllProvidersRequest");
2037
2038 CIMStopAllProvidersRequestMessage * request =
2039 dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message));
2040
2041 PEGASUS_ASSERT(request != 0);
2042
2043 CIMStopAllProvidersResponseMessage * response =
2044 new CIMStopAllProvidersResponseMessage(
2045 request->messageId,
2046 CIMException(),
2047 request->queueIds.copyAndPop());
2048
2049 PEGASUS_ASSERT(response != 0);
2050
2051 // preserve message key
2052 response->setKey(request->getKey());
2053
2054 // Set HTTP method in response from request
2055 schuur 1.1 response->setHttpMethod (request->getHttpMethod ());
2056
2057 // tell the provider manager to shutdown all the providers
2058 providerManager.shutdownAllProviders();
2059
2060 PEG_METHOD_EXIT();
2061
2062 return(response);
2063 }
2064
|
2065 kumpf 1.4 Message * JMPIProviderManager::handleInitializeProviderRequest(const Message * message)
2066 {
2067 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleInitializeProviderRequest");
2068
2069 HandlerIntroInit(InitializeProvider,message,request,response,handler);
2070
2071 try
2072 {
2073 // resolve provider name
2074 ProviderName name = _resolveProviderName(
2075 request->operationContext.get(ProviderIdContainer::NAME));
2076
2077 // get cached or load new provider module
2078 JMPIProvider::OpProviderHolder ph =
2079 providerManager.getProvider(name.getPhysicalName(),
2080 name.getLogicalName(), String::EMPTY);
2081
2082 }
2083 HandlerCatch(handler);
2084
2085 PEG_METHOD_EXIT();
2086 kumpf 1.4
2087 return(response);
2088 }
2089
|
2090 schuur 1.1 Message * JMPIProviderManager::handleUnsupportedRequest(const Message * message) throw()
2091 {
|
2092 konrad.r 1.16 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
2093 "JMPIProviderManager::handleUnsupportedRequest");
2094 CIMRequestMessage* request =
2095 dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
2096 PEGASUS_ASSERT(request != 0 );
2097
2098 CIMResponseMessage* response = request->buildResponse();
2099 response->cimException =
2100 PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
|
2101 schuur 1.1
2102 PEG_METHOD_EXIT();
|
2103 konrad.r 1.16 return response;
|
2104 schuur 1.1 }
2105
|
2106 kumpf 1.2 ProviderName JMPIProviderManager::_resolveProviderName(
2107 const ProviderIdContainer & providerId)
|
2108 schuur 1.1 {
|
2109 kumpf 1.2 String providerName;
2110 String fileName;
2111 String interfaceName;
2112 CIMValue genericValue;
2113
2114 genericValue = providerId.getProvider().getProperty(
2115 providerId.getProvider().findProperty("Name")).getValue();
2116 genericValue.get(providerName);
2117
2118 genericValue = providerId.getModule().getProperty(
2119 providerId.getModule().findProperty("Location")).getValue();
2120 genericValue.get(fileName);
2121 fileName = resolveFileName(fileName);
2122
2123 // ATTN: This attribute is probably not required
2124 genericValue = providerId.getModule().getProperty(
2125 providerId.getModule().findProperty("InterfaceType")).getValue();
2126 genericValue.get(interfaceName);
2127
2128 return ProviderName(providerName, fileName, interfaceName, 0);
|
2129 schuur 1.1 }
2130
2131 String JMPIProviderManager::resolveFileName(String fileName)
2132 {
2133 String name;
2134 #if defined(PEGASUS_OS_TYPE_WINDOWS)
2135 name = fileName; // + String(".dll");
2136 #elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
2137 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
2138 name.append(String("/") + fileName); // + String(".sl"));
2139 #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
2140 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
2141 name.append(String("/") + fileName); // + String(".so"));
2142 #elif defined(PEGASUS_OS_OS400)
2143 name = filrName;
2144 #else
2145 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
2146 name.append(String("/") + fileName); // + String(".so"));
2147 #endif
2148 return name;
2149 }
2150 schuur 1.1
2151 PEGASUS_NAMESPACE_END
|
Return to
JMPIProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI