1 karl  1.8 //%2006////////////////////////////////////////////////////////////////////////

  2 kumpf 1.1 //

  3 karl  1.3 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
  4           // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
  5           // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;

  6 kumpf 1.1 // IBM Corp.; EMC Corporation, The Open Group.

  7 karl  1.3 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
  8           // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

  9 karl  1.5 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 10           // EMC Corporation; VERITAS Software Corporation; The Open Group.

 11 karl  1.8 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 12           // EMC Corporation; Symantec Corporation; The Open Group.

 13 kumpf 1.1 //
 14           // Permission is hereby granted, free of charge, to any person obtaining a copy
 15           // of this software and associated documentation files (the "Software"), to
 16           // deal in the Software without restriction, including without limitation the
 17           // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 18           // sell copies of the Software, and to permit persons to whom the Software is
 19           // furnished to do so, subject to the following conditions:
 20           // 
 21           // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 22           // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 23           // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 24           // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 25           // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 26           // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 27           // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 28           // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 29           //
 30           //==============================================================================
 31           //
 32           // Author: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 33           //
 34 kumpf 1.1 // Modified By:
 35           //
 36           //%/////////////////////////////////////////////////////////////////////////////
 37           
 38           
 39           #include <Pegasus/Common/Thread.h>
 40           #include <Pegasus/Common/Tracer.h>
 41           
 42           #include "ClientCIMOMHandleRep.h"
 43           
 44           PEGASUS_NAMESPACE_BEGIN
 45           
 46           static void deleteContentLanguage(void* data)
 47           {

 48 kumpf 1.9     ContentLanguageList* cl = static_cast<ContentLanguageList*>(data);
 49               delete cl;

 50 kumpf 1.1 }
 51           
 52           /**
 53               This class is used to prevent concurrent access to a non-reentrant
 54               CIMClient object.
 55            */
 56           class ClientCIMOMHandleAccessController
 57           {
 58           public:
 59               ClientCIMOMHandleAccessController(Mutex& lock)
 60                   : _lock(lock)
 61               {
 62                   try
 63                   {

 64 mike  1.11             _lock.try_lock();

 65 kumpf 1.1          }
 66                    catch (AlreadyLocked &)
 67                    {
 68                        PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL2,
 69                            "AlreadyLocked Exception, throwing CIMException");
 70                        throw CIMException(CIM_ERR_ACCESS_DENIED, MessageLoaderParms(
 71                            "Provider.CIMOMHandle.RECURSIVE_USE_CIMOMHANDLE",
 72                            "Recursive Use of CIMOMHandle Attempted"));
 73                    }
 74                    catch (Exception& e)
 75                    {
 76                        PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL2,
 77                            String("Unexpected Exception: ") + e.getMessage());
 78                        throw;
 79                    }
 80                    catch (...)
 81                    {
 82                        PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL2,
 83                            "Unexpected exception");
 84                        throw;
 85                    }
 86 kumpf 1.1      }
 87            
 88                ~ClientCIMOMHandleAccessController()
 89                {
 90                    // Must not throw an exception from a destructor
 91                    try
 92                    {
 93                        _lock.unlock();
 94                    }
 95                    catch (Exception& e)
 96                    {
 97                        PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL2,
 98                            String("Ignoring Exception: ") + e.getMessage());
 99                    }
