(file) Return to CIMClientRep.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Client

Diff for /pegasus/src/Pegasus/Client/CIMClientRep.cpp between version 1.64 and 1.64.4.2

version 1.64, 2007/06/05 09:27:08 version 1.64.4.2, 2007/07/03 09:41:12
Line 36 
Line 36 
 #include <Pegasus/Common/MessageLoader.h> #include <Pegasus/Common/MessageLoader.h>
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
 #include <Pegasus/Common/LanguageParser.h> #include <Pegasus/Common/LanguageParser.h>
   #include <Pegasus/Common/Stopwatch.h>
  
 #include <iostream> #include <iostream>
 #include <fstream> #include <fstream>
   #include <unistd.h>
   #include <sys/types.h>
 #include <Pegasus/Common/Network.h> #include <Pegasus/Common/Network.h>
  
   #ifdef PEGASUS_USE_DIRECTACCESS_FOR_LOCAL_DEPEND
   #endif
   
   int numdacim=0, numnondacim=0,numconnect=0,numredirok=0,numredirnok=0;
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   static Stopwatch temptimer;  // ebbfix
   
   
   
   // _directaccess_redirect flag should only be set via this macro
   #if PEGASUS_DIRECTACCESS_BUILDTYPE == dacimINTEGRATED
   #define ck_dacim_redirect() \
       if (_directaccesslocalproviders) { \
           disconnect();\
           _directaccess_redirect = true; \
           try { connectLocal();\
   ++numredirok; \
           } \
                   catch( Exception& e ) { \
   ++numredirnok; \
               _directaccess_redirect = false; \
               connectLocal(); \
               } \
           }
   #else
   #define ck_dacim_redirect()  ;
   #endif
 /////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
 // //
 // CIMClientRep // CIMClientRep
Line 56 
Line 85 
     MessageQueue(PEGASUS_QUEUENAME_CLIENT),     MessageQueue(PEGASUS_QUEUENAME_CLIENT),
     _timeoutMilliseconds(timeoutMilliseconds),     _timeoutMilliseconds(timeoutMilliseconds),
     _connected(false),     _connected(false),
     _doReconnect(false)      _doReconnect(false),
   #ifdef PEGASUS_USE_DIRECTACCESS_FOR_LOCAL_DEPEND
       _allowdirectaccesslocalproviders(true),
       _directaccess_redirect(false),
       _localizer(  //new CIMDirectAccessRep() )
                    CIMDirectAccessRep::get() )
   #else
       _allowdirectaccesslocalproviders(false),
       _directaccess_redirect(false),
       _localizer(NULL)
   #endif
 { {
   #ifdef PEGASUS_USE_DIRECTACCESS_FOR_LOCAL_DEPEND
   #endif
   temptimer.start();
   
   gid_t groupid = getegid();
     //     //
     // Create Monitor and HTTPConnector     // Create Monitor and HTTPConnector
     //     //
Line 68 
Line 112 
     requestContentLanguages.clear();     requestContentLanguages.clear();
 } }
  
   //----------------------------------------------------------
 CIMClientRep::~CIMClientRep() CIMClientRep::~CIMClientRep()
 { {
    disconnect();    disconnect();
   #ifdef PEGASUS_USE_DIRECTACCESS_FOR_LOCAL_DEPEND
      _localizer->release();
      //delete _localizer;
   #endif
   temptimer.stop();
 } }
  
 void CIMClientRep::handleEnqueue() void CIMClientRep::handleEnqueue()
