1 schuur 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 schuur 1.1 //==============================================================================
 23            //
 24            // Author: Chip Vincent (cvincent@us.ibm.com)
 25            //
 26            // Modified By: Yi Zhou, Hewlett-Packard Company(yi_zhou@hp.com)
 27            //              Mike Day IBM Corporation (mdday@us.ibm.com)
 28            //              Adrian Schuur, schuur@de.ibm.com
 29            //
 30            //%/////////////////////////////////////////////////////////////////////////////
 31            
 32            #include "JMPILocalProviderManager.h"
 33            
 34            #include <Pegasus/Common/Constants.h>
 35            #include <Pegasus/Common/Tracer.h>
 36            #include <Pegasus/Common/PegasusVersion.h>
 37            
 38            #include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h>
 39            #include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.h>
 40            #include <Pegasus/ProviderManager2/ProviderManagerService.h>
 41            
 42            PEGASUS_USING_STD;
 43 schuur 1.1 PEGASUS_NAMESPACE_BEGIN
 44            
 45            JMPILocalProviderManager::JMPILocalProviderManager(void)

 46 kumpf  1.2     : _idle_timeout(IDLE_LIMIT)

 47 schuur 1.1 {
 48            }
 49            
 50            JMPILocalProviderManager::~JMPILocalProviderManager(void)
 51            {
 52                Uint32 ccode;
 53            
 54                _provider_ctrl(UNLOAD_ALL_PROVIDERS, this, &ccode);
 55            }
 56            
 57            Sint32 JMPILocalProviderManager::_provider_ctrl(CTRL code, void *parm, void *ret)
 58            {
 59            
 60                static Uint32 quantum;
 61                PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_provider_ctrl");
 62            
 63                Sint32 ccode = 0;
 64                CTRL_STRINGS *parms = reinterpret_cast<CTRL_STRINGS *>(parm);
 65            
 66                switch(code)
 67                {
 68 schuur 1.1 
 69                case GET_PROVIDER:
 70                    {
 71                        PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
 72                            "_provider_ctrl::GET_PROVIDER");
 73            
 74                        JMPIProvider *pr = NULL;
 75                        JMPIProvider::OpProviderHolder* ph =
 76            	          reinterpret_cast< JMPIProvider::OpProviderHolder* >( ret );
 77            
 78            
 79                        if(true == _providers.lookup( *(parms->providerName), pr ))
 80                        {
 81                            PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
 82                                "Found JMPIProvider " + *(parms->providerName) + " in JMPIProvider Manager Cache");
 83            
 84                            ph->SetProvider( pr );
 85            //                ph->GetProvider().update_idle_timer();
 86                            break;
 87                        }
 88            
 89 schuur 1.1 
 90                        PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
 91                            "Creating JMPIProvider " + *(parms->providerName) );
 92                        JMPIProviderModule *module;
 93            
 94                        if(false  == _modules.lookup(*(parms->fileName), module))
 95                        {
 96                            PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
 97                                "Creating JMPIProvider Module " + *(parms->fileName) );
 98            
 99                            module = new JMPIProviderModule(*(parms->fileName),*(parms->interfaceName));
