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