Line 91 
Line 141 
     return 0;     return 0;
 } }
  
   //---------------------------------------------
 void CIMClientRep::_connect() void CIMClientRep::_connect()
 { {
     //     //
Line 103 
Line 154 
     // Keywords are case insensitive.     // Keywords are case insensitive.
     // PEP 90     // PEP 90
     //     //
   ++numconnect;
     Uint32 showOutput = 0;     Uint32 showOutput = 0;
     Uint32 showInput = 0;     Uint32 showInput = 0;
 #ifdef PEGASUS_CLIENT_TRACE_ENABLE #ifdef PEGASUS_CLIENT_TRACE_ENABLE
Line 126 
Line 178 
         showInput = _getShowType(io);         showInput = _getShowType(io);
     }     }
 #endif #endif
       char *ckdacim = getenv("PEGASUS_USE_DIRECTACCESS_FOR_LOCAL_RT");
       if (ckdacim)
       {
           _allowdirectaccesslocalproviders = (strcmp(ckdacim,"false") != 0);
       }
       else
       {
           //If the runtime environment is not set, use cimserver
           _allowdirectaccesslocalproviders = 0;
       }
       if (_directaccesslocalproviders =     // (assign is intentional)
                _allowdirectaccesslocalproviders
                            && !_directaccess_redirect && _isLocalHost() ) {
           _connected = true;
           _connectHost = "localhost";
           }
   
       else { // do the usual connection functions ...
   
   
           _allowdirectaccesslocalproviders = true; // reset each connect
  
     //     //
     // Create response decoder:     // Create response decoder:
Line 171 
Line 244 
     _connected = true;     _connected = true;
     _httpConnection->setSocketWriteTimeout(_timeoutMilliseconds/1000+1);     _httpConnection->setSocketWriteTimeout(_timeoutMilliseconds/1000+1);
 } }
   }
  
   //------------------------------------------
 void CIMClientRep::_disconnect() void CIMClientRep::_disconnect()
 { {
     if (_connected)     if (_connected)
     {     {
           if (!_directaccesslocalproviders) {
         //         //
         // destroy response decoder         // destroy response decoder
         //         //
Line 195 
Line 271 
         // destroy request encoder         // destroy request encoder
         //         //
         _requestEncoder.reset();         _requestEncoder.reset();
           }
  
         _connected = false;         _connected = false;
   #ifdef PEGASUS_USE_DIRECTACCESS_FOR_LOCAL_DEPEND
           _allowdirectaccesslocalproviders = true;
   #else
           _allowdirectaccesslocalproviders = false;
   #endif
     }     }
  
     // Reconnect no longer applies     // Reconnect no longer applies
Line 206 
Line 288 
     _authenticator.setRequestMessage(0);     _authenticator.setRequestMessage(0);
 } }
  
   //-----------------------------------------------
   Boolean CIMClientRep::_isLocalHost()
   {
       if ( _connectHost == String::EMPTY  ||
            String::equalNoCase(_connectHost,"localhost") ) return true;
       return System::sameHost( _connectHost );
   }
   //-------------------------------------------
 void CIMClientRep::connect( void CIMClientRep::connect(
     const String& host,     const String& host,
     const Uint32 portNumber,     const Uint32 portNumber,
Line 250 
Line 340 
 } }
  
  
   //------------------------------------------
 void CIMClientRep::connect( void CIMClientRep::connect(
     const String& host,     const String& host,
     const Uint32 portNumber,     const Uint32 portNumber,
Line 295 
Line 386 
 } }
  
  
   //----------------------------------------------
 void CIMClientRep::connectLocal() void CIMClientRep::connectLocal()
 { {
     //     //
Line 302 
Line 394 
     //     //
     if (_connected)     if (_connected)
         throw AlreadyConnectedException();         throw AlreadyConnectedException();
       if (_allowdirectaccesslocalproviders && !_directaccess_redirect) {
                   // set up direct access CIM
           _connectHost = String::EMPTY;
           _connect();
           return;                    // <--- note
           }
  
     //     //
     // Set authentication type     // Set authentication type
Line 481 
Line 579 
         nameSpace,         nameSpace,
         className,         className,
         QueueIdStack()));         QueueIdStack()));
           ck_dacim_redirect()
     Message* message = _doRequest(request, CIM_DELETE_CLASS_RESPONSE_MESSAGE);     Message* message = _doRequest(request, CIM_DELETE_CLASS_RESPONSE_MESSAGE);
       _directaccess_redirect = false;
     CIMDeleteClassResponseMessage* response =     CIMDeleteClassResponseMessage* response =
         (CIMDeleteClassResponseMessage*)message;         (CIMDeleteClassResponseMessage*)message;
  