100            
101                            _modules.insert((*parms->fileName), module);
102                        }
103                        else
104                        {
105                            PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
106                                "Using Cached  JMPIProvider Module " + *(parms->fileName) );
107                        }
108            
109            
110 schuur 1.1             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
111                            "Loading/Linking JMPIProvider Module " + *(parms->fileName) );
112            
113                        ProviderVector base ;
114                        try
115                        {
116                            base = module->load(*(parms->fileName));
117                        }
118                        catch(...)
119                        {
120                            PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
121                                "Exception caught Loading/Linking JMPIProvider Module " + *(parms->fileName) );
122                            throw;
123                        }
124            
125                        // create provider module
126            
127                        MessageQueue * queue = MessageQueue::lookup(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP);
128                        PEGASUS_ASSERT(queue != 0);
129                        MessageQueueService * service = dynamic_cast<MessageQueueService *>(queue);
130                        PEGASUS_ASSERT(service != 0);
131 schuur 1.1             pr = new JMPIProvider(*(parms->providerName), module, &base);
132                        if(0 == (pr->_cimom_handle =  new CIMOMHandle()))
133                            throw NullPointer();
134                        pr->_quantum=0;
135            
136            
137                        PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
138                            "Loading JMPIProvider " +  pr->_name);
139                        try
140                        {
141                            pr->initialize(*(pr->_cimom_handle));
142                        }
143                        catch(...)
144                        {
145                            delete pr->_cimom_handle;
146                            delete pr;
147                            throw UninitializedObjectException();
148                        }
149            
150            //            pr->update_idle_timer();
151            
152 schuur 1.1             _providers.insert(*(parms->providerName), pr);
153            
154            
155                        ph->SetProvider( pr );
156                        break;
157                    }
158            
159                case UNLOAD_PROVIDER:
160                    { 
161            	    break;
162                    }
163            
164                case LOOKUP_PROVIDER:
165                    {
166            
167                        PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
168                            "_provider_ctrl::LOOKUP_PROVIDER");
169            
170                        if(true == _providers.lookup(*(parms->providerName),
171                            *(reinterpret_cast<JMPIProvider * *>(ret))))
172                        {
173 schuur 1.1                 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
174                                "Found JMPIProvider in cache: " +
175                                *(parms->providerName));
176            
177            //                (*(reinterpret_cast<JMPIProvider * *>(ret)))->update_idle_timer();
178                        }
179                        else
180                        {
181            
182                            PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
183                                "Could not find  JMPIProvider in cache: " +
184                                *(parms->providerName));
185                            ccode = -1;
186                        }
187            
188                        break;
189                    }
190            
191                case LOOKUP_MODULE:
192                    {
193            
194 schuur 1.1             PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
195                            "_provider_ctrl::LOOKUP_MODULE");
196            
197                        if(false  == _modules.lookup(*(parms->fileName),
198                            *(reinterpret_cast<JMPIProviderModule * *>(ret))))
199                        {
200                            PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
201                                "Could not find  JMPIProvider Module in cache: " +
202                                *(parms->fileName));
203                            ccode = -1;
204                        }
205            
206                        break;
207                    }
208            
209                case INSERT_PROVIDER:
210                    {
211            
212                        PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
213                            "_provider_ctrl::INSERT_PROVIDER");
214                        if(false  == _providers.insert(
215 schuur 1.1                 *(parms->providerName),
216                            *reinterpret_cast<JMPIProvider * *>(parm)))
217                            ccode = -1;
218                        break;
219                    }
220                case INSERT_MODULE:
221                    {
222                        PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
223                            "_provider_ctrl::INSERT_MODULE");
224                        if(false  == _modules.insert(
225                            *(parms->fileName),
226                            *reinterpret_cast<JMPIProviderModule * *>(parm)))
227                            ccode = -1;
228                        break;
229                    }
230                case REMOVE_PROVIDER:
231                    {
232            
233                        PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
234                            "_provider_ctrl::REMOVE_PROVIDER");
235                        if(false == _providers.remove(*(parms->providerName)))
236 schuur 1.1                 ccode = -1;
237                        break;
238                    }
239                case REMOVE_MODULE:
240                    {
241            
242                        PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
243                            "_provider_ctrl::REMOVE_MODULE");
244                        if(false == _modules.remove(*(parms->fileName)))
245                            ccode = -1;
246                        break;
247                    }
248            
249                case UNLOAD_ALL_PROVIDERS:
250                    { 
251            	    break;
252                    }
253            	
254                case UNLOAD_IDLE_PROVIDERS:
255                     { 
256            	    break;
257 schuur 1.1         }
258            
259                case UNLOAD_IDLE_MODULES:
260                    { 
261            	    break;
262                    }
263            
264                default:
265                    ccode = -1;
266                    break;
267                }
268                PEG_METHOD_EXIT();
269                return(ccode);
270            }
271            
272            JMPIProvider * JMPILocalProviderManager::_getResolver
273               (const String & fileName, const String & interfaceType)
274            {
275                JMPIProvider *pr;
276                String id(interfaceType+String("::")+fileName);
277                if (true == _resolvers.lookup(id,pr)) {
278 schuur 1.1        return pr;
279                }
280                return NULL;
281            }
282            /*
283            CMPIResolverModule *JMPILocalProviderManager::_loadResolver
284               (const String & fileName)
285            {
286               CMPIResolverModule *rm=new CMPIResolverModule(fileName);
287               rm->load();
288               return rm;
289            }
290            */
291            JMPIProvider::OpProviderHolder JMPILocalProviderManager::getProvider(
292                const String & fileName,
293                const String & providerName,
294                const String & interfaceName)
295            {
296                JMPIProvider::OpProviderHolder ph;
297                CTRL_STRINGS strings;
298                Sint32 ccode;
299 schuur 1.1     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::getProvider");
300                strings.fileName = &fileName;
301                strings.providerName = &providerName;
302                strings.interfaceName = &interfaceName;
303            
304                try {
305                    ccode = _provider_ctrl( GET_PROVIDER, &strings, &ph );
306                }
307                catch (Exception e) {

308 schuur 1.3        cerr<<"--- loading proxy: "<<e.getMessage()<<endl;

309 schuur 1.1        PEG_METHOD_EXIT();
310                    throw;
311               }
312                catch(...) {
313                    PEG_METHOD_EXIT();
314                    throw;
315                }
316            
317            
318                PEG_METHOD_EXIT();
319                return(ph);
320            
321            }
322            
323            void JMPILocalProviderManager::unloadProvider(
324                const String & fileName,
325                const String & providerName)
326            {
327                CTRL_STRINGS strings;
328                PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::unloadProvider");
329                strings.fileName = &fileName;
330 schuur 1.1     strings.providerName = &providerName;
331                _provider_ctrl(UNLOAD_PROVIDER, &strings, (void *)0);
332                PEG_METHOD_EXIT();
333            }
334            
335            void JMPILocalProviderManager::shutdownAllProviders(void)
336            {
337            
338                PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::shutdownAllProviders");
339                _provider_ctrl(UNLOAD_ALL_PROVIDERS, (void *)this, (void *)0);
340                PEG_METHOD_EXIT();
341            }
342            
343            

