1 chip 1.1 //%/////////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2000 - 2003 BMC Software, Hewlett-Packard Company, IBM,
4 // The Open Group, Tivoli Systems
5 //
6 // Permission is hereby granted, free of charge, to any person obtaining a copy
7 // of this software and associated documentation files (the "Software"), to
8 // deal in the Software without restriction, including without limitation the
9 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10 // sell copies of the Software, and to permit persons to whom the Software is
11 // furnished to do so, subject to the following conditions:
12 //
13 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
14 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
15 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
16 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
17 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
18 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 //
22 chip 1.1 //==============================================================================
23 //
24 // Author: Chip Vincent (cvincent@us.ibm.com)
25 //
26 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
27 // (carolann_graves@hp.com)
28 // Mike Day, IBM (mdday@us.ibm.com)
29 // Karl Schopmeyer(k.schopmeyer@opengroup.org) - Fix associators.
|
30 chip 1.9 // Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
|
31 chip 1.1 //
32 //%/////////////////////////////////////////////////////////////////////////////
33
34 #include "ProviderManagerService.h"
35
36 #include <Pegasus/Common/Config.h>
37 #include <Pegasus/Common/Constants.h>
38 #include <Pegasus/Common/CIMMessage.h>
39 #include <Pegasus/Common/Tracer.h>
40 #include <Pegasus/Common/Logger.h>
41 #include <Pegasus/Common/Destroyer.h>
42
|
43 chip 1.6 #include <Pegasus/Config/ConfigManager.h>
44
|
45 chip 1.1 PEGASUS_NAMESPACE_BEGIN
46
|
47 chip 1.11 class ProviderManagerContainer
|
48 chip 1.5 {
|
49 chip 1.11 public:
50 ProviderManagerContainer(const String & name, const String & path) : _name(name), _module(path)
51 {
52 _module.load();
|
53 chip 1.5
|
54 chip 1.11 _manager = _module.getProviderManager(_name);
55 }
|
56 chip 1.5
|
57 chip 1.11 ~ProviderManagerContainer(void)
58 {
59 _module.unload();
60 }
|
61 chip 1.5
|
62 chip 1.11 String & getName(void)
63 {
64 return(_name);
65 }
|
66 chip 1.5
|
67 chip 1.11 ProviderManager & getProviderManager(void)
68 {
69 return(*_manager);
70 }
|
71 chip 1.5
|
72 chip 1.11 private:
73 String _name;
74 ProviderManagerModule _module;
75 ProviderManager * _manager;
|
76 chip 1.5
|
77 chip 1.11 };
|
78 chip 1.5
|
79 chip 1.11 static Array<ProviderManagerContainer> _providerManagers;
|
80 chip 1.5
|
81 chip 1.11 // BEGIN TEMP SECTION
82 class ProviderManagerRegistration
|
83 chip 1.3 {
|
84 chip 1.11 public:
85 ProviderManagerRegistration(const String & physicalName, const String & logicalName, const String & interfaceName)
86 {
87 #if defined(PEGASUS_OS_TYPE_WINDOWS)
88 _physicalName = physicalName + String(".dll");
89 #elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
90 _physicalName = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
91 _physicalName.append(String("/lib") + physical + String(".sl"));
92 #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
93 _physicalName = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
94 _physicalName.append(String("/lib") + physical + String(".so"));
95 #elif defined(PEGASUS_OS_OS400)
96 _physicalName = physicalName;
97 #else
98 _physicalName = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
99 _physicalName.append(String("/lib") + physical + String(".so"));
100 #endif
|
101 chip 1.3
|
102 chip 1.11 _logicalName = logicalName;
103
104 _interfaceName = interfaceName;
105 }
106
107 const String & getPhysicalName(void) const
|
108 chip 1.3 {
|
109 chip 1.11 return(_physicalName);
|
110 chip 1.3 }
111
|
112 chip 1.11 const String & getLogicalName(void) const
113 {
114 return(_logicalName);
115 }
|
116 chip 1.3
|
117 chip 1.11 const String & getInterfaceName(void) const
118 {
119 return(_interfaceName);
|
120 chip 1.3 }
121
|
122 chip 1.11 private:
123 String _physicalName;
124 String _logicalName;
125 String _interfaceName;
|
126 chip 1.3
|
127 chip 1.11 };
128 // END TEMP SECTION
129
130 inline Boolean _isSupportedRequestType(const Message * message)
131 {
132 // ATTN: needs implementation
133
134 // for now, assume all requests are valid
135
136 return(true);
|
137 chip 1.3 }
138
139 inline Boolean _isSupportedResponseType(const Message * message)
140 {
|
141 chip 1.11 // ATTN: needs implementation
142
143 // for now, assume all responses are invalid
|
144 chip 1.3
|
145 chip 1.11 return(false);
|
146 chip 1.3 }
147
|
148 chip 1.1 ProviderManagerService::ProviderManagerService(void)
149 : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)
150 {
151 }
152
153 ProviderManagerService::ProviderManagerService(ProviderRegistrationManager * providerRegistrationManager)
154 : MessageQueueService(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP)
155 {
|
156 chip 1.10 SetProviderRegistrationManager(providerRegistrationManager);
157
|
158 chip 1.11 // ATTN: this section is a temporary solution to populate the list of enabled
159 // provider managers for a given distribution. it includes another temporary
160 // solution for converting a generic file name into a file name useable by
161 // each platform.
162
163 // BEGIN TEMP SECTION
164 Array<ProviderManagerRegistration> registrations;
165
166 //#if defined(PEGASUS_OS_OS400)
167 //registrations.append(ProviderManagerRegistration("QSYS/??????????", "INTERNAL", "INTERNAL"));
168 //#else
169 //registrations.append(ProviderManagerRegistration("InternalProviderManager", "DEFAULT", "INTERNAL"));
170 //#endif
|
171 chip 1.2
|
172 chip 1.11 #if defined(ENABLE_DEFAULT_PROVIDER_MANAGER)
173 #if defined(PEGASUS_OS_OS400)
174 registrations.append(ProviderManagerRegistration("QSYS/QYCMDFTPVM", "DEFAULT", "C++Default"));
175 #else
176 registrations.append(ProviderManagerRegistration("DefaultProviderManager", "DEFAULT", "C++Default"));
177 #endif
178 #endif
|
179 chip 1.2
|
180 chip 1.11 #if defined(ENABLE_CMPI_PROVIDER_MANAGER)
181 #if defined(PEGASUS_OS_OS400)
182 registrations.append(ProviderManagerRegistration("QSYS/QYCMCMPIPM", "CMPI", "CMPI"));
183 #else
184 registrations.append(ProviderManagerRegistration("CMPIProviderManager", "CMPI", "CMPI"));
185 #endif
186 #endif
187 // END TEMP SECTION
|
188 chip 1.2
|
189 chip 1.11 for(Uint32 i = 0, n = registrations.size(); i < n; i++)
190 {
|
191 chip 1.5 try
192 {
|
193 chip 1.11 ProviderManagerContainer container(registrations[i].getLogicalName(), registrations[i].getPhysicalName());
|
194 chip 1.5
|
195 chip 1.11 _providerManagers.append(container);
|
196 chip 1.5 }
197 catch(...)
198 {
199 }
|
200 chip 1.2 }
|
201 chip 1.1 }
202
203 ProviderManagerService::~ProviderManagerService(void)
204 {
205 }
206
207 Boolean ProviderManagerService::messageOK(const Message * message)
208 {
209 PEGASUS_ASSERT(message != 0);
210
|
211 chip 1.3 if(_isSupportedRequestType(message))
|
212 chip 1.1 {
|
213 chip 1.3 return(MessageQueueService::messageOK(message));
|
214 chip 1.1 }
215
|
216 chip 1.3 return(false);
|
217 chip 1.1 }
218
219 void ProviderManagerService::handleEnqueue(void)
220 {
221 Message * message = dequeue();
222
223 handleEnqueue(message);
224 }
225
226 void ProviderManagerService::handleEnqueue(Message * message)
227 {
228 PEGASUS_ASSERT(message != 0);
229
230 AsyncLegacyOperationStart * asyncRequest;
231
232 if(message->_async != NULL)
233 {
234 asyncRequest = static_cast<AsyncLegacyOperationStart *>(message->_async);
235 }
236 else
237 {
238 chip 1.1 asyncRequest = new AsyncLegacyOperationStart(
239 get_next_xid(),
240 0,
241 this->getQueueId(),
242 message,
243 this->getQueueId());
244 }
245
246 _handle_async_request(asyncRequest);
247 }
248
249 void ProviderManagerService::_handle_async_request(AsyncRequest * request)
250 {
251 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
252 "ProviderManagerService::_handle_async_request");
253
254 PEGASUS_ASSERT((request != 0) && (request->op != 0));
255
256 if(request->getType() == async_messages::ASYNC_LEGACY_OP_START)
257 {
258 request->op->processing();
259 chip 1.1
260 _incomingQueue.enqueue(request->op);
261
262 _thread_pool->allocate_and_awaken((void *)this, ProviderManagerService::handleCimOperation);
263 }
264 else
265 {
266 // pass all other operations to the default handler
267 MessageQueueService::_handle_async_request(request);
268 }
269
270 PEG_METHOD_EXIT();
271
272 return;
273 }
274
275 /*
276 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL ProviderManagerService::handleServiceOperation(void * arg) throw()
277 {
278 // get the service from argument
279 ProviderManagerService * service = reinterpret_cast<ProviderManagerService *>(arg);
280 chip 1.1
281 PEGASUS_ASSERT(service != 0);
282
283 // get message from service queue
284 Message * message = service->_incomingQueue.dequeue();
285
286 PEGASUS_ASSERT(message != 0);
287
288 if(service->_incomingQueue.size() == 0)
289 {
290 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
291 "ProviderManagerService::handleCimOperation() called with no op node in queue" );
292
293 PEG_METHOD_EXIT();
294
295 // thread started with no message in queue.
296 return(PEGASUS_THREAD_RETURN(1));
297 }
298
299 AsyncOpNode * op = service->_incomingQueue.dequeue();
300
301 chip 1.1 PEGASUS_ASSERT(op != 0 );
302
303 if(op->_request.count() == 0)
304 {
305 MessageQueue * queue = MessageQueue::lookup(op->_source_queue);
306
307 PEGASUS_ASSERT(queue != 0);
308
309 PEG_METHOD_EXIT();
310
311 // no request in op node
312 return(PEGASUS_THREAD_RETURN(1));
313 }
314
315 return(0);
316 }
317 */
318
319 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL ProviderManagerService::handleCimOperation(void * arg) throw()
320 {
321 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManagerService::handleCimOperation");
322 chip 1.1
|
323 chip 1.8 if(arg == 0)
324 {
325 // thread started with invalid argument.
326 return(PEGASUS_THREAD_RETURN(1));
327 }
328
|
329 chip 1.1 // get the service from argument
330 ProviderManagerService * service = reinterpret_cast<ProviderManagerService *>(arg);
331
332 if(service->_incomingQueue.size() == 0)
333 {
334 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
335 "ProviderManagerService::handleCimOperation() called with no op node in queue" );
336
337 PEG_METHOD_EXIT();
338
339 // thread started with no message in queue.
340 return(PEGASUS_THREAD_RETURN(1));
341 }
342
343 AsyncOpNode * op = service->_incomingQueue.dequeue();
344
|
345 chip 1.8 if((op == 0) || (op->_request.count() == 0))
|
346 chip 1.1 {
347 MessageQueue * queue = MessageQueue::lookup(op->_source_queue);
348
349 PEGASUS_ASSERT(queue != 0);
350
351 PEG_METHOD_EXIT();
352
353 // no request in op node
354 return(PEGASUS_THREAD_RETURN(1));
355 }
356
357 AsyncRequest * request = static_cast<AsyncRequest *>(op->_request.next(0));
358
|
359 chip 1.8 if((request == 0) || (request->getType() != async_messages::ASYNC_LEGACY_OP_START))
|
360 chip 1.1 {
361 // reply with NAK
362
363 PEG_METHOD_EXIT();
364
365 return(PEGASUS_THREAD_RETURN(0));
366 }
367
|
368 chip 1.8 try
|
369 chip 1.1 {
|
370 chip 1.8 Message * legacy = static_cast<AsyncLegacyOperationStart *>(request)->get_action();
|
371 chip 1.1
|
372 chip 1.8 if(_isSupportedRequestType(legacy))
|
373 chip 1.1 {
|
374 chip 1.8 Destroyer<Message> xmessage(legacy);
|
375 chip 1.1
|
376 chip 1.8 // Set the client's requested language into this service thread.
377 // This will allow functions in this service to return messages
378 // in the correct language.
379 CIMMessage * msg = dynamic_cast<CIMMessage *>(legacy);
380
381 if(msg != 0)
382 {
383 AcceptLanguages * langs = new AcceptLanguages(msg->acceptLanguages);
384
385 Thread::setLanguages(langs);
386 }
387 else
388 {
389 Thread::clearLanguages();
390 }
|
391 chip 1.1
392 service->handleCimRequest(op, legacy);
|
393 chip 1.3 }
|
394 chip 1.8 }
395 catch(...)
396 {
397 // ATTN: log error
|
398 chip 1.1 }
399
400 PEG_METHOD_EXIT();
401
402 return(PEGASUS_THREAD_RETURN(0));
403 }
404
|
405 chip 1.8 void ProviderManagerService::handleCimRequest(AsyncOpNode * op, const Message * message)
|
406 chip 1.1 {
407 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManagerService::handleCimRequest");
408
409 // ATTN: ensure message is a request???
410 CIMMessage * request = dynamic_cast<CIMMessage *>(const_cast<Message *>(message));
411
412 // get request from op node
413 AsyncRequest * async = static_cast<AsyncRequest *>(op->_request.next(0));
414
415 PEGASUS_ASSERT((request != 0) && (async != 0));
416
417 Message * response = 0;
418
|
419 chip 1.11 // get namespace and class name from message
420
|
421 chip 1.12 /*
|
422 chip 1.11 ProviderName name(
423 String::EMPTY,
424 String::EMPTY,
425 String::EMPTY,
426 String::EMPTY,
427 0);
428
|
429 chip 1.1 // find provider manager
|
430 chip 1.11 name = findProvider(name);
431
432 // find provider manager for provider interface
|
433 chip 1.12 */
|
434 chip 1.1
435 try
436 {
|
437 chip 1.4 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
438 "ProviderManagerService::handleCimRequest() passing control to provider manager.");
439
|
440 chip 1.1 // forward request
|
441 chip 1.11 response = _providerManagers[0].getProviderManager().processMessage(request);
|
442 chip 1.1 }
443 catch(...)
444 {
445 // ATTN: create response with error message
446 }
447
448 // preserve message key
449 response->setKey(request->getKey());
450
451 // set HTTP method in response from request
452 response->setHttpMethod(request->getHttpMethod());
453
454 AsyncLegacyOperationResult * async_result =
455 new AsyncLegacyOperationResult(
|
456 chip 1.9 async->getKey(),
457 async->getRouting(),
458 op,
459 response);
|
460 chip 1.1
461 _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0);
462
463 PEG_METHOD_EXIT();
464 }
465
466 void ProviderManagerService::unload_idle_providers(void)
467 {
468 }
469
470 PEGASUS_NAMESPACE_END
|
471 chip 1.9
|
Return to
ProviderManagerService.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2