Line 499 
Line 597 
         nameSpace,         nameSpace,
         instanceName,         instanceName,
         QueueIdStack()));         QueueIdStack()));
           if (nameSpace == "root/PG_InterOp") { ck_dacim_redirect() }
     Message* message =     Message* message =
         _doRequest(request, CIM_DELETE_INSTANCE_RESPONSE_MESSAGE);         _doRequest(request, CIM_DELETE_INSTANCE_RESPONSE_MESSAGE);
       _directaccess_redirect = false;
     CIMDeleteInstanceResponseMessage* response =     CIMDeleteInstanceResponseMessage* response =
         (CIMDeleteInstanceResponseMessage*)message;         (CIMDeleteInstanceResponseMessage*)message;
  
Line 519 
Line 617 
         newClass,         newClass,
         QueueIdStack()));         QueueIdStack()));
  
       ck_dacim_redirect()
     Message* message = _doRequest(request, CIM_CREATE_CLASS_RESPONSE_MESSAGE);     Message* message = _doRequest(request, CIM_CREATE_CLASS_RESPONSE_MESSAGE);
       _directaccess_redirect = false;
     CIMCreateClassResponseMessage* response =     CIMCreateClassResponseMessage* response =
         (CIMCreateClassResponseMessage*)message;         (CIMCreateClassResponseMessage*)message;
  
Line 537 
Line 636 
         newInstance,         newInstance,
         QueueIdStack()));         QueueIdStack()));
  
           if (nameSpace == "root/PG_InterOp") { ck_dacim_redirect() }
     Message* message =     Message* message =
         _doRequest(request, CIM_CREATE_INSTANCE_RESPONSE_MESSAGE);         _doRequest(request, CIM_CREATE_INSTANCE_RESPONSE_MESSAGE);
       _directaccess_redirect = false;
  
     CIMCreateInstanceResponseMessage* response =     CIMCreateInstanceResponseMessage* response =
         (CIMCreateInstanceResponseMessage*)message;         (CIMCreateInstanceResponseMessage*)message;
Line 558 
Line 659 
         modifiedClass,         modifiedClass,
         QueueIdStack()));         QueueIdStack()));
  
           ck_dacim_redirect()
     Message* message = _doRequest(request, CIM_MODIFY_CLASS_RESPONSE_MESSAGE);     Message* message = _doRequest(request, CIM_MODIFY_CLASS_RESPONSE_MESSAGE);
       _directaccess_redirect = false;
     CIMModifyClassResponseMessage* response =     CIMModifyClassResponseMessage* response =
         (CIMModifyClassResponseMessage*)message;         (CIMModifyClassResponseMessage*)message;
  
Line 580 
Line 682 
         propertyList,         propertyList,
         QueueIdStack()));         QueueIdStack()));
  
           if (nameSpace == "root/PG_InterOp") { ck_dacim_redirect() }
     Message* message =     Message* message =
         _doRequest(request, CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE);         _doRequest(request, CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE);
       _directaccess_redirect = false;
     CIMModifyInstanceResponseMessage* response =     CIMModifyInstanceResponseMessage* response =
         (CIMModifyInstanceResponseMessage*)message;         (CIMModifyInstanceResponseMessage*)message;
  
Line 683 
Line 786 
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMName& className)     const CIMName& className)
 { {
   #ifdef PEGASUS_USE_DIRECTACCESS_FOR_LOCAL_DEPEND
   #endif
     AutoPtr<CIMRequestMessage> request(     AutoPtr<CIMRequestMessage> request(
         new CIMEnumerateInstanceNamesRequestMessage(         new CIMEnumerateInstanceNamesRequestMessage(
             String::EMPTY,             String::EMPTY,
Line 914 
Line 1019 
         nameSpace,         nameSpace,
         qualifierDeclaration,         qualifierDeclaration,
         QueueIdStack()));         QueueIdStack()));
           ck_dacim_redirect()
     Message* message = _doRequest(request, CIM_SET_QUALIFIER_RESPONSE_MESSAGE);     Message* message = _doRequest(request, CIM_SET_QUALIFIER_RESPONSE_MESSAGE);
       _directaccess_redirect = false;
     CIMSetQualifierResponseMessage* response =     CIMSetQualifierResponseMessage* response =
         (CIMSetQualifierResponseMessage*)message;         (CIMSetQualifierResponseMessage*)message;
  
Line 933 
Line 1038 
         qualifierName,         qualifierName,
         QueueIdStack()));         QueueIdStack()));
  
           ck_dacim_redirect()
     Message* message =     Message* message =
         _doRequest(request, CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE);         _doRequest(request, CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE);
       _directaccess_redirect = false;
     CIMDeleteQualifierResponseMessage* response =     CIMDeleteQualifierResponseMessage* response =
         (CIMDeleteQualifierResponseMessage*)message;         (CIMDeleteQualifierResponseMessage*)message;
  
