1 karl 1.15 //%2003////////////////////////////////////////////////////////////////////////
|
2 chip 1.1 //
|
3 karl 1.15 // 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 chip 1.17 //
|
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 chip 1.9 // Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
|
33 schuur 1.19 // Adrian Schuur, IBM (schuur@de.ibm.com)
|
34 chip 1.1 //
35 //%/////////////////////////////////////////////////////////////////////////////
36
37 #include "ProviderManagerService.h"
38
39 #include <Pegasus/Common/Config.h>
40 #include <Pegasus/Common/Constants.h>
41 #include <Pegasus/Common/CIMMessage.h>
42 #include <Pegasus/Common/Tracer.h>
43 #include <Pegasus/Common/Logger.h>
44 #include <Pegasus/Common/Destroyer.h>
|
45 schuur 1.22 #include <Pegasus/ProviderManager/OperationResponseHandler.h>
|
46 chip 1.1
|
47 chip 1.6 #include <Pegasus/Config/ConfigManager.h>
48
|
49 chip 1.17 #include <Pegasus/ProviderManager2/ProviderManagerModule.h>
50 #include <Pegasus/ProviderManager2/ProviderManager.h>
51
|
52 chip 1.1 PEGASUS_NAMESPACE_BEGIN
53
|
54 chip 1.13 // BEGIN TEMP SECTION
|
55 chip 1.11 class ProviderManagerContainer
|
56 chip 1.5 {
|
57 chip 1.11 public:
|
58 chip 1.17 ProviderManagerContainer(void) : _manager(0)
59 {
60 }
61
62 ProviderManagerContainer(const ProviderManagerContainer & container) : _manager(0)
63 {
64 *this = container;
65 }
66
67 ProviderManagerContainer(const String & physicalName, const String & logicalName, const String & interfaceName) : _manager(0)
|
68 chip 1.11 {
|
69 schuur 1.25 _physicalName=ProviderManager::_resolvePhysicalName(physicalName);
|
70 chip 1.3
|
71 chip 1.11 _logicalName = logicalName;
72
73 _interfaceName = interfaceName;
|
74 chip 1.13
75 _module = ProviderManagerModule(_physicalName);
76
77 _module.load();
78
79 _manager = _module.getProviderManager(_logicalName);
|
80 chip 1.17
81 PEGASUS_ASSERT(_manager != 0);
|
82 chip 1.11 }
83
|
84 chip 1.13 ~ProviderManagerContainer(void)
85 {
86 _module.unload();
87 }
88
|
89 chip 1.17 ProviderManagerContainer & operator=(const ProviderManagerContainer & container)
90 {
91 if(this == &container)
92 {
93 return(*this);
94 }
95
96 _logicalName = container._logicalName;
97 _physicalName = container._physicalName;
98 _interfaceName = container._interfaceName;
99
100 _module = container._module;
101 _manager = container._manager;
102
103 return(*this);
104 }
105
|
106 schuur 1.19 ProviderManager *getProviderManager(void)
|
107 chip 1.13 {
|
108 schuur 1.19 return _manager;
|
109 chip 1.13 }
110
|
111 chip 1.17 const String & getPhysicalName(void) const
|
112 chip 1.3 {
|
113 chip 1.11 return(_physicalName);
|
114 chip 1.3 }
115
|
116 chip 1.17 const String & getLogicalName(void) const
|
117 chip 1.11 {
118 return(_logicalName);
119 }
|
120 chip 1.3
|
121 chip 1.17 const String & getInterfaceName(void) const
|
122 chip 1.11 {
123 return(_interfaceName);
|
124 chip 1.3 }
125
|
126 chip 1.11 private:
127 String _physicalName;
128 String _logicalName;
129 String _interfaceName;
|
130 chip 1.3
|
131 chip 1.13 ProviderManagerModule _module;
132 ProviderManager * _manager;
133
|
134 chip 1.11 };
|
135 chip 1.13
|
136 schuur 1.19 static Array<ProviderManagerContainer*> _providerManagers;
|
137 chip 1.11 // END TEMP SECTION
138
139 inline Boolean _isSupportedRequestType(const Message * message)
140 {
141 // ATTN: needs implementation
142
143 // for now, assume all requests are valid
144
145 return(true);
|
146 chip 1.3 }
147
148 inline Boolean _isSupportedResponseType(const Message * message)
149 {
|
150 chip 1.11 // ATTN: needs implementation
151
152 // for now, assume all responses are invalid
|
153 chip 1.3
|
154 chip 1.11 return(false);
|
155 chip 1.3 }
156
|
157 schuur 1.19 ProviderManagerService* ProviderManagerService::providerManagerService=NULL;
|
158 schuur 1.25 CIMRepository* ProviderManagerService::_repository=NULL;
|
159 schuur 1.19
|
160 chip 1.1 ProviderManagerService::ProviderManagerService(void)
161 : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)
162 {
|
163 schuur 1.19 providerManagerService=this;
|
164 chip 1.1 }
165
|
166 schuur 1.25 ProviderManagerService::ProviderManagerService(
167 ProviderRegistrationManager * providerRegistrationManager,
168 CIMRepository * repository)
|
169 chip 1.1 : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)
170 {
|
171 schuur 1.19 providerManagerService=this;
|
172 schuur 1.25 _repository=repository;
173
|
174 chip 1.10 SetProviderRegistrationManager(providerRegistrationManager);
175
|
176 chip 1.11 // ATTN: this section is a temporary solution to populate the list of enabled
177 // provider managers for a given distribution. it includes another temporary
178 // solution for converting a generic file name into a file name useable by
179 // each platform.
180
181 // BEGIN TEMP SECTION
182 //#if defined(PEGASUS_OS_OS400)
|
183 chip 1.13 //_providerManagers.append(ProviderManagerContainer("QSYS/??????????", "INTERNAL", "INTERNAL"));
|
184 chip 1.11 //#else
|
185 chip 1.13 //_providerManager.append(ProviderManagerContainer("InternalProviderManager", "DEFAULT", "INTERNAL"));
|
186 chip 1.11 //#endif
|
187 chip 1.2
|
188 chip 1.11 #if defined(ENABLE_DEFAULT_PROVIDER_MANAGER)
189 #if defined(PEGASUS_OS_OS400)
|
190 schuur 1.19 _providerManagers.append(
191 new ProviderManagerContainer("QSYS/QYCMDFTPVM", "DEFAULT", "C++Default"));
|
192 chip 1.11 #else
|
193 schuur 1.19 _providerManagers.append(
194 new ProviderManagerContainer("DefaultProviderManager", "DEFAULT", "C++Default"));
|
195 chip 1.11 #endif
196 #endif
|
197 chip 1.2
|
198 chip 1.11 #if defined(ENABLE_CMPI_PROVIDER_MANAGER)
199 #if defined(PEGASUS_OS_OS400)
|
200 schuur 1.19 _providerManagers.append(
201 new ProviderManagerContainer("QSYS/QYCMCMPIPM", "CMPI", "CMPI"));
|
202 chip 1.11 #else
|
203 schuur 1.19 _providerManagers.append(
204 new ProviderManagerContainer("CMPIProviderManager", "CMPI", "CMPI"));
|
205 chip 1.11 #endif
206 #endif
207 // END TEMP SECTION
|
208 chip 1.1 }
209
210 ProviderManagerService::~ProviderManagerService(void)
211 {
|
212 schuur 1.19 providerManagerService=NULL;
|
213 chip 1.1 }
214
215 Boolean ProviderManagerService::messageOK(const Message * message)
216 {
217 PEGASUS_ASSERT(message != 0);
218
|
219 chip 1.3 if(_isSupportedRequestType(message))
|
220 chip 1.1 {
|
221 chip 1.3 return(MessageQueueService::messageOK(message));
|
222 chip 1.1 }
223
|
224 chip 1.3 return(false);
|
225 chip 1.1 }
226
227 void ProviderManagerService::handleEnqueue(void)
228 {
229 Message * message = dequeue();
230
231 handleEnqueue(message);
232 }
233
234 void ProviderManagerService::handleEnqueue(Message * message)
235 {
236 PEGASUS_ASSERT(message != 0);
237
238 AsyncLegacyOperationStart * asyncRequest;
239
240 if(message->_async != NULL)
241 {
242 asyncRequest = static_cast<AsyncLegacyOperationStart *>(message->_async);
243 }
244 else
245 {
246 chip 1.1 asyncRequest = new AsyncLegacyOperationStart(
247 get_next_xid(),
248 0,
249 this->getQueueId(),
250 message,
251 this->getQueueId());
252 }
253
254 _handle_async_request(asyncRequest);
255 }
256
257 void ProviderManagerService::_handle_async_request(AsyncRequest * request)
258 {
259 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
260 "ProviderManagerService::_handle_async_request");
261
262 PEGASUS_ASSERT((request != 0) && (request->op != 0));
263
264 if(request->getType() == async_messages::ASYNC_LEGACY_OP_START)
265 {
266 request->op->processing();
267 chip 1.1
268 _incomingQueue.enqueue(request->op);
269
270 _thread_pool->allocate_and_awaken((void *)this, ProviderManagerService::handleCimOperation);
271 }
272 else
273 {
274 // pass all other operations to the default handler
275 MessageQueueService::_handle_async_request(request);
276 }
277
278 PEG_METHOD_EXIT();
279
280 return;
281 }
282
283
284 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL ProviderManagerService::handleCimOperation(void * arg) throw()
285 {
286 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManagerService::handleCimOperation");
287
|
288 chip 1.8 if(arg == 0)
289 {
290 // thread started with invalid argument.
291 return(PEGASUS_THREAD_RETURN(1));
292 }
293
|
294 chip 1.1 // get the service from argument
295 ProviderManagerService * service = reinterpret_cast<ProviderManagerService *>(arg);
296
297 if(service->_incomingQueue.size() == 0)
298 {
299 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
300 "ProviderManagerService::handleCimOperation() called with no op node in queue" );
301
302 PEG_METHOD_EXIT();
303
304 // thread started with no message in queue.
305 return(PEGASUS_THREAD_RETURN(1));
306 }
307
308 AsyncOpNode * op = service->_incomingQueue.dequeue();
309
|
310 chip 1.8 if((op == 0) || (op->_request.count() == 0))
|
311 chip 1.1 {
312 MessageQueue * queue = MessageQueue::lookup(op->_source_queue);
313
314 PEGASUS_ASSERT(queue != 0);
315
316 PEG_METHOD_EXIT();
317
318 // no request in op node
319 return(PEGASUS_THREAD_RETURN(1));
320 }
321
322 AsyncRequest * request = static_cast<AsyncRequest *>(op->_request.next(0));
323
|
324 chip 1.8 if((request == 0) || (request->getType() != async_messages::ASYNC_LEGACY_OP_START))
|
325 chip 1.1 {
326 // reply with NAK
327
328 PEG_METHOD_EXIT();
329
330 return(PEGASUS_THREAD_RETURN(0));
331 }
332
|
333 chip 1.8 try
|
334 chip 1.1 {
|
335 chip 1.8 Message * legacy = static_cast<AsyncLegacyOperationStart *>(request)->get_action();
|
336 chip 1.1
|
337 chip 1.8 if(_isSupportedRequestType(legacy))
|
338 chip 1.1 {
|
339 chip 1.8 Destroyer<Message> xmessage(legacy);
|
340 chip 1.1
|
341 chip 1.8 // Set the client's requested language into this service thread.
342 // This will allow functions in this service to return messages
343 // in the correct language.
344 CIMMessage * msg = dynamic_cast<CIMMessage *>(legacy);
345
346 if(msg != 0)
347 {
348 AcceptLanguages * langs = new AcceptLanguages(msg->acceptLanguages);
349
350 Thread::setLanguages(langs);
351 }
352 else
353 {
354 Thread::clearLanguages();
355 }
|
356 chip 1.1
357 service->handleCimRequest(op, legacy);
|
358 chip 1.3 }
|
359 chip 1.8 }
360 catch(...)
361 {
362 // ATTN: log error
|
363 chip 1.1 }
364
365 PEG_METHOD_EXIT();
366
367 return(PEGASUS_THREAD_RETURN(0));
368 }
369
|
370 chip 1.8 void ProviderManagerService::handleCimRequest(AsyncOpNode * op, const Message * message)
|
371 chip 1.1 {
372 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManagerService::handleCimRequest");
373
374 // ATTN: ensure message is a request???
375 CIMMessage * request = dynamic_cast<CIMMessage *>(const_cast<Message *>(message));
376
377 // get request from op node
378 AsyncRequest * async = static_cast<AsyncRequest *>(op->_request.next(0));
379
380 PEGASUS_ASSERT((request != 0) && (async != 0));
381
382 Message * response = 0;
|
383 schuur 1.22 String ifc;
|
384 schuur 1.23
|
385 schuur 1.19 // get the responsible provider Manager
|
386 schuur 1.22 ProviderManager * pm = locateProviderManager(message,ifc);
387 if(pm) {
|
388 chip 1.21 response = pm->processMessage(request);
|
389 schuur 1.19 }
|
390 chip 1.21 else
391 {
|
392 schuur 1.23 if (request->getType()==CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE) {
393 for (Uint32 i = 0, n = _providerManagers.size(); i < n; i++) {
394 ProviderManagerContainer *pmc=_providerManagers[i];
395 // ---- next instruction is disabled because of a bug
396 // response=pmc->getProviderManager()->processMessage(request);
397 // ---- this block is an workaround
398 CIMStopAllProvidersResponseMessage * resp =
399 new CIMStopAllProvidersResponseMessage(
400 request->messageId,
401 CIMException(),
402 ((CIMStopAllProvidersRequestMessage*)request)->queueIds.copyAndPop());
403 resp->setKey(request->getKey());
404 resp->setHttpMethod (request->getHttpMethod ());
405 response=resp;
406 break;
407 // ---- end of workaround
408 }
409 }
410 else {
411 CIMRequestMessage * req =
412 dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
413 schuur 1.23 CIMResponseMessage *resp=new CIMResponseMessage(0,req->messageId,CIMException(),
|
414 schuur 1.22 req->queueIds.copyAndPop());
|
415 schuur 1.23 response=resp;
416 resp->synch_response(req);
417 OperationResponseHandler handler(req, resp);
418 handler.setStatus(CIM_ERR_FAILED, "Unknown error.");
419 }
420 }
|
421 chip 1.13
|
422 schuur 1.19 // preserve message key
423 response->setKey(request->getKey());
|
424 chip 1.13
|
425 schuur 1.19 // set HTTP method in response from request
426 response->setHttpMethod(request->getHttpMethod());
|
427 chip 1.13
|
428 schuur 1.19 AsyncLegacyOperationResult * async_result =
429 new AsyncLegacyOperationResult(
430 async->getKey(),
431 async->getRouting(),
432 op,
433 response);
|
434 chip 1.13
|
435 schuur 1.19 _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0);
|
436 chip 1.13
|
437 schuur 1.19 PEG_METHOD_EXIT();
438 }
|
439 chip 1.13
|
440 schuur 1.23 ProviderManager* ProviderManagerService::locateProviderManager(const Message *message,
|
441 schuur 1.22 String & it)
|
442 schuur 1.19 {
|
443 kumpf 1.24 CIMNamespaceName nameSpace;
444 CIMName className;
|
445 chip 1.13
|
446 schuur 1.22 const CIMOperationRequestMessage * p =
447 dynamic_cast<const CIMOperationRequestMessage *>(message);
|
448 chip 1.13
|
449 schuur 1.22 if (p) {
450 nameSpace=p->nameSpace;
451 if (p->providerType==ProviderType::ASSOCIATION)
452 className=((CIMAssociatorsRequestMessage*)p)->assocClass;
453 else className=p->className;
|
454 schuur 1.23
|
455 schuur 1.22 ProviderName name(
456 CIMObjectPath(String::EMPTY, nameSpace, className).toString(),
457 String::EMPTY,
458 String::EMPTY,
459 String::EMPTY,
460 p->providerType);
461 // find provider manager
462 name = ProviderRegistrar().findProvider(name);
463 it=name.getInterfaceName();
464 }
465
466 else {
467 const CIMIndicationRequestMessage * p =
468 dynamic_cast<const CIMIndicationRequestMessage *>(message);
469 if (p) {
470 CIMIndicationRequestMessage *m=(CIMIndicationRequestMessage*)message;
471 it=m->providerModule.getProperty (m->providerModule.findProperty
472 ("InterfaceType")).getValue ().toString ();
|
473 schuur 1.19 }
|
474 schuur 1.25 /* else {
475 const CIMConsumeIndicationRequestMessage * p =
476 dynamic_cast<const CIMConsumeIndicationRequestMessage *>(message);
477 if (p) {
478 CIMConsumeIndicationRequestMessage *m=(CIMConsumeIndicationRequestMessage*)message;
479 it=m->consumer_module.getProperty (m->consumer_module.findProperty
480 ("InterfaceType")).getValue ().toString ();
481 } */
482 else { // remaining functions are sent to default provider
483 // cout<<"--- ProviderManagerService::locateProviderManager(): unknown message type: "<<
484 // message->getType()<<endl;
485 it="C++Default";
486 // return NULL;
|
487 schuur 1.19 }
|
488 schuur 1.25 // }
|
489 chip 1.13 }
490
|
491 chip 1.11 // find provider manager for provider interface
|
492 chip 1.14 for(Uint32 i = 0, n = _providerManagers.size(); i < n; i++)
493 {
|
494 schuur 1.22 if (String::equalNoCase(it,_providerManagers[i]->getInterfaceName())) {
|
495 schuur 1.19 ProviderManagerContainer *pmc=_providerManagers[i];
496 return pmc->getProviderManager();
|
497 chip 1.14 }
|
498 chip 1.1 }
|
499 schuur 1.22 ProviderManagerContainer *pmc=_providerManagers[0];
500 return pmc->getProviderManager();
|
501 chip 1.1 }
502
503 void ProviderManagerService::unload_idle_providers(void)
504 {
505 }
506
507 PEGASUS_NAMESPACE_END
|
508 chip 1.9
|