pegasus/src/Pegasus/ProviderManager2/Default/DefaultProviderManager.cpp - annotate

Return to DefaultProviderManager.cpp CVS log

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

1 karl 1.7 //%2003////////////////////////////////////////////////////////////////////////
2 chip 1.1 //
3 karl 1.7 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Development 4 // Company, L. P., IBM Corp., The Open Group, Tivoli Systems. 5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; 6 // IBM Corp.; EMC Corporation, The Open Group.
7 chip 1.1 // 8 // Permission is hereby granted, free of charge, to any person obtaining a copy 9 // of this software and associated documentation files (the "Software"), to 10 // deal in the Software without restriction, including without limitation the 11 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 12 // sell copies of the Software, and to permit persons to whom the Software is 13 // furnished to do so, subject to the following conditions:
14 schuur 1.19 //
15 chip 1.1 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN 16 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED 17 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 18 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 19 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 20 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 21 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 22 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23 // 24 //============================================================================== 25 // 26 // Author: Chip Vincent (cvincent@us.ibm.com) 27 // 28 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company 29 // (carolann_graves@hp.com) 30 // Mike Day, IBM (mdday@us.ibm.com) 31 // Karl Schopmeyer(k.schopmeyer@opengroup.org) - Fix associators. 32 // Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com) 33 // 34 //%///////////////////////////////////////////////////////////////////////////// 35 36 chip 1.1 #include "DefaultProviderManager.h" 37 38 #include <Pegasus/Common/CIMMessage.h> 39 #include <Pegasus/Common/OperationContext.h> 40 #include <Pegasus/Common/Destroyer.h> 41 #include <Pegasus/Common/Tracer.h> 42 #include <Pegasus/Common/StatisticalData.h> 43 #include <Pegasus/Common/Logger.h> 44 #include <Pegasus/Common/MessageLoader.h> //l10n 45
46 schuur 1.12 #include <Pegasus/Common/QueryExpression.h> 47 #include <Pegasus/ProviderManager2/QueryExpressionFactory.h> 48
49 chip 1.1 #include <Pegasus/Config/ConfigManager.h> 50 51 #include <Pegasus/ProviderManager2/Default/Provider.h> 52 #include <Pegasus/ProviderManager2/Default/OperationResponseHandler.h> 53 54 #include <Pegasus/Server/ProviderRegistrationManager/ProviderRegistrationManager.h>
55 schuur 1.14 #include <Pegasus/ProviderManager2/ProviderManagerService.h>
56 chip 1.1 57 PEGASUS_NAMESPACE_BEGIN 58 59 // auto variable to protect provider during operations 60 class pm_service_op_lock 61 { 62 private: 63 pm_service_op_lock(void); 64 65 public: 66 pm_service_op_lock(Provider provider) : _provider(provider) 67 { 68 _provider->protect(); 69 } 70 71 ~pm_service_op_lock(void) 72 { 73 _provider->unprotect(); 74 } 75 76 Provider _provider; 77 chip 1.1 }; 78 79 // 80 // Provider module status 81 // 82 static const Uint16 _MODULE_OK = 2; 83 static const Uint16 _MODULE_STOPPING = 9; 84 static const Uint16 _MODULE_STOPPED = 10; 85 86 // provider manager
87 schuur 1.10 static LocalProviderManager providerManager;
88 chip 1.1 89 DefaultProviderManager::DefaultProviderManager(void) 90 { 91 } 92 93 DefaultProviderManager::~DefaultProviderManager(void) 94 { 95 } 96
97 kumpf 1.3 Message * DefaultProviderManager::processMessage(Message * request) throw()
98 chip 1.1 { 99 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, 100 "DefaultProviderManager::processMessage()"); 101 102 Message * response = 0; 103 104 // pass the request message to a handler method based on message type 105 switch(request->getType()) 106 { 107 case CIM_GET_INSTANCE_REQUEST_MESSAGE: 108 response = handleGetInstanceRequest(request); 109 110 break; 111 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE: 112 response = handleEnumerateInstancesRequest(request); 113 114 break; 115 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE: 116 response = handleEnumerateInstanceNamesRequest(request); 117 118 break; 119 chip 1.1 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE: 120 response = handleCreateInstanceRequest(request); 121 122 break; 123 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE: 124 response = handleModifyInstanceRequest(request); 125 126 break; 127 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE: 128 response = handleDeleteInstanceRequest(request); 129 130 break; 131 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
132 schuur 1.12 response = handleExecQueryRequest(request);
133 chip 1.1 134 break; 135 case CIM_ASSOCIATORS_REQUEST_MESSAGE: 136 response = handleAssociatorsRequest(request); 137 138 break; 139 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE: 140 response = handleAssociatorNamesRequest(request); 141 142 break; 143 case CIM_REFERENCES_REQUEST_MESSAGE: 144 response = handleReferencesRequest(request); 145 146 break; 147 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE: 148 response = handleReferenceNamesRequest(request); 149 150 break; 151 case CIM_GET_PROPERTY_REQUEST_MESSAGE: 152 response = handleGetPropertyRequest(request); 153 154 chip 1.1 break; 155 case CIM_SET_PROPERTY_REQUEST_MESSAGE: 156 response = handleSetPropertyRequest(request); 157 158 break; 159 case CIM_INVOKE_METHOD_REQUEST_MESSAGE: 160 response = handleInvokeMethodRequest(request); 161 162 break; 163 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE: 164 response = handleCreateSubscriptionRequest(request); 165 166 break; 167 case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE: 168 response = handleModifySubscriptionRequest(request); 169 170 break; 171 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE: 172 response = handleDeleteSubscriptionRequest(request); 173 174 break; 175 chip 1.1 case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE: 176 response = handleEnableIndicationsRequest(request); 177 178 break; 179 case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE: 180 response = handleDisableIndicationsRequest(request); 181 182 break; 183 case CIM_CONSUME_INDICATION_REQUEST_MESSAGE: 184 response = handleConsumeIndicationRequest(request); 185 break; 186
187 schuur 1.14 case CIM_EXPORT_INDICATION_REQUEST_MESSAGE: 188 response = handleExportIndicationRequest(request); 189 break; 190
191 chip 1.1 case CIM_DISABLE_MODULE_REQUEST_MESSAGE: 192 response = handleDisableModuleRequest(request); 193 194 break; 195 case CIM_ENABLE_MODULE_REQUEST_MESSAGE: 196 response = handleEnableModuleRequest(request); 197 198 break; 199 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE: 200 response = handleStopAllProvidersRequest(request); 201 202 break; 203 default: 204 response = handleUnsupportedRequest(request); 205 206 break; 207 } 208 209 PEG_METHOD_EXIT(); 210 211 return(response); 212 chip 1.1 } 213 214 Message * DefaultProviderManager::handleUnsupportedRequest(const Message * message) throw() 215 { 216 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleUnsupportedRequest"); 217 218 PEG_METHOD_EXIT(); 219 220 // a null response implies unsupported or unknown operation 221 return(0); 222 } 223 224 Message * DefaultProviderManager::handleGetInstanceRequest(const Message * message) throw() 225 { 226 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetInstanceRequest"); 227 228 CIMGetInstanceRequestMessage * request = 229 dynamic_cast<CIMGetInstanceRequestMessage >(const_cast<Message >(message)); 230 231 PEGASUS_ASSERT(request != 0); 232 233 chip 1.1 CIMGetInstanceResponseMessage * response = 234 new CIMGetInstanceResponseMessage( 235 request->messageId, 236 CIMException(), 237 request->queueIds.copyAndPop(), 238 CIMInstance()); 239 240 PEGASUS_ASSERT(response != 0); 241 242 // preserve message key 243 response->setKey(request->getKey()); 244 245 // Set HTTP method in response from request 246 response->setHttpMethod(request->getHttpMethod()); 247 248 // create a handler for this request 249 GetInstanceResponseHandler handler(request, response); 250 251 try 252 { 253 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 254 chip 1.1 "DefaultProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2", 255 System::getHostName(), 256 request->nameSpace.getString(), 257 request->instanceName.getClassName().getString()); 258 259 // make target object path 260 CIMObjectPath objectPath( 261 System::getHostName(), 262 request->nameSpace, 263 request->instanceName.getClassName(), 264 request->instanceName.getKeyBindings()); 265
266 chip 1.4 ProviderName name(
267 schuur 1.20 objectPath,
268 schuur 1.11 ProviderType::INSTANCE);
269 chip 1.1
270 chip 1.5 // resolve provider name 271 name = _resolveProviderName(name);
272 chip 1.1 273 // get cached or load new provider module 274 OpProviderHolder ph =
275 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
276 chip 1.1 277 // convert arguments 278 OperationContext context; 279 280 context.insert(IdentityContainer(request->userName)); 281 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 282 context.insert(ContentLanguageListContainer(request->contentLanguages)); 283 284 CIMPropertyList propertyList(request->propertyList); 285 286 // forward request 287 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 288 "Calling provider.getInstance: " + 289 ph.GetProvider().getName()); 290 291 pm_service_op_lock op_lock(&ph.GetProvider()); 292 293 STAT_GETSTARTTIME; 294 295 ph.GetProvider().getInstance( 296 context, 297 chip 1.1 objectPath, 298 request->includeQualifiers, 299 request->includeClassOrigin, 300 propertyList, 301 handler); 302 303 STAT_PMS_PROVIDEREND; 304 } 305 catch(CIMException & e) 306 { 307 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 308 "Exception: " + e.getMessage()); 309 310 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 311 } 312 catch(Exception & e) 313 { 314 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 315 "Exception: " + e.getMessage());
316 chip 1.2
317 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 318 } 319 catch(...) 320 { 321 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 322 "Exception: Unknown");
323 chip 1.2
324 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 325 } 326 327 PEG_METHOD_EXIT(); 328 329 return(response); 330 } 331 332 Message * DefaultProviderManager::handleEnumerateInstancesRequest(const Message * message) throw() 333 { 334 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceRequest"); 335 336 CIMEnumerateInstancesRequestMessage * request = 337 dynamic_cast<CIMEnumerateInstancesRequestMessage >(const_cast<Message >(message)); 338 339 PEGASUS_ASSERT(request != 0); 340 341 CIMEnumerateInstancesResponseMessage * response = 342 new CIMEnumerateInstancesResponseMessage( 343 request->messageId, 344 CIMException(), 345 chip 1.1 request->queueIds.copyAndPop(), 346 Array<CIMInstance>()); 347 348 PEGASUS_ASSERT(response != 0); 349 350 // preserve message key 351 response->setKey(request->getKey()); 352 353 // Set HTTP method in response from request 354 response->setHttpMethod (request->getHttpMethod ()); 355 356 // create a handler for this request 357 EnumerateInstancesResponseHandler handler(request, response); 358 359 try 360 { 361 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 362 "DefaultProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2", 363 System::getHostName(), 364 request->nameSpace.getString(), 365 request->className.getString()); 366 chip 1.1 367 // make target object path 368 CIMObjectPath objectPath( 369 System::getHostName(), 370 request->nameSpace, 371 request->className); 372
373 chip 1.4 ProviderName name(
374 schuur 1.20 objectPath,
375 schuur 1.11 ProviderType::INSTANCE);
376 chip 1.1
377 chip 1.5 // resolve provider name 378 name = _resolveProviderName(name);
379 chip 1.1 380 // get cached or load new provider module
381 schuur 1.12 OpProviderHolder ph = providerManager.getProvider(name.getPhysicalName(), 382 name.getLogicalName(), String::EMPTY);
383 chip 1.1 384 // convert arguments 385 OperationContext context; 386 387 context.insert(IdentityContainer(request->userName)); 388 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 389 context.insert(ContentLanguageListContainer(request->contentLanguages)); 390 391 CIMPropertyList propertyList(request->propertyList); 392 393 // forward request 394 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 395 "Calling provider.enumerateInstances: " + 396 ph.GetProvider().getName()); 397 398 pm_service_op_lock op_lock(&ph.GetProvider()); 399 400 STAT_GETSTARTTIME; 401 402 ph.GetProvider().enumerateInstances( 403 context, 404 chip 1.1 objectPath, 405 request->includeQualifiers, 406 request->includeClassOrigin, 407 propertyList, 408 handler); 409 410 STAT_PMS_PROVIDEREND; 411 } 412 catch(CIMException & e) 413 { 414 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 415 "Exception: " + e.getMessage());
416 chip 1.2
417 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 418 } 419 catch(Exception & e) 420 { 421 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 422 "Exception: " + e.getMessage());
423 chip 1.2
424 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 425 } 426 catch(...) 427 { 428 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 429 "Exception: Unknown");
430 chip 1.2
431 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 432 } 433 434 PEG_METHOD_EXIT(); 435 436 return(response); 437 } 438 439 Message * DefaultProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw() 440 { 441 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnumerateInstanceNamesRequest"); 442 443 CIMEnumerateInstanceNamesRequestMessage * request = 444 dynamic_cast<CIMEnumerateInstanceNamesRequestMessage >(const_cast<Message >(message)); 445 446 PEGASUS_ASSERT(request != 0); 447 448 CIMEnumerateInstanceNamesResponseMessage * response = 449 new CIMEnumerateInstanceNamesResponseMessage( 450 request->messageId, 451 CIMException(), 452 chip 1.1 request->queueIds.copyAndPop(), 453 Array<CIMObjectPath>()); 454 455 PEGASUS_ASSERT(response != 0); 456 457 // preserve message key 458 response->setKey(request->getKey()); 459 460 //set HTTP method in response from request 461 response->setHttpMethod(request->getHttpMethod());; 462 463 // create a handler for this request 464 EnumerateInstanceNamesResponseHandler handler(request, response); 465 466 // process the request 467 try 468 { 469 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 470 "DefaultProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2", 471 System::getHostName(), 472 request->nameSpace.getString(), 473 chip 1.1 request->className.getString()); 474 475 // make target object path 476 CIMObjectPath objectPath( 477 System::getHostName(), 478 request->nameSpace, 479 request->className); 480 481 // build an internal provider name from the request arguments
482 chip 1.4 ProviderName name(
483 schuur 1.20 objectPath,
484 schuur 1.11 ProviderType::INSTANCE);
485 chip 1.1
486 chip 1.5 // resolve provider name 487 name = _resolveProviderName(name);
488 chip 1.1 489 // get cached or load new provider module 490 OpProviderHolder ph =
491 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
492 chip 1.1 493 // convert arguments 494 OperationContext context; 495 496 context.insert(IdentityContainer(request->userName)); 497 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 498 context.insert(ContentLanguageListContainer(request->contentLanguages)); 499 500 // forward request 501 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 502 "Calling provider.enumerateInstanceNames: " + 503 ph.GetProvider().getName()); 504 505 pm_service_op_lock op_lock(&ph.GetProvider()); 506 507 STAT_GETSTARTTIME; 508 509 ph.GetProvider().enumerateInstanceNames( 510 context, 511 objectPath, 512 handler); 513 chip 1.1 514 STAT_PMS_PROVIDEREND; 515 } 516 catch(CIMException & e) 517 { 518 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 519 "Exception: " + e.getMessage());
520 chip 1.2
521 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 522 } 523 catch(Exception & e) 524 { 525 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 526 "Exception: " + e.getMessage());
527 chip 1.2
528 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 529 } 530 catch(...) 531 { 532 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 533 "Exception: Unknown");
534 chip 1.2
535 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 536 } 537 538 PEG_METHOD_EXIT(); 539 540 return(response); 541 } 542 543 Message * DefaultProviderManager::handleCreateInstanceRequest(const Message * message) throw() 544 { 545 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateInstanceRequest"); 546 547 CIMCreateInstanceRequestMessage * request = 548 dynamic_cast<CIMCreateInstanceRequestMessage >(const_cast<Message >(message)); 549 550 PEGASUS_ASSERT(request != 0); 551 552 // create response message 553 CIMCreateInstanceResponseMessage * response = 554 new CIMCreateInstanceResponseMessage( 555 request->messageId, 556 chip 1.1 CIMException(), 557 request->queueIds.copyAndPop(), 558 CIMObjectPath()); 559 560 PEGASUS_ASSERT(response != 0); 561 562 // preserve message key 563 response->setKey(request->getKey()); 564 565 // Set HTTP method in response from request 566 response->setHttpMethod (request->getHttpMethod ()); 567 568 // create a handler for this request 569 CreateInstanceResponseHandler handler(request, response); 570 571 try 572 { 573 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 574 "DefaultProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2", 575 System::getHostName(), 576 request->nameSpace.getString(), 577 chip 1.1 request->newInstance.getPath().getClassName().getString()); 578 579 // make target object path 580 CIMObjectPath objectPath( 581 System::getHostName(), 582 request->nameSpace, 583 request->newInstance.getPath().getClassName(), 584 request->newInstance.getPath().getKeyBindings()); 585
586 chip 1.4 ProviderName name(
587 schuur 1.20 objectPath,
588 schuur 1.11 ProviderType::INSTANCE);
589 chip 1.1
590 chip 1.5 // resolve provider name 591 name = _resolveProviderName(name);
592 chip 1.1 593 // get cached or load new provider module 594 OpProviderHolder ph =
595 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
596 chip 1.1 597 // convert arguments 598 OperationContext context; 599 600 context.insert(IdentityContainer(request->userName)); 601 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 602 context.insert(ContentLanguageListContainer(request->contentLanguages)); 603 604 // forward request 605 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 606 "Calling provider.createInstance: " + 607 ph.GetProvider().getName()); 608 609 pm_service_op_lock op_lock(&ph.GetProvider()); 610 611 STAT_GETSTARTTIME; 612 613 ph.GetProvider().createInstance( 614 context, 615 objectPath, 616 request->newInstance, 617 chip 1.1 handler); 618 619 STAT_PMS_PROVIDEREND; 620 } 621 catch(CIMException & e) 622 { 623 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 624 "Exception: " + e.getMessage());
625 chip 1.2
626 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 627 } 628 catch(Exception & e) 629 { 630 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 631 "Exception: " + e.getMessage());
632 chip 1.2
633 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 634 } 635 catch(...) 636 { 637 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 638 "Exception: Unknown");
639 chip 1.2
640 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 641 } 642 643 PEG_METHOD_EXIT(); 644 645 return(response); 646 } 647 648 Message * DefaultProviderManager::handleModifyInstanceRequest(const Message * message) throw() 649 { 650 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifyInstanceRequest"); 651 652 CIMModifyInstanceRequestMessage * request = 653 dynamic_cast<CIMModifyInstanceRequestMessage >(const_cast<Message >(message)); 654 655 PEGASUS_ASSERT(request != 0); 656 657 // create response message 658 CIMModifyInstanceResponseMessage * response = 659 new CIMModifyInstanceResponseMessage( 660 request->messageId, 661 chip 1.1 CIMException(), 662 request->queueIds.copyAndPop()); 663 664 PEGASUS_ASSERT(response != 0); 665 666 // preserve message key 667 response->setKey(request->getKey()); 668 669 // Set HTTP method in response from request 670 response->setHttpMethod (request->getHttpMethod ()); 671 672 // create a handler for this request 673 ModifyInstanceResponseHandler handler(request, response); 674 675 try 676 { 677 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 678 "DefaultProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2", 679 System::getHostName(), 680 request->nameSpace.getString(), 681 request->modifiedInstance.getPath().getClassName().getString()); 682 chip 1.1 683 // make target object path 684 CIMObjectPath objectPath( 685 System::getHostName(), 686 request->nameSpace, 687 request->modifiedInstance.getPath ().getClassName(), 688 request->modifiedInstance.getPath ().getKeyBindings()); 689
690 chip 1.4 ProviderName name(
691 schuur 1.20 objectPath,
692 schuur 1.11 ProviderType::INSTANCE);
693 chip 1.1
694 chip 1.5 // resolve provider name 695 name = _resolveProviderName(name);
696 chip 1.1 697 // get cached or load new provider module 698 OpProviderHolder ph =
699 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
700 chip 1.1 701 // convert arguments 702 OperationContext context; 703 704 context.insert(IdentityContainer(request->userName)); 705 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 706 context.insert(ContentLanguageListContainer(request->contentLanguages)); 707 708 CIMPropertyList propertyList(request->propertyList); 709 710 // forward request 711 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 712 "Calling provider.modifyInstance: " + 713 ph.GetProvider().getName()); 714 715 pm_service_op_lock op_lock(&ph.GetProvider()); 716 717 STAT_GETSTARTTIME; 718 719 ph.GetProvider().modifyInstance( 720 context, 721 chip 1.1 objectPath, 722 request->modifiedInstance, 723 request->includeQualifiers, 724 propertyList, 725 handler); 726 727 STAT_PMS_PROVIDEREND; 728 } 729 catch(CIMException & e) 730 { 731 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 732 "Exception: " + e.getMessage());
733 chip 1.2
734 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 735 } 736 catch(Exception & e) 737 { 738 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 739 "Exception: " + e.getMessage());
740 chip 1.2
741 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 742 } 743 catch(...) 744 { 745 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 746 "Exception: Unknown");
747 chip 1.2
748 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 749 } 750 751 PEG_METHOD_EXIT(); 752 753 return(response); 754 } 755 756 Message * DefaultProviderManager::handleDeleteInstanceRequest(const Message * message) throw() 757 { 758 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteInstanceRequest"); 759 760 CIMDeleteInstanceRequestMessage * request = 761 dynamic_cast<CIMDeleteInstanceRequestMessage >(const_cast<Message >(message)); 762 763 PEGASUS_ASSERT(request != 0); 764 765 // create response message 766 CIMDeleteInstanceResponseMessage * response = 767 new CIMDeleteInstanceResponseMessage( 768 request->messageId, 769 chip 1.1 CIMException(), 770 request->queueIds.copyAndPop()); 771 772 PEGASUS_ASSERT(response != 0); 773 774 // preserve message key 775 response->setKey(request->getKey()); 776 777 // Set HTTP method in response from request 778 response->setHttpMethod (request->getHttpMethod ()); 779 780 // create a handler for this request 781 DeleteInstanceResponseHandler handler(request, response); 782 783 try 784 { 785 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 786 "DefaultProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2", 787 System::getHostName(), 788 request->nameSpace.getString(), 789 request->instanceName.getClassName().getString()); 790 chip 1.1 791 // make target object path 792 CIMObjectPath objectPath( 793 System::getHostName(), 794 request->nameSpace, 795 request->instanceName.getClassName(), 796 request->instanceName.getKeyBindings()); 797
798 chip 1.4 ProviderName name(
799 schuur 1.20 objectPath,
800 schuur 1.11 ProviderType::INSTANCE);
801 chip 1.1
802 chip 1.5 // resolve provider name 803 name = _resolveProviderName(name);
804 chip 1.1 805 // get cached or load new provider module 806 OpProviderHolder ph =
807 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
808 chip 1.1 809 // convert arguments 810 OperationContext context; 811 812 context.insert(IdentityContainer(request->userName)); 813 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 814 context.insert(ContentLanguageListContainer(request->contentLanguages)); 815 816 // forward request 817 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 818 "Calling provider.deleteInstance: " + 819 ph.GetProvider().getName()); 820 821 pm_service_op_lock op_lock(&ph.GetProvider()); 822 823 STAT_GETSTARTTIME; 824 825 ph.GetProvider().deleteInstance( 826 context, 827 objectPath, 828 handler); 829 chip 1.1 830 STAT_PMS_PROVIDEREND; 831 } 832 catch(CIMException & e) 833 { 834 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 835 "Exception: " + e.getMessage());
836 chip 1.2
837 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 838 } 839 catch(Exception & e) 840 { 841 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 842 "Exception: " + e.getMessage());
843 chip 1.2
844 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 845 } 846 catch(...) 847 { 848 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 849 "Exception: Unknown");
850 chip 1.2
851 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 852 } 853 854 PEG_METHOD_EXIT(); 855 856 return(response); 857 } 858
859 schuur 1.12 Message * DefaultProviderManager::handleExecQueryRequest(const Message * message) throw()
860 chip 1.1 {
861 schuur 1.12 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleExecQueryRequest");
862 chip 1.1 863 CIMExecQueryRequestMessage * request = 864 dynamic_cast<CIMExecQueryRequestMessage >(const_cast<Message >(message)); 865 866 PEGASUS_ASSERT(request != 0); 867 868 CIMExecQueryResponseMessage * response = 869 new CIMExecQueryResponseMessage( 870 request->messageId,
871 schuur 1.12 CIMException(),
872 chip 1.1 request->queueIds.copyAndPop(), 873 Array<CIMObject>()); 874 875 PEGASUS_ASSERT(response != 0); 876 877 // preserve message key 878 response->setKey(request->getKey()); 879 880 // Set HTTP method in response from request
881 schuur 1.12 response->setHttpMethod (request->getHttpMethod ()); 882 883 // create a handler for this request 884 ExecQueryResponseHandler handler(request, response); 885 886 try 887 { 888 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 889 "DefaultProviderManager::handleExecQueryRequest - Host name: $0 Name space: $1 Class name: $2", 890 System::getHostName(), 891 request->nameSpace.getString(), 892 request->className.getString()); 893 894 // make target object path 895 CIMObjectPath objectPath( 896 System::getHostName(), 897 request->nameSpace, 898 request->className); 899 900 ProviderName name(
901 schuur 1.20 objectPath,
902 schuur 1.12 ProviderType::QUERY); 903 904 // resolve provider name 905 name = _resolveProviderName(name); 906 907 // get cached or load new provider module 908 OpProviderHolder ph = 909 providerManager.getProvider(name.getPhysicalName(), 910 name.getLogicalName(), String::EMPTY); 911 912 if (dynamic_cast<CIMInstanceQueryProvider*>(ph.GetCIMProvider()) == 0) { 913 String errorString = " instance provider is registered supporting execQuery " 914 "but is not a CIMQueryInstanceProvider subclass."; 915 throw CIMException(CIM_ERR_FAILED,"ProviderLoadFailure (" + name.getPhysicalName() + ":" + 916 name.getLogicalName() + "):" + errorString); 917 } 918 919 // convert arguments 920 OperationContext context; 921 922 context.insert(IdentityContainer(request->userName)); 923 schuur 1.12 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 924 context.insert(ContentLanguageListContainer(request->contentLanguages)); 925
926 schuur 1.18 QueryExpression qx(QueryExpressionFactory::routeBuildQueryExpressionRep 927 (request->queryLanguage,request->query));
928 schuur 1.12 929 // forward request 930 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 931 "Calling provider.executeQueryRequest: " + 932 ph.GetProvider().getName()); 933 934 pm_service_op_lock op_lock(&ph.GetProvider()); 935 936 STAT_GETSTARTTIME; 937 938 ph.GetProvider().execQuery( 939 context, 940 objectPath, 941 qx, 942 handler); 943 944 STAT_PMS_PROVIDEREND; 945 } 946 catch(CIMException & e) 947 { 948 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 949 schuur 1.12 "Exception: " + e.getMessage()); 950 951 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 952 } 953 catch(Exception & e) 954 { 955 cout<<"--- exception not a CIMInstanceQueryProvider"<<endl; 956 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 957 "Exception: " + e.getMessage()); 958 959 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 960 } 961 catch(...) 962 { 963 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 964 "Exception: Unknown");
965 chip 1.1
966 schuur 1.12 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 967 }
968 chip 1.1 969 PEG_METHOD_EXIT(); 970 971 return(response); 972 } 973 974 Message * DefaultProviderManager::handleAssociatorsRequest(const Message * message) throw() 975 { 976 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorsRequest"); 977 978 CIMAssociatorsRequestMessage * request = 979 dynamic_cast<CIMAssociatorsRequestMessage >(const_cast<Message >(message)); 980 981 PEGASUS_ASSERT(request != 0); 982 983 CIMAssociatorsResponseMessage * response = 984 new CIMAssociatorsResponseMessage( 985 request->messageId, 986 CIMException(), 987 request->queueIds.copyAndPop(), 988 Array<CIMObject>()); 989 chip 1.1 990 PEGASUS_ASSERT(response != 0); 991 992 // preserve message key 993 response->setKey(request->getKey()); 994 995 // create a handler for this request 996 AssociatorsResponseHandler handler(request, response); 997 998 // process the request 999 try 1000 { 1001 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 1002 "DefaultProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2", 1003 System::getHostName(), 1004 request->nameSpace.getString(), 1005 request->objectName.getClassName().getString()); 1006 1007 // make target object path 1008 CIMObjectPath objectPath( 1009 System::getHostName(), 1010 chip 1.1 request->nameSpace, 1011 request->objectName.getClassName()); 1012 1013 objectPath.setKeyBindings(request->objectName.getKeyBindings()); 1014
1015 schuur 1.19 CIMObjectPath assocPath( 1016 System::getHostName(), 1017 request->nameSpace, 1018 request->assocClass.getString()); 1019
1020 chip 1.4 ProviderName name(
1021 schuur 1.20 assocPath,
1022 schuur 1.11 ProviderType::ASSOCIATION);
1023 chip 1.2
1024 chip 1.5 // resolve provider name 1025 name = _resolveProviderName(name);
1026 chip 1.2 1027 // get cached or load new provider module 1028 OpProviderHolder ph =
1029 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1030 chip 1.2 1031 // convert arguments 1032 OperationContext context; 1033 1034 context.insert(IdentityContainer(request->userName)); 1035 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 1036 context.insert(ContentLanguageListContainer(request->contentLanguages));
1037 chip 1.1
1038 chip 1.2 // ATTN KS STAT_GETSTARTTIME; 1039 pm_service_op_lock op_lock(&ph.GetProvider());
1040 chip 1.1
1041 chip 1.2 ph.GetProvider().associators( 1042 context, 1043 objectPath, 1044 request->assocClass, 1045 request->resultClass, 1046 request->role, 1047 request->resultRole, 1048 request->includeQualifiers, 1049 request->includeClassOrigin, 1050 request->propertyList.getPropertyNameArray(), 1051 handler);
1052 chip 1.1
1053 chip 1.2 STAT_PMS_PROVIDEREND;
1054 chip 1.1 } 1055 catch(CIMException & e) 1056 { 1057 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1058 "Exception: " + e.getMessage());
1059 chip 1.2
1060 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 1061 } 1062 catch(Exception & e) 1063 { 1064 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1065 "Exception: " + e.getMessage());
1066 chip 1.2
1067 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 1068 } 1069 catch(...) 1070 { 1071 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1072 "Exception: Unknown");
1073 chip 1.2
1074 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 1075 } 1076 1077 PEG_METHOD_EXIT(); 1078 1079 return(response); 1080 } 1081 1082 Message * DefaultProviderManager::handleAssociatorNamesRequest(const Message * message) throw() 1083 { 1084 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleAssociatorNamesRequest"); 1085 1086 CIMAssociatorNamesRequestMessage * request = 1087 dynamic_cast<CIMAssociatorNamesRequestMessage >(const_cast<Message >(message)); 1088 1089 PEGASUS_ASSERT(request != 0); 1090 1091 CIMAssociatorNamesResponseMessage * response = 1092 new CIMAssociatorNamesResponseMessage( 1093 request->messageId, 1094 CIMException(), 1095 chip 1.1 request->queueIds.copyAndPop(), 1096 Array<CIMObjectPath>()); 1097 1098 PEGASUS_ASSERT(response != 0); 1099 1100 // preserve message key 1101 response->setKey(request->getKey()); 1102 1103 // Set HTTP method in response from request 1104 response->setHttpMethod(request->getHttpMethod()); 1105 1106 // create a handler for this request 1107 AssociatorNamesResponseHandler handler(request, response); 1108 1109 // process the request 1110 try 1111 { 1112 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 1113 "DefaultProviderManager::handleAssociationNamesRequest - Host name: $0 Name space: $1 Class name: $2", 1114 System::getHostName(), 1115 request->nameSpace.getString(), 1116 chip 1.1 request->objectName.getClassName().getString()); 1117 1118 // make target object path 1119 CIMObjectPath objectPath( 1120 System::getHostName(), 1121 request->nameSpace, 1122 request->objectName.getClassName()); 1123 1124 objectPath.setKeyBindings(request->objectName.getKeyBindings()); 1125
1126 schuur 1.19 CIMObjectPath assocPath( 1127 System::getHostName(), 1128 request->nameSpace, 1129 request->assocClass.getString()); 1130
1131 chip 1.4 ProviderName name(
1132 schuur 1.20 assocPath,
1133 schuur 1.11 ProviderType::ASSOCIATION);
1134 chip 1.2
1135 chip 1.5 // resolve provider name 1136 name = _resolveProviderName(name);
1137 chip 1.2 1138 // get cached or load new provider module 1139 OpProviderHolder ph =
1140 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1141 chip 1.2 1142 // convert arguments 1143 OperationContext context;
1144 chip 1.1
1145 chip 1.2 context.insert(IdentityContainer(request->userName)); 1146 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 1147 context.insert(ContentLanguageListContainer(request->contentLanguages));
1148 chip 1.1
1149 chip 1.2 pm_service_op_lock op_lock(&ph.GetProvider());
1150 chip 1.1
1151 chip 1.2 ph.GetProvider().associatorNames( 1152 context, 1153 objectPath, 1154 request->assocClass, 1155 request->resultClass, 1156 request->role, 1157 request->resultRole, 1158 handler);
1159 chip 1.1
1160 chip 1.2 STAT_PMS_PROVIDEREND;
1161 chip 1.1 } 1162 catch(CIMException & e) 1163 {
1164 chip 1.2 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1165 "Exception: " + e.getMessage()); 1166
1167 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 1168 } 1169 catch(Exception & e) 1170 {
1171 chip 1.2 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1172 "Exception: " + e.getMessage()); 1173
1174 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 1175 } 1176 catch(...) 1177 { 1178 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1179 "Exception: Unknown");
1180 chip 1.2
1181 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 1182 } 1183 1184 PEG_METHOD_EXIT(); 1185 1186 return(response); 1187 } 1188 1189 Message * DefaultProviderManager::handleReferencesRequest(const Message * message) throw() 1190 { 1191 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferencesRequest"); 1192 1193 CIMReferencesRequestMessage * request = 1194 dynamic_cast<CIMReferencesRequestMessage >(const_cast<Message >(message)); 1195 1196 PEGASUS_ASSERT(request != 0); 1197 1198 CIMReferencesResponseMessage * response = 1199 new CIMReferencesResponseMessage( 1200 request->messageId, 1201 CIMException(), 1202 chip 1.1 request->queueIds.copyAndPop(), 1203 Array<CIMObject>()); 1204 1205 PEGASUS_ASSERT(response != 0); 1206 1207 // preserve message key 1208 response->setKey(request->getKey()); 1209 1210 // Set HTTP method in response from request 1211 response->setHttpMethod (request->getHttpMethod ()); 1212 1213 // create a handler for this request 1214 ReferencesResponseHandler handler(request, response); 1215 1216 // process the request 1217 try 1218 { 1219 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 1220 "DefaultProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2", 1221 System::getHostName(), 1222 request->nameSpace.getString(), 1223 chip 1.1 request->objectName.getClassName().getString()); 1224 1225 // make target object path 1226 CIMObjectPath objectPath( 1227 System::getHostName(), 1228 request->nameSpace, 1229 request->objectName.getClassName()); 1230 1231 objectPath.setKeyBindings(request->objectName.getKeyBindings()); 1232
1233 schuur 1.19 CIMObjectPath resultPath( 1234 System::getHostName(), 1235 request->nameSpace, 1236 request->resultClass.getString()); 1237
1238 chip 1.4 ProviderName name(
1239 schuur 1.20 resultPath,
1240 schuur 1.11 ProviderType::ASSOCIATION);
1241 chip 1.2
1242 chip 1.5 // resolve provider name 1243 name = _resolveProviderName(name);
1244 chip 1.2 1245 // get cached or load new provider module 1246 OpProviderHolder ph =
1247 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1248 chip 1.2 1249 // convert arguments 1250 OperationContext context; 1251 1252 context.insert(IdentityContainer(request->userName)); 1253 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 1254 context.insert(ContentLanguageListContainer(request->contentLanguages)); 1255 1256 STAT_GETSTARTTIME;
1257 chip 1.1
1258 chip 1.2 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1259 "Calling provider.references: " + 1260 ph.GetProvider().getName());
1261 chip 1.1
1262 chip 1.2 pm_service_op_lock op_lock(&ph.GetProvider());
1263 chip 1.1
1264 chip 1.2 ph.GetProvider().references( 1265 context, 1266 objectPath, 1267 request->resultClass, 1268 request->role, 1269 request->includeQualifiers, 1270 request->includeClassOrigin, 1271 request->propertyList.getPropertyNameArray(), 1272 handler);
1273 chip 1.1
1274 chip 1.2 STAT_PMS_PROVIDEREND;
1275 chip 1.1 } 1276 catch(CIMException & e) 1277 { 1278 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1279 "Exception: " + e.getMessage());
1280 chip 1.2
1281 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 1282 } 1283 catch(Exception & e) 1284 { 1285 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1286 "Exception: " + e.getMessage());
1287 chip 1.2
1288 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 1289 } 1290 catch(...) 1291 { 1292 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1293 "Exception: Unknown");
1294 chip 1.2
1295 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 1296 } 1297 1298 PEG_METHOD_EXIT(); 1299 1300 return(response); 1301 } 1302 1303 Message * DefaultProviderManager::handleReferenceNamesRequest(const Message * message) throw() 1304 { 1305 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleReferenceNamesRequest"); 1306 1307 CIMReferenceNamesRequestMessage * request = 1308 dynamic_cast<CIMReferenceNamesRequestMessage >(const_cast<Message >(message)); 1309 1310 PEGASUS_ASSERT(request != 0); 1311 1312 CIMReferenceNamesResponseMessage * response = 1313 new CIMReferenceNamesResponseMessage( 1314 request->messageId, 1315 CIMException(), 1316 chip 1.1 request->queueIds.copyAndPop(), 1317 Array<CIMObjectPath>()); 1318 1319 // preserve message key 1320 response->setKey(request->getKey()); 1321 1322 // Set HTTP method in response from request 1323 response->setHttpMethod (request->getHttpMethod ()); 1324 1325 // create a handler for this request 1326 ReferenceNamesResponseHandler handler(request, response); 1327 1328 // process the request 1329 try 1330 { 1331 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 1332 "DefaultProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2", 1333 System::getHostName(), 1334 request->nameSpace.getString(), 1335 request->objectName.getClassName().getString()); 1336 1337 chip 1.1 // make target object path 1338 CIMObjectPath objectPath( 1339 System::getHostName(), 1340 request->nameSpace, 1341 request->objectName.getClassName()); 1342 1343 objectPath.setKeyBindings(request->objectName.getKeyBindings()); 1344
1345 schuur 1.19 CIMObjectPath resultPath( 1346 System::getHostName(), 1347 request->nameSpace, 1348 request->resultClass.getString()); 1349
1350 chip 1.4 ProviderName name(
1351 schuur 1.20 resultPath,
1352 schuur 1.11 ProviderType::ASSOCIATION);
1353 chip 1.1
1354 chip 1.5 // resolve provider name 1355 name = _resolveProviderName(name);
1356 chip 1.1
1357 chip 1.2 // get cached or load new provider module 1358 OpProviderHolder ph =
1359 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1360 chip 1.1
1361 chip 1.2 // convert arguments 1362 OperationContext context;
1363 chip 1.1
1364 chip 1.2 context.insert(IdentityContainer(request->userName)); 1365 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 1366 context.insert(ContentLanguageListContainer(request->contentLanguages));
1367 chip 1.1
1368 chip 1.2 STAT_GETSTARTTIME;
1369 chip 1.1
1370 chip 1.2 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1371 "Calling provider.referenceNames: " + 1372 ph.GetProvider().getName());
1373 chip 1.1
1374 chip 1.2 pm_service_op_lock op_lock(&ph.GetProvider());
1375 chip 1.1
1376 chip 1.2 ph.GetProvider().referenceNames( 1377 context, 1378 objectPath, 1379 request->resultClass, 1380 request->role, 1381 handler);
1382 chip 1.1
1383 chip 1.2 STAT_PMS_PROVIDEREND;
1384 chip 1.1 } 1385 catch(CIMException & e) 1386 { 1387 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1388 "Exception: " + e.getMessage());
1389 chip 1.2
1390 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 1391 } 1392 catch(Exception & e) 1393 { 1394 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1395 "Exception: " + e.getMessage());
1396 chip 1.2
1397 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 1398 } 1399 catch(...) 1400 { 1401 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1402 "Exception: Unknown");
1403 chip 1.2
1404 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 1405 } 1406 1407 PEG_METHOD_EXIT(); 1408 1409 return(response); 1410 } 1411 1412 Message * DefaultProviderManager::handleGetPropertyRequest(const Message * message) throw() 1413 { 1414 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleGetPropertyRequest"); 1415 1416 CIMGetPropertyRequestMessage * request = 1417 dynamic_cast<CIMGetPropertyRequestMessage >(const_cast<Message >(message)); 1418 1419 PEGASUS_ASSERT(request != 0); 1420 1421 // create response message 1422 CIMGetPropertyResponseMessage * response = 1423 new CIMGetPropertyResponseMessage( 1424 request->messageId, 1425 chip 1.1 CIMException(), 1426 request->queueIds.copyAndPop(), 1427 CIMValue()); 1428 1429 PEGASUS_ASSERT(response != 0); 1430 1431 // preserve message key 1432 response->setKey(request->getKey()); 1433 1434 // Set HTTP method in response from request 1435 response->setHttpMethod(request->getHttpMethod()); 1436 1437 GetPropertyResponseHandler handler(request, response); 1438 1439 try 1440 { 1441 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 1442 "DefaultProviderManager::handleGetPropertyRequest - Host name: $0 Name space: $1 Class name: $2", 1443 System::getHostName(), 1444 request->nameSpace.getString(), 1445 request->instanceName.getClassName().getString()); 1446 chip 1.1 1447 // make target object path 1448 CIMObjectPath objectPath( 1449 System::getHostName(), 1450 request->nameSpace, 1451 request->instanceName.getClassName(), 1452 request->instanceName.getKeyBindings()); 1453
1454 chip 1.4 ProviderName name(
1455 schuur 1.20 objectPath,
1456 chip 1.4 0);
1457 chip 1.1
1458 chip 1.5 // resolve provider name 1459 name = _resolveProviderName(name);
1460 chip 1.1 1461 // get cached or load new provider module 1462 OpProviderHolder ph =
1463 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1464 chip 1.1 1465 // convert arguments 1466 OperationContext context; 1467 1468 context.insert(IdentityContainer(request->userName)); 1469 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 1470 context.insert(ContentLanguageListContainer(request->contentLanguages)); 1471 1472 CIMName propertyName = request->propertyName; 1473 1474 STAT_GETSTARTTIME; 1475 1476 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1477 "Calling provider.getProperty: " + 1478 ph.GetProvider().getName()); 1479 1480 // forward request 1481 pm_service_op_lock op_lock(&ph.GetProvider()); 1482 1483 ph.GetProvider().getProperty( 1484 context, 1485 chip 1.1 objectPath, 1486 propertyName, 1487 handler); 1488 1489 STAT_PMS_PROVIDEREND; 1490 } 1491 catch(CIMException & e) 1492 { 1493 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1494 "Exception: " + e.getMessage());
1495 chip 1.2
1496 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 1497 } 1498 catch(Exception & e) 1499 { 1500 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1501 "Exception: " + e.getMessage());
1502 chip 1.2
1503 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 1504 } 1505 catch(...) 1506 { 1507 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1508 "Exception: Unknown");
1509 chip 1.2
1510 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 1511 } 1512 1513 PEG_METHOD_EXIT(); 1514 1515 return(response); 1516 } 1517 1518 Message * DefaultProviderManager::handleSetPropertyRequest(const Message * message) throw() 1519 { 1520 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleSetPropertyRequest"); 1521 1522 CIMSetPropertyRequestMessage * request = 1523 dynamic_cast<CIMSetPropertyRequestMessage >(const_cast<Message >(message)); 1524 1525 PEGASUS_ASSERT(request != 0); 1526 1527 // create response message 1528 //l10n 1529 CIMSetPropertyResponseMessage * response = 1530 new CIMSetPropertyResponseMessage( 1531 chip 1.1 request->messageId, 1532 PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms( 1533 "ProviderManager.DefaultProviderManager.NOT_IMPLEMENTED", 1534 "not implemented")), 1535 request->queueIds.copyAndPop()); 1536 1537 PEGASUS_ASSERT(response != 0); 1538 1539 // preserve message key 1540 response->setKey(request->getKey()); 1541 1542 // Set HTTP method in response from request 1543 response->setHttpMethod(request->getHttpMethod()); 1544 1545 SetPropertyResponseHandler handler(request, response); 1546 1547 try 1548 { 1549 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 1550 "DefaultProviderManager::handleSetPropertyRequest - Host name: $0 Name space: $1 Class name: $2", 1551 System::getHostName(), 1552 chip 1.1 request->nameSpace.getString(), 1553 request->instanceName.getClassName().getString()); 1554 1555 // make target object path 1556 CIMObjectPath objectPath( 1557 System::getHostName(), 1558 request->nameSpace, 1559 request->instanceName.getClassName(), 1560 request->instanceName.getKeyBindings()); 1561
1562 chip 1.4 ProviderName name(
1563 schuur 1.20 objectPath,
1564 chip 1.4 0);
1565 chip 1.1
1566 chip 1.5 // resolve provider name 1567 name = _resolveProviderName(name);
1568 chip 1.1 1569 // get cached or load new provider module 1570 OpProviderHolder ph =
1571 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1572 chip 1.1 1573 // convert arguments 1574 OperationContext context; 1575 1576 context.insert(IdentityContainer(request->userName)); 1577 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 1578 context.insert(ContentLanguageListContainer(request->contentLanguages)); 1579 1580 CIMName propertyName = request->propertyName; 1581 CIMValue propertyValue = request->newValue; 1582 1583 STAT_GETSTARTTIME; 1584 1585 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1586 "Calling provider.setProperty: " + 1587 ph.GetProvider().getName()); 1588 1589 // forward request 1590 pm_service_op_lock op_lock(&ph.GetProvider()); 1591 1592 ph.GetProvider().setProperty( 1593 chip 1.1 context, 1594 objectPath, 1595 propertyName, 1596 propertyValue, 1597 handler); 1598 1599 STAT_PMS_PROVIDEREND; 1600 } 1601 catch(CIMException & e) 1602 { 1603 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1604 "Exception: " + e.getMessage());
1605 chip 1.2
1606 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 1607 } 1608 catch(Exception & e) 1609 { 1610 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1611 "Exception: " + e.getMessage());
1612 chip 1.2
1613 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 1614 } 1615 catch(...) 1616 { 1617 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1618 "Exception: Unknown");
1619 chip 1.2
1620 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 1621 } 1622 1623 PEG_METHOD_EXIT(); 1624 1625 return(response); 1626 } 1627 1628 Message * DefaultProviderManager::handleInvokeMethodRequest(const Message * message) throw() 1629 { 1630 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleInvokeMethodRequest"); 1631 1632 CIMInvokeMethodRequestMessage * request = 1633 dynamic_cast<CIMInvokeMethodRequestMessage >(const_cast<Message >(message)); 1634 1635 PEGASUS_ASSERT(request != 0); 1636 1637 // create response message 1638 CIMInvokeMethodResponseMessage * response = 1639 new CIMInvokeMethodResponseMessage( 1640 request->messageId, 1641 chip 1.1 CIMException(), 1642 request->queueIds.copyAndPop(), 1643 CIMValue(), 1644 Array<CIMParamValue>(), 1645 request->methodName); 1646 1647 PEGASUS_ASSERT(response != 0); 1648 1649 // propagate message key 1650 response->setKey(request->getKey()); 1651 1652 // Set HTTP method in response from request 1653 response->setHttpMethod (request->getHttpMethod ()); 1654 1655 // create a handler for this request 1656 InvokeMethodResponseHandler handler(request, response); 1657 1658 try 1659 { 1660 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 1661 "DefaultProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2", 1662 chip 1.1 System::getHostName(), 1663 request->nameSpace.getString(), 1664 request->instanceName.getClassName().getString()); 1665 1666 // make target object path 1667 CIMObjectPath objectPath( 1668 System::getHostName(), 1669 request->nameSpace, 1670 request->instanceName.getClassName(), 1671 request->instanceName.getKeyBindings()); 1672
1673 chip 1.4 ProviderName name(
1674 schuur 1.20 objectPath,
1675 schuur 1.16 ProviderType::METHOD, 1676 request->methodName);
1677 chip 1.1
1678 chip 1.5 // resolve provider name 1679 name = _resolveProviderName(name);
1680 chip 1.1 1681 // get cached or load new provider module 1682 OpProviderHolder ph =
1683 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1684 chip 1.1 1685 // convert arguments 1686 OperationContext context; 1687 1688 context.insert(IdentityContainer(request->userName)); 1689 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 1690 context.insert(ContentLanguageListContainer(request->contentLanguages)); 1691 1692 CIMObjectPath instanceReference(request->instanceName); 1693 1694 // ATTN: propagate namespace 1695 instanceReference.setNameSpace(request->nameSpace); 1696 1697 // forward request 1698 STAT_GETSTARTTIME; 1699 1700 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1701 "Calling provider.invokeMethod: " + 1702 ph.GetProvider().getName()); 1703 1704 pm_service_op_lock op_lock(&ph.GetProvider()); 1705 chip 1.1 1706 ph.GetProvider().invokeMethod( 1707 context, 1708 instanceReference, 1709 request->methodName, 1710 request->inParameters, 1711 handler); 1712 1713 STAT_PMS_PROVIDEREND; 1714 } 1715 catch(CIMException & e) 1716 { 1717 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1718 "Exception: " + e.getMessage());
1719 chip 1.2
1720 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 1721 } 1722 catch(Exception & e) 1723 { 1724 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1725 "Exception: " + e.getMessage());
1726 chip 1.2
1727 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 1728 } 1729 catch(...) 1730 { 1731 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1732 "Exception: Unknown");
1733 chip 1.2
1734 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); 1735 } 1736 1737 PEG_METHOD_EXIT(); 1738 1739 return(response); 1740 } 1741 1742 Message * DefaultProviderManager::handleCreateSubscriptionRequest(const Message * message) throw() 1743 { 1744 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateSubscriptionRequest"); 1745 1746 CIMCreateSubscriptionRequestMessage * request = 1747 dynamic_cast<CIMCreateSubscriptionRequestMessage >(const_cast<Message >(message)); 1748 1749 PEGASUS_ASSERT(request != 0); 1750 1751 CIMCreateSubscriptionResponseMessage * response = 1752 new CIMCreateSubscriptionResponseMessage( 1753 request->messageId, 1754 CIMException(), 1755 chip 1.1 request->queueIds.copyAndPop()); 1756 1757 PEGASUS_ASSERT(response != 0); 1758 1759 // preserve message key 1760 response->setKey(request->getKey()); 1761 1762 // Set HTTP method in response from request 1763 response->setHttpMethod (request->getHttpMethod ()); 1764 1765 OperationResponseHandler handler(request, response); 1766 1767 try 1768 {
1769 chip 1.2 String temp; 1770 1771 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) 1772 { 1773 temp.append(request->classNames[i].getString()); 1774 1775 if(i == (n - 1)) 1776 { 1777 temp.append(", "); 1778 } 1779 } 1780 1781 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 1782 "DefaultProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Class name(s): $2", 1783 System::getHostName(), 1784 request->nameSpace.getString(), 1785 temp); 1786
1787 schuur 1.18 String physicalName=_resolvePhysicalName( 1788 request->providerModule.getProperty( 1789 request->providerModule.findProperty("Location")).getValue().toString()); 1790
1791 schuur 1.20 ProviderName name(
1792 schuur 1.18 request->provider.getProperty(request->provider.findProperty 1793 ("Name")).getValue ().toString (), 1794 physicalName, 1795 request->providerModule.getProperty(request->providerModule.findProperty 1796 ("InterfaceType")).getValue().toString(), 1797 0);
1798 chip 1.1 1799 // get cached or load new provider module 1800 OpProviderHolder ph =
1801 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1802 schuur 1.18
1803 chip 1.1 // convert arguments 1804 OperationContext context; 1805 1806 context.insert(IdentityContainer(request->userName)); 1807 context.insert(SubscriptionInstanceContainer 1808 (request->subscriptionInstance)); 1809 context.insert(SubscriptionFilterConditionContainer 1810 (request->condition, request->queryLanguage)); 1811 context.insert(SubscriptionLanguageListContainer 1812 (request->acceptLanguages)); 1813 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 1814 context.insert(ContentLanguageListContainer(request->contentLanguages)); 1815 1816 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); 1817 1818 Array<CIMObjectPath> classNames; 1819 1820 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) 1821 { 1822 CIMObjectPath className( 1823 System::getHostName(), 1824 chip 1.1 request->nameSpace, 1825 request->classNames[i]); 1826 1827 classNames.append(className); 1828 } 1829 1830 CIMPropertyList propertyList = request->propertyList; 1831 1832 Uint16 repeatNotificationPolicy = request->repeatNotificationPolicy; 1833 1834 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1835 "Calling provider.createSubscription: " + 1836 ph.GetProvider().getName()); 1837 1838 pm_service_op_lock op_lock(&ph.GetProvider()); 1839 1840 ph.GetProvider().createSubscription( 1841 context, 1842 subscriptionName, 1843 classNames, 1844 propertyList, 1845 chip 1.1 repeatNotificationPolicy); 1846 } 1847 catch(CIMException & e) 1848 { 1849 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1850 "Exception: " + e.getMessage());
1851 chip 1.2
1852 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 1853 } 1854 catch(Exception & e) 1855 { 1856 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1857 "Exception: " + e.getMessage());
1858 chip 1.2
1859 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 1860 } 1861 catch(...) 1862 { 1863 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1864 "Exception: Unknown");
1865 chip 1.2
1866 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown Error"); 1867 } 1868 1869 PEG_METHOD_EXIT(); 1870 1871 return(response); 1872 } 1873 1874 Message * DefaultProviderManager::handleModifySubscriptionRequest( const Message * message) throw() 1875 { 1876 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleModifySubscriptionRequest"); 1877 1878 CIMModifySubscriptionRequestMessage * request = 1879 dynamic_cast<CIMModifySubscriptionRequestMessage >(const_cast<Message >(message)); 1880 1881 PEGASUS_ASSERT(request != 0); 1882 1883 CIMModifySubscriptionResponseMessage * response = 1884 new CIMModifySubscriptionResponseMessage( 1885 request->messageId, 1886 CIMException(), 1887 chip 1.1 request->queueIds.copyAndPop()); 1888 1889 PEGASUS_ASSERT(response != 0); 1890 1891 // preserve message key 1892 response->setKey(request->getKey()); 1893 1894 // Set HTTP method in response from request 1895 response->setHttpMethod (request->getHttpMethod ()); 1896 1897 OperationResponseHandler handler(request, response); 1898 1899 try 1900 {
1901 chip 1.2 String temp; 1902 1903 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) 1904 { 1905 temp.append(request->classNames[i].getString()); 1906 1907 if(i == (n - 1)) 1908 { 1909 temp.append(", "); 1910 } 1911 } 1912 1913 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1914 schuur 1.18 "DefaultProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Class name(s): $2",
1915 chip 1.2 System::getHostName(), 1916 request->nameSpace.getString(), 1917 temp); 1918
1919 schuur 1.18 String physicalName=_resolvePhysicalName( 1920 request->providerModule.getProperty( 1921 request->providerModule.findProperty("Location")).getValue().toString()); 1922
1923 schuur 1.20 ProviderName name(
1924 schuur 1.18 request->provider.getProperty(request->provider.findProperty 1925 ("Name")).getValue ().toString (), 1926 physicalName, 1927 request->providerModule.getProperty(request->providerModule.findProperty 1928 ("InterfaceType")).getValue().toString(), 1929 0);
1930 chip 1.1 1931 // get cached or load new provider module 1932 OpProviderHolder ph =
1933 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1934 schuur 1.18
1935 chip 1.1 // convert arguments 1936 OperationContext context; 1937 1938 context.insert(IdentityContainer(request->userName)); 1939 context.insert(SubscriptionInstanceContainer 1940 (request->subscriptionInstance)); 1941 context.insert(SubscriptionFilterConditionContainer 1942 (request->condition, request->queryLanguage)); 1943 context.insert(SubscriptionLanguageListContainer 1944 (request->acceptLanguages)); 1945 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 1946 context.insert(ContentLanguageListContainer(request->contentLanguages)); 1947 1948 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); 1949 1950 Array<CIMObjectPath> classNames; 1951 1952 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) 1953 { 1954 CIMObjectPath className( 1955 System::getHostName(), 1956 chip 1.1 request->nameSpace, 1957 request->classNames[i]); 1958 1959 classNames.append(className); 1960 } 1961 1962 CIMPropertyList propertyList = request->propertyList; 1963 1964 Uint16 repeatNotificationPolicy = request->repeatNotificationPolicy; 1965 1966 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1967 "Calling provider.modifySubscription: " + 1968 ph.GetProvider().getName()); 1969 1970 pm_service_op_lock op_lock(&ph.GetProvider()); 1971 1972 ph.GetProvider().modifySubscription( 1973 context, 1974 subscriptionName, 1975 classNames, 1976 propertyList, 1977 chip 1.1 repeatNotificationPolicy); 1978 } 1979 catch(CIMException & e) 1980 { 1981 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1982 "Exception: " + e.getMessage());
1983 chip 1.2
1984 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 1985 } 1986 catch(Exception & e) 1987 { 1988 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1989 "Exception: " + e.getMessage());
1990 chip 1.2
1991 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 1992 } 1993 catch(...) 1994 { 1995 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 1996 "Exception: Unknown");
1997 chip 1.2
1998 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown Error"); 1999 } 2000 2001 PEG_METHOD_EXIT(); 2002 2003 return(response); 2004 } 2005 2006 Message * DefaultProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw() 2007 { 2008 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDeleteSubscriptionRequest"); 2009 2010 CIMDeleteSubscriptionRequestMessage * request = 2011 dynamic_cast<CIMDeleteSubscriptionRequestMessage >(const_cast<Message >(message)); 2012 2013 PEGASUS_ASSERT(request != 0); 2014 2015 CIMDeleteSubscriptionResponseMessage * response = 2016 new CIMDeleteSubscriptionResponseMessage( 2017 request->messageId, 2018 CIMException(), 2019 chip 1.1 request->queueIds.copyAndPop()); 2020 2021 PEGASUS_ASSERT(response != 0); 2022 2023 // preserve message key 2024 response->setKey(request->getKey()); 2025 2026 // Set HTTP method in response from request 2027 response->setHttpMethod(request->getHttpMethod()); 2028 2029 OperationResponseHandler handler(request, response); 2030 2031 try 2032 {
2033 chip 1.2 String temp; 2034 2035 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) 2036 { 2037 temp.append(request->classNames[i].getString()); 2038 2039 if(i == (n - 1)) 2040 { 2041 temp.append(", "); 2042 } 2043 } 2044 2045 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, 2046 "DefaultProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Class name(s): $2", 2047 System::getHostName(), 2048 request->nameSpace.getString(), 2049 temp); 2050
2051 schuur 1.18 String physicalName=_resolvePhysicalName( 2052 request->providerModule.getProperty( 2053 request->providerModule.findProperty("Location")).getValue().toString()); 2054
2055 schuur 1.20 ProviderName name(
2056 schuur 1.18 request->provider.getProperty(request->provider.findProperty 2057 ("Name")).getValue ().toString (), 2058 physicalName, 2059 request->providerModule.getProperty(request->providerModule.findProperty 2060 ("InterfaceType")).getValue().toString(), 2061 0);
2062 chip 1.1 2063 // get cached or load new provider module 2064 OpProviderHolder ph =
2065 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
2066 schuur 1.18
2067 chip 1.1 // convert arguments 2068 OperationContext context; 2069 2070 context.insert(IdentityContainer(request->userName)); 2071 context.insert(SubscriptionInstanceContainer 2072 (request->subscriptionInstance)); 2073 context.insert(SubscriptionLanguageListContainer 2074 (request->acceptLanguages)); 2075 context.insert(AcceptLanguageListContainer(request->acceptLanguages)); 2076 context.insert(ContentLanguageListContainer(request->contentLanguages)); 2077 2078 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath(); 2079 2080 Array<CIMObjectPath> classNames; 2081 2082 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) 2083 { 2084 CIMObjectPath className( 2085 System::getHostName(), 2086 request->nameSpace, 2087 request->classNames[i]); 2088 chip 1.1 2089 classNames.append(className); 2090 } 2091 2092 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2093 "Calling provider.deleteSubscription: " + 2094 ph.GetProvider().getName()); 2095 2096 pm_service_op_lock op_lock(&ph.GetProvider()); 2097 2098 ph.GetProvider().deleteSubscription( 2099 context, 2100 subscriptionName, 2101 classNames); 2102 } 2103 catch(CIMException & e) 2104 { 2105 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2106 "Exception: " + e.getMessage());
2107 chip 1.2
2108 chip 1.1 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 2109 } 2110 catch(Exception & e) 2111 { 2112 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2113 "Exception: " + e.getMessage());
2114 chip 1.2
2115 chip 1.1 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 2116 } 2117 catch(...) 2118 { 2119 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2120 "Exception: Unknown");
2121 chip 1.2
2122 chip 1.1 handler.setStatus(CIM_ERR_FAILED, "Unknown Error"); 2123 } 2124 2125 PEG_METHOD_EXIT(); 2126 2127 return(response); 2128 } 2129 2130 Message * DefaultProviderManager::handleEnableIndicationsRequest(const Message * message) throw() 2131 { 2132 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager:: handleEnableIndicationsRequest"); 2133 2134 CIMEnableIndicationsRequestMessage * request = 2135 dynamic_cast<CIMEnableIndicationsRequestMessage >(const_cast<Message >(message)); 2136 2137 PEGASUS_ASSERT(request != 0); 2138 2139 CIMEnableIndicationsResponseMessage * response = 2140 new CIMEnableIndicationsResponseMessage( 2141 request->messageId, 2142 CIMException(), 2143 chip 1.1 request->queueIds.copyAndPop()); 2144 2145 CIMEnableIndicationsResponseMessage * responseforhandler = 2146 new CIMEnableIndicationsResponseMessage( 2147 request->messageId, 2148 CIMException(), 2149 request->queueIds.copyAndPop()); 2150 2151 PEGASUS_ASSERT(response != 0); 2152 2153 // preserve message key 2154 response->setKey(request->getKey()); 2155 2156 // Set HTTP method in response from request 2157 response->setHttpMethod(request->getHttpMethod()); 2158 2159 response->dest = request->queueIds.top(); 2160 2161 // ATTN: need pointer to Provider Manager Server!
2162 schuur 1.14 EnableIndicationsResponseHandler *handler = 2163 new EnableIndicationsResponseHandler(request, response, 2164 request->provider, ProviderManagerService::providerManagerService);
2165 chip 1.1 2166 try 2167 {
2168 schuur 1.14 String physicalName=_resolvePhysicalName( 2169 request->providerModule.getProperty( 2170 request->providerModule.findProperty("Location")).getValue().toString()); 2171
2172 schuur 1.20 ProviderName name(
2173 schuur 1.16 request->provider.getProperty(request->provider.findProperty
2174 schuur 1.14 ("Name")).getValue ().toString (), 2175 physicalName, 2176 request->providerModule.getProperty(request->providerModule.findProperty 2177 ("InterfaceType")).getValue().toString(), 2178 0);
2179 chip 1.1 2180 // get cached or load new provider module 2181 OpProviderHolder ph =
2182 schuur 1.14 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
2183 chip 1.1 2184 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2185 "Calling provider.enableIndications: " + 2186 ph.GetProvider().getName());
2187 schuur 1.14 2188 pm_service_op_lock op_lock(&ph.GetProvider()); 2189
2190 chip 1.1 ph.GetProvider().enableIndications(*handler); 2191 2192 2193 // if no exception, store the handler so it is persistent for as 2194 // long as the provider has indications enabled. 2195 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2196 "Storing indication handler for " + ph.GetProvider().getName()); 2197 2198 _insertEntry(ph.GetProvider(), handler); 2199 } 2200 catch(CIMException & e) 2201 { 2202 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2203 "Exception: " + e.getMessage());
2204 schuur 1.14
2205 chip 1.1 response->cimException = CIMException(e); 2206 } 2207 catch(Exception & e) 2208 { 2209 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2210 "Exception: " + e.getMessage()); 2211 response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms( 2212 "ProviderManager.DefaultProviderManager.INTERNAL_ERROR", 2213 "Internal Error")); 2214 } 2215 catch(...) 2216 { 2217 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2218 "Exception: Unknown"); 2219 response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms( 2220 "ProviderManager.DefaultProviderManager.UNKNOWN_ERROR", 2221 "Unknown Error")); 2222 } 2223 2224 PEG_METHOD_EXIT(); 2225 2226 chip 1.1 return(response); 2227 } 2228 2229 Message * DefaultProviderManager::handleDisableIndicationsRequest(const Message * message) throw() 2230 { 2231 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableIndicationsRequest"); 2232 2233 CIMDisableIndicationsRequestMessage * request = 2234 dynamic_cast<CIMDisableIndicationsRequestMessage >(const_cast<Message >(message)); 2235 2236 PEGASUS_ASSERT(request != 0); 2237 2238 CIMDisableIndicationsResponseMessage * response = 2239 new CIMDisableIndicationsResponseMessage( 2240 request->messageId, 2241 CIMException(), 2242 request->queueIds.copyAndPop()); 2243 2244 // preserve message key 2245 response->setKey(request->getKey()); 2246 2247 chip 1.1 // Set HTTP method in response from request 2248 response->setHttpMethod (request->getHttpMethod ()); 2249 2250 OperationResponseHandler handler(request, response); 2251 2252 try 2253 {
2254 schuur 1.14 String physicalName=_resolvePhysicalName( 2255 request->providerModule.getProperty( 2256 request->providerModule.findProperty("Location")).getValue().toString()); 2257
2258 schuur 1.20 ProviderName name(
2259 schuur 1.16 request->provider.getProperty(request->provider.findProperty
2260 schuur 1.14 ("Name")).getValue ().toString (), 2261 physicalName, 2262 request->providerModule.getProperty(request->providerModule.findProperty 2263 ("InterfaceType")).getValue().toString(),
2264 chip 1.6 0);
2265 chip 1.1 2266 // get cached or load new provider module 2267 OpProviderHolder ph =
2268 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
2269 chip 1.1 2270 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2271 "Calling provider.disableIndications: " + 2272 ph.GetProvider().getName()); 2273 2274 ph.GetProvider().disableIndications(); 2275 2276 ph.GetProvider().unprotect(); 2277 2278 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2279 "Removing and Destroying indication handler for " + 2280 ph.GetProvider().getName()); 2281 2282 delete _removeEntry(_generateKey(ph.GetProvider())); 2283 } 2284 2285 catch(CIMException & e) 2286 { 2287 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2288 "Exception: " + e.getMessage());
2289 chip 1.2
2290 chip 1.1 response->cimException = CIMException(e); 2291 } 2292 catch(Exception & e) 2293 { 2294 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2295 "Exception: " + e.getMessage());
2296 chip 1.2 response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(
2297 chip 1.1 "ProviderManager.DefaultProviderManager.INTERNAL_ERROR", 2298 "Internal Error")); 2299 } 2300 catch(...) 2301 { 2302 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2303 "Exception: Unknown");
2304 chip 1.2 response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms(
2305 chip 1.1 "ProviderManager.DefaultProviderManager.UNKNOWN_ERROR", 2306 "Unknown Error")); 2307 } 2308 2309 PEG_METHOD_EXIT(); 2310 2311 return(response); 2312 } 2313 2314 Message * DefaultProviderManager::handleConsumeIndicationRequest(const Message message) throw() 2315 { 2316 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handlConsumeIndicationRequest"); 2317 2318 CIMConsumeIndicationRequestMessage request = 2319 dynamic_cast<CIMConsumeIndicationRequestMessage >(const_cast<Message >(message)); 2320 2321 PEGASUS_ASSERT(request != 0); 2322 2323 CIMResponseMessage * response = 2324 new CIMResponseMessage( 2325 CIM_CONSUME_INDICATION_RESPONSE_MESSAGE, 2326 chip 1.1 request->messageId, 2327 CIMException(), 2328 request->queueIds.copyAndPop()); 2329 2330 PEGASUS_ASSERT(response != 0); 2331 2332 response->setKey(request->getKey()); 2333 2334 // Set HTTP method in response from request 2335 response->setHttpMethod (request->getHttpMethod ()); 2336 2337 Uint32 type = 3; 2338 2339 try 2340 {
2341 chip 1.6 ProviderName name( 2342 String::EMPTY, 2343 String::EMPTY, 2344 String::EMPTY, 2345 0);
2346 chip 1.1 2347 /*
2348 chip 1.4 ProviderName name(
2349 chip 1.1 String::EMPTY, 2350 String::EMPTY, 2351 objectPath.toString()); 2352
2353 chip 1.5 // resolve provider name 2354 name = _resolveProviderName(name);
2355 chip 1.1 */ 2356 2357 // get cached or load new provider module 2358 OpProviderHolder ph =
2359 schuur 1.10 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
2360 chip 1.1 2361 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2362 "Calling provider.: " + 2363 ph.GetProvider().getName()); 2364 2365 OperationContext context; 2366 2367 //l10n 2368 // ATTN-CEC 06/04/03 NOTE: I can't find where the consume msg is sent. This 2369 // does not appear to be hooked-up. When it is added, need to 2370 // make sure that Content-Language is set in the consume msg. 2371 // NOTE: A-L is not needed to be set in the consume msg. 2372 // add the langs to the context 2373 context.insert(ContentLanguageListContainer(request->contentLanguages)); 2374 2375 CIMInstance indication_copy = request->indicationInstance; 2376 2377 SimpleIndicationResponseHandler handler; 2378 2379 ph.GetProvider().consumeIndication(context, 2380 "", 2381 chip 1.1 indication_copy); 2382 } 2383 catch(CIMException & e) 2384 { 2385 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2386 "Exception: " + e.getMessage());
2387 chip 1.2
2388 chip 1.1 response->cimException = CIMException(e); 2389 } 2390 catch(Exception & e) 2391 { 2392 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2393 "Exception: " + e.getMessage()); 2394 //l10n 2395 //response->cimException = CIMException(CIM_ERR_FAILED, "Internal Error"); 2396 response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms( 2397 "ProviderManager.DefaultProviderManager.INTERNAL_ERROR", 2398 "Internal Error")); 2399 } 2400 catch(...) 2401 { 2402 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2403 "Exception: Unknown"); 2404 //l10n 2405 //response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error"); 2406 response->cimException = CIMException(CIM_ERR_FAILED, MessageLoaderParms( 2407 "ProviderManager.DefaultProviderManager.UNKNOWN_ERROR", 2408 "Unknown Error")); 2409 chip 1.1 } 2410 2411 PEG_METHOD_EXIT(); 2412 2413 return(response); 2414 } 2415
2416 schuur 1.14 2417 Message DefaultProviderManager::handleExportIndicationRequest(const Message message) throw() 2418 { 2419 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManagerService::handlExportIndicationRequest"); 2420 2421 CIMExportIndicationRequestMessage * request = 2422 dynamic_cast<CIMExportIndicationRequestMessage >(const_cast<Message >(message)); 2423 2424 PEGASUS_ASSERT(request != 0); 2425 2426 CIMExportIndicationResponseMessage * response = 2427 new CIMExportIndicationResponseMessage( 2428 request->messageId, 2429 CIMException(), 2430 request->queueIds.copyAndPop()); 2431 2432 PEGASUS_ASSERT(response != 0); 2433 2434 // preserve message key 2435 response->setKey(request->getKey()); 2436 2437 schuur 1.14 // Set HTTP method in response from request 2438 response->setHttpMethod (request->getHttpMethod ()); 2439 2440 OperationResponseHandler handler(request, response); 2441 2442 try 2443 { 2444 ProviderName name( 2445 String::EMPTY, 2446 String::EMPTY, 2447 String::EMPTY, 2448 0); 2449 2450 // resolve provider name 2451 name = _resolveProviderName(request->destinationPath); 2452 2453 // get cached or load new provider module 2454 OpProviderHolder ph = 2455 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY); 2456 2457 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2458 schuur 1.14 "Calling provider.: " + 2459 ph.GetProvider().getName()); 2460 2461 OperationContext context; 2462 2463 //L10N_TODO 2464 //l10n 2465 // ATTN-CEC 06/04/03 NOTE: I can't find where the consume msg is sent. This 2466 // does not appear to be hooked-up. When it is added, need to 2467 // make sure that Content-Language is set in the consume msg. 2468 // NOTE: A-L is not needed to be set in the consume msg. 2469 // add the langs to the context 2470 context.insert(ContentLanguageListContainer(request->contentLanguages)); 2471 2472 CIMInstance indication_copy = request->indicationInstance; 2473 pm_service_op_lock op_lock(&ph.GetProvider()); 2474 2475 ph.GetProvider().consumeIndication(context, 2476 request->destinationPath, 2477 indication_copy); 2478 2479 schuur 1.14 } 2480 2481 catch(CIMException & e) 2482 { 2483 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2484 "Exception: " + e.getMessage()); 2485 2486 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); // l10n 2487 } 2488 catch(Exception & e) 2489 { 2490 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2491 "Exception: " + e.getMessage()); 2492 2493 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); // l10n 2494 } 2495 catch(...) 2496 { 2497 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2498 "Exception: Unknown"); 2499 2500 schuur 1.14 handler.setStatus(CIM_ERR_FAILED, "Unknown Error"); 2501 } 2502 2503 PEG_METHOD_EXIT(); 2504 2505 return(response); 2506 } 2507 2508 2509 2510
2511 chip 1.1 // 2512 // This function disables a provider module if disableProviderOnly is not true, 2513 // otherwise, disables a provider. Disable provider module means that 2514 // block all the providers which contain in the module and unload the 2515 // providers. 2516 // Disable provider means unload the provider and the provider is not blocked. 2517 // 2518 // ATTN-YZ-P2-20030519: Provider needs to be blocked when disable a provider. 2519 // 2520 Message * DefaultProviderManager::handleDisableModuleRequest(const Message * message) throw() 2521 { 2522 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleDisableModuleRequest");
2523 schuur 1.19
2524 chip 1.1 CIMDisableModuleRequestMessage * request = 2525 dynamic_cast<CIMDisableModuleRequestMessage >(const_cast<Message >(message)); 2526 2527 PEGASUS_ASSERT(request != 0);
2528 schuur 1.18 2529 Array<Uint16> operationalStatus;
2530 chip 1.1 Boolean disableProviderOnly = request->disableProviderOnly;
2531 schuur 1.18 CIMException cimException;
2532 chip 1.1
2533 schuur 1.18 ProviderRegistrationManager * _providerRegistrationManager = GetProviderRegistrationManager(); 2534 2535 try
2536 chip 1.1 {
2537 schuur 1.18 // get provider module name 2538 String moduleName; 2539 CIMInstance mInstance = request->providerModule; 2540 Uint32 pos = mInstance.findProperty(CIMName ("Name"));
2541 chip 1.2
2542 schuur 1.18 if(pos != PEG_NOT_FOUND)
2543 chip 1.1 {
2544 schuur 1.18 mInstance.getProperty(pos).getValue().get(moduleName);
2545 chip 1.1 } 2546
2547 schuur 1.18 Boolean disableProviderOnly = request->disableProviderOnly; 2548
2549 chip 1.1 //
2550 schuur 1.18 // get operational status
2551 chip 1.1 //
2552 schuur 1.18 if (!disableProviderOnly)
2553 chip 1.1 {
2554 schuur 1.18 Uint32 pos2 = mInstance.findProperty(CIMName ("OperationalStatus")); 2555 if (pos2 != PEG_NOT_FOUND) 2556 { 2557 // 2558 // ATTN-CAKG-P2-20020821: Check for null status? 2559 // 2560 mInstance.getProperty(pos2).getValue().get(operationalStatus); 2561 } 2562 2563 // 2564 // update module status from OK to Stopping 2565 // 2566 for (Uint32 i=0, n = operationalStatus.size(); i < n; i++)
2567 chip 1.1 {
2568 schuur 1.18 if (operationalStatus[i] == _MODULE_OK) 2569 { 2570 operationalStatus.remove(i); 2571 } 2572 } 2573 2574 operationalStatus.append(_MODULE_STOPPING); 2575 2576 if(_providerRegistrationManager->setProviderModuleStatus 2577 (moduleName, operationalStatus) == false) 2578 { 2579 //l10n 2580 //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed."); 2581 throw PEGASUS_CIM_EXCEPTION_L( 2582 CIM_ERR_FAILED, 2583 MessageLoaderParms( 2584 "ProviderManager.ProviderManagerService." 2585 "SET_MODULE_STATUS_FAILED", 2586 "set module status failed."));
2587 chip 1.1 } 2588 } 2589
2590 schuur 1.18 // Unload providers 2591 Array<CIMInstance> _pInstances = request->providers; 2592 Array<Boolean> _indicationProviders = request->indicationProviders; 2593 2594 String physicalName=_resolvePhysicalName( 2595 mInstance.getProperty( 2596 mInstance.findProperty("Location")).getValue().toString()); 2597 2598 for(Uint32 i = 0, n = _pInstances.size(); i < n; i++)
2599 chip 1.1 {
2600 schuur 1.18 String pName(_pInstances[i].getProperty( 2601 _pInstances[i].findProperty("Name")).getValue().toString());
2602 chip 1.1
2603 schuur 1.18 Sint16 ret_value = providerManager.disableProvider(physicalName,pName);
2604 chip 1.1
2605 schuur 1.18 if (ret_value == 0) 2606 { 2607 // disable failed since there are pending requests, 2608 // update module status from Stopping to OK if 2609 // disableProviderOnly is not true 2610 if (!disableProviderOnly) 2611 { 2612 for(Uint32 j=0, m = operationalStatus.size(); j < m; j++) 2613 { 2614 if (operationalStatus[j] == _MODULE_STOPPING) 2615 { 2616 operationalStatus.remove(j); 2617 } 2618 } 2619 2620 operationalStatus.append(_MODULE_OK); 2621 2622 if(_providerRegistrationManager->setProviderModuleStatus 2623 (moduleName, operationalStatus) == false) 2624 { 2625 throw PEGASUS_CIM_EXCEPTION_L( 2626 schuur 1.18 CIM_ERR_FAILED, 2627 MessageLoaderParms( 2628 "ProviderManager.ProviderManagerService." 2629 "SET_MODULE_STATUS_FAILED", 2630 "set module status failed.")); 2631 } 2632 } 2633 } 2634 else if (ret_value == 1) 2635 { 2636 // if It is an indication provider 2637 // remove the entry from the table since the 2638 // provider has been disabled 2639 if (_indicationProviders[i]) 2640 { 2641 _removeEntry(_generateKey(pName,physicalName)); 2642 } 2643 } 2644 else 2645 { 2646 // disable failed for other reason, throw exception 2647 schuur 1.18 // update module status from Stopping to OK if 2648 // disableProviderOnly is not true 2649 if (!disableProviderOnly) 2650 { 2651 for(Uint32 j=0, m = operationalStatus.size(); j < m; j++) 2652 { 2653 if (operationalStatus[j] == _MODULE_STOPPING) 2654 { 2655 operationalStatus.remove(j); 2656 } 2657 } 2658 2659 operationalStatus.append(_MODULE_OK); 2660 2661 if(_providerRegistrationManager->setProviderModuleStatus 2662 (moduleName, operationalStatus) == false) 2663 { 2664 throw PEGASUS_CIM_EXCEPTION_L( 2665 CIM_ERR_FAILED, 2666 MessageLoaderParms( 2667 "ProviderManager.ProviderManagerService." 2668 schuur 1.18 "SET_MODULE_STATUS_FAILED", 2669 "set module status failed.")); 2670 } 2671 } 2672 2673 throw PEGASUS_CIM_EXCEPTION_L( 2674 CIM_ERR_FAILED, 2675 MessageLoaderParms( 2676 "ProviderManager.ProviderManagerService." 2677 "DISABLE_PROVIDER_FAILED", 2678 "Failed to disable the provider.")); 2679 } 2680 } 2681 // disable succeed 2682 // update module status from Stopping to Stopped if 2683 // disableProviderOnly is not true 2684 if (!disableProviderOnly)
2685 chip 1.1 {
2686 schuur 1.18 // update module status from Stopping to Stopped 2687 for(Uint32 j=0, m = operationalStatus.size(); j < m; j++)
2688 chip 1.1 {
2689 schuur 1.18 if (operationalStatus[j] == _MODULE_STOPPING) 2690 { 2691 operationalStatus.remove(j); 2692 operationalStatus.append(_MODULE_STOPPED); 2693 }
2694 chip 1.1 }
2695 chip 1.2
2696 schuur 1.18 if(_providerRegistrationManager->setProviderModuleStatus 2697 (moduleName, operationalStatus) == false) 2698 { 2699 //l10n 2700 //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, 2701 //"set module status failed."); 2702 throw PEGASUS_CIM_EXCEPTION_L( 2703 CIM_ERR_FAILED, 2704 MessageLoaderParms( 2705 "ProviderManager.ProviderManagerService." 2706 "SET_MODULE_STATUS_FAILED", 2707 "set module status failed.")); 2708 } 2709 } 2710 } 2711 catch(CIMException & e) 2712 { 2713 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2714 "Exception: " + e.getMessage()); 2715 cimException = e; 2716 } 2717 schuur 1.18 catch(Exception & e) 2718 { 2719 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2720 "Exception: " + e.getMessage()); 2721 cimException = CIMException(CIM_ERR_FAILED, e.getMessage()); 2722 } 2723 catch(...) 2724 { 2725 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, 2726 "Exception: Unknown"); 2727 //l10n 2728 //response->cimException = CIMException(CIM_ERR_FAILED, "Unknown Error"); 2729 cimException = PEGASUS_CIM_EXCEPTION_L( 2730 CIM_ERR_FAILED, 2731 MessageLoaderParms( 2732 "ProviderManager.ProviderManagerService.UNKNOWN_ERROR", 2733 "Unknown Error"));
2734 chip 1.1 } 2735 2736 CIMDisableModuleResponseMessage * response = 2737 new CIMDisableModuleResponseMessage( 2738 request->messageId, 2739 CIMException(), 2740 request->queueIds.copyAndPop(), 2741 operationalStatus); 2742 2743 // preserve message key 2744 response->setKey(request->getKey()); 2745 2746 // Set HTTP method in response from request 2747 response->setHttpMethod (request->getHttpMethod ()); 2748 2749 PEG_METHOD_EXIT(); 2750 2751 return(response); 2752 } 2753 2754 Message * DefaultProviderManager::handleEnableModuleRequest(const Message * message) throw() 2755 chip 1.1 { 2756 // HACK
2757 chip 1.4 ProviderRegistrationManager * _providerRegistrationManager = GetProviderRegistrationManager();
2758 chip 1.1 2759 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleEnableModuleRequest"); 2760 2761 CIMEnableModuleRequestMessage * request = 2762 dynamic_cast<CIMEnableModuleRequestMessage >(const_cast<Message >(message)); 2763 2764 PEGASUS_ASSERT(request != 0); 2765 2766 // 2767 // get module status 2768 // 2769 CIMInstance mInstance = request->providerModule; 2770 Array<Uint16> operationalStatus; 2771 Uint32 pos = mInstance.findProperty(CIMName ("OperationalStatus")); 2772 2773 if(pos != PEG_NOT_FOUND) 2774 { 2775 // 2776 // ATTN-CAKG-P2-20020821: Check for null status? 2777 // 2778 mInstance.getProperty(pos).getValue().get(operationalStatus); 2779 chip 1.1 } 2780 2781 // update module status from Stopped to OK 2782 for(Uint32 i=0, n = operationalStatus.size(); i < n; i++) 2783 { 2784 if(operationalStatus[i] == _MODULE_STOPPED) 2785 { 2786 operationalStatus.remove(i); 2787 } 2788 } 2789 2790 operationalStatus.append(_MODULE_OK); 2791 2792 // 2793 // get module name 2794 // 2795 String moduleName; 2796 2797 Uint32 pos2 = mInstance.findProperty(CIMName ("Name")); 2798 2799 if(pos2 != PEG_NOT_FOUND) 2800 chip 1.1 { 2801 mInstance.getProperty(pos2).getValue().get(moduleName); 2802 } 2803 2804 if(_providerRegistrationManager->setProviderModuleStatus 2805 (moduleName, operationalStatus) == false) 2806 { 2807 //l10n 2808 //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "set module status failed."); 2809 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms( 2810 "ProviderManager.DefaultProviderManager.SET_MODULE_STATUS_FAILED", 2811 "set module status failed.")); 2812 } 2813 2814 CIMEnableModuleResponseMessage * response = 2815 new CIMEnableModuleResponseMessage( 2816 request->messageId, 2817 CIMException(), 2818 request->queueIds.copyAndPop(), 2819 operationalStatus); 2820 2821 chip 1.1 PEGASUS_ASSERT(response != 0); 2822 2823 // preserve message key 2824 response->setKey(request->getKey()); 2825 2826 // Set HTTP method in response from request 2827 response->setHttpMethod (request->getHttpMethod ()); 2828 2829 PEG_METHOD_EXIT(); 2830 2831 return(response); 2832 } 2833 2834 Message * DefaultProviderManager::handleStopAllProvidersRequest(const Message * message) throw() 2835 { 2836 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleStopAllProvidersRequest"); 2837 2838 CIMStopAllProvidersRequestMessage * request = 2839 dynamic_cast<CIMStopAllProvidersRequestMessage >(const_cast<Message >(message)); 2840 2841 PEGASUS_ASSERT(request != 0); 2842 chip 1.1 2843 CIMStopAllProvidersResponseMessage * response = 2844 new CIMStopAllProvidersResponseMessage( 2845 request->messageId, 2846 CIMException(), 2847 request->queueIds.copyAndPop()); 2848 2849 PEGASUS_ASSERT(response != 0); 2850 2851 // preserve message key 2852 response->setKey(request->getKey()); 2853 2854 // Set HTTP method in response from request 2855 response->setHttpMethod (request->getHttpMethod ()); 2856 2857 // tell the provider manager to shutdown all the providers
2858 schuur 1.10 providerManager.shutdownAllProviders();
2859 chip 1.1 2860 PEG_METHOD_EXIT(); 2861 2862 return(response); 2863 } 2864 2865 void DefaultProviderManager::_insertEntry ( 2866 const Provider & provider, 2867 const EnableIndicationsResponseHandler handler) 2868 { 2869 PEG_METHOD_ENTER (TRC_INDICATION_SERVICE, 2870 "DefaultProviderManager::_insertEntry"); 2871 2872 String tableKey = _generateKey 2873 (provider); 2874 2875 _responseTable.insert (tableKey, const_cast<EnableIndicationsResponseHandler >(handler)); 2876 2877 PEG_METHOD_EXIT(); 2878 } 2879 2880 chip 1.1 EnableIndicationsResponseHandler * DefaultProviderManager::_removeEntry( 2881 const String & key) 2882 { 2883 PEG_METHOD_ENTER (TRC_INDICATION_SERVICE, 2884 "DefaultProviderManager::_removeEntry"); 2885 EnableIndicationsResponseHandler *ret = 0; 2886 2887 _responseTable.lookup(key, ret);
2888 schuur 1.14 _responseTable.remove(key); // why is this needed ? - we get killed when removed...
2889 chip 1.1 2890 PEG_METHOD_EXIT(); 2891 2892 return(ret); 2893 } 2894 2895 String DefaultProviderManager::_generateKey ( 2896 const Provider & provider) 2897 { 2898 String tableKey; 2899 2900 PEG_METHOD_ENTER (TRC_INDICATION_SERVICE, 2901 "DefaultProviderManager::_generateKey"); 2902 2903 // 2904 // Append provider key values to key 2905 // 2906 String providerName = provider.getName(); 2907 String providerFileName = provider.getModule()->getFileName(); 2908 tableKey.append (providerName); 2909 tableKey.append (providerFileName); 2910 chip 1.1 2911 PEG_METHOD_EXIT(); 2912 2913 return(tableKey);
2914 schuur 1.18 } 2915 2916 String DefaultProviderManager::_generateKey ( 2917 const String & providerName, 2918 const String & providerFileName) 2919 { 2920 String tableKey; 2921 2922 PEG_METHOD_ENTER (TRC_INDICATION_SERVICE, 2923 "DefaultProviderManagerService::_generateKey"); 2924 2925 // 2926 // Append providerName and providerFileName to key 2927 // 2928 tableKey.append (providerName); 2929 tableKey.append (providerFileName); 2930 2931 PEG_METHOD_EXIT (); 2932 return tableKey;
2933 chip 1.5 } 2934 2935 ProviderName DefaultProviderManager::_resolveProviderName(const ProviderName & providerName) 2936 { 2937 ProviderName temp = findProvider(providerName);
2938 schuur 1.14 String physicalName = _resolvePhysicalName(temp.getPhysicalName()); 2939 temp.setPhysicalName(physicalName);
2940 chip 1.5
2941 schuur 1.14 return(temp); 2942 } 2943 2944 ProviderName DefaultProviderManager::_resolveProviderName(String & destinationPath) 2945 { 2946 ProviderName temp = findProvider(destinationPath);
2947 kv.le 1.8
2948 schuur 1.14 String physicalName = _resolvePhysicalName(temp.getPhysicalName());
2949 chip 1.5 2950 temp.setPhysicalName(physicalName); 2951 2952 return(temp);
2953 chip 1.1 } 2954 2955 PEGASUS_NAMESPACE_END

No CVS admin address has been configured