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

No CVS admin address has been configured