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

No CVS admin address has been configured