Line 996 
Line 1102 
     return response->retValue;     return response->retValue;
 } }
  
   //------------------------------------------------------
 Message* CIMClientRep::_doRequest( Message* CIMClientRep::_doRequest(
     AutoPtr<CIMRequestMessage>& request,     AutoPtr<CIMRequestMessage>& request,
     Uint32 expectedResponseMessageType)     Uint32 expectedResponseMessageType)
 { {
     if (!_connected && !_doReconnect)     if (!_connected && !_doReconnect)
     {     {
           request.reset();
         throw NotConnectedException();         throw NotConnectedException();
     }     }
   #ifdef PEGASUS_USE_DIRECTACCESS_FOR_LOCAL_DEPEND
       if ( _directaccesslocalproviders && !_directaccess_redirect ) {
   ++numdacim;
           Message *response = _localizer->dorequest(request);
           if (!response) {
               }
           if ( response->getType() == CLIENT_EXCEPTION_MESSAGE ) {
               Exception *clientexcep = ((ClientExceptionMessage*)response)->
                                        clientException;
               CIMException *cimexcep = dynamic_cast<CIMException*>(clientexcep);
               delete response;                  // fix! deletes what??
               if (cimexcep) throw cimexcep;
               throw *clientexcep;
               }
           else if ( response->getType() == DIRECTACCESSCIM_NOTSUPPORTED_TEMP ) {
                           // should see these only during dev; should not occur with intg
                           // build done.
               CIMException cimexcep( CIM_ERR_NOT_SUPPORTED,
                                      "DACIM does not yet handle this." );
               delete response;
               throw cimexcep;
               }
           //else if ( response->getType() == DIRECTACCESSCIM_NOTSUPPORTED_REQUEST ) {
                   //      // pass these along to the cimserver, bau, as if direct access cim didn't
                   //      // exist.
                   //      _directaccess_redirect = true;
                   //      connectLocal();
                   //      _directaccess_redirect = false;
                   //      // note; don't return here.
                   //    }
           else {
               if ( response->getType() != expectedResponseMessageType ) {
                   MessageLoaderParms mlParms(
                     "Client.CIMOperationResponseDecoder.MISMATCHED_RESPONSE_TYPE",
                     "Mismatched response message type.");               // fix
                   String mlString(MessageLoader::getMessage(mlParms));
                   CIMClientResponseException responseexcep(mlString);
                   delete response;
                   throw responseexcep;
                   }
               CIMResponseMessage *crm = (CIMResponseMessage*)response;
               if (crm->cimException.getCode() != CIM_ERR_SUCCESS) {
                   CIMException cimexcep( crm->cimException.getCode(),
                                 (crm->cimException.getMessage().size() > 0)?TraceableCIMException(crm->cimException).getDescription():cimStatusCodeToString(crm->cimException.getCode()));
                   delete response;
                   throw cimexcep;
                   }
               return response;                          // <-- note.
               }
       }
   #endif
   
   ++numnondacim;
  
     if (_doReconnect)     if (_doReconnect)
     {     {
Line 1244 
Line 1405 
     throw ConnectionTimeoutException();     throw ConnectionTimeoutException();
 } }
  
   //---------------------------------------------
   String CIMClientRep::_getLocalHostName()
   {
       static String hostname;
   
       if (!hostname.size())
       {
           hostname.assign(System::getHostName());
       }
   
       return hostname;
   }
 void CIMClientRep::registerClientOpPerformanceDataHandler( void CIMClientRep::registerClientOpPerformanceDataHandler(
     ClientOpPerformanceDataHandler& handler)     ClientOpPerformanceDataHandler& handler)
 { {

Legend:
Removed from v.1.64  
changed lines
  Added in v.1.64.4.2
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2