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