pegasus/src/Pegasus/ProviderManager2/CMPI/CMPIProviderManager.cpp - annotate

Return to CMPIProviderManager.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI

1 karl 1.82 //%2006////////////////////////////////////////////////////////////////////////
2 marek 1.63 // 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 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; 8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. 9 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; 10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
11 karl 1.82 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; 12 // EMC Corporation; Symantec Corporation; The Open Group.
13 marek 1.63 // 14 // Permission is hereby granted, free of charge, to any person obtaining a copy 15 // of this software and associated documentation files (the "Software"), to 16 // deal in the Software without restriction, including without limitation the 17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 18 // sell copies of the Software, and to permit persons to whom the Software is 19 // furnished to do so, subject to the following conditions:
20 karl 1.82 //
21 marek 1.63 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN 22 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED 23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 24 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 27 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 29 // 30 //============================================================================== 31 // 32 //%///////////////////////////////////////////////////////////////////////////// 33 34 #include "CMPI_Version.h" 35 36 #include "CMPIProviderManager.h" 37 38 #include "CMPI_Object.h" 39 #include "CMPI_ContextArgs.h" 40 #include "CMPI_Instance.h" 41 #include "CMPI_ObjectPath.h" 42 marek 1.63 #include "CMPI_Result.h" 43 #include "CMPI_SelectExp.h" 44 45 #include <Pegasus/Common/CIMMessage.h> 46 #include <Pegasus/Common/OperationContext.h>
47 a.dunfey 1.85 #include <Pegasus/Common/OperationContextInternal.h>
48 marek 1.63 #include <Pegasus/Common/Tracer.h> 49 #include <Pegasus/Common/StatisticalData.h> 50 #include <Pegasus/Common/Logger.h>
51 kumpf 1.79 #include <Pegasus/Common/LanguageParser.h>
52 marek 1.63 #include <Pegasus/Common/MessageLoader.h> //l10n 53 #include <Pegasus/Common/Constants.h>
54 thilo.boehm 1.89 #include <Pegasus/Common/FileSystem.h>
55 marek 1.63 56 #include <Pegasus/Config/ConfigManager.h> 57 58 #include <Pegasus/Provider/CIMOMHandleQueryContext.h>
59 a.dunfey 1.85 #include <Pegasus/ProviderManager2/CIMOMHandleContext.h>
60 marek 1.63 #include <Pegasus/ProviderManager2/ProviderName.h>
61 kumpf 1.93 #include <Pegasus/ProviderManager2/AutoPThreadSecurity.h>
62 marek 1.63 #include <Pegasus/ProviderManager2/CMPI/CMPIProviderModule.h> 63 #include <Pegasus/ProviderManager2/CMPI/CMPIProvider.h> 64
65 kumpf 1.93 PEGASUS_USING_STD;
66 marek 1.63 67 PEGASUS_NAMESPACE_BEGIN 68
69 dave.sudlik 1.96
70 marek 1.95 ReadWriteSem CMPIProviderManager::rwSemProvTab; 71 ReadWriteSem CMPIProviderManager::rwSemSelxTab;
72 marek 1.63 CMPIProviderManager::IndProvTab CMPIProviderManager::provTab; 73 CMPIProviderManager::IndSelectTab CMPIProviderManager::selxTab;
74 marek 1.95
75 venkat.puvvada 1.108 class CMPIPropertyList 76 { 77 char **props; 78 int pCount; 79 public: 80 CMPIPropertyList(CIMPropertyList &propertyList) : props(0), pCount(0) 81 {
82 ms.aruran 1.115 PEG_METHOD_ENTER( 83 TRC_PROVIDERMANAGER, 84 "CMPIPropertyList::CMPIPropertyList()");
85 venkat.puvvada 1.108 if (!propertyList.isNull()) 86 { 87 Array<CIMName> p=propertyList.getPropertyNameArray(); 88 pCount=p.size(); 89 props = new char*[1+pCount]; 90 for (int i=0; i<pCount; i++) 91 { 92 props[i]=strdup(p[i].getString().getCString()); 93 } 94 props[pCount]=NULL; 95 } 96 else props=NULL;
97 ms.aruran 1.115 PEG_METHOD_EXIT();
98 venkat.puvvada 1.108 } 99 ~CMPIPropertyList() 100 {
101 ms.aruran 1.115 PEG_METHOD_ENTER( 102 TRC_PROVIDERMANAGER, 103 "CMPIPropertyList::~CMPIPropertyList()");
104 venkat.puvvada 1.108 if (props) 105 { 106 for (int i=0; i<pCount; i++) 107 free(props[i]); 108 delete [] props; 109 }
110 ms.aruran 1.115 PEG_METHOD_EXIT();
111 venkat.puvvada 1.108 } 112 char **getList() 113 { 114 return props; 115 }
116 marek 1.63 }; 117 118 CMPIProviderManager::CMPIProviderManager(Mode m) 119 {
120 ms.aruran 1.115 PEG_METHOD_ENTER( 121 TRC_PROVIDERMANAGER, 122 "CMPIProviderManager::CMPIProviderManager()"); 123
124 venkat.puvvada 1.108 mode=m; 125 _subscriptionInitComplete = false;
126 ms.aruran 1.115 PEG_TRACE_CSTRING ( 127 TRC_PROVIDERMANAGER, 128 Tracer::LEVEL2, 129 "-- CMPI Provider Manager activated"); 130 PEG_METHOD_EXIT();
131 marek 1.63 } 132
133 venkat.puvvada 1.108 CMPIProviderManager::~CMPIProviderManager()
134 marek 1.63 {
135 ms.aruran 1.115 PEG_METHOD_ENTER( 136 TRC_PROVIDERMANAGER, 137 "CMPIProviderManager::~CMPIProviderManager()");
138 venkat.puvvada 1.108 /* Clean up the hash-tables */
139 marek 1.63 indProvRecord *prec=NULL;
140 marek 1.95 { 141 WriteLock writeLock(rwSemProvTab);
142 venkat.puvvada 1.108 for (IndProvTab::Iterator i = provTab.start(); i; i++) 143 { 144 provTab.lookup(i.key(),prec); 145 if (prec->handler) 146 delete prec->handler; 147 delete prec; 148 //Remove is not neccessary, since the hashtable destructor takes 149 //care of this already. But instead removing entries while 150 //iterating the hashtable sometimes causes a segmentation fault!!! 151 //provTab.remove(i.key()); 152 prec=NULL; 153 }
154 marek 1.95 } 155
156 venkat.puvvada 1.108 indSelectRecord *selx=NULL;
157 marek 1.95 { 158 WriteLock writeLock(rwSemSelxTab);
159 venkat.puvvada 1.108 for (IndSelectTab::Iterator i = selxTab.start(); i; i++) 160 { 161 selxTab.lookup(i.key(), selx); 162 if (selx->eSelx) 163 delete selx->eSelx; 164 if (selx->qContext) 165 delete selx->qContext; 166 delete selx; 167 //Same as above! 168 //selxTab.remove(i.key()); 169 selx=NULL; 170 }
171 marek 1.95 }
172 ms.aruran 1.115 PEG_METHOD_EXIT();
173 marek 1.63 } 174 175 Message * CMPIProviderManager::processMessage(Message * request) 176 {
177 ms.aruran 1.115 PEG_METHOD_ENTER( 178 TRC_PROVIDERMANAGER,
179 marek 1.63 "CMPIProviderManager::processMessage()"); 180 181 Message * response = 0; 182 183 // pass the request message to a handler method based on message type
184 venkat.puvvada 1.108 switch (request->getType())
185 marek 1.63 {
186 venkat.puvvada 1.108 case CIM_GET_INSTANCE_REQUEST_MESSAGE: 187 response = handleGetInstanceRequest(request);
188 marek 1.63
189 venkat.puvvada 1.108 break; 190 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE: 191 response = handleEnumerateInstancesRequest(request); 192 193 break; 194 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE: 195 response = handleEnumerateInstanceNamesRequest(request); 196 197 break; 198 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE: 199 response = handleCreateInstanceRequest(request); 200 201 break; 202 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE: 203 response = handleModifyInstanceRequest(request); 204 205 break; 206 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE: 207 response = handleDeleteInstanceRequest(request); 208 209 break; 210 venkat.puvvada 1.108 case CIM_EXEC_QUERY_REQUEST_MESSAGE: 211 response = handleExecQueryRequest(request); 212 213 break; 214 case CIM_ASSOCIATORS_REQUEST_MESSAGE: 215 response = handleAssociatorsRequest(request); 216 217 break; 218 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE: 219 response = handleAssociatorNamesRequest(request); 220 221 break; 222 case CIM_REFERENCES_REQUEST_MESSAGE: 223 response = handleReferencesRequest(request); 224 225 break; 226 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE: 227 response = handleReferenceNamesRequest(request); 228 229 break; 230 case CIM_INVOKE_METHOD_REQUEST_MESSAGE: 231 venkat.puvvada 1.108 response = handleInvokeMethodRequest(request); 232 233 break; 234 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE: 235 response = handleCreateSubscriptionRequest(request);
236 marek 1.63
237 venkat.puvvada 1.108 break;
238 marek 1.63 /* case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE: 239 response = handleModifySubscriptionRequest(request); 240 241 break;
242 venkat.puvvada 1.108 */ 243 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE: 244 response = handleDeleteSubscriptionRequest(request);
245 marek 1.63
246 venkat.puvvada 1.108 break;
247 marek 1.63 /* case CIM_EXPORT_INDICATION_REQUEST_MESSAGE: 248 response = handleExportIndicationRequest(request); 249 break; 250 */
251 venkat.puvvada 1.108 case CIM_DISABLE_MODULE_REQUEST_MESSAGE: 252 response = handleDisableModuleRequest(request);
253 marek 1.63
254 venkat.puvvada 1.108 break; 255 case CIM_ENABLE_MODULE_REQUEST_MESSAGE: 256 response = handleEnableModuleRequest(request); 257 258 break; 259 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE: 260 response = handleStopAllProvidersRequest(request); 261 262 break;
263 s.kodali 1.113 // Note: The PG_Provider AutoStart property is not yet supported 264 #if 0
265 venkat.puvvada 1.108 case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE: 266 response = handleInitializeProviderRequest(request); 267 268 break;
269 s.kodali 1.113 #endif
270 venkat.puvvada 1.108 case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE: 271 response = handleSubscriptionInitCompleteRequest (request); 272 273 break; 274 case CIM_GET_PROPERTY_REQUEST_MESSAGE: 275 response = handleGetPropertyRequest(request); 276 277 break; 278 case CIM_SET_PROPERTY_REQUEST_MESSAGE: 279 response = handleSetPropertyRequest(request); 280 281 break; 282 default: 283 response = handleUnsupportedRequest(request);
284 marek 1.63
285 venkat.puvvada 1.108 break;
286 marek 1.63 } 287 288 PEG_METHOD_EXIT(); 289 290 return(response); 291 } 292 293 Boolean CMPIProviderManager::hasActiveProviders() 294 {
295 venkat.puvvada 1.108 return providerManager.hasActiveProviders();
296 marek 1.63 } 297 298 void CMPIProviderManager::unloadIdleProviders() 299 {
300 venkat.puvvada 1.108 providerManager.unloadIdleProviders();
301 marek 1.63 } 302 303 304 #define CHARS(cstring) (char)(strlen(cstring)?(const char)cstring:NULL) 305 306
307 kumpf 1.92 #define HandlerIntroBase(type,type1,message,request,response,handler) \
308 marek 1.63 CIM##type##RequestMessage * request = \
309 venkat.puvvada 1.108 dynamic_cast<CIM##type##RequestMessage >(const_cast<Message > \ 310 (message)); \
311 marek 1.63 PEGASUS_ASSERT(request != 0); \ 312 CIM##type##ResponseMessage * response = \
313 kumpf 1.92 dynamic_cast<CIM##type##ResponseMessage*>(request->buildResponse()); \
314 marek 1.63 PEGASUS_ASSERT(response != 0); \
315 kumpf 1.84 type1##ResponseHandler handler(request, response, _responseChunkCallback);
316 marek 1.63 317 #define HandlerIntroInd(type,message,request,response,handler) \
318 kumpf 1.92 HandlerIntroBase(type,Operation,message,request,response,handler)
319 marek 1.63 320 #define HandlerIntroInit(type,message,request,response,handler) \
321 kumpf 1.92 HandlerIntroBase(type,Operation,message,request,response,handler)
322 marek 1.63
323 kumpf 1.92 #define HandlerIntro(type,message,request,response,handler) \ 324 HandlerIntroBase(type,type,message,request,response,handler)
325 marek 1.63 326 #define HandlerCatch(handler) \
327 konrad.r 1.64 catch(const CIMException & e) \
328 marek 1.63 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \ 329 "Exception: " + e.getMessage()); \
330 dave.sudlik 1.103 handler.setCIMException(e); \
331 marek 1.63 } \
332 konrad.r 1.64 catch(const Exception & e) \
333 marek 1.63 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \ 334 "Exception: " + e.getMessage()); \
335 venkat.puvvada 1.108 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), \ 336 e.getMessage()); \
337 marek 1.63 } \ 338 catch(...) \
339 marek 1.107 { PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
340 marek 1.63 "Exception: Unknown"); \ 341 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \ 342 } 343
344 venkat.puvvada 1.108 Message * CMPIProviderManager::handleGetInstanceRequest( 345 const Message * message)
346 marek 1.63 {
347 ms.aruran 1.115 PEG_METHOD_ENTER( 348 TRC_PROVIDERMANAGER, 349 "CMPIProviderManager::handleGetInstanceRequest()");
350 marek 1.63
351 kumpf 1.92 HandlerIntro(GetInstance,message,request,response,handler);
352 marek 1.63
353 venkat.puvvada 1.108 try 354 {
355 marek 1.63 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
356 venkat.puvvada 1.108 "CmpiProviderManager::handleGetInstanceRequest - Host name: $0 " 357 "hi sure man Name space: $1 Class name: $2",
358 marek 1.63 System::getHostName(), 359 request->nameSpace.getString(), 360 request->instanceName.getClassName().getString()); 361 362 // make target object path 363 CIMObjectPath objectPath( 364 System::getHostName(), 365 request->nameSpace, 366 request->instanceName.getClassName(), 367 request->instanceName.getKeyBindings()); 368 369 Boolean remote=false; 370 CMPIProvider::OpProviderHolder ph; 371 372 // resolve provider name
373 venkat.puvvada 1.108 ProviderIdContainer pidc = 374 request->operationContext.get(ProviderIdContainer::NAME); 375
376 marek 1.63 ProviderName name = _resolveProviderName(pidc); 377
378 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 379 { 380 ph = providerManager.getRemoteProvider( 381 name.getLocation(), name.getLogicalName());
382 a.dunfey 1.85 }
383 venkat.puvvada 1.108 else 384 {
385 a.dunfey 1.85 // get cached or load new provider module
386 venkat.puvvada 1.108 ph = providerManager.getProvider( 387 name.getPhysicalName(), name.getLogicalName());
388 marek 1.63 } 389 390 // convert arguments 391 OperationContext context; 392 393 context.insert(request->operationContext.get(IdentityContainer::NAME));
394 venkat.puvvada 1.108 context.insert( 395 request->operationContext.get(AcceptLanguageListContainer::NAME)); 396 context.insert( 397 request->operationContext.get(ContentLanguageListContainer::NAME));
398 marek 1.63 // forward request 399 CMPIProvider & pr=ph.GetProvider(); 400
401 a.dunfey 1.85 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
402 venkat.puvvada 1.118.2.2 AutoPtr<NormalizerContext> tmpNormalizerContext( 403 new CIMOMHandleContext(*pr._cimom_handle)); 404 request->operationContext.insert( 405 NormalizerContextContainer(tmpNormalizerContext)); 406 #endif
407 a.dunfey 1.85
408 ms.aruran 1.115 PEG_TRACE_STRING( 409 TRC_PROVIDERMANAGER, 410 Tracer::LEVEL4,
411 marek 1.63 "Calling provider.getInstance: " + pr.getName()); 412 413 CMPIStatus rc={CMPI_RC_OK,NULL}; 414 CMPI_ContextOnStack eCtx(context); 415 CMPI_ObjectPathOnStack eRef(objectPath); 416 CMPI_ResultOnStack eRes(handler,&pr.broker); 417 CMPI_ThreadContext thr(&pr.broker,&eCtx); 418 419 CMPIPropertyList props(request->propertyList); 420 421 CMPIFlags flgs=0; 422 if (request->includeQualifiers) flgs\|=CMPI_FLAG_IncludeQualifiers; 423 if (request->includeClassOrigin) flgs\|=CMPI_FLAG_IncludeClassOrigin;
424 venkat.puvvada 1.108 eCtx.ft->addEntry( 425 &eCtx,CMPIInvocationFlags,(CMPIValue*)&flgs,CMPI_uint32);
426 marek 1.63 427 const IdentityContainer container =
428 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME); 429 eCtx.ft->addEntry( 430 &eCtx, 431 CMPIPrincipal, 432 (CMPIValue)(const char)container.getUserName().getCString(), 433 CMPI_chars);
434 marek 1.63
435 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
436 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME);
437 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
438 konrad.r 1.67
439 kumpf 1.79 eCtx.ft->addEntry( 440 &eCtx,
441 dave.sudlik 1.99 CMPIAcceptLanguage,
442 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
443 venkat.puvvada 1.108 acceptLangs).getCString(),
444 kumpf 1.79 CMPI_chars);
445 venkat.puvvada 1.108 446 if (remote) 447 { 448 CString info=pidc.getRemoteInfo().getCString(); 449 eCtx.ft->addEntry( 450 &eCtx, 451 "CMPIRRemoteInfo",(CMPIValue)(const char)info, 452 CMPI_chars);
453 marek 1.63 } 454 455 CMPIProvider::pm_service_op_lock op_lock(&pr); 456
457 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
458 marek 1.63
459 kumpf 1.92 { 460 StatProviderTimeMeasurement providerTime(response);
461 marek 1.63
462 kumpf 1.92 rc = pr.miVector.instMI->ft->getInstance(
463 venkat.puvvada 1.108 pr.miVector.instMI, 464 &eCtx, 465 &eRes, 466 &eRef,
467 kumpf 1.92 (const char **)props.getList()); 468 }
469 marek 1.63
470 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 471 // Do this before checking rc from provider to throw exception in case 472 // rc.msg is also localized. 473 CMPIStatus tmprc={CMPI_RC_OK,NULL};
474 venkat.puvvada 1.108 CMPIData cldata = 475 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
476 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 477 { 478 response->operationContext.set( 479 ContentLanguageListContainer(
480 venkat.puvvada 1.108 ContentLanguageList( 481 LanguageParser::parseContentLanguageHeader( 482 CMGetCharPtr(cldata.value.string)))));
483 dave.sudlik 1.103 handler.setContext(response->operationContext);
484 dave.sudlik 1.99 } 485
486 marek 1.63 if (rc.rc!=CMPI_RC_OK)
487 dave.sudlik 1.102 {
488 venkat.puvvada 1.108 CIMException cimException( 489 (CIMStatusCode)rc.rc, 490 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 491 492 if (eRes.resError) 493 { 494 for (CMPI_Error* currErr=eRes.resError;
495 dave.sudlik 1.102 currErr!=NULL; 496 currErr=currErr->nextError)
497 venkat.puvvada 1.108 { 498 cimException.addError( 499 ((CIMError*)currErr->hdl)->getInstance()); 500 } 501 } 502 throw cimException;
503 dave.sudlik 1.102 }
504 marek 1.63 } 505 HandlerCatch(handler); 506 507 PEG_METHOD_EXIT(); 508 509 return(response); 510 } 511
512 venkat.puvvada 1.108 Message * CMPIProviderManager::handleEnumerateInstancesRequest( 513 const Message * message)
514 marek 1.63 {
515 ms.aruran 1.115 PEG_METHOD_ENTER( 516 TRC_PROVIDERMANAGER, 517 "CMPIProviderManager::handleEnumerateInstanceRequest()");
518 marek 1.63
519 kumpf 1.92 HandlerIntro(EnumerateInstances,message,request,response,handler);
520 venkat.puvvada 1.108 try 521 { 522 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 523 "CMPIProviderManager::handleEnumerateInstancesRequest - Host name:" 524 " $0 Name space: $1 Class name: $2",
525 marek 1.63 System::getHostName(), 526 request->nameSpace.getString(), 527 request->className.getString()); 528 529 // make target object path 530 CIMObjectPath objectPath( 531 System::getHostName(), 532 request->nameSpace, 533 request->className); 534 535 Boolean remote=false; 536 CMPIProvider::OpProviderHolder ph; 537 538 // resolve provider name
539 venkat.puvvada 1.108 ProviderIdContainer pidc = 540 request->operationContext.get(ProviderIdContainer::NAME);
541 marek 1.63 ProviderName name = _resolveProviderName(pidc); 542
543 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 544 { 545 ph = providerManager.getRemoteProvider( 546 name.getLocation(), name.getLogicalName()); 547 } 548 else 549 { 550 // get cached or load new provider module 551 ph = providerManager.getProvider( 552 name.getPhysicalName(), name.getLogicalName());
553 marek 1.63 } 554 555 // convert arguments 556 OperationContext context; 557 558 context.insert(request->operationContext.get(IdentityContainer::NAME));
559 venkat.puvvada 1.108 context.insert( 560 request->operationContext.get(AcceptLanguageListContainer::NAME)); 561 context.insert( 562 request->operationContext.get(ContentLanguageListContainer::NAME));
563 marek 1.63 564 CIMPropertyList propertyList(request->propertyList); 565 566 // forward request 567 CMPIProvider & pr=ph.GetProvider(); 568
569 a.dunfey 1.85 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
570 venkat.puvvada 1.118.2.2 AutoPtr<NormalizerContext> tmpNormalizerContext( 571 new CIMOMHandleContext(*pr._cimom_handle)); 572 request->operationContext.insert( 573 NormalizerContextContainer(tmpNormalizerContext)); 574 #endif
575 a.dunfey 1.85
576 ms.aruran 1.115 PEG_TRACE_STRING( 577 TRC_PROVIDERMANAGER, 578 Tracer::LEVEL4,
579 marek 1.63 "Calling provider.enumerateInstances: " + pr.getName()); 580 581 CMPIStatus rc={CMPI_RC_OK,NULL}; 582 CMPI_ContextOnStack eCtx(context); 583 CMPI_ObjectPathOnStack eRef(objectPath); 584 CMPI_ResultOnStack eRes(handler,&pr.broker); 585 CMPI_ThreadContext thr(&pr.broker,&eCtx); 586 587 CMPIPropertyList props(propertyList); 588 589 CMPIFlags flgs=0; 590 if (request->includeQualifiers) flgs\|=CMPI_FLAG_IncludeQualifiers; 591 if (request->includeClassOrigin) flgs\|=CMPI_FLAG_IncludeClassOrigin;
592 venkat.puvvada 1.108 eCtx.ft->addEntry( 593 &eCtx, 594 CMPIInvocationFlags, 595 (CMPIValue*)&flgs, 596 CMPI_uint32);
597 marek 1.63 598 const IdentityContainer container =
599 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME); 600 eCtx.ft->addEntry( 601 &eCtx, 602 CMPIPrincipal, 603 (CMPIValue)(const char)container.getUserName().getCString(), 604 CMPI_chars);
605 marek 1.63
606 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
607 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME); 608
609 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
610 kumpf 1.79 eCtx.ft->addEntry( 611 &eCtx,
612 dave.sudlik 1.99 CMPIAcceptLanguage,
613 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
614 venkat.puvvada 1.108 acceptLangs).getCString(),
615 kumpf 1.79 CMPI_chars);
616 venkat.puvvada 1.108 if (remote) 617 { 618 CString info=pidc.getRemoteInfo().getCString(); 619 eCtx.ft->addEntry( 620 &eCtx, 621 "CMPIRRemoteInfo", 622 (CMPIValue)(const char)info, 623 CMPI_chars);
624 marek 1.63 } 625 626 CMPIProvider::pm_service_op_lock op_lock(&pr); 627
628 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
629 marek 1.63
630 kumpf 1.92 { 631 StatProviderTimeMeasurement providerTime(response);
632 marek 1.63
633 kumpf 1.92 rc = pr.miVector.instMI->ft->enumInstances(
634 venkat.puvvada 1.108 pr.miVector.instMI, 635 &eCtx, 636 &eRes, 637 &eRef,
638 kumpf 1.92 (const char **)props.getList()); 639 }
640 marek 1.63
641 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 642 // Do this before checking rc from provider to throw exception in case 643 // rc.msg is also localized. 644 CMPIStatus tmprc={CMPI_RC_OK,NULL};
645 venkat.puvvada 1.108 CMPIData cldata = 646 eCtx.ft->getEntry(&eCtx, CMPIContentLanguage, &tmprc);
647 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 648 { 649 response->operationContext.set( 650 ContentLanguageListContainer(
651 venkat.puvvada 1.108 ContentLanguageList( 652 LanguageParser::parseContentLanguageHeader( 653 CMGetCharPtr(cldata.value.string)))));
654 dave.sudlik 1.103 handler.setContext(response->operationContext);
655 dave.sudlik 1.99 } 656
657 marek 1.63 if (rc.rc!=CMPI_RC_OK)
658 dave.sudlik 1.102 {
659 venkat.puvvada 1.108 CIMException cimException( 660 (CIMStatusCode)rc.rc, 661 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 662 663 if (eRes.resError) 664 { 665 for (CMPI_Error* currErr=eRes.resError;
666 dave.sudlik 1.102 currErr!=NULL; 667 currErr=currErr->nextError)
668 venkat.puvvada 1.108 { 669 cimException.addError( 670 ((CIMError*)currErr->hdl)->getInstance()); 671 } 672 } 673 throw cimException;
674 dave.sudlik 1.102 } 675
676 marek 1.63 } 677 HandlerCatch(handler); 678 679 PEG_METHOD_EXIT(); 680 681 return(response); 682 } 683
684 venkat.puvvada 1.108 Message * CMPIProviderManager::handleEnumerateInstanceNamesRequest( 685 const Message * message)
686 marek 1.63 {
687 ms.aruran 1.115 PEG_METHOD_ENTER( 688 TRC_PROVIDERMANAGER, 689 "CMPIProviderManager::handleEnumerateInstanceNamesRequest()");
690 marek 1.63
691 kumpf 1.92 HandlerIntro(EnumerateInstanceNames,message,request,response,handler);
692 venkat.puvvada 1.108 try 693 {
694 marek 1.63 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
695 venkat.puvvada 1.108 "CMPIProviderManager::handleEnumerateInstanceNamesRequest - Host " 696 "name: $0 Name space: $1 Class name: $2",
697 marek 1.63 System::getHostName(), 698 request->nameSpace.getString(), 699 request->className.getString()); 700
701 venkat.puvvada 1.108 // make target object path
702 marek 1.63 CIMObjectPath objectPath( 703 System::getHostName(), 704 request->nameSpace, 705 request->className); 706 707 Boolean remote=false; 708 CMPIProvider::OpProviderHolder ph; 709 710 // resolve provider name
711 venkat.puvvada 1.108 ProviderIdContainer pidc = 712 request->operationContext.get(ProviderIdContainer::NAME);
713 marek 1.63 ProviderName name = _resolveProviderName(pidc); 714
715 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 716 { 717 ph = providerManager.getRemoteProvider( 718 name.getLocation(), name.getLogicalName());
719 marek 1.63 }
720 venkat.puvvada 1.108 else 721 { 722 // get cached or load new provider module 723 ph = providerManager.getProvider( 724 name.getPhysicalName(), name.getLogicalName());
725 marek 1.63 } 726 727 // convert arguments 728 OperationContext context; 729 730 context.insert(request->operationContext.get(IdentityContainer::NAME));
731 venkat.puvvada 1.108 context.insert( 732 request->operationContext.get(AcceptLanguageListContainer::NAME)); 733 context.insert( 734 request->operationContext.get(ContentLanguageListContainer::NAME));
735 marek 1.63 CMPIProvider & pr=ph.GetProvider(); 736
737 ms.aruran 1.115 PEG_TRACE_STRING( 738 TRC_PROVIDERMANAGER, 739 Tracer::LEVEL4,
740 marek 1.63 "Calling provider.enumerateInstanceNames: " + pr.getName()); 741 742 CMPIStatus rc={CMPI_RC_OK,NULL}; 743 CMPI_ContextOnStack eCtx(context); 744 CMPI_ObjectPathOnStack eRef(objectPath); 745 CMPI_ResultOnStack eRes(handler,&pr.broker); 746 CMPI_ThreadContext thr(&pr.broker,&eCtx); 747 748 CMPIFlags flgs=0;
749 venkat.puvvada 1.108 eCtx.ft->addEntry( 750 &eCtx, 751 CMPIInvocationFlags, 752 (CMPIValue*)&flgs, 753 CMPI_uint32);
754 marek 1.63 755 const IdentityContainer container =
756 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME); 757 eCtx.ft->addEntry( 758 &eCtx, 759 CMPIPrincipal, 760 (CMPIValue)(const char)container.getUserName().getCString(), 761 CMPI_chars);
762 marek 1.63
763 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
764 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME); 765
766 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
767 kumpf 1.79 eCtx.ft->addEntry( 768 &eCtx,
769 dave.sudlik 1.99 CMPIAcceptLanguage,
770 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
771 venkat.puvvada 1.108 acceptLangs).getCString(),
772 kumpf 1.79 CMPI_chars);
773 venkat.puvvada 1.108 if (remote) 774 { 775 CString info=pidc.getRemoteInfo().getCString(); 776 eCtx.ft->addEntry( 777 &eCtx, 778 "CMPIRRemoteInfo", 779 (CMPIValue)(const char)info, 780 CMPI_chars);
781 marek 1.63 } 782 783 CMPIProvider::pm_service_op_lock op_lock(&pr); 784
785 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
786 venkat.puvvada 1.108
787 kumpf 1.92 { 788 StatProviderTimeMeasurement providerTime(response);
789 marek 1.63
790 kumpf 1.92 rc = pr.miVector.instMI->ft->enumInstanceNames( 791 pr.miVector.instMI,&eCtx,&eRes,&eRef); 792 }
793 marek 1.63
794 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 795 // Do this before checking rc from provider to throw exception in case 796 // rc.msg is also localized. 797 CMPIStatus tmprc={CMPI_RC_OK,NULL};
798 venkat.puvvada 1.108 CMPIData cldata = 799 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
800 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 801 { 802 response->operationContext.set( 803 ContentLanguageListContainer(
804 venkat.puvvada 1.108 ContentLanguageList( 805 LanguageParser::parseContentLanguageHeader( 806 CMGetCharPtr(cldata.value.string)))));
807 dave.sudlik 1.103 handler.setContext(response->operationContext);
808 dave.sudlik 1.99 } 809
810 marek 1.63 if (rc.rc!=CMPI_RC_OK)
811 dave.sudlik 1.102 {
812 venkat.puvvada 1.108 CIMException cimException( 813 (CIMStatusCode)rc.rc, 814 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 815 816 if (eRes.resError) 817 { 818 for (CMPI_Error* currErr=eRes.resError;
819 dave.sudlik 1.102 currErr!=NULL; 820 currErr=currErr->nextError)
821 venkat.puvvada 1.108 { 822 cimException.addError( 823 ((CIMError*)currErr->hdl)->getInstance()); 824 } 825 } 826 throw cimException;
827 dave.sudlik 1.102 }
828 marek 1.63 } 829 HandlerCatch(handler); 830 831 PEG_METHOD_EXIT(); 832 833 return(response); 834 } 835
836 venkat.puvvada 1.108 Message * CMPIProviderManager::handleCreateInstanceRequest( 837 const Message * message)
838 marek 1.63 {
839 ms.aruran 1.115 PEG_METHOD_ENTER( 840 TRC_PROVIDERMANAGER, 841 "CMPIProviderManager::handleCreateInstanceRequest()");
842 marek 1.63
843 kumpf 1.92 HandlerIntro(CreateInstance,message,request,response,handler);
844 venkat.puvvada 1.108 try 845 {
846 marek 1.63 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
847 venkat.puvvada 1.108 "CMPIProviderManager::handleCreateInstanceRequest - Host name: " 848 "$0 Name space: $1 Class name: $2",
849 marek 1.63 System::getHostName(), 850 request->nameSpace.getString(), 851 request->newInstance.getPath().getClassName().getString()); 852 853 // make target object path 854 CIMObjectPath objectPath( 855 System::getHostName(), 856 request->nameSpace, 857 request->newInstance.getPath().getClassName(), 858 request->newInstance.getPath().getKeyBindings());
859 venkat.puvvada 1.108 request->newInstance.setPath(objectPath);
860 marek 1.63 861 Boolean remote=false; 862 CMPIProvider::OpProviderHolder ph; 863 864 // resolve provider name
865 venkat.puvvada 1.108 ProviderIdContainer pidc = 866 request->operationContext.get(ProviderIdContainer::NAME);
867 marek 1.63 ProviderName name = _resolveProviderName(pidc); 868
869 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 870 { 871 ph = providerManager.getRemoteProvider( 872 name.getLocation(), name.getLogicalName()); 873 } 874 else 875 { 876 // get cached or load new provider module 877 ph = providerManager.getProvider( 878 name.getPhysicalName(), name.getLogicalName());
879 marek 1.63 } 880 881 // convert arguments 882 OperationContext context; 883 884 context.insert(request->operationContext.get(IdentityContainer::NAME));
885 venkat.puvvada 1.108 context.insert( 886 request->operationContext.get(AcceptLanguageListContainer::NAME)); 887 context.insert( 888 request->operationContext.get(ContentLanguageListContainer::NAME));
889 marek 1.63 // forward request 890 CMPIProvider & pr=ph.GetProvider(); 891
892 ms.aruran 1.115 PEG_TRACE_STRING( 893 TRC_PROVIDERMANAGER, 894 Tracer::LEVEL4,
895 marek 1.63 "Calling provider.createInstance: " + 896 ph.GetProvider().getName()); 897 898 CMPIStatus rc={CMPI_RC_OK,NULL}; 899 CMPI_ContextOnStack eCtx(context); 900 CMPI_ObjectPathOnStack eRef(objectPath); 901 CMPI_ResultOnStack eRes(handler,&pr.broker); 902 CMPI_InstanceOnStack eInst(request->newInstance); 903 CMPI_ThreadContext thr(&pr.broker,&eCtx); 904 905 CMPIFlags flgs=0;
906 venkat.puvvada 1.108 eCtx.ft->addEntry( 907 &eCtx, 908 CMPIInvocationFlags, 909 (CMPIValue*)&flgs, 910 CMPI_uint32);
911 marek 1.63 912 const IdentityContainer container =
913 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME); 914 eCtx.ft->addEntry( 915 &eCtx, 916 CMPIPrincipal, 917 (CMPIValue)(const char)container.getUserName().getCString(), 918 CMPI_chars);
919 marek 1.63
920 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
921 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME); 922
923 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
924 kumpf 1.79 eCtx.ft->addEntry( 925 &eCtx,
926 dave.sudlik 1.99 CMPIAcceptLanguage,
927 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
928 venkat.puvvada 1.108 acceptLangs).getCString(),
929 kumpf 1.79 CMPI_chars);
930 venkat.puvvada 1.108 if (remote) 931 { 932 CString info=pidc.getRemoteInfo().getCString(); 933 eCtx.ft->addEntry( 934 &eCtx, 935 "CMPIRRemoteInfo", 936 (CMPIValue)(const char)info,CMPI_chars);
937 marek 1.63 } 938 939 CMPIProvider::pm_service_op_lock op_lock(&pr); 940
941 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
942 marek 1.63
943 kumpf 1.92 { 944 StatProviderTimeMeasurement providerTime(response);
945 marek 1.63
946 kumpf 1.92 rc = pr.miVector.instMI->ft->createInstance( 947 pr.miVector.instMI,&eCtx,&eRes,&eRef,&eInst); 948 }
949 marek 1.63
950 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 951 // Do this before checking rc from provider to throw exception in case 952 // rc.msg is also localized. 953 CMPIStatus tmprc={CMPI_RC_OK,NULL};
954 venkat.puvvada 1.108 CMPIData cldata = 955 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
956 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 957 { 958 response->operationContext.set( 959 ContentLanguageListContainer(
960 venkat.puvvada 1.108 ContentLanguageList( 961 LanguageParser::parseContentLanguageHeader( 962 CMGetCharPtr(cldata.value.string)))));
963 dave.sudlik 1.103 handler.setContext(response->operationContext);
964 dave.sudlik 1.99 } 965
966 marek 1.63 if (rc.rc!=CMPI_RC_OK)
967 dave.sudlik 1.102 {
968 venkat.puvvada 1.108 CIMException cimException( 969 (CIMStatusCode)rc.rc, 970 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 971 972 if (eRes.resError) 973 { 974 for (CMPI_Error* currErr=eRes.resError;
975 dave.sudlik 1.102 currErr!=NULL; 976 currErr=currErr->nextError)
977 venkat.puvvada 1.108 { 978 cimException.addError( 979 ((CIMError*)currErr->hdl)->getInstance()); 980 } 981 } 982 throw cimException;
983 dave.sudlik 1.102 }
984 marek 1.63 } 985 HandlerCatch(handler); 986 987 PEG_METHOD_EXIT(); 988 989 return(response); 990 } 991
992 venkat.puvvada 1.108 Message * CMPIProviderManager::handleModifyInstanceRequest( 993 const Message * message)
994 marek 1.63 {
995 ms.aruran 1.115 PEG_METHOD_ENTER( 996 TRC_PROVIDERMANAGER, 997 "CMPIProviderManager::handleModifyInstanceRequest()");
998 marek 1.63
999 kumpf 1.92 HandlerIntro(ModifyInstance,message,request,response,handler);
1000 venkat.puvvada 1.108 try 1001 {
1002 marek 1.63 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1003 venkat.puvvada 1.108 "CMPIProviderManager::handleModifyInstanceRequest - Host name: $0" 1004 " Name space: $1 Class name: $2",
1005 marek 1.63 System::getHostName(), 1006 request->nameSpace.getString(), 1007 request->modifiedInstance.getPath().getClassName().getString()); 1008 1009 // make target object path 1010 CIMObjectPath objectPath( 1011 System::getHostName(), 1012 request->nameSpace, 1013 request->modifiedInstance.getPath ().getClassName(), 1014 request->modifiedInstance.getPath ().getKeyBindings()); 1015 1016 Boolean remote=false; 1017 CMPIProvider::OpProviderHolder ph; 1018 1019 // resolve provider name
1020 venkat.puvvada 1.108 ProviderIdContainer pidc = 1021 request->operationContext.get(ProviderIdContainer::NAME);
1022 marek 1.63 ProviderName name = _resolveProviderName(pidc); 1023
1024 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 1025 { 1026 ph = providerManager.getRemoteProvider( 1027 name.getLocation(), name.getLogicalName());
1028 marek 1.63 }
1029 venkat.puvvada 1.108 else 1030 { 1031 // get cached or load new provider module 1032 ph = providerManager.getProvider( 1033 name.getPhysicalName(), name.getLogicalName());
1034 marek 1.63 } 1035 1036 // convert arguments 1037 OperationContext context; 1038 1039 context.insert(request->operationContext.get(IdentityContainer::NAME));
1040 venkat.puvvada 1.108 context.insert( 1041 request->operationContext.get(AcceptLanguageListContainer::NAME)); 1042 context.insert( 1043 request->operationContext.get(ContentLanguageListContainer::NAME));
1044 marek 1.63 // forward request 1045 CMPIProvider & pr=ph.GetProvider(); 1046
1047 ms.aruran 1.115 PEG_TRACE_STRING( 1048 TRC_PROVIDERMANAGER, 1049 Tracer::LEVEL4,
1050 marek 1.63 "Calling provider.modifyInstance: " + pr.getName()); 1051 1052 CMPIStatus rc={CMPI_RC_OK,NULL}; 1053 CMPI_ContextOnStack eCtx(context); 1054 CMPI_ObjectPathOnStack eRef(objectPath); 1055 CMPI_ResultOnStack eRes(handler,&pr.broker); 1056 CMPI_InstanceOnStack eInst(request->modifiedInstance); 1057 CMPI_ThreadContext thr(&pr.broker,&eCtx); 1058 1059 CMPIPropertyList props(request->propertyList); 1060 1061 CMPIFlags flgs=0; 1062 if (request->includeQualifiers) flgs\|=CMPI_FLAG_IncludeQualifiers;
1063 venkat.puvvada 1.108 eCtx.ft->addEntry( 1064 &eCtx, 1065 CMPIInvocationFlags, 1066 (CMPIValue*)&flgs, 1067 CMPI_uint32);
1068 marek 1.63 1069 const IdentityContainer container =
1070 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME);
1071 marek 1.63 eCtx.ft->addEntry(&eCtx,
1072 venkat.puvvada 1.108 CMPIPrincipal, 1073 (CMPIValue)(const char)container.getUserName().getCString(), 1074 CMPI_chars);
1075 marek 1.63
1076 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
1077 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME);
1078 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
1079 kumpf 1.79 eCtx.ft->addEntry( 1080 &eCtx,
1081 dave.sudlik 1.99 CMPIAcceptLanguage,
1082 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
1083 venkat.puvvada 1.108 acceptLangs).getCString(),
1084 kumpf 1.79 CMPI_chars);
1085 venkat.puvvada 1.108 1086 if (remote) 1087 { 1088 CString info=pidc.getRemoteInfo().getCString(); 1089 eCtx.ft->addEntry( 1090 &eCtx, 1091 "CMPIRRemoteInfo", 1092 (CMPIValue)(const char)info, 1093 CMPI_chars);
1094 marek 1.63 } 1095 1096 CMPIProvider::pm_service_op_lock op_lock(&pr); 1097
1098 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
1099 marek 1.63
1100 kumpf 1.92 { 1101 StatProviderTimeMeasurement providerTime(response);
1102 marek 1.63
1103 kumpf 1.92 rc = pr.miVector.instMI->ft->modifyInstance( 1104 pr.miVector.instMI,&eCtx,&eRes,&eRef,&eInst, 1105 (const char **)props.getList()); 1106 }
1107 marek 1.63
1108 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 1109 // Do this before checking rc from provider to throw exception in case 1110 // rc.msg is also localized. 1111 CMPIStatus tmprc={CMPI_RC_OK,NULL};
1112 venkat.puvvada 1.108 CMPIData cldata = 1113 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
1114 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 1115 { 1116 response->operationContext.set( 1117 ContentLanguageListContainer(
1118 venkat.puvvada 1.108 ContentLanguageList( 1119 LanguageParser::parseContentLanguageHeader( 1120 CMGetCharPtr(cldata.value.string)))));
1121 dave.sudlik 1.103 handler.setContext(response->operationContext);
1122 dave.sudlik 1.99 } 1123
1124 marek 1.63 if (rc.rc!=CMPI_RC_OK)
1125 dave.sudlik 1.102 {
1126 venkat.puvvada 1.108 CIMException cimException( 1127 (CIMStatusCode)rc.rc, 1128 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 1129 1130 if (eRes.resError) 1131 { 1132 for (CMPI_Error* currErr=eRes.resError;
1133 dave.sudlik 1.102 currErr!=NULL; 1134 currErr=currErr->nextError)
1135 venkat.puvvada 1.108 { 1136 cimException.addError( 1137 ((CIMError*)currErr->hdl)->getInstance()); 1138 } 1139 } 1140 throw cimException;
1141 dave.sudlik 1.102 }
1142 marek 1.63 } 1143 HandlerCatch(handler); 1144 1145 PEG_METHOD_EXIT(); 1146 1147 return(response); 1148 } 1149
1150 venkat.puvvada 1.108 Message * CMPIProviderManager::handleDeleteInstanceRequest( 1151 const Message * message)
1152 marek 1.63 {
1153 ms.aruran 1.115 PEG_METHOD_ENTER( 1154 TRC_PROVIDERMANAGER, 1155 "CMPIProviderManager::handleDeleteInstanceRequest()");
1156 marek 1.63
1157 kumpf 1.92 HandlerIntro(DeleteInstance,message,request,response,handler);
1158 venkat.puvvada 1.108 try 1159 {
1160 marek 1.63 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1161 venkat.puvvada 1.108 "CMPIProviderManager::handleDeleteInstanceRequest - Host name: $0" 1162 " Name space: $1 Class name: $2",
1163 marek 1.63 System::getHostName(), 1164 request->nameSpace.getString(), 1165 request->instanceName.getClassName().getString()); 1166 1167 // make target object path 1168 CIMObjectPath objectPath( 1169 System::getHostName(), 1170 request->nameSpace, 1171 request->instanceName.getClassName(), 1172 request->instanceName.getKeyBindings()); 1173 1174 Boolean remote=false; 1175 CMPIProvider::OpProviderHolder ph; 1176 1177 // resolve provider name
1178 venkat.puvvada 1.108 ProviderIdContainer pidc = 1179 request->operationContext.get(ProviderIdContainer::NAME);
1180 marek 1.63 ProviderName name = _resolveProviderName(pidc); 1181
1182 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 1183 { 1184 ph = providerManager.getRemoteProvider( 1185 name.getLocation(), name.getLogicalName());
1186 marek 1.63 }
1187 venkat.puvvada 1.108 else 1188 { 1189 // get cached or load new provider module 1190 ph = providerManager.getProvider( 1191 name.getPhysicalName(), name.getLogicalName());
1192 marek 1.63 } 1193 1194 // convert arguments 1195 OperationContext context; 1196 1197 context.insert(request->operationContext.get(IdentityContainer::NAME));
1198 venkat.puvvada 1.108 context.insert( 1199 request->operationContext.get(AcceptLanguageListContainer::NAME)); 1200 context.insert( 1201 request->operationContext.get(ContentLanguageListContainer::NAME));
1202 marek 1.63 // forward request 1203 CMPIProvider & pr=ph.GetProvider(); 1204
1205 ms.aruran 1.115 PEG_TRACE_STRING( 1206 TRC_PROVIDERMANAGER, 1207 Tracer::LEVEL4,
1208 marek 1.63 "Calling provider.deleteInstance: " + pr.getName()); 1209 1210 CMPIStatus rc={CMPI_RC_OK,NULL}; 1211 CMPI_ContextOnStack eCtx(context); 1212 CMPI_ObjectPathOnStack eRef(objectPath); 1213 CMPI_ResultOnStack eRes(handler,&pr.broker); 1214 CMPI_ThreadContext thr(&pr.broker,&eCtx); 1215 1216 CMPIFlags flgs=0;
1217 venkat.puvvada 1.108 eCtx.ft->addEntry( 1218 &eCtx, 1219 CMPIInvocationFlags, 1220 (CMPIValue*)&flgs, 1221 CMPI_uint32);
1222 marek 1.63 1223 const IdentityContainer container =
1224 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME);
1225 marek 1.63 eCtx.ft->addEntry(&eCtx,
1226 venkat.puvvada 1.108 CMPIPrincipal, 1227 (CMPIValue)(const char)container.getUserName().getCString(), 1228 CMPI_chars);
1229 marek 1.63
1230 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
1231 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME); 1232
1233 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
1234 kumpf 1.79 eCtx.ft->addEntry( 1235 &eCtx,
1236 dave.sudlik 1.99 CMPIAcceptLanguage,
1237 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
1238 venkat.puvvada 1.108 acceptLangs).getCString(),
1239 kumpf 1.79 CMPI_chars);
1240 venkat.puvvada 1.108 if (remote) 1241 { 1242 CString info=pidc.getRemoteInfo().getCString(); 1243 eCtx.ft->addEntry( 1244 &eCtx, 1245 "CMPIRRemoteInfo", 1246 (CMPIValue)(const char)info, 1247 CMPI_chars);
1248 marek 1.63 } 1249 1250 CMPIProvider::pm_service_op_lock op_lock(&pr); 1251
1252 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
1253 marek 1.63
1254 kumpf 1.92 { 1255 StatProviderTimeMeasurement providerTime(response);
1256 marek 1.63
1257 kumpf 1.92 rc = pr.miVector.instMI->ft->deleteInstance( 1258 pr.miVector.instMI,&eCtx,&eRes,&eRef); 1259 }
1260 marek 1.63
1261 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 1262 // Do this before checking rc from provider to throw exception in case 1263 // rc.msg is also localized. 1264 CMPIStatus tmprc={CMPI_RC_OK,NULL};
1265 venkat.puvvada 1.108 CMPIData cldata = 1266 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
1267 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 1268 { 1269 response->operationContext.set( 1270 ContentLanguageListContainer(
1271 venkat.puvvada 1.108 ContentLanguageList( 1272 LanguageParser::parseContentLanguageHeader( 1273 CMGetCharPtr(cldata.value.string)))));
1274 dave.sudlik 1.103 handler.setContext(response->operationContext);
1275 dave.sudlik 1.99 } 1276
1277 marek 1.63 if (rc.rc!=CMPI_RC_OK)
1278 dave.sudlik 1.102 {
1279 venkat.puvvada 1.108 CIMException cimException( 1280 (CIMStatusCode)rc.rc, 1281 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 1282 1283 if (eRes.resError) 1284 { 1285 for (CMPI_Error* currErr=eRes.resError;
1286 dave.sudlik 1.102 currErr!=NULL; 1287 currErr=currErr->nextError)
1288 venkat.puvvada 1.108 { 1289 cimException.addError( 1290 ((CIMError*)currErr->hdl)->getInstance()); 1291 } 1292 } 1293 throw cimException;
1294 dave.sudlik 1.102 }
1295 marek 1.63 } 1296 HandlerCatch(handler); 1297 1298 PEG_METHOD_EXIT(); 1299 1300 return(response); 1301 } 1302 1303 Message * CMPIProviderManager::handleExecQueryRequest(const Message * message) 1304 {
1305 ms.aruran 1.115 PEG_METHOD_ENTER( 1306 TRC_PROVIDERMANAGER, 1307 "CMPIProviderManager::handleExecQueryRequest()");
1308 marek 1.63
1309 kumpf 1.92 HandlerIntro(ExecQuery,message,request,response,handler);
1310 marek 1.63
1311 venkat.puvvada 1.108 try 1312 { 1313 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 1314 "CMPIProviderManager::ExecQueryRequest - Host name: $0 Name " 1315 "space: $1 Class name: $2",
1316 marek 1.63 System::getHostName(), 1317 request->nameSpace.getString(), 1318 request->className.getString()); 1319 1320 // make target object path 1321 CIMObjectPath objectPath( 1322 System::getHostName(), 1323 request->nameSpace, 1324 request->className); 1325 1326 Boolean remote=false; 1327 1328 CMPIProvider::OpProviderHolder ph; 1329 1330 // resolve provider name
1331 venkat.puvvada 1.108 ProviderIdContainer pidc = 1332 request->operationContext.get(ProviderIdContainer::NAME);
1333 marek 1.63 ProviderName name = _resolveProviderName(pidc); 1334
1335 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 1336 { 1337 ph = providerManager.getRemoteProvider( 1338 name.getLocation(), name.getLogicalName());
1339 marek 1.63 }
1340 venkat.puvvada 1.108 else 1341 { 1342 // get cached or load new provider module 1343 ph = providerManager.getProvider( 1344 name.getPhysicalName(), name.getLogicalName());
1345 marek 1.63 } 1346 1347 // convert arguments 1348 OperationContext context; 1349 1350 context.insert(request->operationContext.get(IdentityContainer::NAME));
1351 venkat.puvvada 1.108 context.insert( 1352 request->operationContext.get(AcceptLanguageListContainer::NAME)); 1353 context.insert( 1354 request->operationContext.get(ContentLanguageListContainer::NAME));
1355 marek 1.63 1356 // forward request 1357 CMPIProvider & pr=ph.GetProvider(); 1358
1359 ms.aruran 1.115 PEG_TRACE_STRING( 1360 TRC_PROVIDERMANAGER, 1361 Tracer::LEVEL4,
1362 marek 1.63 "Calling provider.execQuery: " + pr.getName()); 1363 1364 const char **props=NULL; 1365 1366 CMPIStatus rc={CMPI_RC_OK,NULL}; 1367 CMPI_ContextOnStack eCtx(context); 1368 CMPI_ObjectPathOnStack eRef(objectPath); 1369 CMPI_ResultOnStack eRes(handler,&pr.broker); 1370 CMPI_ThreadContext thr(&pr.broker,&eCtx); 1371 1372 const CString queryLan=request->queryLanguage.getCString(); 1373 const CString query=request->query.getCString(); 1374 1375 CMPIFlags flgs=0;
1376 venkat.puvvada 1.108 eCtx.ft->addEntry( 1377 &eCtx, 1378 CMPIInvocationFlags, 1379 (CMPIValue*)&flgs, 1380 CMPI_uint32);
1381 marek 1.63 1382 const IdentityContainer container =
1383 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME);
1384 marek 1.63 eCtx.ft->addEntry(&eCtx,
1385 venkat.puvvada 1.108 CMPIPrincipal, 1386 (CMPIValue)(const char)container.getUserName().getCString(), 1387 CMPI_chars); 1388 eCtx.ft->addEntry( 1389 &eCtx, 1390 CMPIInitNameSpace, 1391 (CMPIValue)(const char)request-> 1392 nameSpace.getString().getCString(), 1393 CMPI_chars);
1394 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
1395 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME); 1396
1397 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
1398 kumpf 1.79 eCtx.ft->addEntry( 1399 &eCtx,
1400 dave.sudlik 1.99 CMPIAcceptLanguage,
1401 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
1402 venkat.puvvada 1.108 acceptLangs).getCString(),
1403 kumpf 1.79 CMPI_chars);
1404 venkat.puvvada 1.108 if (remote) 1405 { 1406 CString info=pidc.getRemoteInfo().getCString(); 1407 eCtx.ft->addEntry( 1408 &eCtx, 1409 "CMPIRRemoteInfo", 1410 (CMPIValue)(const char)info, 1411 CMPI_chars);
1412 marek 1.63 } 1413 1414 CMPIProvider::pm_service_op_lock op_lock(&pr); 1415
1416 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
1417 marek 1.63
1418 kumpf 1.92 { 1419 StatProviderTimeMeasurement providerTime(response);
1420 marek 1.63
1421 kumpf 1.92 rc = pr.miVector.instMI->ft->execQuery( 1422 pr.miVector.instMI,&eCtx,&eRes,&eRef, 1423 CHARS(queryLan),CHARS(query)); 1424 }
1425 marek 1.63
1426 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 1427 // Do this before checking rc from provider to throw exception in case 1428 // rc.msg is also localized. 1429 CMPIStatus tmprc={CMPI_RC_OK,NULL};
1430 venkat.puvvada 1.108 CMPIData cldata = 1431 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
1432 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 1433 { 1434 response->operationContext.set( 1435 ContentLanguageListContainer(
1436 venkat.puvvada 1.108 ContentLanguageList( 1437 LanguageParser::parseContentLanguageHeader( 1438 CMGetCharPtr(cldata.value.string)))));
1439 dave.sudlik 1.103 handler.setContext(response->operationContext);
1440 dave.sudlik 1.99 } 1441
1442 marek 1.63 if (rc.rc!=CMPI_RC_OK)
1443 dave.sudlik 1.102 {
1444 venkat.puvvada 1.108 CIMException cimException( 1445 (CIMStatusCode)rc.rc, 1446 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 1447 1448 if (eRes.resError) 1449 { 1450 for (CMPI_Error* currErr=eRes.resError;
1451 dave.sudlik 1.102 currErr!=NULL; 1452 currErr=currErr->nextError)
1453 venkat.puvvada 1.108 { 1454 cimException.addError( 1455 ((CIMError*)currErr->hdl)->getInstance()); 1456 } 1457 } 1458 throw cimException;
1459 dave.sudlik 1.102 } 1460
1461 marek 1.63 } 1462 HandlerCatch(handler); 1463 1464 PEG_METHOD_EXIT(); 1465 1466 return(response); 1467 } 1468 1469 Message * CMPIProviderManager::handleAssociatorsRequest(const Message * message) 1470 {
1471 ms.aruran 1.115 PEG_METHOD_ENTER( 1472 TRC_PROVIDERMANAGER, 1473 "CMPIProviderManager::handleAssociatorsRequest()");
1474 marek 1.63
1475 kumpf 1.92 HandlerIntro(Associators,message,request,response,handler);
1476 venkat.puvvada 1.108 try 1477 {
1478 marek 1.63 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1479 venkat.puvvada 1.108 "CMPIProviderManager::handleAssociatorsRequest - Host name: $0 " 1480 "Name space: $1 Class name: $2",
1481 marek 1.63 System::getHostName(), 1482 request->nameSpace.getString(), 1483 request->objectName.getClassName().getString()); 1484 1485 // make target object path 1486 CIMObjectPath objectPath( 1487 System::getHostName(), 1488 request->nameSpace, 1489 request->objectName.getClassName()); 1490 1491 objectPath.setKeyBindings(request->objectName.getKeyBindings()); 1492 1493 CIMObjectPath assocPath( 1494 System::getHostName(), 1495 request->nameSpace, 1496 request->assocClass.getString()); 1497 1498 Boolean remote=false; 1499 1500 CMPIProvider::OpProviderHolder ph; 1501 1502 marek 1.63 // resolve provider name
1503 venkat.puvvada 1.108 ProviderIdContainer pidc = 1504 request->operationContext.get(ProviderIdContainer::NAME);
1505 marek 1.63 ProviderName name = _resolveProviderName(pidc); 1506
1507 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 1508 { 1509 ph = providerManager.getRemoteProvider( 1510 name.getLocation(), name.getLogicalName());
1511 marek 1.63 }
1512 venkat.puvvada 1.108 else 1513 { 1514 // get cached or load new provider module 1515 ph = providerManager.getProvider( 1516 name.getPhysicalName(), name.getLogicalName());
1517 marek 1.63 } 1518
1519 venkat.puvvada 1.108 // convert arguments
1520 marek 1.63 OperationContext context; 1521 1522 context.insert(request->operationContext.get(IdentityContainer::NAME));
1523 venkat.puvvada 1.108 context.insert( 1524 request->operationContext.get(AcceptLanguageListContainer::NAME)); 1525 context.insert( 1526 request->operationContext.get(ContentLanguageListContainer::NAME));
1527 marek 1.63 1528 // forward request 1529 CMPIProvider & pr=ph.GetProvider(); 1530
1531 a.dunfey 1.85 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
1532 venkat.puvvada 1.118.2.2 AutoPtr<NormalizerContext> tmpNormalizerContext( 1533 new CIMOMHandleContext(*pr._cimom_handle)); 1534 request->operationContext.insert( 1535 NormalizerContextContainer(tmpNormalizerContext)); 1536 #endif
1537 a.dunfey 1.85
1538 ms.aruran 1.115 PEG_TRACE_STRING( 1539 TRC_PROVIDERMANAGER, 1540 Tracer::LEVEL4,
1541 marek 1.63 "Calling provider.associators: " + pr.getName()); 1542
1543 ms.aruran 1.115 PEG_TRACE_STRING( 1544 TRC_PROVIDERMANAGER, 1545 Tracer::LEVEL4, 1546 String("--- CMPIProviderManager::associators < role: >" ) + 1547 request->role + 1548 request->assocClass.getString());
1549 marek 1.63 1550 CMPIStatus rc={CMPI_RC_OK,NULL}; 1551 CMPI_ContextOnStack eCtx(context); 1552 CMPI_ObjectPathOnStack eRef(objectPath); 1553 CMPI_ResultOnStack eRes(handler,&pr.broker); 1554 CMPI_ThreadContext thr(&pr.broker,&eCtx); 1555 const CString aClass=request->assocClass.getString().getCString(); 1556 const CString rClass=request->resultClass.getString().getCString(); 1557 const CString rRole=request->role.getCString(); 1558 const CString resRole=request->resultRole.getCString(); 1559 1560 CMPIPropertyList props(request->propertyList); 1561 1562 CMPIFlags flgs=0; 1563 if (request->includeQualifiers) flgs\|=CMPI_FLAG_IncludeQualifiers; 1564 if (request->includeClassOrigin) flgs\|=CMPI_FLAG_IncludeClassOrigin;
1565 venkat.puvvada 1.108 eCtx.ft->addEntry( 1566 &eCtx, 1567 CMPIInvocationFlags, 1568 (CMPIValue*)&flgs, 1569 CMPI_uint32);
1570 marek 1.63 1571 const IdentityContainer container =
1572 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME);
1573 marek 1.63 eCtx.ft->addEntry(&eCtx,
1574 venkat.puvvada 1.108 CMPIPrincipal, 1575 (CMPIValue)(const char)container.getUserName().getCString(), 1576 CMPI_chars);
1577 marek 1.63
1578 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
1579 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME);
1580 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
1581 kumpf 1.79 eCtx.ft->addEntry( 1582 &eCtx,
1583 dave.sudlik 1.99 CMPIAcceptLanguage,
1584 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
1585 venkat.puvvada 1.108 acceptLangs).getCString(),
1586 kumpf 1.79 CMPI_chars);
1587 venkat.puvvada 1.108 1588 if (remote) 1589 { 1590 CString info=pidc.getRemoteInfo().getCString(); 1591 eCtx.ft->addEntry( 1592 &eCtx, 1593 "CMPIRRemoteInfo", 1594 (CMPIValue)(const char)info, 1595 CMPI_chars);
1596 marek 1.63 } 1597 1598 CMPIProvider::pm_service_op_lock op_lock(&pr); 1599
1600 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
1601 marek 1.63
1602 kumpf 1.92 { 1603 StatProviderTimeMeasurement providerTime(response);
1604 marek 1.63
1605 kumpf 1.92 rc = pr.miVector.assocMI->ft->associators( 1606 pr.miVector.assocMI,&eCtx,&eRes,&eRef, 1607 CHARS(aClass),CHARS(rClass),CHARS(rRole),CHARS(resRole), 1608 (const char **)props.getList()); 1609 }
1610 marek 1.63
1611 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 1612 // Do this before checking rc from provider to throw exception in case 1613 // rc.msg is also localized. 1614 CMPIStatus tmprc={CMPI_RC_OK,NULL};
1615 venkat.puvvada 1.108 CMPIData cldata = eCtx.ft->getEntry ( 1616 &eCtx, 1617 CMPIContentLanguage, 1618 &tmprc);
1619 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 1620 { 1621 response->operationContext.set( 1622 ContentLanguageListContainer(
1623 venkat.puvvada 1.108 ContentLanguageList( 1624 LanguageParser::parseContentLanguageHeader( 1625 CMGetCharPtr(cldata.value.string)))));
1626 dave.sudlik 1.103 handler.setContext(response->operationContext);
1627 dave.sudlik 1.99 } 1628
1629 marek 1.63 if (rc.rc!=CMPI_RC_OK)
1630 dave.sudlik 1.102 {
1631 venkat.puvvada 1.108 CIMException cimException( 1632 (CIMStatusCode)rc.rc, 1633 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 1634 1635 if (eRes.resError) 1636 { 1637 for (CMPI_Error* currErr=eRes.resError;
1638 dave.sudlik 1.102 currErr!=NULL; 1639 currErr=currErr->nextError)
1640 venkat.puvvada 1.108 { 1641 cimException.addError( 1642 ((CIMError*)currErr->hdl)->getInstance()); 1643 } 1644 } 1645 throw cimException;
1646 dave.sudlik 1.102 }
1647 marek 1.63 } 1648 HandlerCatch(handler); 1649 1650 PEG_METHOD_EXIT(); 1651 1652 return(response); 1653 } 1654
1655 venkat.puvvada 1.108 Message * CMPIProviderManager::handleAssociatorNamesRequest( 1656 const Message * message)
1657 marek 1.63 {
1658 ms.aruran 1.115 PEG_METHOD_ENTER( 1659 TRC_PROVIDERMANAGER, 1660 "CMPIProviderManager::handleAssociatorNamesRequest()");
1661 marek 1.63
1662 kumpf 1.92 HandlerIntro(AssociatorNames,message,request,response,handler);
1663 venkat.puvvada 1.108 try 1664 {
1665 marek 1.63 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1666 venkat.puvvada 1.108 "CMPIProviderManager::handleAssociatorNamesRequest - Host name: $0" 1667 " Name space: $1 Class name: $2",
1668 marek 1.63 System::getHostName(), 1669 request->nameSpace.getString(), 1670 request->objectName.getClassName().getString()); 1671 1672 // make target object path 1673 CIMObjectPath objectPath( 1674 System::getHostName(), 1675 request->nameSpace, 1676 request->objectName.getClassName()); 1677 1678 objectPath.setKeyBindings(request->objectName.getKeyBindings()); 1679 1680 CIMObjectPath assocPath( 1681 System::getHostName(), 1682 request->nameSpace, 1683 request->assocClass.getString()); 1684 1685 Boolean remote=false; 1686 CMPIProvider::OpProviderHolder ph; 1687 1688 // resolve provider name
1689 venkat.puvvada 1.108 ProviderIdContainer pidc = 1690 request->operationContext.get(ProviderIdContainer::NAME);
1691 marek 1.63 ProviderName name = _resolveProviderName(pidc); 1692
1693 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 1694 { 1695 ph = providerManager.getRemoteProvider( 1696 name.getLocation(), name.getLogicalName());
1697 marek 1.63 }
1698 venkat.puvvada 1.108 else 1699 { 1700 // get cached or load new provider module 1701 ph = providerManager.getProvider( 1702 name.getPhysicalName(), name.getLogicalName());
1703 marek 1.63 } 1704 1705 // convert arguments 1706 OperationContext context; 1707 1708 context.insert(request->operationContext.get(IdentityContainer::NAME));
1709 venkat.puvvada 1.108 context.insert( 1710 request->operationContext.get(AcceptLanguageListContainer::NAME)); 1711 context.insert( 1712 request->operationContext.get(ContentLanguageListContainer::NAME));
1713 marek 1.63 1714 // forward request 1715 CMPIProvider & pr=ph.GetProvider(); 1716
1717 ms.aruran 1.115 PEG_TRACE_STRING( 1718 TRC_PROVIDERMANAGER, 1719 Tracer::LEVEL4,
1720 marek 1.63 "Calling provider.associatorNames: " + pr.getName()); 1721
1722 ms.aruran 1.115 PEG_TRACE_STRING( 1723 TRC_PROVIDERMANAGER, 1724 Tracer::LEVEL4, 1725 String("--- CMPIProviderManager::associatorNames -- role: ") + 1726 request->role + "< aCls " + request->assocClass.getString());
1727 marek 1.63 1728 CMPIStatus rc={CMPI_RC_OK,NULL}; 1729 CMPI_ContextOnStack eCtx(context); 1730 CMPI_ObjectPathOnStack eRef(objectPath); 1731 CMPI_ResultOnStack eRes(handler,&pr.broker); 1732 CMPI_ThreadContext thr(&pr.broker,&eCtx); 1733 const CString aClass=request->assocClass.getString().getCString(); 1734 const CString rClass=request->resultClass.getString().getCString(); 1735 const CString rRole=request->role.getCString(); 1736 const CString resRole=request->resultRole.getCString(); 1737 1738 CMPIFlags flgs=0;
1739 venkat.puvvada 1.108 eCtx.ft->addEntry( 1740 &eCtx, 1741 CMPIInvocationFlags, 1742 (CMPIValue*)&flgs, 1743 CMPI_uint32);
1744 marek 1.63 1745 const IdentityContainer container =
1746 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME);
1747 marek 1.63 eCtx.ft->addEntry(&eCtx,
1748 venkat.puvvada 1.108 CMPIPrincipal, 1749 (CMPIValue)(const char)container.getUserName().getCString(), 1750 CMPI_chars);
1751 marek 1.63
1752 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
1753 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME);
1754 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
1755 kumpf 1.79 eCtx.ft->addEntry( 1756 &eCtx,
1757 dave.sudlik 1.99 CMPIAcceptLanguage,
1758 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
1759 venkat.puvvada 1.108 acceptLangs).getCString(),
1760 kumpf 1.79 CMPI_chars);
1761 venkat.puvvada 1.108 1762 if (remote) 1763 { 1764 CString info=pidc.getRemoteInfo().getCString(); 1765 eCtx.ft->addEntry( 1766 &eCtx, 1767 "CMPIRRemoteInfo", 1768 (CMPIValue)(const char)info, 1769 CMPI_chars);
1770 marek 1.63 } 1771 1772 CMPIProvider::pm_service_op_lock op_lock(&pr); 1773
1774 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
1775 marek 1.63
1776 kumpf 1.92 { 1777 StatProviderTimeMeasurement providerTime(response);
1778 marek 1.63
1779 kumpf 1.92 rc = pr.miVector.assocMI->ft->associatorNames( 1780 pr.miVector.assocMI,&eCtx,&eRes,&eRef,CHARS(aClass), 1781 CHARS(rClass),CHARS(rRole),CHARS(resRole)); 1782 }
1783 marek 1.63
1784 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 1785 // Do this before checking rc from provider to throw exception in case 1786 // rc.msg is also localized. 1787 CMPIStatus tmprc={CMPI_RC_OK,NULL};
1788 venkat.puvvada 1.108 CMPIData cldata = 1789 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
1790 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 1791 { 1792 response->operationContext.set( 1793 ContentLanguageListContainer(
1794 venkat.puvvada 1.108 ContentLanguageList( 1795 LanguageParser::parseContentLanguageHeader( 1796 CMGetCharPtr(cldata.value.string)))));
1797 dave.sudlik 1.103 handler.setContext(response->operationContext);
1798 dave.sudlik 1.99 } 1799
1800 marek 1.63 if (rc.rc!=CMPI_RC_OK)
1801 dave.sudlik 1.102 {
1802 venkat.puvvada 1.108 CIMException cimException( 1803 (CIMStatusCode)rc.rc, 1804 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 1805 1806 if (eRes.resError) 1807 { 1808 for (CMPI_Error* currErr=eRes.resError;
1809 dave.sudlik 1.102 currErr!=NULL; 1810 currErr=currErr->nextError)
1811 venkat.puvvada 1.108 { 1812 cimException.addError( 1813 ((CIMError*)currErr->hdl)->getInstance()); 1814 } 1815 } 1816 throw cimException;
1817 dave.sudlik 1.102 }
1818 marek 1.63 } 1819 HandlerCatch(handler); 1820 1821 PEG_METHOD_EXIT(); 1822 1823 return(response); 1824 } 1825 1826 Message * CMPIProviderManager::handleReferencesRequest(const Message * message) 1827 {
1828 ms.aruran 1.115 PEG_METHOD_ENTER( 1829 TRC_PROVIDERMANAGER, 1830 "CMPIProviderManager::handleReferencesRequest()");
1831 marek 1.63
1832 kumpf 1.92 HandlerIntro(References,message,request,response,handler);
1833 venkat.puvvada 1.108 try 1834 {
1835 marek 1.63 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1836 venkat.puvvada 1.108 "CMPIProviderManager::handleReferencesRequest - Host name: $0 " 1837 "Name space: $1 Class name: $2",
1838 marek 1.63 System::getHostName(), 1839 request->nameSpace.getString(), 1840 request->objectName.getClassName().getString()); 1841 1842 // make target object path 1843 CIMObjectPath objectPath( 1844 System::getHostName(), 1845 request->nameSpace, 1846 request->objectName.getClassName()); 1847 1848 objectPath.setKeyBindings(request->objectName.getKeyBindings()); 1849 1850 CIMObjectPath resultPath( 1851 System::getHostName(), 1852 request->nameSpace, 1853 request->resultClass.getString()); 1854 1855 Boolean remote=false; 1856 CMPIProvider::OpProviderHolder ph; 1857 1858 // resolve provider name
1859 venkat.puvvada 1.108 ProviderIdContainer pidc = 1860 request->operationContext.get(ProviderIdContainer::NAME);
1861 marek 1.63 ProviderName name = _resolveProviderName(pidc); 1862
1863 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 1864 { 1865 ph = providerManager.getRemoteProvider( 1866 name.getLocation(), name.getLogicalName());
1867 marek 1.63 }
1868 venkat.puvvada 1.108 else 1869 { 1870 // get cached or load new provider module 1871 ph = providerManager.getProvider( 1872 name.getPhysicalName(), name.getLogicalName());
1873 marek 1.63 } 1874 1875 // convert arguments 1876 OperationContext context; 1877 1878 context.insert(request->operationContext.get(IdentityContainer::NAME));
1879 venkat.puvvada 1.108 context.insert( 1880 request->operationContext.get(AcceptLanguageListContainer::NAME)); 1881 context.insert( 1882 request->operationContext.get(ContentLanguageListContainer::NAME));
1883 marek 1.63 // forward request 1884 CMPIProvider & pr=ph.GetProvider(); 1885
1886 a.dunfey 1.85 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
1887 venkat.puvvada 1.118.2.2 AutoPtr<NormalizerContext> tmpNormalizerContext( 1888 new CIMOMHandleContext(*pr._cimom_handle)); 1889 request->operationContext.insert( 1890 NormalizerContextContainer(tmpNormalizerContext)); 1891 #endif
1892 a.dunfey 1.85
1893 ms.aruran 1.115 PEG_TRACE_STRING( 1894 TRC_PROVIDERMANAGER, 1895 Tracer::LEVEL4,
1896 marek 1.63 "Calling provider.references: " + pr.getName()); 1897
1898 ms.aruran 1.115 PEG_TRACE_STRING( 1899 TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1900 String("--- CMPIProviderManager::references -- role:") + 1901 request->role + "< aCls " + request->resultClass.getString());
1902 marek 1.63 1903 CMPIStatus rc={CMPI_RC_OK,NULL}; 1904 CMPI_ContextOnStack eCtx(context); 1905 CMPI_ObjectPathOnStack eRef(objectPath); 1906 CMPI_ResultOnStack eRes(handler,&pr.broker); 1907 CMPI_ThreadContext thr(&pr.broker,&eCtx); 1908 const CString rClass=request->resultClass.getString().getCString(); 1909 const CString rRole=request->role.getCString(); 1910 1911 CMPIPropertyList props(request->propertyList); 1912 1913 CMPIFlags flgs=0; 1914 if (request->includeQualifiers) flgs\|=CMPI_FLAG_IncludeQualifiers; 1915 if (request->includeClassOrigin) flgs\|=CMPI_FLAG_IncludeClassOrigin;
1916 venkat.puvvada 1.108 eCtx.ft->addEntry( 1917 &eCtx, 1918 CMPIInvocationFlags, 1919 (CMPIValue*)&flgs, 1920 CMPI_uint32);
1921 marek 1.63 1922 const IdentityContainer container =
1923 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME);
1924 marek 1.63 eCtx.ft->addEntry(&eCtx,
1925 venkat.puvvada 1.108 CMPIPrincipal, 1926 (CMPIValue)(const char)container.getUserName().getCString(), 1927 CMPI_chars);
1928 marek 1.63
1929 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
1930 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME);
1931 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
1932 kumpf 1.79 eCtx.ft->addEntry( 1933 &eCtx,
1934 dave.sudlik 1.99 CMPIAcceptLanguage,
1935 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
1936 venkat.puvvada 1.108 acceptLangs).getCString(),
1937 kumpf 1.79 CMPI_chars);
1938 venkat.puvvada 1.108 1939 if (remote) 1940 { 1941 CString info=pidc.getRemoteInfo().getCString(); 1942 eCtx.ft->addEntry( 1943 &eCtx, 1944 "CMPIRRemoteInfo", 1945 (CMPIValue)(const char)info, 1946 CMPI_chars);
1947 marek 1.63 } 1948 1949 CMPIProvider::pm_service_op_lock op_lock(&pr); 1950
1951 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
1952 marek 1.63
1953 kumpf 1.92 { 1954 StatProviderTimeMeasurement providerTime(response);
1955 marek 1.63
1956 kumpf 1.92 rc = pr.miVector.assocMI->ft->references( 1957 pr.miVector.assocMI,&eCtx,&eRes,&eRef, 1958 CHARS(rClass),CHARS(rRole),(const char **)props.getList()); 1959 }
1960 marek 1.63
1961 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 1962 // Do this before checking rc from provider to throw exception in case 1963 // rc.msg is also localized. 1964 CMPIStatus tmprc={CMPI_RC_OK,NULL};
1965 venkat.puvvada 1.108 CMPIData cldata = 1966 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
1967 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 1968 { 1969 response->operationContext.set( 1970 ContentLanguageListContainer(
1971 venkat.puvvada 1.108 ContentLanguageList( 1972 LanguageParser::parseContentLanguageHeader( 1973 CMGetCharPtr(cldata.value.string)))));
1974 dave.sudlik 1.103 handler.setContext(response->operationContext);
1975 dave.sudlik 1.99 } 1976
1977 marek 1.63 if (rc.rc!=CMPI_RC_OK)
1978 dave.sudlik 1.102 {
1979 venkat.puvvada 1.108 CIMException cimException( 1980 (CIMStatusCode)rc.rc, 1981 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 1982 1983 if (eRes.resError) 1984 { 1985 for (CMPI_Error* currErr=eRes.resError;
1986 dave.sudlik 1.102 currErr!=NULL; 1987 currErr=currErr->nextError)
1988 venkat.puvvada 1.108 { 1989 cimException.addError( 1990 ((CIMError*)currErr->hdl)->getInstance()); 1991 } 1992 } 1993 throw cimException;
1994 dave.sudlik 1.102 }
1995 marek 1.63 } 1996 HandlerCatch(handler); 1997 1998 PEG_METHOD_EXIT(); 1999 2000 return(response); 2001 } 2002
2003 venkat.puvvada 1.108 Message * CMPIProviderManager::handleReferenceNamesRequest( 2004 const Message * message)
2005 marek 1.63 {
2006 ms.aruran 1.115 PEG_METHOD_ENTER( 2007 TRC_PROVIDERMANAGER, 2008 "CMPIProviderManager::handleReferenceNamesRequest()");
2009 marek 1.63
2010 kumpf 1.92 HandlerIntro(ReferenceNames,message,request,response,handler);
2011 venkat.puvvada 1.108 try 2012 {
2013 marek 1.63 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2014 venkat.puvvada 1.108 "CMPIProviderManager::handleReferenceNamesRequest - Host name: $0" 2015 " Name space: $1 Class name: $2",
2016 marek 1.63 System::getHostName(), 2017 request->nameSpace.getString(), 2018 request->objectName.getClassName().getString()); 2019 2020 // make target object path 2021 CIMObjectPath objectPath( 2022 System::getHostName(), 2023 request->nameSpace, 2024 request->objectName.getClassName()); 2025 2026 objectPath.setKeyBindings(request->objectName.getKeyBindings()); 2027 2028 CIMObjectPath resultPath( 2029 System::getHostName(), 2030 request->nameSpace, 2031 request->resultClass.getString()); 2032 2033 Boolean remote=false; 2034 CMPIProvider::OpProviderHolder ph; 2035 2036 // resolve provider name
2037 venkat.puvvada 1.108 ProviderIdContainer pidc = 2038 request->operationContext.get(ProviderIdContainer::NAME);
2039 marek 1.63 ProviderName name = _resolveProviderName(pidc); 2040
2041 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 2042 { 2043 ph = providerManager.getRemoteProvider( 2044 name.getLocation(), name.getLogicalName());
2045 marek 1.63 }
2046 venkat.puvvada 1.108 else 2047 { 2048 // get cached or load new provider module 2049 ph = providerManager.getProvider( 2050 name.getPhysicalName(), name.getLogicalName());
2051 marek 1.63 } 2052 2053 // convert arguments 2054 OperationContext context; 2055
2056 venkat.puvvada 1.108 context.insert(request->operationContext.get(IdentityContainer::NAME)); 2057 context.insert( 2058 request->operationContext.get(AcceptLanguageListContainer::NAME)); 2059 context.insert( 2060 request->operationContext.get(ContentLanguageListContainer::NAME));
2061 marek 1.63 CMPIProvider & pr=ph.GetProvider(); 2062
2063 ms.aruran 1.115 PEG_TRACE_STRING( 2064 TRC_PROVIDERMANAGER, 2065 Tracer::LEVEL4,
2066 marek 1.63 "Calling provider.referenceNames: " + pr.getName()); 2067
2068 ms.aruran 1.115 PEG_TRACE_STRING( 2069 TRC_PROVIDERMANAGER, 2070 Tracer::LEVEL4, 2071 String("--- CMPIProviderManager::referenceNames -- role: ") + 2072 request->role + "< aCls " + request->resultClass.getString());
2073 marek 1.63 2074 CMPIStatus rc={CMPI_RC_OK,NULL}; 2075 CMPI_ContextOnStack eCtx(context); 2076 CMPI_ObjectPathOnStack eRef(objectPath); 2077 CMPI_ResultOnStack eRes(handler,&pr.broker); 2078 CMPI_ThreadContext thr(&pr.broker,&eCtx); 2079 const CString rClass=request->resultClass.getString().getCString(); 2080 const CString rRole=request->role.getCString(); 2081 2082 CMPIFlags flgs=0;
2083 venkat.puvvada 1.108 eCtx.ft->addEntry( 2084 &eCtx, 2085 CMPIInvocationFlags, 2086 (CMPIValue*)&flgs, 2087 CMPI_uint32);
2088 marek 1.63 2089 const IdentityContainer container =
2090 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME);
2091 marek 1.63 eCtx.ft->addEntry(&eCtx,
2092 venkat.puvvada 1.108 CMPIPrincipal, 2093 (CMPIValue)(const char)container.getUserName().getCString(), 2094 CMPI_chars);
2095 marek 1.63
2096 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
2097 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME); 2098
2099 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
2100 kumpf 1.79 eCtx.ft->addEntry( 2101 &eCtx,
2102 dave.sudlik 1.99 CMPIAcceptLanguage,
2103 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
2104 venkat.puvvada 1.108 acceptLangs).getCString(),
2105 kumpf 1.79 CMPI_chars);
2106 venkat.puvvada 1.108 if (remote) 2107 { 2108 CString info=pidc.getRemoteInfo().getCString(); 2109 eCtx.ft->addEntry( 2110 &eCtx, 2111 "CMPIRRemoteInfo", 2112 (CMPIValue)(const char)info, 2113 CMPI_chars);
2114 marek 1.63 } 2115 2116 CMPIProvider::pm_service_op_lock op_lock(&pr); 2117
2118 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
2119 marek 1.63
2120 kumpf 1.92 { 2121 StatProviderTimeMeasurement providerTime(response);
2122 marek 1.63
2123 kumpf 1.92 rc = pr.miVector.assocMI->ft->referenceNames( 2124 pr.miVector.assocMI,&eCtx,&eRes,&eRef, 2125 CHARS(rClass),CHARS(rRole)); 2126 }
2127 marek 1.63
2128 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 2129 // Do this before checking rc from provider to throw exception in case 2130 // rc.msg is also localized. 2131 CMPIStatus tmprc={CMPI_RC_OK,NULL};
2132 venkat.puvvada 1.108 CMPIData cldata = 2133 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
2134 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 2135 { 2136 response->operationContext.set( 2137 ContentLanguageListContainer(
2138 venkat.puvvada 1.108 ContentLanguageList( 2139 LanguageParser::parseContentLanguageHeader( 2140 CMGetCharPtr(cldata.value.string)))));
2141 dave.sudlik 1.103 handler.setContext(response->operationContext);
2142 dave.sudlik 1.99 } 2143
2144 marek 1.63 if (rc.rc!=CMPI_RC_OK)
2145 dave.sudlik 1.102 {
2146 venkat.puvvada 1.108 CIMException cimException( 2147 (CIMStatusCode)rc.rc, 2148 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 2149 2150 if (eRes.resError) 2151 { 2152 for (CMPI_Error* currErr=eRes.resError;
2153 dave.sudlik 1.102 currErr!=NULL; 2154 currErr=currErr->nextError)
2155 venkat.puvvada 1.108 { 2156 cimException.addError( 2157 ((CIMError*)currErr->hdl)->getInstance()); 2158 } 2159 } 2160 throw cimException;
2161 dave.sudlik 1.102 }
2162 marek 1.63 } 2163 HandlerCatch(handler); 2164 2165 PEG_METHOD_EXIT(); 2166 2167 return(response); 2168 } 2169
2170 venkat.puvvada 1.108 Message * CMPIProviderManager::handleInvokeMethodRequest( 2171 const Message * message)
2172 marek 1.63 {
2173 ms.aruran 1.115 PEG_METHOD_ENTER( 2174 TRC_PROVIDERMANAGER, 2175 "CMPIProviderManager::handleInvokeMethodRequest()");
2176 marek 1.63
2177 kumpf 1.92 HandlerIntro(InvokeMethod,message,request,response,handler);
2178 venkat.puvvada 1.108 try 2179 {
2180 marek 1.63 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2181 venkat.puvvada 1.108 "CMPIProviderManager::handleInvokeMethodRequest - Host name: $0 " 2182 "Name space: $1 Class name: $2",
2183 marek 1.63 System::getHostName(), 2184 request->nameSpace.getString(), 2185 request->instanceName.getClassName().getString()); 2186 2187 // make target object path 2188 CIMObjectPath objectPath( 2189 System::getHostName(), 2190 request->nameSpace, 2191 request->instanceName.getClassName(), 2192 request->instanceName.getKeyBindings()); 2193 2194 Boolean remote=false; 2195 CMPIProvider::OpProviderHolder ph; 2196 2197 // resolve provider name
2198 venkat.puvvada 1.108 ProviderIdContainer pidc = 2199 request->operationContext.get(ProviderIdContainer::NAME);
2200 marek 1.63 ProviderName name = _resolveProviderName(pidc); 2201
2202 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 2203 { 2204 ph = providerManager.getRemoteProvider( 2205 name.getLocation(), name.getLogicalName());
2206 marek 1.63 }
2207 venkat.puvvada 1.108 else 2208 { 2209 // get cached or load new provider module 2210 ph = providerManager.getProvider( 2211 name.getPhysicalName(), name.getLogicalName());
2212 marek 1.63 } 2213 2214 // convert arguments 2215 OperationContext context; 2216 2217 context.insert(request->operationContext.get(IdentityContainer::NAME));
2218 venkat.puvvada 1.108 context.insert( 2219 request->operationContext.get(AcceptLanguageListContainer::NAME)); 2220 context.insert( 2221 request->operationContext.get(ContentLanguageListContainer::NAME));
2222 marek 1.63 2223 CIMObjectPath instanceReference(request->instanceName); 2224 2225 // ATTN: propagate namespace 2226 instanceReference.setNameSpace(request->nameSpace); 2227 2228 // forward request 2229 CMPIProvider & pr=ph.GetProvider(); 2230
2231 a.dunfey 1.85 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
2232 venkat.puvvada 1.118.2.2 AutoPtr<NormalizerContext> tmpNormalizerContext( 2233 new CIMOMHandleContext(*pr._cimom_handle)); 2234 request->operationContext.insert( 2235 NormalizerContextContainer(tmpNormalizerContext)); 2236 #endif
2237 a.dunfey 1.85
2238 ms.aruran 1.115 PEG_TRACE_STRING( 2239 TRC_PROVIDERMANAGER, 2240 Tracer::LEVEL4,
2241 marek 1.63 "Calling provider.invokeMethod: " + pr.getName()); 2242 2243 CMPIStatus rc={CMPI_RC_OK,NULL}; 2244 CMPI_ContextOnStack eCtx(context); 2245 CMPI_ObjectPathOnStack eRef(objectPath); 2246 CMPI_ResultOnStack eRes(handler,&pr.broker); 2247 CMPI_ThreadContext thr(&pr.broker,&eCtx); 2248 CMPI_ArgsOnStack eArgsIn(request->inParameters); 2249 Array<CIMParamValue> outArgs; 2250 CMPI_ArgsOnStack eArgsOut(outArgs); 2251 CString mName=request->methodName.getString().getCString(); 2252 2253 CMPIFlags flgs=0;
2254 venkat.puvvada 1.108 eCtx.ft->addEntry( 2255 &eCtx, 2256 CMPIInvocationFlags, 2257 (CMPIValue*)&flgs, 2258 CMPI_uint32);
2259 marek 1.63 2260 const IdentityContainer container =
2261 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME);
2262 marek 1.63 eCtx.ft->addEntry(&eCtx,
2263 venkat.puvvada 1.108 CMPIPrincipal, 2264 (CMPIValue)(const char)container.getUserName().getCString(), 2265 CMPI_chars);
2266 marek 1.63
2267 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
2268 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME); 2269
2270 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
2271 kumpf 1.79 eCtx.ft->addEntry( 2272 &eCtx,
2273 dave.sudlik 1.99 CMPIAcceptLanguage,
2274 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
2275 venkat.puvvada 1.108 acceptLangs).getCString(),
2276 kumpf 1.79 CMPI_chars);
2277 venkat.puvvada 1.108 if (remote) 2278 { 2279 CString info=pidc.getRemoteInfo().getCString(); 2280 eCtx.ft->addEntry( 2281 &eCtx, 2282 "CMPIRRemoteInfo", 2283 (CMPIValue)(const char)info, 2284 CMPI_chars);
2285 marek 1.63 } 2286 2287 CMPIProvider::pm_service_op_lock op_lock(&pr); 2288
2289 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
2290 venkat.puvvada 1.108
2291 kumpf 1.92 { 2292 StatProviderTimeMeasurement providerTime(response);
2293 marek 1.63
2294 kumpf 1.92 rc = pr.miVector.methMI->ft->invokeMethod( 2295 pr.miVector.methMI,&eCtx,&eRes,&eRef, 2296 CHARS(mName),&eArgsIn,&eArgsOut); 2297 }
2298 marek 1.63
2299 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 2300 // Do this before checking rc from provider to throw exception in case 2301 // rc.msg is also localized. 2302 CMPIStatus tmprc={CMPI_RC_OK,NULL};
2303 venkat.puvvada 1.108 CMPIData cldata = 2304 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
2305 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 2306 { 2307 response->operationContext.set( 2308 ContentLanguageListContainer(
2309 venkat.puvvada 1.108 ContentLanguageList( 2310 LanguageParser::parseContentLanguageHeader( 2311 CMGetCharPtr(cldata.value.string)))));
2312 dave.sudlik 1.103 handler.setContext(response->operationContext);
2313 dave.sudlik 1.99 } 2314
2315 marek 1.63 if (rc.rc!=CMPI_RC_OK)
2316 dave.sudlik 1.102 {
2317 venkat.puvvada 1.108 CIMException cimException( 2318 (CIMStatusCode)rc.rc, 2319 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 2320 2321 if (eRes.resError) 2322 { 2323 for (CMPI_Error* currErr=eRes.resError;
2324 dave.sudlik 1.102 currErr!=NULL; 2325 currErr=currErr->nextError)
2326 venkat.puvvada 1.108 { 2327 cimException.addError( 2328 ((CIMError*)currErr->hdl)->getInstance()); 2329 } 2330 } 2331 throw cimException;
2332 dave.sudlik 1.102 } 2333
2334 a.dunfey 1.85 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
2335 venkat.puvvada 1.118.2.2 // Even if external normalization is enabled we don't normalize the 2336 // Embedded instances present in output args. Normalize them here.
2337 a.dunfey 1.85 { 2338 // There is no try catch here because if there is no external 2339 // normalization, then these containers were added by this method. 2340 const CachedClassDefinitionContainer * classCont = 2341 dynamic_cast<const CachedClassDefinitionContainer *>(
2342 venkat.puvvada 1.108 &request->operationContext.get( 2343 CachedClassDefinitionContainer::NAME));
2344 kumpf 1.106 PEGASUS_ASSERT(classCont != 0);
2345 a.dunfey 1.85 const NormalizerContextContainer * contextCont = 2346 dynamic_cast<const NormalizerContextContainer*>(
2347 venkat.puvvada 1.108 &request->operationContext.get( 2348 NormalizerContextContainer::NAME));
2349 kumpf 1.106 PEGASUS_ASSERT(contextCont != 0); 2350
2351 a.dunfey 1.85 CIMClass classDef(classCont->getClass()); 2352 Uint32 methodIndex = classDef.findMethod(request->methodName); 2353 PEGASUS_ASSERT(methodIndex != PEG_NOT_FOUND); 2354 CIMMethod methodDef(classDef.getMethod(methodIndex));
2355 venkat.puvvada 1.108 for (unsigned int i = 0, n = outArgs.size(); i < n; ++i)
2356 a.dunfey 1.85 { 2357 CIMParamValue currentParam(outArgs[i]); 2358 CIMValue paramValue(currentParam.getValue()); 2359 // If the parameter value is an EmbeddedObject type, we have 2360 // to check against the type of the parameter definition. 2361 // CMPI does not distinguish between EmbeddedObjects and 2362 // EmbeddedInstances, so if the parameter definition has a type 2363 // of EmbeddedInstance, the type of the output parameter must 2364 // be changed.
2365 venkat.puvvada 1.108 if (paramValue.getType() == CIMTYPE_OBJECT)
2366 a.dunfey 1.85 { 2367 CIMObject paramObject; 2368 paramValue.get(paramObject); 2369 CIMInstance paramInst(paramObject); 2370 resolveEmbeddedInstanceTypes(&handler, paramInst); 2371 String currentParamName(currentParam.getParameterName()); 2372 Uint32 paramIndex = methodDef.findParameter( 2373 CIMName(currentParamName));
2374 venkat.puvvada 1.108 if (paramIndex == PEG_NOT_FOUND)
2375 a.dunfey 1.85 { 2376 MessageLoaderParms msg("ProviderManager.CMPI." 2377 "CMPIProviderManager.PARAMETER_NOT_FOUND",
2378 dave.sudlik 1.117 "Parameter $0 not found in definition for " 2379 "method $1.", currentParamName,
2380 a.dunfey 1.85 request->methodName.getString()); 2381 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2382 dave.sudlik 1.117 MessageLoader::getMessage(msg));
2383 a.dunfey 1.85 handler.setStatus(CIM_ERR_FAILED,
2384 dave.sudlik 1.117 MessageLoader::getMessage(msg));
2385 a.dunfey 1.85 } 2386 else 2387 { 2388 CIMConstParameter paramDef( 2389 methodDef.getParameter(paramIndex));
2390 venkat.puvvada 1.108 if (paramDef.findQualifier(CIMName("EmbeddedInstance"))
2391 a.dunfey 1.85 != PEG_NOT_FOUND) 2392 { 2393 currentParam = CIMParamValue(currentParamName, 2394 CIMValue(paramInst)); 2395 } 2396 else 2397 { 2398 currentParam = CIMParamValue(currentParamName, 2399 CIMValue(paramObject)); 2400 } 2401 2402 handler.deliverParamValue(currentParam); 2403 } 2404 } 2405 else 2406 { 2407 handler.deliverParamValue(currentParam); 2408 } 2409 } 2410 } 2411 #else 2412 a.dunfey 1.85 for (int i=0,s=outArgs.size(); i<s; i++) 2413 { 2414 handler.deliverParamValue(outArgs[i]); 2415 } 2416 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
2417 venkat.puvvada 1.108 handler.complete();
2418 marek 1.63 } 2419 HandlerCatch(handler); 2420 2421 PEG_METHOD_EXIT(); 2422 2423 return(response); 2424 } 2425
2426 venkat.puvvada 1.108 int LocateIndicationProviderNames( 2427 const CIMInstance& pInstance, 2428 const CIMInstance& pmInstance, 2429 String& providerName, 2430 String& location)
2431 marek 1.63 {
2432 ms.aruran 1.115 PEG_METHOD_ENTER( 2433 TRC_PROVIDERMANAGER, 2434 "CMPIProviderManager:LocateIndicationProviderNames()");
2435 marek 1.63 Uint32 pos = pInstance.findProperty(CIMName ("Name")); 2436 pInstance.getProperty(pos).getValue().get(providerName); 2437 2438 pos = pmInstance.findProperty(CIMName ("Location")); 2439 pmInstance.getProperty(pos).getValue().get(location);
2440 ms.aruran 1.115 PEG_METHOD_EXIT();
2441 marek 1.63 return 0; 2442 } 2443
2444 venkat.puvvada 1.108 Message * CMPIProviderManager::handleCreateSubscriptionRequest( 2445 const Message * message)
2446 marek 1.63 {
2447 ms.aruran 1.115 PEG_METHOD_ENTER( 2448 TRC_PROVIDERMANAGER, 2449 "CMPIProviderManager::handleCreateSubscriptionRequest()");
2450 marek 1.63 2451 HandlerIntroInd(CreateSubscription,message,request,response,
2452 venkat.puvvada 1.108 handler); 2453 try 2454 {
2455 marek 1.63 CIMInstance req_provider, req_providerModule;
2456 venkat.puvvada 1.108 ProviderIdContainer pidc = 2457 (ProviderIdContainer)request->operationContext.get( 2458 ProviderIdContainer::NAME);
2459 marek 1.63 req_provider = pidc.getProvider(); 2460 req_providerModule = pidc.getModule(); 2461 2462 String providerName,providerLocation; 2463 LocateIndicationProviderNames(req_provider, req_providerModule,
2464 venkat.puvvada 1.108 providerName,providerLocation);
2465 marek 1.63 2466 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2467 venkat.puvvada 1.108 "CMPIProviderManager::handleCreateSubscriptionRequest - Host name:" 2468 " $0 Name space: $1 Provider name(s): $2",
2469 marek 1.63 System::getHostName(), 2470 request->nameSpace.getString(), 2471 providerName); 2472 2473 Boolean remote=false; 2474 CMPIProvider::OpProviderHolder ph; 2475
2476 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 2477 { 2478 ph = providerManager.getRemoteProvider( 2479 providerLocation, providerName);
2480 marek 1.63 }
2481 venkat.puvvada 1.108 else 2482 { 2483 // get cached or load new provider module 2484 ph = providerManager.getProvider( 2485 providerLocation, providerName);
2486 marek 1.63 } 2487 2488 indProvRecord *prec=NULL;
2489 marek 1.95 { 2490 WriteLock writeLock(rwSemProvTab);
2491 venkat.puvvada 1.108 provTab.lookup(ph.GetProvider().getName(),prec); 2492 if (prec) prec->count++; 2493 else 2494 { 2495 prec=new indProvRecord();
2496 venkat.puvvada 1.110 #ifdef PEGASUS_ENABLE_REMOTE_CMPI 2497 if (remote) 2498 { 2499 prec->remoteInfo = pidc.getRemoteInfo(); 2500 } 2501 #endif
2502 venkat.puvvada 1.108 provTab.insert(ph.GetProvider().getName(),prec); 2503 }
2504 marek 1.95 }
2505 marek 1.63 2506 // 2507 // Save the provider instance from the request 2508 // 2509 ph.GetProvider ().setProviderInstance (req_provider); 2510 2511 const CIMObjectPath &sPath=request->subscriptionInstance.getPath(); 2512
2513 marek 1.95 indSelectRecord *srec=NULL; 2514 2515 { 2516 WriteLock writeLock(rwSemSelxTab); 2517 selxTab.lookup(sPath,srec); 2518 if (srec) srec->count++;
2519 venkat.puvvada 1.108 else 2520 { 2521 srec=new indSelectRecord(); 2522 selxTab.insert(sPath,srec);
2523 marek 1.95 } 2524 }
2525 marek 1.63 2526 // convert arguments 2527 OperationContext context; 2528 context.insert(request->operationContext.get(IdentityContainer::NAME));
2529 venkat.puvvada 1.108 context.insert( 2530 request->operationContext.get(AcceptLanguageListContainer::NAME)); 2531 context.insert( 2532 request->operationContext.get(ContentLanguageListContainer::NAME)); 2533 context.insert( 2534 request->operationContext.get(SubscriptionInstanceContainer::NAME)); 2535 context.insert( 2536 request->operationContext.get( 2537 SubscriptionFilterConditionContainer::NAME));
2538 marek 1.63
2539 venkat.puvvada 1.108 CIMObjectPath subscriptionName = 2540 request->subscriptionInstance.getPath();
2541 marek 1.63 2542 CMPIProvider & pr=ph.GetProvider(); 2543 2544 CMPIStatus rc={CMPI_RC_OK,NULL}; 2545 CMPI_ContextOnStack eCtx(context);
2546 venkat.puvvada 1.108 SubscriptionFilterConditionContainer sub_cntr = 2547 request->operationContext.get( 2548 SubscriptionFilterConditionContainer::NAME); 2549 2550 CIMOMHandleQueryContext _context= 2551 new CIMOMHandleQueryContext( 2552 CIMNamespaceName( 2553 request->nameSpace.getString()), 2554 pr._cimom_handle); 2555 2556 CMPI_SelectExp *eSelx=new CMPI_SelectExp( 2557 context, 2558 _context, 2559 request->query, 2560 sub_cntr.getQueryLanguage());
2561 marek 1.63 2562 srec->eSelx=eSelx;
2563 venkat.puvvada 1.108 srec->qContext=_context;
2564 marek 1.63 2565 CMPI_ThreadContext thr(&pr.broker,&eCtx); 2566
2567 ms.aruran 1.115 PEG_TRACE_STRING( 2568 TRC_PROVIDERMANAGER, 2569 Tracer::LEVEL4,
2570 marek 1.63 "Calling provider.createSubscriptionRequest: " + pr.getName()); 2571
2572 venkat.puvvada 1.108 for (Uint32 i = 0, n = request->classNames.size(); i < n; i++) 2573 {
2574 marek 1.63 CIMObjectPath className( 2575 System::getHostName(), 2576 request->nameSpace, 2577 request->classNames[i]); 2578 eSelx->classNames.append(className); 2579 } 2580 CMPI_ObjectPathOnStack eRef(eSelx->classNames[0]); 2581 2582 CIMPropertyList propertyList = request->propertyList;
2583 venkat.puvvada 1.108 if (!propertyList.isNull()) 2584 { 2585 Array<CIMName> p=propertyList.getPropertyNameArray(); 2586 int pCount=p.size(); 2587 eSelx->props = new const char*[1+pCount]; 2588 for (int i=0; i<pCount; i++) 2589 { 2590 eSelx->props[i]=strdup(p[i].getString().getCString()); 2591 } 2592 eSelx->props[pCount]=NULL;
2593 marek 1.63 } 2594 2595 Uint16 repeatNotificationPolicy = request->repeatNotificationPolicy; 2596 2597 const IdentityContainer container =
2598 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME); 2599 eCtx.ft->addEntry(&eCtx, 2600 CMPIPrincipal, 2601 (CMPIValue)(const char)container.getUserName().getCString(), 2602 CMPI_chars); 2603
2604 marek 1.63 eCtx.ft->addEntry(&eCtx,
2605 venkat.puvvada 1.108 CMPIInitNameSpace, 2606 (CMPIValue)(const char)request-> 2607 nameSpace.getString().getCString(), 2608 CMPI_chars);
2609 marek 1.63
2610 konrad.r 1.65 const AcceptLanguageListContainer accept_language=
2611 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME); 2612
2613 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
2614 kumpf 1.79 eCtx.ft->addEntry( 2615 &eCtx,
2616 dave.sudlik 1.99 CMPIAcceptLanguage,
2617 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
2618 venkat.puvvada 1.108 acceptLangs).getCString(),
2619 kumpf 1.79 CMPI_chars);
2620 dave.sudlik 1.100 CString info;
2621 venkat.puvvada 1.108 if (remote) 2622 { 2623 info=pidc.getRemoteInfo().getCString(); 2624 eCtx.ft->addEntry( 2625 &eCtx, 2626 "CMPIRRemoteInfo", 2627 (CMPIValue)(const char)info, 2628 CMPI_chars);
2629 marek 1.63 } 2630 2631 CMPIProvider::pm_service_op_lock op_lock(&pr); 2632
2633 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
2634 venkat.puvvada 1.108
2635 kumpf 1.92 { 2636 StatProviderTimeMeasurement providerTime(response); 2637
2638 venkat.puvvada 1.108 if (pr.miVector.indMI->ft->ftVersion >= 100)
2639 kumpf 1.92 { 2640 rc = pr.miVector.indMI->ft->activateFilter( 2641 pr.miVector.indMI,&eCtx,eSelx, 2642 CHARS(eSelx->classNames[0].getClassName().getString().
2643 dave.sudlik 1.96 getCString()),&eRef,false);
2644 kumpf 1.92 } 2645 else 2646 {
2647 venkat.puvvada 1.108 // Older version of (pre 1.00) also pass in a CMPIResult
2648 marek 1.63
2649 kumpf 1.92 rc = ((CMPIStatus ()(CMPIIndicationMI, CMPIContext*,
2650 venkat.puvvada 1.108 CMPIResult, CMPISelectExp, 2651 const char , CMPIObjectPath, CMPIBoolean))
2652 dave.sudlik 1.96 pr.miVector.indMI->ft->activateFilter)
2653 venkat.puvvada 1.108 (pr.miVector.indMI,&eCtx,NULL,eSelx, 2654 CHARS(eSelx->classNames[0].getClassName().getString().
2655 dave.sudlik 1.96 getCString()),&eRef,false);
2656 kumpf 1.92 } 2657 }
2658 marek 1.63
2659 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 2660 // Do this before checking rc from provider to throw exception in case 2661 // rc.msg is also localized. 2662 CMPIStatus tmprc={CMPI_RC_OK,NULL};
2663 venkat.puvvada 1.108 CMPIData cldata = 2664 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
2665 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 2666 { 2667 response->operationContext.set( 2668 ContentLanguageListContainer(
2669 venkat.puvvada 1.108 ContentLanguageList( 2670 LanguageParser::parseContentLanguageHeader( 2671 CMGetCharPtr(cldata.value.string)))));
2672 dave.sudlik 1.99 } 2673
2674 marek 1.63 if (rc.rc!=CMPI_RC_OK) 2675 {
2676 marek 1.95 // Removed the select expression from the cache 2677 WriteLock lock(rwSemSelxTab); 2678 if (--srec->count<=0) 2679 { 2680 selxTab.remove(sPath); 2681 delete _context; 2682 delete eSelx; 2683 delete srec; 2684 }
2685 venkat.puvvada 1.108 throw CIMException((CIMStatusCode)rc.rc, 2686 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
2687 marek 1.63 } 2688 else 2689 { 2690 // 2691 // Increment count of current subscriptions for this provider 2692 // 2693 if (ph.GetProvider ().testIfZeroAndIncrementSubscriptions ()) 2694 { 2695 // 2696 // If there were no current subscriptions before the increment, 2697 // the first subscription has been created 2698 // Call the provider's enableIndications method 2699 // 2700 if (_subscriptionInitComplete) 2701 { 2702 _callEnableIndications (req_provider, _indicationCallback,
2703 dave.sudlik 1.100 ph, (const char*)info);
2704 marek 1.63 } 2705 } 2706 } 2707 } 2708 HandlerCatch(handler); 2709 2710 PEG_METHOD_EXIT(); 2711 2712 return(response); 2713 } 2714
2715 venkat.puvvada 1.108 Message * CMPIProviderManager::handleDeleteSubscriptionRequest( 2716 const Message * message)
2717 marek 1.63 {
2718 ms.aruran 1.115 PEG_METHOD_ENTER( 2719 TRC_PROVIDERMANAGER, 2720 "CMPIProviderManager::handleDeleteSubscriptionRequest()");
2721 marek 1.63 2722 HandlerIntroInd(DeleteSubscription,message,request,response,
2723 venkat.puvvada 1.108 handler); 2724 try 2725 {
2726 marek 1.63 String providerName,providerLocation; 2727 2728 CIMInstance req_provider, req_providerModule;
2729 venkat.puvvada 1.108 ProviderIdContainer pidc = 2730 (ProviderIdContainer)request->operationContext.get( 2731 ProviderIdContainer::NAME);
2732 marek 1.63 req_provider = pidc.getProvider(); 2733 req_providerModule = pidc.getModule(); 2734 2735 LocateIndicationProviderNames(req_provider, req_providerModule,
2736 venkat.puvvada 1.108 providerName,providerLocation);
2737 marek 1.63 2738 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2739 venkat.puvvada 1.108 "CMPIProviderManager::handleDeleteSubscriptionRequest - Host name:" 2740 " $0 Name space: $1 Provider name(s): $2",
2741 marek 1.63 System::getHostName(), 2742 request->nameSpace.getString(), 2743 providerName); 2744 2745 Boolean remote=false; 2746 CMPIProvider::OpProviderHolder ph; 2747
2748 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 2749 { 2750 ph = providerManager.getRemoteProvider( 2751 providerLocation, providerName);
2752 marek 1.63 }
2753 venkat.puvvada 1.108 else 2754 { 2755 // get cached or load new provider module 2756 ph = providerManager.getProvider( 2757 providerLocation, providerName);
2758 marek 1.63 } 2759 2760 2761 indProvRecord *prec=NULL;
2762 marek 1.95 { 2763 WriteLock writeLock(rwSemProvTab);
2764 venkat.puvvada 1.108 provTab.lookup(ph.GetProvider().getName(),prec); 2765 if (--prec->count<=0) 2766 { 2767 if (prec->handler) 2768 delete prec->handler; 2769 delete prec; 2770 provTab.remove(ph.GetProvider().getName()); 2771 prec=NULL; 2772 }
2773 marek 1.95 }
2774 marek 1.63 2775 indSelectRecord *srec=NULL; 2776 const CIMObjectPath &sPath=request->subscriptionInstance.getPath();
2777 r.kieninger 1.81
2778 marek 1.95 WriteLock writeLock(rwSemSelxTab);
2779 venkat.puvvada 1.108 if (!selxTab.lookup(sPath,srec)) 2780 {
2781 dave.sudlik 1.117 MessageLoaderParms parms( 2782 "ProviderManager.CMPI.CMPIProviderManager." 2783 "FAILED_LOCATE_SUBSCRIPTION_FILTER", 2784 "Failed to locate the subscription filter.");
2785 venkat.puvvada 1.108 // failed to get select expression from hash table
2786 dave.sudlik 1.117 throw CIMException(CIM_ERR_FAILED, parms);
2787 venkat.puvvada 1.108 };
2788 marek 1.63 2789 CMPI_SelectExp *eSelx=srec->eSelx;
2790 venkat.puvvada 1.108 CIMOMHandleQueryContext *qContext=srec->qContext;
2791 marek 1.63 2792 CMPI_ObjectPathOnStack eRef(eSelx->classNames[0]);
2793 marek 1.95 if (--srec->count<=0) 2794 {
2795 venkat.puvvada 1.108 selxTab.remove(sPath);
2796 marek 1.95 }
2797 marek 1.63 2798 // convert arguments 2799 OperationContext context; 2800 context.insert(request->operationContext.get(IdentityContainer::NAME));
2801 venkat.puvvada 1.108 context.insert( 2802 request->operationContext.get(AcceptLanguageListContainer::NAME)); 2803 context.insert( 2804 request->operationContext.get(ContentLanguageListContainer::NAME)); 2805 context.insert( 2806 request->operationContext.get(SubscriptionInstanceContainer::NAME));
2807 marek 1.63
2808 venkat.puvvada 1.108 CIMObjectPath subscriptionName = 2809 request->subscriptionInstance.getPath();
2810 marek 1.63 2811 CMPIProvider & pr=ph.GetProvider(); 2812 2813 CMPIStatus rc={CMPI_RC_OK,NULL}; 2814 CMPI_ContextOnStack eCtx(context); 2815 CMPI_ThreadContext thr(&pr.broker,&eCtx); 2816
2817 ms.aruran 1.115 PEG_TRACE_STRING( 2818 TRC_PROVIDERMANAGER, 2819 Tracer::LEVEL4,
2820 marek 1.63 "Calling provider.deleteSubscriptionRequest: " + pr.getName()); 2821 2822 const IdentityContainer container =
2823 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME);
2824 marek 1.63 eCtx.ft->addEntry(&eCtx,
2825 venkat.puvvada 1.108 CMPIPrincipal, 2826 (CMPIValue)(const char)container.getUserName().getCString(), 2827 CMPI_chars); 2828 2829 eCtx.ft->addEntry( 2830 &eCtx, 2831 CMPIInitNameSpace, 2832 (CMPIValue)(const char)request-> 2833 nameSpace.getString().getCString(), 2834 CMPI_chars);
2835 konrad.r 1.65 2836 const AcceptLanguageListContainer accept_language=
2837 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME);
2838 kumpf 1.80 const AcceptLanguageList acceptLangs = accept_language.getLanguages();
2839 kumpf 1.79 eCtx.ft->addEntry( 2840 &eCtx,
2841 dave.sudlik 1.99 CMPIAcceptLanguage,
2842 kumpf 1.79 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
2843 venkat.puvvada 1.108 acceptLangs).getCString(),
2844 kumpf 1.79 CMPI_chars);
2845 dave.sudlik 1.100 CString info;
2846 venkat.puvvada 1.108 if (remote) 2847 { 2848 info=pidc.getRemoteInfo().getCString(); 2849 eCtx.ft->addEntry( 2850 &eCtx, 2851 "CMPIRRemoteInfo", 2852 (CMPIValue)(const char)info, 2853 CMPI_chars);
2854 marek 1.63 } 2855 2856 CMPIProvider::pm_service_op_lock op_lock(&pr); 2857
2858 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
2859 venkat.puvvada 1.108
2860 kumpf 1.92 { 2861 StatProviderTimeMeasurement providerTime(response); 2862
2863 venkat.puvvada 1.108 if (pr.miVector.indMI->ft->ftVersion >= 100)
2864 kumpf 1.92 { 2865 rc = pr.miVector.indMI->ft->deActivateFilter( 2866 pr.miVector.indMI,&eCtx,eSelx, 2867 CHARS(eSelx->classNames[0].getClassName().getString().
2868 dave.sudlik 1.96 getCString()),&eRef,prec==NULL);
2869 kumpf 1.92 } 2870 else 2871 { 2872 // Older version of (pre 1.00) also pass in a CMPIResult
2873 marek 1.63
2874 kumpf 1.92 rc = ((CMPIStatus ()(CMPIIndicationMI, CMPIContext, 2875 CMPIResult, CMPISelectExp*,
2876 venkat.puvvada 1.108 const char , CMPIObjectPath, CMPIBoolean))
2877 dave.sudlik 1.96 pr.miVector.indMI->ft->deActivateFilter)
2878 venkat.puvvada 1.108 (pr.miVector.indMI,&eCtx,NULL,eSelx, 2879 CHARS(eSelx->classNames[0].getClassName().getString().
2880 dave.sudlik 1.96 getCString()),&eRef,prec==NULL);
2881 kumpf 1.92 } 2882 }
2883 marek 1.63
2884 marek 1.95 if (srec->count<=0) 2885 {
2886 venkat.puvvada 1.108 delete qContext; 2887 delete eSelx; 2888 delete srec;
2889 marek 1.95 }
2890 marek 1.63
2891 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 2892 // Do this before checking rc from provider to throw exception in case 2893 // rc.msg is also localized. 2894 CMPIStatus tmprc={CMPI_RC_OK,NULL};
2895 venkat.puvvada 1.108 CMPIData cldata = 2896 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
2897 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 2898 { 2899 response->operationContext.set( 2900 ContentLanguageListContainer(
2901 venkat.puvvada 1.108 ContentLanguageList( 2902 LanguageParser::parseContentLanguageHeader( 2903 CMGetCharPtr(cldata.value.string)))));
2904 dave.sudlik 1.99 } 2905
2906 marek 1.63 if (rc.rc!=CMPI_RC_OK) 2907 {
2908 venkat.puvvada 1.108 throw CIMException((CIMStatusCode)rc.rc, 2909 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY);
2910 marek 1.63 } 2911 else 2912 { 2913 // 2914 // Decrement count of current subscriptions for this provider 2915 // 2916 if (ph.GetProvider ().decrementSubscriptionsAndTestIfZero ()) 2917 { 2918 // 2919 // If there are no current subscriptions after the decrement, 2920 // the last subscription has been deleted 2921 // Call the provider's disableIndications method 2922 // 2923 if (_subscriptionInitComplete) 2924 {
2925 dave.sudlik 1.100 _callDisableIndications (ph, (const char*)info);
2926 marek 1.63 } 2927 } 2928 } 2929 } 2930 HandlerCatch(handler); 2931 2932 PEG_METHOD_EXIT(); 2933 2934 return(response); 2935 } 2936
2937 venkat.puvvada 1.108 Message * CMPIProviderManager::handleDisableModuleRequest( 2938 const Message * message)
2939 marek 1.63 {
2940 ms.aruran 1.115 PEG_METHOD_ENTER( 2941 TRC_PROVIDERMANAGER, 2942 "CMPIProviderManager::handleDisableModuleRequest()");
2943 marek 1.63 2944 CIMDisableModuleRequestMessage * request =
2945 venkat.puvvada 1.108 dynamic_cast<CIMDisableModuleRequestMessage >( 2946 const_cast<Message >(message));
2947 marek 1.63 2948 PEGASUS_ASSERT(request != 0); 2949 2950 // get provider module name 2951 Boolean disableProviderOnly = request->disableProviderOnly; 2952 2953 Array<Uint16> operationalStatus; 2954 // Assume success. 2955 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED); 2956 2957 // 2958 // Unload providers 2959 // 2960 Array<CIMInstance> _pInstances = request->providers; 2961 Array <Boolean> _indicationProviders = request->indicationProviders;
2962 venkat.puvvada 1.108 /* The CIMInstances on request->providers array is completly _different_ 2963 than the request->providerModule CIMInstance. Hence */
2964 marek 1.63
2965 konrad.r 1.69 String physicalName=(request->providerModule.getProperty(
2966 venkat.puvvada 1.108 request-> 2967 providerModule.findProperty("Location")).getValue().toString());
2968 marek 1.63
2969 venkat.puvvada 1.108 for (Uint32 i = 0, n = _pInstances.size(); i < n; i++)
2970 marek 1.63 { 2971 String providerName; 2972 _pInstances [i].getProperty (_pInstances [i].findProperty 2973 (CIMName ("Name"))).getValue ().get (providerName); 2974
2975 venkat.puvvada 1.108 Uint32 pos = _pInstances[i].findProperty("Name");
2976 marek 1.63 2977 // 2978 // Reset the indication provider's count of current 2979 // subscriptions since it has been disabled 2980 // 2981 if (_indicationProviders [i]) 2982 { 2983 if (physicalName.size () > 0) 2984 {
2985 venkat.puvvada 1.108 try 2986 { 2987 CMPIProvider::OpProviderHolder ph = 2988 providerManager.getProvider( 2989 physicalName, 2990 providerName); 2991 ph.GetProvider ().resetSubscriptions (); 2992 } 2993 catch (const Exception &e) 2994 { 2995 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2, 2996 e.getMessage()); 2997 }
2998 marek 1.63 } 2999 }
3000 venkat.puvvada 1.108 providerManager.unloadProvider( 3001 physicalName, 3002 _pInstances[i].getProperty( 3003 _pInstances[i].findProperty("Name") 3004 ).getValue ().toString ());
3005 marek 1.63 } 3006 3007 CIMDisableModuleResponseMessage * response = 3008 new CIMDisableModuleResponseMessage( 3009 request->messageId, 3010 CIMException(), 3011 request->queueIds.copyAndPop(), 3012 operationalStatus); 3013 3014 PEGASUS_ASSERT(response != 0); 3015 3016 // 3017 // Set HTTP method in response from request 3018 // 3019 response->setHttpMethod (request->getHttpMethod ()); 3020 3021 PEG_METHOD_EXIT(); 3022 3023 return(response); 3024 } 3025
3026 venkat.puvvada 1.108 Message * CMPIProviderManager::handleEnableModuleRequest( 3027 const Message * message)
3028 marek 1.63 {
3029 ms.aruran 1.115 PEG_METHOD_ENTER( 3030 TRC_PROVIDERMANAGER, 3031 "CMPIProviderManager::handleEnableModuleRequest()");
3032 marek 1.63 3033 CIMEnableModuleRequestMessage * request =
3034 venkat.puvvada 1.108 dynamic_cast<CIMEnableModuleRequestMessage >( 3035 const_cast<Message >(message));
3036 marek 1.63 3037 PEGASUS_ASSERT(request != 0); 3038 3039 Array<Uint16> operationalStatus; 3040 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK); 3041 3042 CIMEnableModuleResponseMessage * response = 3043 new CIMEnableModuleResponseMessage( 3044 request->messageId, 3045 CIMException(), 3046 request->queueIds.copyAndPop(), 3047 operationalStatus); 3048 3049 PEGASUS_ASSERT(response != 0); 3050 3051 // Set HTTP method in response from request 3052 response->setHttpMethod (request->getHttpMethod ()); 3053 3054 PEG_METHOD_EXIT(); 3055 3056 return(response); 3057 marek 1.63 } 3058
3059 venkat.puvvada 1.108 Message * CMPIProviderManager::handleStopAllProvidersRequest( 3060 const Message * message)
3061 marek 1.63 {
3062 ms.aruran 1.115 PEG_METHOD_ENTER( 3063 TRC_PROVIDERMANAGER, 3064 "CMPIProviderManager::handleStopAllProvidersRequest()");
3065 marek 1.63 3066 CIMStopAllProvidersRequestMessage * request =
3067 venkat.puvvada 1.108 dynamic_cast<CIMStopAllProvidersRequestMessage >( 3068 const_cast<Message >(message));
3069 marek 1.63 3070 PEGASUS_ASSERT(request != 0); 3071 3072 CIMStopAllProvidersResponseMessage * response = 3073 new CIMStopAllProvidersResponseMessage( 3074 request->messageId, 3075 CIMException(), 3076 request->queueIds.copyAndPop()); 3077 3078 PEGASUS_ASSERT(response != 0); 3079 3080 // Set HTTP method in response from request 3081 response->setHttpMethod (request->getHttpMethod ()); 3082 3083 // tell the provider manager to shutdown all the providers 3084 providerManager.shutdownAllProviders(); 3085 3086 PEG_METHOD_EXIT(); 3087 3088 return(response); 3089 } 3090 marek 1.63
3091 s.kodali 1.113 // Note: The PG_Provider AutoStart property is not yet supported 3092 #if 0 3093 Message * CMPIProviderManager::handleInitializeProviderRequest( 3094 const Message * message) 3095 { 3096 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, 3097 "CMPIProviderManager::handleInitializeProviderRequest");
3098 marek 1.63
3099 s.kodali 1.113 HandlerIntroInit(InitializeProvider,message,request,response,handler);
3100 marek 1.63
3101 s.kodali 1.113 try 3102 { 3103 // resolve provider name 3104 ProviderName name = _resolveProviderName( 3105 request->operationContext.get(ProviderIdContainer::NAME));
3106 marek 1.63
3107 s.kodali 1.113 // get cached or load new provider module 3108 CMPIProvider::OpProviderHolder ph = 3109 providerManager.getProvider( 3110 name.getPhysicalName(), name.getLogicalName());
3111 marek 1.63
3112 s.kodali 1.113 } 3113 HandlerCatch(handler);
3114 marek 1.63
3115 s.kodali 1.113 PEG_METHOD_EXIT();
3116 marek 1.63
3117 s.kodali 1.113 return(response); 3118 } 3119 #endif
3120 marek 1.63
3121 venkat.puvvada 1.108 Message * CMPIProviderManager::handleSubscriptionInitCompleteRequest( 3122 const Message * message)
3123 marek 1.63 {
3124 ms.aruran 1.115 PEG_METHOD_ENTER( 3125 TRC_PROVIDERMANAGER, 3126 "CMPIProviderManager::handleSubscriptionInitCompleteRequest()");
3127 marek 1.63 3128 CIMSubscriptionInitCompleteRequestMessage * request = 3129 dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>
3130 venkat.puvvada 1.108 (const_cast <Message *> (message));
3131 marek 1.63 3132 PEGASUS_ASSERT (request != 0); 3133 3134 CIMSubscriptionInitCompleteResponseMessage * response = 3135 dynamic_cast <CIMSubscriptionInitCompleteResponseMessage *>
3136 venkat.puvvada 1.108 (request->buildResponse ());
3137 marek 1.63 3138 PEGASUS_ASSERT (response != 0); 3139 3140 // 3141 // Set indicator 3142 // 3143 _subscriptionInitComplete = true; 3144 3145 // 3146 // For each provider that has at least one subscription, call 3147 // provider's enableIndications method 3148 // 3149 Array <CMPIProvider *> enableProviders; 3150 enableProviders = providerManager.getIndicationProvidersToEnable (); 3151 3152 Uint32 numProviders = enableProviders.size (); 3153 for (Uint32 i = 0; i < numProviders; i++) 3154 { 3155 try 3156 { 3157 CIMInstance provider; 3158 marek 1.63 provider = enableProviders [i]->getProviderInstance (); 3159
3160 venkat.puvvada 1.110 CString info; 3161 #ifdef PEGASUS_ENABLE_REMOTE_CMPI 3162 indProvRecord *provRec = 0; 3163 if (provTab.lookup (enableProviders [i]->getName(), provRec)) 3164 { 3165 if (provRec->remoteInfo != String::EMPTY) 3166 { 3167 info = provRec->remoteInfo.getCString(); 3168 } 3169 } 3170 #endif
3171 marek 1.63 // 3172 // Get cached or load new provider module 3173 //
3174 venkat.puvvada 1.110 CMPIProvider::OpProviderHolder ph; 3175 if ((const char*)info) 3176 { 3177 ph = providerManager.getRemoteProvider 3178 (enableProviders [i]->getModule ()->getFileName (), 3179 enableProviders [i]->getName ()); 3180 } 3181 else 3182 { 3183 ph = providerManager.getProvider 3184 (enableProviders [i]->getModule ()->getFileName (), 3185 enableProviders [i]->getName ()); 3186 }
3187 venkat.puvvada 1.108 _callEnableIndications( 3188 provider, 3189 _indicationCallback, 3190 ph, 3191 (const char*)info);
3192 marek 1.63 }
3193 konrad.r 1.64 catch (const CIMException & e)
3194 marek 1.63 {
3195 ms.aruran 1.115 PEG_TRACE_STRING( 3196 TRC_PROVIDERMANAGER, 3197 Tracer::LEVEL2,
3198 marek 1.63 "CIMException: " + e.getMessage ()); 3199 }
3200 konrad.r 1.64 catch (const Exception & e)
3201 marek 1.63 {
3202 ms.aruran 1.115 PEG_TRACE_STRING( 3203 TRC_PROVIDERMANAGER, 3204 Tracer::LEVEL2,
3205 marek 1.63 "Exception: " + e.getMessage ()); 3206 }
3207 venkat.puvvada 1.108 catch (...)
3208 marek 1.63 {
3209 ms.aruran 1.115 PEG_TRACE_CSTRING( 3210 TRC_PROVIDERMANAGER, 3211 Tracer::LEVEL2,
3212 marek 1.63 "Unknown error in handleSubscriptionInitCompleteRequest"); 3213 } 3214 } 3215 3216 PEG_METHOD_EXIT ();
3217 venkat.puvvada 1.108 return(response);
3218 marek 1.63 } 3219
3220 venkat.puvvada 1.108 Message * CMPIProviderManager::handleGetPropertyRequest( 3221 const Message * message)
3222 dave.sudlik 1.98 {
3223 ms.aruran 1.115 PEG_METHOD_ENTER( 3224 TRC_PROVIDERMANAGER, 3225 "CMPIProviderManager::handleGetPropertyRequest()");
3226 dave.sudlik 1.98 3227 HandlerIntro(GetProperty,message,request,response,handler); 3228 3229 // We're only going to be interested in the specific property from this 3230 // instance. 3231 Array<CIMName> localPropertyListArray; 3232 localPropertyListArray.append(request->propertyName); 3233 CIMPropertyList localPropertyList(localPropertyListArray); 3234 3235 // NOTE: GetProperty will use the CIMInstanceProvider interface, so we 3236 // must manually define a request, response, and handler (emulate 3237 // HandlerIntro macro) 3238 CIMGetInstanceRequestMessage * GI_request = 3239 new CIMGetInstanceRequestMessage(
3240 venkat.puvvada 1.108 request->messageId, 3241 request->nameSpace, 3242 request->instanceName, 3243 false, 3244 false, 3245 false, 3246 localPropertyList, 3247 request->queueIds, 3248 request->authType, 3249 request->userName 3250 );
3251 dave.sudlik 1.98 3252 PEGASUS_ASSERT(GI_request != 0); 3253 3254 CIMGetInstanceResponseMessage * GI_response =
3255 venkat.puvvada 1.108 dynamic_cast<CIMGetInstanceResponseMessage*> 3256 (GI_request->buildResponse());
3257 dave.sudlik 1.98 3258 PEGASUS_ASSERT(GI_response != 0); 3259
3260 venkat.puvvada 1.108 GetInstanceResponseHandler GI_handler( 3261 GI_request, 3262 GI_response, 3263 _responseChunkCallback);
3264 dave.sudlik 1.98
3265 venkat.puvvada 1.108 try
3266 dave.sudlik 1.98 { 3267 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3268 venkat.puvvada 1.108 "CmpiProviderManager::handleGetPropertyRequest - Host name: $0 " 3269 "Name space: $1 Class name: $2 Property name: $3",
3270 dave.sudlik 1.98 System::getHostName(), 3271 request->nameSpace.getString(), 3272 request->instanceName.getClassName().getString(), 3273 request->propertyName.getString()); 3274 3275 // make target object path 3276 CIMObjectPath objectPath( 3277 System::getHostName(), 3278 request->nameSpace, 3279 request->instanceName.getClassName(), 3280 request->instanceName.getKeyBindings()); 3281 3282 Boolean remote=false; 3283 CMPIProvider::OpProviderHolder ph; 3284 3285 // resolve provider name
3286 venkat.puvvada 1.108 ProviderIdContainer pidc = 3287 request->operationContext.get(ProviderIdContainer::NAME);
3288 dave.sudlik 1.98 ProviderName name = _resolveProviderName(pidc); 3289
3290 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 3291 { 3292 ph = providerManager.getRemoteProvider( 3293 name.getLocation(), name.getLogicalName());
3294 dave.sudlik 1.98 }
3295 venkat.puvvada 1.108 else 3296 { 3297 // get cached or load new provider module 3298 ph = providerManager.getProvider( 3299 name.getPhysicalName(), name.getLogicalName());
3300 dave.sudlik 1.98 } 3301 3302 // convert arguments 3303 OperationContext context; 3304 3305 context.insert(request->operationContext.get(IdentityContainer::NAME));
3306 venkat.puvvada 1.108 context.insert( 3307 request->operationContext.get(AcceptLanguageListContainer::NAME)); 3308 context.insert( 3309 request->operationContext.get(ContentLanguageListContainer::NAME));
3310 dave.sudlik 1.98 // forward request 3311 CMPIProvider & pr=ph.GetProvider(); 3312 3313 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
3314 venkat.puvvada 1.118.2.2 AutoPtr<NormalizerContext> tmpNormalizerContext( 3315 new CIMOMHandleContext(*pr._cimom_handle)); 3316 request->operationContext.insert( 3317 NormalizerContextContainer(tmpNormalizerContext)); 3318 #endif
3319 dave.sudlik 1.98
3320 ms.aruran 1.115 PEG_TRACE_STRING( 3321 TRC_PROVIDERMANAGER, 3322 Tracer::LEVEL4,
3323 dave.sudlik 1.98 "Calling provider.getInstance via getProperty: " + pr.getName()); 3324 3325 CMPIStatus rc={CMPI_RC_OK,NULL}; 3326 CMPI_ContextOnStack eCtx(context); 3327 CMPI_ObjectPathOnStack eRef(objectPath); 3328 CMPI_ResultOnStack eRes(GI_handler,&pr.broker); 3329 CMPI_ThreadContext thr(&pr.broker,&eCtx); 3330 3331 // For the getInstance provider call, use the property list that we 3332 // created containing the single property from the getProperty call. 3333 CMPIPropertyList props(localPropertyList); 3334 3335 CMPIFlags flgs=0;
3336 venkat.puvvada 1.108 // Leave includeQualifiers and includeClassOrigin as false for this 3337 // call to getInstance 3338 eCtx.ft->addEntry( 3339 &eCtx, 3340 CMPIInvocationFlags, 3341 (CMPIValue*)&flgs, 3342 CMPI_uint32);
3343 dave.sudlik 1.98 3344 const IdentityContainer container =
3345 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME);
3346 dave.sudlik 1.98 eCtx.ft->addEntry(&eCtx,
3347 venkat.puvvada 1.108 CMPIPrincipal, 3348 (CMPIValue)(const char)container.getUserName().getCString(), 3349 CMPI_chars);
3350 dave.sudlik 1.98 3351 const AcceptLanguageListContainer accept_language=
3352 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME);
3353 dave.sudlik 1.98 const AcceptLanguageList acceptLangs = accept_language.getLanguages(); 3354 3355 eCtx.ft->addEntry( 3356 &eCtx,
3357 dave.sudlik 1.99 CMPIAcceptLanguage,
3358 dave.sudlik 1.98 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
3359 venkat.puvvada 1.108 acceptLangs).getCString(),
3360 dave.sudlik 1.98 CMPI_chars);
3361 venkat.puvvada 1.108 3362 if (remote) 3363 { 3364 CString info=pidc.getRemoteInfo().getCString(); 3365 eCtx.ft->addEntry( 3366 &eCtx, 3367 "CMPIRRemoteInfo", 3368 (CMPIValue)(const char)info, 3369 CMPI_chars);
3370 dave.sudlik 1.98 } 3371 3372 CMPIProvider::pm_service_op_lock op_lock(&pr); 3373
3374 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
3375 dave.sudlik 1.98 3376 { 3377 StatProviderTimeMeasurement providerTime(response); 3378 3379 rc = pr.miVector.instMI->ft->getInstance( 3380 pr.miVector.instMI,&eCtx,&eRes,&eRef, 3381 (const char **)props.getList()); 3382 } 3383
3384 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 3385 // Do this before checking rc from provider to throw exception in case 3386 // rc.msg is also localized. 3387 CMPIStatus tmprc={CMPI_RC_OK,NULL};
3388 venkat.puvvada 1.108 CMPIData cldata = 3389 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
3390 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 3391 { 3392 response->operationContext.set( 3393 ContentLanguageListContainer(
3394 venkat.puvvada 1.108 ContentLanguageList( 3395 LanguageParser::parseContentLanguageHeader( 3396 CMGetCharPtr(cldata.value.string)))));
3397 dave.sudlik 1.103 handler.setContext(response->operationContext);
3398 dave.sudlik 1.99 } 3399
3400 dave.sudlik 1.98 if (rc.rc!=CMPI_RC_OK)
3401 dave.sudlik 1.102 {
3402 venkat.puvvada 1.108 CIMException cimException( 3403 (CIMStatusCode)rc.rc, 3404 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 3405 3406 if (eRes.resError) 3407 { 3408 for (CMPI_Error* currErr=eRes.resError;
3409 dave.sudlik 1.102 currErr!=NULL; 3410 currErr=currErr->nextError)
3411 venkat.puvvada 1.108 { 3412 cimException.addError( 3413 ((CIMError*)currErr->hdl)->getInstance()); 3414 } 3415 } 3416 throw cimException;
3417 dave.sudlik 1.102 }
3418 dave.sudlik 1.98 3419 // Copy property value from instance to getProperty response
3420 venkat.puvvada 1.108 if (!(GI_response->cimInstance.isUninitialized()))
3421 dave.sudlik 1.98 {
3422 venkat.puvvada 1.108 Uint32 pos = 3423 GI_response->cimInstance.findProperty(request->propertyName);
3424 dave.sudlik 1.98
3425 venkat.puvvada 1.108 if (pos != PEG_NOT_FOUND)
3426 dave.sudlik 1.98 {
3427 venkat.puvvada 1.108 response->value = 3428 GI_response->cimInstance.getProperty(pos).getValue();
3429 dave.sudlik 1.98 } 3430 // Else property not found. Return CIM_ERR_NO_SUCH_PROPERTY. 3431 else 3432 { 3433 throw PEGASUS_CIM_EXCEPTION( 3434 CIM_ERR_NO_SUCH_PROPERTY, 3435 request->propertyName.getString() 3436 ); 3437 } 3438 } 3439 } 3440 HandlerCatch(handler); 3441 3442 delete GI_request; 3443 delete GI_response; 3444 3445 PEG_METHOD_EXIT(); 3446 3447 return(response); 3448 } 3449
3450 venkat.puvvada 1.108 Message * CMPIProviderManager::handleSetPropertyRequest( 3451 const Message * message)
3452 dave.sudlik 1.98 {
3453 ms.aruran 1.115 PEG_METHOD_ENTER( 3454 TRC_PROVIDERMANAGER, 3455 "CMPIProviderManager::handleSetPropertyRequest()");
3456 dave.sudlik 1.98 3457 HandlerIntro(SetProperty,message,request,response,handler); 3458
3459 venkat.puvvada 1.108 // We're only going to be interested in the specific property from this 3460 // instance.
3461 dave.sudlik 1.98 Array<CIMName> localPropertyListArray; 3462 localPropertyListArray.append(request->propertyName); 3463 CIMPropertyList localPropertyList(localPropertyListArray); 3464
3465 venkat.puvvada 1.108 // Build a modified instance with just the specific property and its 3466 // new value.
3467 dave.sudlik 1.98 CIMInstance localModifiedInstance(request->instanceName.getClassName()); 3468 localModifiedInstance.setPath(request->instanceName);
3469 venkat.puvvada 1.108 localModifiedInstance.addProperty( 3470 CIMProperty(request->propertyName, request->newValue));
3471 dave.sudlik 1.98
3472 venkat.puvvada 1.108 // NOTE: SetProperty will use the CIMInstanceProvider interface, so we must 3473 // manually define a request, response, and handler.
3474 dave.sudlik 1.98 CIMModifyInstanceRequestMessage * MI_request = 3475 new CIMModifyInstanceRequestMessage(
3476 venkat.puvvada 1.108 request->messageId, 3477 request->nameSpace, 3478 localModifiedInstance, 3479 false, 3480 localPropertyList, 3481 request->queueIds, 3482 request->authType, 3483 request->userName 3484 );
3485 dave.sudlik 1.98 3486 PEGASUS_ASSERT(MI_request != 0); 3487 3488 CIMModifyInstanceResponseMessage * MI_response =
3489 venkat.puvvada 1.108 dynamic_cast<CIMModifyInstanceResponseMessage*>( 3490 MI_request->buildResponse());
3491 dave.sudlik 1.98 3492 PEGASUS_ASSERT(MI_response != 0); 3493
3494 venkat.puvvada 1.108 ModifyInstanceResponseHandler MI_handler( 3495 MI_request, 3496 MI_response, 3497 _responseChunkCallback);
3498 dave.sudlik 1.98
3499 venkat.puvvada 1.108 try
3500 dave.sudlik 1.98 { 3501 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3502 venkat.puvvada 1.108 "CmpiProviderManager::handleSetPropertyRequest - Host name: $0 " 3503 "Name space: $1 Class name: $2 Property name: $3",
3504 dave.sudlik 1.98 System::getHostName(), 3505 request->nameSpace.getString(), 3506 request->instanceName.getClassName().getString(), 3507 request->propertyName.getString()); 3508 3509 // make target object path 3510 CIMObjectPath objectPath( 3511 System::getHostName(), 3512 request->nameSpace, 3513 request->instanceName.getClassName(), 3514 request->instanceName.getKeyBindings()); 3515 3516 Boolean remote=false; 3517 CMPIProvider::OpProviderHolder ph; 3518 3519 // resolve provider name
3520 venkat.puvvada 1.108 ProviderIdContainer pidc = 3521 request->operationContext.get(ProviderIdContainer::NAME);
3522 dave.sudlik 1.98 ProviderName name = _resolveProviderName(pidc); 3523
3524 venkat.puvvada 1.108 if ((remote=pidc.isRemoteNameSpace())) 3525 { 3526 ph = providerManager.getRemoteProvider( 3527 name.getLocation(), name.getLogicalName());
3528 dave.sudlik 1.98 }
3529 venkat.puvvada 1.108 else 3530 { 3531 // get cached or load new provider module 3532 ph = providerManager.getProvider( 3533 name.getPhysicalName(), name.getLogicalName());
3534 dave.sudlik 1.98 } 3535 3536 // convert arguments 3537 OperationContext context; 3538 3539 context.insert(request->operationContext.get(IdentityContainer::NAME));
3540 venkat.puvvada 1.108 context.insert( 3541 request->operationContext.get(AcceptLanguageListContainer::NAME)); 3542 context.insert( 3543 request->operationContext.get(ContentLanguageListContainer::NAME));
3544 dave.sudlik 1.98 // forward request 3545 CMPIProvider & pr=ph.GetProvider(); 3546
3547 ms.aruran 1.115 PEG_TRACE_STRING( 3548 TRC_PROVIDERMANAGER, 3549 Tracer::LEVEL4,
3550 dave.sudlik 1.98 "Calling provider.modifyInstance via setProperty: " + pr.getName()); 3551 3552 CMPIStatus rc={CMPI_RC_OK,NULL}; 3553 CMPI_ContextOnStack eCtx(context); 3554 CMPI_ObjectPathOnStack eRef(objectPath); 3555 CMPI_ResultOnStack eRes(MI_handler,&pr.broker); 3556 CMPI_InstanceOnStack eInst(localModifiedInstance); 3557 CMPI_ThreadContext thr(&pr.broker,&eCtx); 3558 3559 CMPIPropertyList props(localPropertyList); 3560 3561 CMPIFlags flgs=0; 3562 // Leave includeQualifiers as false for this call to modifyInstance
3563 venkat.puvvada 1.108 eCtx.ft->addEntry( 3564 &eCtx, 3565 CMPIInvocationFlags, 3566 (CMPIValue*)&flgs, 3567 CMPI_uint32);
3568 dave.sudlik 1.98 3569 const IdentityContainer container =
3570 venkat.puvvada 1.108 request->operationContext.get(IdentityContainer::NAME);
3571 dave.sudlik 1.98 eCtx.ft->addEntry(&eCtx,
3572 venkat.puvvada 1.108 CMPIPrincipal, 3573 (CMPIValue)(const char)container.getUserName().getCString(), 3574 CMPI_chars);
3575 dave.sudlik 1.98 3576 const AcceptLanguageListContainer accept_language=
3577 venkat.puvvada 1.108 request->operationContext.get(AcceptLanguageListContainer::NAME);
3578 dave.sudlik 1.98 const AcceptLanguageList acceptLangs = accept_language.getLanguages(); 3579 eCtx.ft->addEntry( 3580 &eCtx,
3581 dave.sudlik 1.99 CMPIAcceptLanguage,
3582 dave.sudlik 1.98 (CMPIValue)(const char)LanguageParser::buildAcceptLanguageHeader(
3583 venkat.puvvada 1.108 acceptLangs).getCString(),
3584 dave.sudlik 1.98 CMPI_chars);
3585 venkat.puvvada 1.108 3586 if (remote) 3587 { 3588 CString info=pidc.getRemoteInfo().getCString(); 3589 eCtx.ft->addEntry( 3590 &eCtx, 3591 "CMPIRRemoteInfo", 3592 (CMPIValue)(const char)info, 3593 CMPI_chars);
3594 dave.sudlik 1.98 } 3595 3596 CMPIProvider::pm_service_op_lock op_lock(&pr); 3597
3598 r.kieninger 1.118.2.1 AutoPThreadSecurity threadLevelSecurity(request->operationContext);
3599 dave.sudlik 1.98 3600 { 3601 StatProviderTimeMeasurement providerTime(response); 3602 3603 rc = pr.miVector.instMI->ft->modifyInstance( 3604 pr.miVector.instMI,&eCtx,&eRes,&eRef,&eInst, 3605 (const char **)props.getList()); 3606 } 3607
3608 dave.sudlik 1.99 // Need to save ContentLanguage value into operation context of response 3609 // Do this before checking rc from provider to throw exception in case 3610 // rc.msg is also localized. 3611 CMPIStatus tmprc={CMPI_RC_OK,NULL};
3612 venkat.puvvada 1.108 CMPIData cldata = 3613 eCtx.ft->getEntry (&eCtx, CMPIContentLanguage, &tmprc);
3614 dave.sudlik 1.99 if (tmprc.rc == CMPI_RC_OK) 3615 { 3616 response->operationContext.set( 3617 ContentLanguageListContainer(
3618 venkat.puvvada 1.108 ContentLanguageList( 3619 LanguageParser::parseContentLanguageHeader( 3620 CMGetCharPtr(cldata.value.string)))));
3621 dave.sudlik 1.103 handler.setContext(response->operationContext);
3622 dave.sudlik 1.99 } 3623
3624 dave.sudlik 1.98 if (rc.rc!=CMPI_RC_OK)
3625 dave.sudlik 1.102 {
3626 venkat.puvvada 1.108 CIMException cimException( 3627 (CIMStatusCode)rc.rc, 3628 rc.msg ? CMGetCharsPtr(rc.msg,NULL) : String::EMPTY); 3629 3630 if (eRes.resError) 3631 { 3632 for (CMPI_Error* currErr=eRes.resError;
3633 dave.sudlik 1.102 currErr!=NULL; 3634 currErr=currErr->nextError)
3635 venkat.puvvada 1.108 { 3636 cimException.addError( 3637 ((CIMError*)currErr->hdl)->getInstance()); 3638 } 3639 } 3640 throw cimException;
3641 dave.sudlik 1.102 }
3642 dave.sudlik 1.98 } 3643 HandlerCatch(handler); 3644 3645 delete MI_request; 3646 delete MI_response; 3647 3648 PEG_METHOD_EXIT(); 3649 3650 return(response); 3651 } 3652
3653 venkat.puvvada 1.108 Message * CMPIProviderManager::handleUnsupportedRequest( 3654 const Message * message)
3655 marek 1.63 {
3656 ms.aruran 1.115 PEG_METHOD_ENTER( 3657 TRC_PROVIDERMANAGER, 3658 "CMPIProviderManager::handleUnsupportedRequest()");
3659 marek 1.63 CIMRequestMessage* request = 3660 dynamic_cast<CIMRequestMessage >(const_cast<Message >(message)); 3661 PEGASUS_ASSERT(request != 0 ); 3662 3663 CIMResponseMessage* response = request->buildResponse(); 3664 response->cimException = 3665 PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY); 3666 3667 PEG_METHOD_EXIT(); 3668 return response; 3669 } 3670 3671 ProviderName CMPIProviderManager::_resolveProviderName( 3672 const ProviderIdContainer & providerId) 3673 { 3674 String providerName; 3675 String fileName; 3676 String location;
3677 dmitry.mikulin 1.114 String moduleName;
3678 marek 1.63 CIMValue genericValue; 3679
3680 ms.aruran 1.115 PEG_METHOD_ENTER( 3681 TRC_PROVIDERMANAGER, 3682 "CMPIProviderManager::_resolveProviderName()"); 3683
3684 dmitry.mikulin 1.114 genericValue = providerId.getModule().getProperty( 3685 providerId.getModule().findProperty("Name")).getValue(); 3686 genericValue.get(moduleName); 3687
3688 marek 1.63 genericValue = providerId.getProvider().getProperty( 3689 providerId.getProvider().findProperty("Name")).getValue(); 3690 genericValue.get(providerName); 3691 3692 genericValue = providerId.getModule().getProperty( 3693 providerId.getModule().findProperty("Location")).getValue(); 3694 genericValue.get(location); 3695 fileName = _resolvePhysicalName(location); 3696
3697 thilo.boehm 1.89 // An empty file name is only for interest if we are in the 3698 // local name space. So the message is only issued if not 3699 // in the remote Name Space. 3700 if (fileName == String::EMPTY && (!providerId.isRemoteNameSpace())) 3701 {
3702 venkat.puvvada 1.108 genericValue.get(location); 3703 String fullName = FileSystem::buildLibraryFileName(location); 3704 Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::SEVERE, 3705 "ProviderManager.CMPI.CMPIProviderManager.CANNOT_FIND_LIBRARY", 3706 "For provider $0 library $1 was not found.", 3707 providerName, fullName);
3708 thilo.boehm 1.89 3709 }
3710 dmitry.mikulin 1.114 ProviderName name(moduleName, providerName, fileName);
3711 marek 1.63 name.setLocation(location);
3712 ms.aruran 1.115 PEG_METHOD_EXIT();
3713 marek 1.63 return name; 3714 } 3715 3716 void CMPIProviderManager::_callEnableIndications 3717 (CIMInstance & req_provider,
3718 venkat.puvvada 1.108 PEGASUS_INDICATION_CALLBACK_T _indicationCallback, 3719 CMPIProvider::OpProviderHolder & ph, 3720 const char* remoteInfo)
3721 marek 1.63 {
3722 ms.aruran 1.115 PEG_METHOD_ENTER( 3723 TRC_PROVIDERMANAGER, 3724 "CMPIProviderManager::_callEnableIndications()");
3725 marek 1.63 3726 try 3727 {
3728 w.otsuka 1.86 indProvRecord *provRec =0;
3729 marek 1.95 { 3730 WriteLock lock(rwSemProvTab); 3731
3732 venkat.puvvada 1.108 if (provTab.lookup (ph.GetProvider ().getName (), provRec)) 3733 { 3734 provRec->enabled = true; 3735 CIMRequestMessage * request = 0; 3736 CIMResponseMessage * response = 0; 3737 provRec->handler=new EnableIndicationsResponseHandler( 3738 request, 3739 response, 3740 req_provider, 3741 _indicationCallback, 3742 _responseChunkCallback); 3743 }
3744 marek 1.95 }
3745 marek 1.63 3746 CMPIProvider & pr=ph.GetProvider(); 3747 3748 // 3749 // Versions prior to 86 did not include enableIndications routine 3750 // 3751 if (pr.miVector.indMI->ft->ftVersion >= 86) 3752 { 3753 OperationContext context;
3754 kumpf 1.112 #ifdef PEGASUS_ZOS_THREADLEVEL_SECURITY
3755 venkat.puvvada 1.108 // For the z/OS security model we always need an Identity container 3756 // in the operation context. Since we don't have a client request 3757 // ID here we have to use the cim servers identity for the time 3758 // being. 3759 IdentityContainer idContainer(System::getEffectiveUserName()); 3760 context.insert(idContainer);
3761 kumpf 1.112 #endif
3762 marek 1.90
3763 marek 1.63 CMPIStatus rc={CMPI_RC_OK,NULL}; 3764 CMPI_ContextOnStack eCtx(context); 3765 CMPI_ThreadContext thr(&pr.broker,&eCtx); 3766
3767 dave.sudlik 1.100 // Add RemoteInformation -V 5245 3768 if (remoteInfo) 3769 { 3770 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo",
3771 venkat.puvvada 1.108 (CMPIValue)(const char)remoteInfo,CMPI_chars);
3772 dave.sudlik 1.100 } 3773
3774 ms.aruran 1.115 PEG_TRACE_STRING( 3775 TRC_PROVIDERMANAGER, 3776 Tracer::LEVEL4,
3777 marek 1.63 "Calling provider.enableIndications: " + pr.getName()); 3778
3779 venkat.puvvada 1.111 pr.protect();
3780 marek 1.63
3781 dave.sudlik 1.101 // enableIndications() is defined by the CMPI standard as 3782 // returning a CMPIStatus return value. Unfortunately, Pegasus 3783 // originally implemented enableIndications() with a void 3784 // return type, and this incompatibility was not detected for 3785 // some time. Since exceptions thrown from enableIndications() 3786 // are not reported (other than via logging), it was decided to 3787 // discard the returned CMPIStatus here. This will prevent us from 3788 // breaking existing CMPI Indication providers. This is ok since 3789 // there really isn't a user to which the problem should be 3790 // reported.
3791 konrad.r 1.64 pr.miVector.indMI->ft->enableIndications(pr.miVector.indMI,&eCtx);
3792 marek 1.63 } 3793 else 3794 {
3795 ms.aruran 1.115 PEG_TRACE_STRING( 3796 TRC_PROVIDERMANAGER, 3797 Tracer::LEVEL4,
3798 marek 1.63 "Not calling provider.enableIndications: " + pr.getName() +
3799 venkat.puvvada 1.108 " routine as it is an earlier version that does not support " \ 3800 "this function");
3801 marek 1.63 } 3802 }
3803 konrad.r 1.64 catch (const Exception & e)
3804 marek 1.63 {
3805 ms.aruran 1.115 PEG_TRACE_STRING( 3806 TRC_PROVIDERMANAGER, 3807 Tracer::LEVEL2,
3808 dave.sudlik 1.101 "Exception in _callEnableIndications: " + e.getMessage ());
3809 marek 1.63 3810 Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING, 3811 "ProviderManager.CMPI.CMPIProviderManager."
3812 venkat.puvvada 1.108 "ENABLE_INDICATIONS_FAILED",
3813 marek 1.63 "Failed to enable indications for provider $0: $1.", 3814 ph.GetProvider ().getName (), e.getMessage ()); 3815 }
3816 venkat.puvvada 1.108 catch (...)
3817 marek 1.63 {
3818 ms.aruran 1.115 PEG_TRACE_CSTRING( 3819 TRC_PROVIDERMANAGER, 3820 Tracer::LEVEL2,
3821 marek 1.63 "Unexpected error in _callEnableIndications"); 3822 3823 Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING, 3824 "ProviderManager.CMPI.CMPIProviderManager."
3825 venkat.puvvada 1.108 "ENABLE_INDICATIONS_FAILED_UNKNOWN",
3826 marek 1.63 "Failed to enable indications for provider $0.", 3827 ph.GetProvider ().getName ()); 3828 } 3829 3830 PEG_METHOD_EXIT (); 3831 } 3832 3833 void CMPIProviderManager::_callDisableIndications
3834 dave.sudlik 1.100 (CMPIProvider::OpProviderHolder & ph, const char *remoteInfo)
3835 marek 1.63 {
3836 ms.aruran 1.115 PEG_METHOD_ENTER( 3837 TRC_PROVIDERMANAGER, 3838 "CMPIProviderManager::_callDisableIndications()");
3839 marek 1.63
3840 dave.sudlik 1.101 try
3841 marek 1.95 {
3842 dave.sudlik 1.101 indProvRecord * provRec = 0; 3843 { 3844 WriteLock writeLock(rwSemProvTab);
3845 venkat.puvvada 1.108 if (provTab.lookup (ph.GetProvider ().getName (), provRec)) 3846 { 3847 provRec->enabled = false; 3848 if (provRec->handler) delete provRec->handler; 3849 provRec->handler = NULL; 3850 }
3851 dave.sudlik 1.101 } 3852 3853 CMPIProvider & pr=ph.GetProvider();
3854 marek 1.63
3855 dave.sudlik 1.101 // 3856 // Versions prior to 86 did not include disableIndications routine 3857 // 3858 if (pr.miVector.indMI->ft->ftVersion >= 86) 3859 { 3860 OperationContext context; 3861 CMPIStatus rc={CMPI_RC_OK,NULL}; 3862 CMPI_ContextOnStack eCtx(context); 3863 3864 if (remoteInfo) 3865 {
3866 venkat.puvvada 1.108 eCtx.ft->addEntry(&eCtx,"CMPIRRemoteInfo", 3867 (CMPIValue)(const char)remoteInfo,CMPI_chars);
3868 dave.sudlik 1.101 } 3869 CMPI_ThreadContext thr(&pr.broker,&eCtx);
3870 dave.sudlik 1.96
3871 ms.aruran 1.115 PEG_TRACE_STRING( 3872 TRC_PROVIDERMANAGER, 3873 Tracer::LEVEL4,
3874 dave.sudlik 1.101 "Calling provider.disableIndications: " + pr.getName());
3875 dave.sudlik 1.100
3876 dave.sudlik 1.101 // disableIndications() is defined by the CMPI standard as 3877 // returning a CMPIStatus return value. Unfortunately, Pegasus 3878 // originally implemented disableIndications() with a void 3879 // return type, and this incompatibility was not detected for 3880 // some time. For consistency with the enableIndications() 3881 // interface, it was decided to discard the returned CMPIStatus 3882 // here. This will prevent us from breaking existing CMPI 3883 // Indication providers. This is ok since there really isn't a 3884 // user to which the problem should be reported.
3885 venkat.puvvada 1.108 pr.miVector.indMI->ft->disableIndications( 3886 pr.miVector.indMI, 3887 &eCtx);
3888 marek 1.63
3889 venkat.puvvada 1.111 pr.unprotect();
3890 dave.sudlik 1.101 } 3891 else 3892 {
3893 ms.aruran 1.115 PEG_TRACE_STRING( 3894 TRC_PROVIDERMANAGER, 3895 Tracer::LEVEL4,
3896 dave.sudlik 1.101 "Not calling provider.disableIndications: " 3897 + pr.getName() +
3898 venkat.puvvada 1.108 " routine as it is an earlier version that does not support" \ 3899 " this function");
3900 dave.sudlik 1.101 } 3901 } 3902 catch (const Exception & e) 3903 {
3904 ms.aruran 1.115 PEG_TRACE_STRING( 3905 TRC_PROVIDERMANAGER, 3906 Tracer::LEVEL2,
3907 dave.sudlik 1.101 "Exception in _callDisableIndications: " + e.getMessage ());
3908 marek 1.63
3909 dave.sudlik 1.101 Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING, 3910 "ProviderManager.CMPI.CMPIProviderManager."
3911 venkat.puvvada 1.108 "DISABLE_INDICATIONS_FAILED",
3912 dave.sudlik 1.101 "Failed to disable indications for provider $0: $1.", 3913 ph.GetProvider ().getName (), e.getMessage ());
3914 marek 1.63 }
3915 venkat.puvvada 1.108 catch (...)
3916 marek 1.63 {
3917 ms.aruran 1.115 PEG_TRACE_CSTRING( 3918 TRC_PROVIDERMANAGER, 3919 Tracer::LEVEL2,
3920 dave.sudlik 1.101 "Unexpected error in _callDisableIndications"); 3921 3922 Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING, 3923 "ProviderManager.CMPI.CMPIProviderManager."
3924 venkat.puvvada 1.108 "DISABLE_INDICATIONS_FAILED_UNKNOWN",
3925 dave.sudlik 1.101 "Failed to disable indications for provider $0.", 3926 ph.GetProvider ().getName ());
3927 marek 1.63 } 3928 3929 PEG_METHOD_EXIT (); 3930 } 3931 3932 PEGASUS_NAMESPACE_END
3933 venkat.puvvada 1.108

No CVS admin address has been configured