344 kumpf  1.2 Boolean JMPILocalProviderManager::hasActiveProviders()

345 schuur 1.1 {

346 kumpf  1.2     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
347                    "ProviderManager::hasActiveProviders");
348            
349                PEG_METHOD_EXIT();
350                return (_providers.size() > 0);
351            }
352            
353            void JMPILocalProviderManager::unloadIdleProviders()
354            {
355                PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
356                    "ProviderManager::unloadIdleProviders");
357            

358 schuur 1.1     static struct timeval first = {0,0}, now, last = {0,0};
359               
360                if(first.tv_sec == 0)

361 kumpf  1.2     {

362 schuur 1.1         gettimeofday(&first, NULL);

363 kumpf  1.2     }

364 schuur 1.1     gettimeofday(&now, NULL);

365 kumpf  1.2 
366                if (((now.tv_sec - first.tv_sec) > IDLE_LIMIT) &&
367                   ((now.tv_sec - last.tv_sec) > IDLE_LIMIT))

368 schuur 1.1     {
369                    gettimeofday(&last, NULL);

370 kumpf  1.2         PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
371                        "Checking for Idle providers to unload.");
372                    try
373                    {
374                        _provider_ctrl(UNLOAD_IDLE_PROVIDERS, this, (void *)0);
375                    }
376                    catch(...)

377 schuur 1.1         {
378                        PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,

379 kumpf  1.2                 "Caught unexpected exception from UNLOAD_IDLE_PROVIDERS.");

380 schuur 1.1         }
381                }
382                PEG_METHOD_EXIT();
383            }
384            
385            PEGASUS_NAMESPACE_END