100                    catch (...)
101                    {
102                        PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL2,
103                            "Ignoring unknown exception");
104                    }
105                }
106            
107 kumpf 1.1  private:
108                // Unimplemented constructors and assignment operator
109                ClientCIMOMHandleAccessController();
110                ClientCIMOMHandleAccessController(const ClientCIMOMHandleAccessController&);
111                ClientCIMOMHandleAccessController& operator=(
112                    const ClientCIMOMHandleAccessController&);
113            
114                Mutex& _lock;
115            };
116            
117            
118            /**
119                The ClientCIMOMHandleSetup class encapsulates the logic to set up the
120                CIMClient object state based on a specified OperationContext.  The
121                original CIMClient state is restored by the destructor.  Only one
122                ClientCIMOMHandleSetup object may operate on a given CIMClient object
123                at a time.  Use of the ClientCIMOMHandleAccessController class is
124                recommend to control access to CIMClient objects.
125             */
126            class ClientCIMOMHandleSetup
127            {
128 kumpf 1.1  public:
129                ClientCIMOMHandleSetup(
130                    CIMClient*& client,
131                    const OperationContext& context)
132                {
133                    //
134                    // Initialize the CIMClient object if necessary
135                    //
136                    if (client == 0)
137                    {
138                        PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL2,
139                            "Creating CIMClient connection");
140                        client = new CIMClient();
141                        client->connectLocal();
142                    }
143                    _client = client;
144            
145                    //
146                    // If the caller specified a timeout value in the OperationContext,
147                    // set it in the CIMClient object.
148                    //
149 kumpf 1.1          _origTimeout = client->getTimeout();

150 a.dunfey 1.10         if(context.contains(TimeoutContainer::NAME))

151 kumpf    1.1          {
152                           TimeoutContainer t_cntr = (TimeoutContainer)
153                               context.get(TimeoutContainer::NAME);
154                           client->setTimeout(t_cntr.getTimeOut());
155                       }
156               
157                       //
158                       // If the caller specified an Accept-Language in the
159                       // OperationContext, set it in the CIMClient object.
160                       //
161                       _origAcceptLanguages = client->getRequestAcceptLanguages();

162 a.dunfey 1.10         if(context.contains(AcceptLanguageListContainer::NAME))

163 kumpf    1.1          {
164                           AcceptLanguageListContainer al_cntr = (AcceptLanguageListContainer)
165                               context.get(AcceptLanguageListContainer::NAME);
166                           _client->setRequestAcceptLanguages(al_cntr.getLanguages());
167                       }

168 a.dunfey 1.10         else

169 kumpf    1.1          {
170                           // No AcceptLanguageListContainer in OperationContext; try

171 kumpf    1.7              // getting the AcceptLanguageList from the current thread
172                           AcceptLanguageList* al = Thread::getLanguages();

173 kumpf    1.1              if (al != NULL)
174                           {
175                               _client->setRequestAcceptLanguages(*al);
176                           }
177                       }
178               
179                       //
180                       // If the caller specified a Content-Language in the
181                       // OperationContext, set it in the CIMClient object.
182                       //
183                       _origContentLanguages = client->getRequestContentLanguages();

184 a.dunfey 1.10         if(context.contains(ContentLanguageListContainer::NAME))

185 kumpf    1.1          {
186                           ContentLanguageListContainer cl_cntr =
187                               (ContentLanguageListContainer)context.get(
188                                   ContentLanguageListContainer::NAME);
189                           _client->setRequestContentLanguages(cl_cntr.getLanguages());
190                       }
191                   }
192               
193                   ~ClientCIMOMHandleSetup()
194                   {
195                       // Must not throw an exception from a destructor
196                       try
197                       {
198                           //
199                           // If the response has a Content-Language then save it into
200                           // thread-specific storage
201                           //
202                           if (_client->getResponseContentLanguages().size() > 0)
203                           {
204                                Thread* curThrd = Thread::getCurrent();
205                                if (curThrd != NULL)
206 kumpf    1.1                   {
207                                    // deletes the old tsd and creates a new one
208                                    curThrd->put_tsd("cimomHandleContentLanguages",
209                                        deleteContentLanguage,

210 kumpf    1.7                           sizeof(ContentLanguageList*),
211                                        new ContentLanguageList(

212 kumpf    1.1                               _client->getResponseContentLanguages()));
213                                }
214                           }
215               
216                           //
217                           // Reset CIMClient timeout value and languages to original values
218                           //
219                           _client->setTimeout(_origTimeout);
220                           _client->setRequestAcceptLanguages(_origAcceptLanguages);
221                           _client->setRequestContentLanguages(_origContentLanguages);
222                       }
223                       catch (Exception& e)
224                       {
225                           PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL2,
226                               String("Ignoring Exception: ") + e.getMessage());
227                       }
228                       catch (...)
229                       {
230                           PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL2,
231                               "Ignoring unknown exception");
232                       }
233 kumpf    1.1      }
234               
235               private:
236                   // Unimplemented constructors and assignment operator
237                   ClientCIMOMHandleSetup();
238                   ClientCIMOMHandleSetup(const ClientCIMOMHandleSetup&);
239                   ClientCIMOMHandleSetup& operator=(const ClientCIMOMHandleSetup&);
240               
241                   CIMClient* _client;
242                   Uint32 _origTimeout;

243 kumpf    1.7      AcceptLanguageList _origAcceptLanguages;
244                   ContentLanguageList _origContentLanguages;

245 kumpf    1.1  };
246               
247               
248               //
249               // ClientCIMOMHandleRep
250               //
251               
252               ClientCIMOMHandleRep::ClientCIMOMHandleRep()
253                   : _client(0)
254               {
255               }
256               
257               ClientCIMOMHandleRep::~ClientCIMOMHandleRep()
258               {
259                   if (_client != 0)
260                   {

261 kumpf    1.2          // Must not throw an exception from a destructor
262                       try
263                       {
264                           _client->disconnect();
265                       }
266                       catch (...)
267                       {
268                           // Ignore disconnect exceptions
269                       }
270               

271 kumpf    1.1          delete _client;
272                   }
273               }
274               
275               
276               //
277               // CIM Operations
278               //
279               
280               CIMClass ClientCIMOMHandleRep::getClass(
281                   const OperationContext & context,
282                   const CIMNamespaceName& nameSpace,
283                   const CIMName& className,
284                   Boolean localOnly,
285                   Boolean includeQualifiers,
286                   Boolean includeClassOrigin,
287                   const CIMPropertyList& propertyList)
288               {
289                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "ClientCIMOMHandleRep::getClass");
290               
291                   ClientCIMOMHandleAccessController access(_clientMutex);
292 kumpf    1.1      ClientCIMOMHandleSetup setup(_client, context);
293               
294                   PEG_METHOD_EXIT();
295                   return _client->getClass(
296                       nameSpace,
297                       className,
298                       localOnly,
299                       includeQualifiers,
300                       includeClassOrigin,
301                       propertyList);
302               }
303               
304               Array<CIMClass> ClientCIMOMHandleRep::enumerateClasses(
305                   const OperationContext & context,
306                   const CIMNamespaceName& nameSpace,
307                   const CIMName& className,
308                   Boolean deepInheritance,
309                   Boolean localOnly,
310                   Boolean includeQualifiers,
311                   Boolean includeClassOrigin)
312               {
313 kumpf    1.1      PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
314                       "ClientCIMOMHandleRep::enumerateClasses");
315               
316                   ClientCIMOMHandleAccessController access(_clientMutex);
317                   ClientCIMOMHandleSetup setup(_client, context);
318               
319                   PEG_METHOD_EXIT();
320                   return _client->enumerateClasses(
321                       nameSpace,
322                       className,
323                       deepInheritance,
324                       localOnly,
325                       includeQualifiers,
326                       includeClassOrigin);
327               }
328               
329               Array<CIMName> ClientCIMOMHandleRep::enumerateClassNames(
330                   const OperationContext & context,
331                   const CIMNamespaceName &nameSpace,
332                   const CIMName& className,
333                   Boolean deepInheritance)
334 kumpf    1.1  {
335                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
336                       "ClientCIMOMHandleRep::enumerateClassNames");
337               
338                   ClientCIMOMHandleAccessController access(_clientMutex);
339                   ClientCIMOMHandleSetup setup(_client, context);
340               
341                   PEG_METHOD_EXIT();
342                   return _client->enumerateClassNames(
343                       nameSpace,
344                       className,
345                       deepInheritance);
346               }
347               
348               void ClientCIMOMHandleRep::createClass(
349                   const OperationContext & context,
350                   const CIMNamespaceName& nameSpace,
351                   const CIMClass& newClass)
352               {
353                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "ClientCIMOMHandleRep::createClass");
354               
355 kumpf    1.1      ClientCIMOMHandleAccessController access(_clientMutex);
356                   ClientCIMOMHandleSetup setup(_client, context);
357               
358                   _client->createClass(
359                       nameSpace,
360                       newClass);
361               
362                   PEG_METHOD_EXIT();
363               }
364               
365               void ClientCIMOMHandleRep::modifyClass(
366                   const OperationContext & context,
367                   const CIMNamespaceName &nameSpace,
368                   const CIMClass& modifiedClass)
369               {
370                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "ClientCIMOMHandleRep::modifyClass");
371               
372                   ClientCIMOMHandleAccessController access(_clientMutex);
373                   ClientCIMOMHandleSetup setup(_client, context);
374               
375                   _client->modifyClass(
376 kumpf    1.1          nameSpace,
377                       modifiedClass);
378               
379                   PEG_METHOD_EXIT();
380               }
381               
382               void ClientCIMOMHandleRep::deleteClass(
383                   const OperationContext & context,
384                   const CIMNamespaceName &nameSpace,
385                   const CIMName& className)
386               {
387               
388                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "ClientCIMOMHandleRep::deleteClass");
389               
390                   ClientCIMOMHandleAccessController access(_clientMutex);
391                   ClientCIMOMHandleSetup setup(_client, context);
392               
393                   _client->deleteClass(
394                       nameSpace,
395                       className);
396               
397 kumpf    1.1      PEG_METHOD_EXIT();
398               }
399               
400               CIMInstance ClientCIMOMHandleRep::getInstance(
401                   const OperationContext & context,
402                   const CIMNamespaceName &nameSpace,
403                   const CIMObjectPath& instanceName,
404                   Boolean localOnly,
405                   Boolean includeQualifiers,
406                   Boolean includeClassOrigin,
407                   const CIMPropertyList& propertyList)
408               {
409                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "ClientCIMOMHandleRep::getInstance");
410               
411                   ClientCIMOMHandleAccessController access(_clientMutex);
412                   ClientCIMOMHandleSetup setup(_client, context);
413               
414                   PEG_METHOD_EXIT();
415                   return _client->getInstance(
416                       nameSpace,
417                       instanceName,
418 kumpf    1.1          localOnly,
419                       includeQualifiers,
420                       includeClassOrigin,
421                       propertyList);
422               }
423               
424               Array<CIMInstance> ClientCIMOMHandleRep::enumerateInstances(
425                   const OperationContext & context,
426                   const CIMNamespaceName &nameSpace,
427                   const CIMName& className,
428                   Boolean deepInheritance,
429                   Boolean localOnly,
430                   Boolean includeQualifiers,
431                   Boolean includeClassOrigin,
432                   const CIMPropertyList& propertyList)
433               {
434                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
435                       "ClientCIMOMHandleRep::enumerateInstances");
436               
437                   ClientCIMOMHandleAccessController access(_clientMutex);
438                   ClientCIMOMHandleSetup setup(_client, context);
439 kumpf    1.1  
440                   PEG_METHOD_EXIT();
441                   return _client->enumerateInstances(
442                       nameSpace,
443                       className,
444                       deepInheritance,
445                       localOnly,
446                       includeQualifiers,
447                       includeClassOrigin,
448                       propertyList);
449               }
450               
451               Array<CIMObjectPath> ClientCIMOMHandleRep::enumerateInstanceNames(
452                   const OperationContext & context,
453                   const CIMNamespaceName &nameSpace,
454                   const CIMName& className)
455               {
456                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
457                       "ClientCIMOMHandleRep::enumerateInstanceNames");
458               
459                   ClientCIMOMHandleAccessController access(_clientMutex);
460 kumpf    1.1      ClientCIMOMHandleSetup setup(_client, context);
461               
462                   PEG_METHOD_EXIT();
463                   return _client->enumerateInstanceNames(
464                       nameSpace,
465                       className);
466               }
467               
468               CIMObjectPath ClientCIMOMHandleRep::createInstance(
469                   const OperationContext & context,
470                   const CIMNamespaceName &nameSpace,
471                   const CIMInstance& newInstance)
472               {
473                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
474                       "ClientCIMOMHandleRep::createInstance");
475               
476                   ClientCIMOMHandleAccessController access(_clientMutex);
477                   ClientCIMOMHandleSetup setup(_client, context);
478               
479                   PEG_METHOD_EXIT();
480                   return _client->createInstance(
481 kumpf    1.1          nameSpace,
482                       newInstance);
483               }
484               
485               void ClientCIMOMHandleRep::modifyInstance(
486                   const OperationContext & context,
487                   const CIMNamespaceName &nameSpace,
488                   const CIMInstance& modifiedInstance,
489                   Boolean includeQualifiers,
490                   const CIMPropertyList& propertyList)
491               {
492                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
493                       "ClientCIMOMHandleRep::modifyInstance");
494               
495                   ClientCIMOMHandleAccessController access(_clientMutex);
496                   ClientCIMOMHandleSetup setup(_client, context);
497               
498                   _client->modifyInstance(
499                       nameSpace,
500                       modifiedInstance,
501                       includeQualifiers,
502 kumpf    1.1          propertyList);
503               
504                   PEG_METHOD_EXIT();
505               }
506               
507               void ClientCIMOMHandleRep::deleteInstance(
508                   const OperationContext & context,
509                   const CIMNamespaceName &nameSpace,
510                   const CIMObjectPath& instanceName)
511               {
512                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
513                       "ClientCIMOMHandleRep::deleteInstance");
514               
515                   ClientCIMOMHandleAccessController access(_clientMutex);
516                   ClientCIMOMHandleSetup setup(_client, context);
517               
518                   _client->deleteInstance(
519                       nameSpace,
520                       instanceName);
521               
522                   PEG_METHOD_EXIT();
523 kumpf    1.1  }
524               
525               Array<CIMObject> ClientCIMOMHandleRep::execQuery(
526                   const OperationContext & context,
527                   const CIMNamespaceName &nameSpace,
528                   const String& queryLanguage,
529                   const String& query)
530               {
531                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "ClientCIMOMHandleRep::execQuery");
532               
533                   ClientCIMOMHandleAccessController access(_clientMutex);
534                   ClientCIMOMHandleSetup setup(_client, context);
535               
536                   PEG_METHOD_EXIT();
537                   return _client->execQuery(
538                       nameSpace,
539                       queryLanguage,
540                       query);
541               }
542               
543               Array<CIMObject> ClientCIMOMHandleRep::associators(
544 kumpf    1.1      const OperationContext & context,
545                   const CIMNamespaceName &nameSpace,
546                   const CIMObjectPath& objectName,
547                   const CIMName& assocClass,
548                   const CIMName& resultClass,
549                   const String& role,
550                   const String& resultRole,
551                   Boolean includeQualifiers,
552                   Boolean includeClassOrigin,
553                   const CIMPropertyList& propertyList)
554               {
555                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "ClientCIMOMHandleRep::associators");
556               
557                   ClientCIMOMHandleAccessController access(_clientMutex);
558                   ClientCIMOMHandleSetup setup(_client, context);
559               
560                   PEG_METHOD_EXIT();
561                   return _client->associators(
562                       nameSpace,
563                       objectName,
564                       assocClass,
565 kumpf    1.1          resultClass,
566                       role,
567                       resultRole,
568                       includeQualifiers,
569                       includeClassOrigin,
570                       propertyList);
571               }
572               
573               Array<CIMObjectPath> ClientCIMOMHandleRep::associatorNames(
574                   const OperationContext & context,
575                   const CIMNamespaceName &nameSpace,
576                   const CIMObjectPath& objectName,
577                   const CIMName& assocClass,
578                   const CIMName& resultClass,
579                   const String& role,
580                   const String& resultRole)
581               {
582                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
583                       "ClientCIMOMHandleRep::associatorNames");
584               
585                   ClientCIMOMHandleAccessController access(_clientMutex);
586 kumpf    1.1      ClientCIMOMHandleSetup setup(_client, context);
587               
588                   PEG_METHOD_EXIT();
589                   return _client->associatorNames(
590                       nameSpace,
591                       objectName,
592                       assocClass,
593                       resultClass,
594                       role,
595                       resultRole);
596               }
597               
598               Array<CIMObject> ClientCIMOMHandleRep::references(
599                   const OperationContext & context,
600                   const CIMNamespaceName &nameSpace,
601                   const CIMObjectPath& objectName,
602                   const CIMName& resultClass,
603                   const String& role,
604                   Boolean includeQualifiers,
605                   Boolean includeClassOrigin,
606                   const CIMPropertyList& propertyList)
607 kumpf    1.1  {
608                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "ClientCIMOMHandleRep::references");
609               
610                   ClientCIMOMHandleAccessController access(_clientMutex);
611                   ClientCIMOMHandleSetup setup(_client, context);
612               
613                   PEG_METHOD_EXIT();
614                   return _client->references(
615                       nameSpace,
616                       objectName,
617                       resultClass,
618                       role,
619                       includeQualifiers,
620                       includeClassOrigin,
621                       propertyList);
622               }
623               
624               Array<CIMObjectPath> ClientCIMOMHandleRep::referenceNames(
625                   const OperationContext & context,
626                   const CIMNamespaceName &nameSpace,
627                   const CIMObjectPath& objectName,
628 kumpf    1.1      const CIMName& resultClass,
629                   const String& role)
630               {
631                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE,
632                       "ClientCIMOMHandleRep::referenceNames");
633               
634                   ClientCIMOMHandleAccessController access(_clientMutex);
635                   ClientCIMOMHandleSetup setup(_client, context);
636               
637                   PEG_METHOD_EXIT();
638                   return _client->referenceNames(
639                       nameSpace,
640                       objectName,
641                       resultClass,
642                       role);
643               }
644               
645               CIMValue ClientCIMOMHandleRep::getProperty(
646                   const OperationContext & context,
647                   const CIMNamespaceName &nameSpace,
648                   const CIMObjectPath& instanceName,
649 kumpf    1.1      const CIMName& propertyName)
650               {
651                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "ClientCIMOMHandleRep::getProperty");
652               
653                   ClientCIMOMHandleAccessController access(_clientMutex);
654                   ClientCIMOMHandleSetup setup(_client, context);
655               
656                   PEG_METHOD_EXIT();
657                   return _client->getProperty(
658                       nameSpace,
659                       instanceName,
660                       propertyName);
661               }
662               
663               void ClientCIMOMHandleRep::setProperty(
664                   const OperationContext & context,
665                   const CIMNamespaceName &nameSpace,
666                   const CIMObjectPath& instanceName,
667                   const CIMName& propertyName,
668                   const CIMValue& newValue)
669               {
670 kumpf    1.1      PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "ClientCIMOMHandleRep::setProperty");
671               
672                   ClientCIMOMHandleAccessController access(_clientMutex);
673                   ClientCIMOMHandleSetup setup(_client, context);
674               
675                   _client->setProperty(
676                       nameSpace,
677                       instanceName,
678                       propertyName,
679                       newValue);
680               
681                   PEG_METHOD_EXIT();
682               }
683               
684               CIMValue ClientCIMOMHandleRep::invokeMethod(
685                   const OperationContext & context,
686                   const CIMNamespaceName &nameSpace,
687                   const CIMObjectPath& instanceName,
688                   const CIMName& methodName,
689                   const Array<CIMParamValue>& inParameters,
690                   Array<CIMParamValue>& outParameters)
691 kumpf    1.1  {
692                   PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "ClientCIMOMHandleRep::invokeMethod");
693               
694                   ClientCIMOMHandleAccessController access(_clientMutex);
695                   ClientCIMOMHandleSetup setup(_client, context);
696               
697                   PEG_METHOD_EXIT();
698                   return _client->invokeMethod(
699                       nameSpace,
700                       instanceName,
701                       methodName,
702                       inParameters,
703                       outParameters);
704               }
705               
706               
707               //
708               // Other public methods
709               //
710               
711               #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
712 kumpf    1.1  OperationContext ClientCIMOMHandleRep::getResponseContext()
713               {
714                   OperationContext ctx;
715               
716                   Thread* curThrd = Thread::getCurrent();
717                   if (curThrd == NULL)
718                   {

719 kumpf    1.7          ctx.insert(ContentLanguageListContainer(ContentLanguageList()));

720 kumpf    1.1      }
721                   else
722                   {

723 kumpf    1.7          ContentLanguageList* contentLangs = (ContentLanguageList*)

724 kumpf    1.1              curThrd->reference_tsd("cimomHandleContentLanguages");
725                       curThrd->dereference_tsd();
726                
727                       if (contentLangs == NULL)
728                       {

729 kumpf    1.7              ctx.insert(ContentLanguageListContainer(ContentLanguageList()));

730 kumpf    1.1          }
731                       else
732                       {
733                           ctx.insert(ContentLanguageListContainer(*contentLangs));
734                           // delete the old tsd to free the memory
735                           curThrd->delete_tsd("cimomHandleContentLanguages");
736                       }
737                   }
738               
739                   return ctx;
740               }
741               #endif
742               
743               PEGASUS_NAMESPACE_END