(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.81.2.11 and 1.82

version 1.81.2.11, 2014/06/12 20:35:16 version 1.82, 2011/01/20 13:09:09
Line 38 
Line 38 
 #include <iostream> #include <iostream>
 #include <fstream> #include <fstream>
 #include <Pegasus/Common/Network.h> #include <Pegasus/Common/Network.h>
 #include <Pegasus/Common/Logger.h>  
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
Line 54 
Line 53 
 CIMClientRep::CIMClientRep(Uint32 timeoutMilliseconds) CIMClientRep::CIMClientRep(Uint32 timeoutMilliseconds)
     :     :
     MessageQueue(PEGASUS_QUEUENAME_CLIENT),     MessageQueue(PEGASUS_QUEUENAME_CLIENT),
     _binaryResponse(false),  
     _timeoutMilliseconds(timeoutMilliseconds),     _timeoutMilliseconds(timeoutMilliseconds),
     _connected(false),     _connected(false),
     _doReconnect(false),     _doReconnect(false),
     _binaryRequest(false),     _binaryRequest(false),
       _binaryResponse(false),
     _localConnect(false)     _localConnect(false)
 { {
     //     //
Line 80 
Line 79 
 { {
 } }
  
   Uint32 _getShowType(String& s)
   {
       String log = "log";
       String con = "con";
       String both = "both";
       if (s == log)
           return 2;
       if (s == con)
           return 1;
       if (s == both)
           return 3;
       return 0;
   }
   
 void CIMClientRep::_connect(bool binaryRequest, bool binaryResponse) void CIMClientRep::_connect(bool binaryRequest, bool binaryResponse)
 { {
     ClientTrace::setup();      //
       // Test for Display optons of the form
       // Use Env variable PEGASUS_CLIENT_TRACE= <intrace> : <outtrace
       // intrace = "con" | "log" | "both"
       // outtrace = intrace
       // ex set PEGASUS_CLIENT_TRACE=BOTH:BOTH traces input and output
       // to console and log
       // Keywords are case insensitive.
       // PEP 90
       //
       Uint32 showOutput = 0;
       Uint32 showInput = 0;
   #ifdef PEGASUS_CLIENT_TRACE_ENABLE
       String input;
       if (char * envVar = getenv("PEGASUS_CLIENT_TRACE"))
       {
           input = envVar;
           input.toLower();
           String io;
           Uint32 pos = input.find(':');
           if (pos == PEG_NOT_FOUND)
               pos = 0;
           else
               io = input.subString(0,pos);
   
           // some compilers do not allow temporaries to be passed to a
           // reference argument - so break into 2 lines
           String out = input.subString(pos + 1);
           showOutput = _getShowType(out);
   
           showInput = _getShowType(io);
       }
   #endif
  
     //     //
     // Create response decoder:     // Create response decoder:
     //     //
     AutoPtr<CIMOperationResponseDecoder> responseDecoder(     AutoPtr<CIMOperationResponseDecoder> responseDecoder(
         new CIMOperationResponseDecoder(         new CIMOperationResponseDecoder(
             this, _requestEncoder.get(), &_authenticator ));              this, _requestEncoder.get(), &_authenticator, showInput));
  
     //     //
     // Attempt to establish a connection:     // Attempt to establish a connection:
Line 114 
Line 159 
  
     AutoPtr<CIMOperationRequestEncoder> requestEncoder(     AutoPtr<CIMOperationRequestEncoder> requestEncoder(
         new CIMOperationRequestEncoder(         new CIMOperationRequestEncoder(
             httpConnection.get(), connectHost, &_authenticator,              httpConnection.get(), connectHost, &_authenticator, showOutput,
             binaryRequest,             binaryRequest,
             binaryResponse));             binaryResponse));
  
Line 134 
Line 179 
     _httpConnection->setSocketWriteTimeout(_timeoutMilliseconds/1000+1);     _httpConnection->setSocketWriteTimeout(_timeoutMilliseconds/1000+1);
 } }
  
 void CIMClientRep::_disconnect(bool keepChallengeStatus)  void CIMClientRep::_disconnect()
 { {
     if (_connected)     if (_connected)
     {     {
Line 167 
Line 212 
     // Let go of the cached request message if we have one     // Let go of the cached request message if we have one
     _authenticator.setRequestMessage(0);     _authenticator.setRequestMessage(0);
  
     if (keepChallengeStatus == false)  
     {  
     // Reset the challenge status     // Reset the challenge status
     _authenticator.resetChallengeStatus();     _authenticator.resetChallengeStatus();
 } }
 }  
  
 void CIMClientRep::connect( void CIMClientRep::connect(
     const String& host,     const String& host,
Line 984 
Line 1026 
     return response->retValue;     return response->retValue;
 } }
  
 // EXP_PULL_BEGIN  
 CIMResponseData CIMClientRep::openEnumerateInstances(  
     CIMEnumerationContext& enumerationContext,  
     Boolean& endOfSequence,  
     const CIMNamespaceName& nameSpace,  
     const CIMName& className,  
     Boolean deepInheritance,  
     Boolean includeClassOrigin,  
     const CIMPropertyList& propertyList,  
     const String& filterQueryLanguage,  
     const String& filterQuery,  
     const Uint32Arg& operationTimeout,  
     Boolean continueOnError,  
     Uint32 maxObjectCount)  
 {  
     // Save requied information in enumerationContext  
     enumerationContext.setNameSpace(nameSpace);  
   
     // Create/send the request message  
     AutoPtr<CIMRequestMessage> request(  
         new CIMOpenEnumerateInstancesRequestMessage(  
             String::EMPTY,                  // messageId_ param  
             nameSpace,  
             className,  
             deepInheritance,  
             includeClassOrigin,  
             propertyList,  
             filterQueryLanguage,  
             filterQuery,  
             operationTimeout,  
             continueOnError,  
             maxObjectCount,  
             QueueIdStack()));  
   
     Message* message =  
         _doRequest(request, CIM_OPEN_ENUMERATE_INSTANCES_RESPONSE_MESSAGE);  
   
     // When Response received, get response message, get output parameters  
     // and return data  
     CIMOpenEnumerateInstancesResponseMessage* response =  
         (CIMOpenEnumerateInstancesResponseMessage*)message;  
   
     AutoPtr<CIMOpenEnumerateInstancesResponseMessage> destroyer(response);  
   
     // set endOfSequence and context return parameters  
     endOfSequence = response->endOfSequence;  
     enumerationContext.setContextString(response->enumerationContext);  
   
     return response->getResponseData();  
 }  
   
   
 CIMResponseData CIMClientRep::openEnumerateInstancePaths(  
     CIMEnumerationContext& enumerationContext,  
     Boolean& endOfSequence,  
     const CIMNamespaceName& nameSpace,  
     const CIMName& className,  
     const String& filterQueryLanguage,  
     const String& filterQuery,  
     const Uint32Arg& operationTimeout,  
     Boolean continueOnError,  
     Uint32 maxObjectCount)  
 {  
     AutoPtr<CIMRequestMessage> request(  
         new CIMOpenEnumerateInstancePathsRequestMessage(  
             String::EMPTY,                  // messageId_ param  
             nameSpace,  
             className,  
             filterQueryLanguage,  
             filterQuery,  
             operationTimeout,  
             continueOnError,  
             maxObjectCount,  
             QueueIdStack()));  
   
     enumerationContext.setNameSpace(nameSpace);  
     Message* message =  
         _doRequest(request, CIM_OPEN_ENUMERATE_INSTANCE_PATHS_RESPONSE_MESSAGE);  
   
     CIMOpenEnumerateInstancePathsResponseMessage* response =  
         (CIMOpenEnumerateInstancePathsResponseMessage*)message;  
   
     AutoPtr<CIMOpenEnumerateInstancePathsResponseMessage> destroyer(response);  
   
     // set paramters to be returned to caller  
     endOfSequence = response->endOfSequence;  
     enumerationContext.setContextString(response->enumerationContext);  
   
     return response->getResponseData();  
 }  
   
 CIMResponseData  CIMClientRep::openReferenceInstances(  
     CIMEnumerationContext& enumerationContext,  
     Boolean& endOfSequence,  
     const CIMNamespaceName& nameSpace,  
     const CIMObjectPath& objectName,  
     const CIMName& resultClass,  
     const String& role,  
     Boolean includeClassOrigin,  
     const CIMPropertyList& propertyList,  
     const String& filterQueryLanguage,  
     const String& filterQuery,  
     const Uint32Arg& operationTimeout,  
     Boolean continueOnError,  
     Uint32 maxObjectCount)  
 {  
     AutoPtr<CIMRequestMessage> request(  
         new CIMOpenReferenceInstancesRequestMessage(  
             String::EMPTY,                  // messageId_ param  
             nameSpace,  
             objectName,  
             resultClass,  
             role,  
             includeClassOrigin,  
             propertyList,  
             filterQueryLanguage,  
             filterQuery,  
             operationTimeout,  
             continueOnError,  
             maxObjectCount,  
             QueueIdStack()));  
   
     enumerationContext.setNameSpace(nameSpace);  
     Message* message =  
         _doRequest(request, CIM_OPEN_REFERENCE_INSTANCES_RESPONSE_MESSAGE);  
   
     CIMOpenReferenceInstancesResponseMessage* response =  
         (CIMOpenReferenceInstancesResponseMessage*)message;  
   
     AutoPtr<CIMOpenReferenceInstancesResponseMessage> destroyer(response);  
   
     // set paramters to be returned to caller  
     endOfSequence = response->endOfSequence;  
     enumerationContext.setContextString(response->enumerationContext);  
   
     return response->getResponseData();  
 }  
   
   
 CIMResponseData CIMClientRep::openReferenceInstancePaths(  
     CIMEnumerationContext& enumerationContext,  
     Boolean& endOfSequence,  
     const CIMNamespaceName& nameSpace,  
     const CIMObjectPath& objectName,  
     const CIMName& resultClass,  
     const String& role,  
     const String& filterQueryLanguage,  
     const String& filterQuery,  
     const Uint32Arg& operationTimeout,  
     Boolean continueOnError,  
     Uint32 maxObjectCount)  
 {  
     AutoPtr<CIMRequestMessage> request(  
         new CIMOpenReferenceInstancePathsRequestMessage(  
             String::EMPTY,                  // messageId_ param  
             nameSpace,  
             objectName,  
             resultClass,  
             role,  
             filterQueryLanguage,  
             filterQuery,  
             operationTimeout,  
             continueOnError,  
             maxObjectCount,  
             QueueIdStack()));  
   
     enumerationContext.setNameSpace(nameSpace);  
     Message* message =  
         _doRequest(request, CIM_OPEN_REFERENCE_INSTANCE_PATHS_RESPONSE_MESSAGE);  
   
     CIMOpenReferenceInstancePathsResponseMessage* response =  
         (CIMOpenReferenceInstancePathsResponseMessage*)message;  
   
     AutoPtr<CIMOpenReferenceInstancePathsResponseMessage> destroyer(response);  
   
     // set paramters to be returned to caller  
     endOfSequence = response->endOfSequence;  
     enumerationContext.setContextString(response->enumerationContext);  
   
     return response->getResponseData();  
 }  
   
 CIMResponseData CIMClientRep::openAssociatorInstances(  
     CIMEnumerationContext& enumerationContext,  
     Boolean& endOfSequence,  
     const CIMNamespaceName& nameSpace,  
     const CIMObjectPath& objectName,  
     const CIMName& assocClass,  
     const CIMName& resultClass,  
     const String& role,  
     const String& resultRole,  
     Boolean includeClassOrigin,  
     const CIMPropertyList& propertyList,  
     const String& filterQueryLanguage,  
     const String& filterQuery,  
     const Uint32Arg& operationTimeout,  
     Boolean continueOnError,  
     Uint32 maxObjectCount )  
 {  
     AutoPtr<CIMRequestMessage> request(  
         new CIMOpenAssociatorInstancesRequestMessage(  
             String::EMPTY,                  // messageId_ param  
             nameSpace,  
             objectName,  
             assocClass,  
             resultClass,  
             role,  
             resultRole,  
             includeClassOrigin,  
             propertyList,  
             filterQueryLanguage,  
             filterQuery,  
             operationTimeout,  
             continueOnError,  
             maxObjectCount,  
             QueueIdStack()));  
   
     enumerationContext.setNameSpace(nameSpace);  
   
     Message* message =  
         _doRequest(request, CIM_OPEN_ASSOCIATOR_INSTANCES_RESPONSE_MESSAGE);  
   
     CIMOpenAssociatorInstancesResponseMessage* response =  
         (CIMOpenAssociatorInstancesResponseMessage*)message;  
   
     AutoPtr<CIMOpenAssociatorInstancesResponseMessage> destroyer(response);  
   
     // set parameters to be returned to caller  
     endOfSequence = response->endOfSequence;  
     enumerationContext.setContextString(response->enumerationContext);  
   
     return response->getResponseData();  
 }  
   
 CIMResponseData CIMClientRep::openAssociatorInstancePaths(  
     CIMEnumerationContext& enumerationContext,  
     Boolean& endOfSequence,  
     const CIMNamespaceName& nameSpace,  
     const CIMObjectPath& objectName,  
     const CIMName& assocClass,  
     const CIMName& resultClass,  
     const String& role,  
     const String& resultRole,  
     const String& filterQueryLanguage,  
     const String& filterQuery,  
     const Uint32Arg& operationTimeout,  
     Boolean continueOnError,  
     Uint32 maxObjectCount)  
 {  
     AutoPtr<CIMRequestMessage> request(  
         new CIMOpenAssociatorInstancePathsRequestMessage(  
             String::EMPTY,                  // messageId_ param  
             nameSpace,  
             objectName,  
             assocClass,  
             resultClass,  
             role,  
             resultRole,  
             filterQueryLanguage,  
             filterQuery,  
             operationTimeout,  
             continueOnError,  
             maxObjectCount,  
             QueueIdStack()));  
   
     enumerationContext.setNameSpace(nameSpace);  
     Message* message =  
         _doRequest(request,  
                    CIM_OPEN_ASSOCIATOR_INSTANCE_PATHS_RESPONSE_MESSAGE);  
   
     CIMOpenAssociatorInstancePathsResponseMessage* response =  
         (CIMOpenAssociatorInstancePathsResponseMessage*)message;  
   
     AutoPtr<CIMOpenAssociatorInstancePathsResponseMessage> destroyer(response);  
   
     // set paramters to be returned to caller  
     endOfSequence = response->endOfSequence;  
     enumerationContext.setContextString(response->enumerationContext);  
   
     return response->getResponseData();  
 }  
   
 CIMResponseData CIMClientRep::pullInstancesWithPath(  
     CIMEnumerationContext& enumerationContext,  
     Boolean& endOfSequence,  
     Uint32 maxObjectCount)  
 {  
     AutoPtr<CIMRequestMessage> request(  
         new CIMPullInstancesWithPathRequestMessage(  
             String::EMPTY,                  // messageId_ param  
             enumerationContext.getNameSpace(),  
             enumerationContext.getContextString(),  
             maxObjectCount,  
             QueueIdStack() ));  
   
         Message* message =  
             _doRequest(request, CIM_PULL_INSTANCES_WITH_PATH_RESPONSE_MESSAGE);  
   
         CIMPullInstancesWithPathResponseMessage* response =  
             (CIMPullInstancesWithPathResponseMessage*)message;  
   
         AutoPtr<CIMPullInstancesWithPathResponseMessage> destroyer(response);  
   
         // set paramters to be returned to caller  
         endOfSequence = response->endOfSequence;  
         enumerationContext.setContextString(response->enumerationContext);  
   
         return response->getResponseData();  
 }  
   
 CIMResponseData CIMClientRep::pullInstancePaths(  
     CIMEnumerationContext& enumerationContext,  
     Boolean& endOfSequence,  
     Uint32 maxObjectCount)  
 {  
     AutoPtr<CIMRequestMessage> request(  
         new CIMPullInstancePathsRequestMessage(  
             String::EMPTY,                  // messageId_ param  
             enumerationContext.getNameSpace(),  
             enumerationContext.getContextString(),  
             maxObjectCount,  
             QueueIdStack()  
             ));  
   
         Message* message =  
             _doRequest(request, CIM_PULL_INSTANCE_PATHS_RESPONSE_MESSAGE);  
   
         CIMPullInstancePathsResponseMessage* response =  
             (CIMPullInstancePathsResponseMessage*)message;  
   
         AutoPtr<CIMPullInstancePathsResponseMessage> destroyer(response);  
   
         // set paramters to be returned to caller  
         endOfSequence = response->endOfSequence;  
         enumerationContext.setContextString(response->enumerationContext);  
   
         return response->getResponseData();  
 }  
   
 CIMResponseData CIMClientRep::pullInstances(  
     CIMEnumerationContext& enumerationContext,  
     Boolean& endOfSequence,  
     Uint32 maxObjectCount)  
 {  
     AutoPtr<CIMRequestMessage> request(  
         new CIMPullInstancesRequestMessage(  
             String::EMPTY,                  // messageId_ param  
             enumerationContext.getNameSpace(),  
             enumerationContext.getContextString(),  
             maxObjectCount,  
             QueueIdStack() ));  
   
         Message* message =  
             _doRequest(request, CIM_PULL_INSTANCES_RESPONSE_MESSAGE);  
   
         CIMPullInstancesResponseMessage* response =  
             (CIMPullInstancesResponseMessage*)message;  
   
         AutoPtr<CIMPullInstancesResponseMessage> destroyer(response);  
   
         // set paramters to be returned to caller  
         endOfSequence = response->endOfSequence;  
         enumerationContext.setContextString(response->enumerationContext);  
   
         return response->getResponseData();  
 }  
   
 void CIMClientRep::closeEnumeration(  
     CIMEnumerationContext& enumerationContext)  
 {  
     AutoPtr<CIMRequestMessage> request(  
         new CIMCloseEnumerationRequestMessage(  
             String::EMPTY,                  // messageId_ param  
             enumerationContext.getNameSpace(),  
             enumerationContext.getContextString(),  
             QueueIdStack()  
             ));  
   
         Message* message =  
             _doRequest(request, CIM_CLOSE_ENUMERATION_RESPONSE_MESSAGE);  
   
         CIMCloseEnumerationResponseMessage* response =  
             (CIMCloseEnumerationResponseMessage*)message;  
   
         AutoPtr<CIMCloseEnumerationResponseMessage> destroyer(response);  
   
         return;  
 }  
   
 Uint64Arg CIMClientRep::enumerationCount(  
     CIMEnumerationContext& enumerationContext)  
 {  
     if (enumerationContext.getContextString().size())  
     {  
         throw InvalidEnumerationContextException();  
     }  
     AutoPtr<CIMRequestMessage> request(  
         new CIMEnumerationCountRequestMessage(  
             String::EMPTY,                  // messageId_ param  
             enumerationContext.getNameSpace(),  
             enumerationContext.getContextString(),  
             QueueIdStack()  
             ));  
   
         Message* message =  
             _doRequest(request, CIM_ENUMERATION_COUNT_RESPONSE_MESSAGE);  
   
         CIMEnumerationCountResponseMessage* response =  
             (CIMEnumerationCountResponseMessage*)message;  
   
         AutoPtr<CIMEnumerationCountResponseMessage> destroyer(response);  
   
         return response->count ;  
 }  
   
 CIMResponseData CIMClientRep::openQueryInstances(  
     CIMEnumerationContext& enumerationContext,  
     Boolean& endOfSequence,  
     const CIMNamespaceName& nameSpace,  
     const String& queryLanguage,  
     const String& query,  
     CIMClass& queryResultClass,  
     Boolean returnQueryResultClass,  
     const Uint32Arg& operationTimeout,  
     Boolean continueOnError,  
     Uint32 maxObjectCount)  
 {  
     // Save requied information in enumerationContext  
     enumerationContext.setNameSpace(nameSpace);  
   
     // Create/send the request message  
     AutoPtr<CIMRequestMessage> request(  
         new CIMOpenQueryInstancesRequestMessage(  
             String::EMPTY,                  // messageId_ param  
             nameSpace,  
             queryLanguage,  
             query,  
             returnQueryResultClass,  
             operationTimeout,  
             continueOnError,  
             maxObjectCount,  
             QueueIdStack()));  
   
     Message* message =  
         _doRequest(request, CIM_OPEN_QUERY_INSTANCES_RESPONSE_MESSAGE);  
   
     // When Response received, get response message, get output parameters  
     // and return data  
     CIMOpenQueryInstancesResponseMessage* response =  
         (CIMOpenQueryInstancesResponseMessage*)message;  
   
     AutoPtr<CIMOpenQueryInstancesResponseMessage> destroyer(response);  
   
     // set endOfSequence and context return parameters  
     endOfSequence = response->endOfSequence;  
     enumerationContext.setContextString(response->enumerationContext);  
   
     return response->getResponseData();  
 }  
 //EXP_PULL_END  
   
 Message* CIMClientRep::_doRequest( Message* CIMClientRep::_doRequest(
     AutoPtr<CIMRequestMessage>& request,     AutoPtr<CIMRequestMessage>& request,
     MessageType expectedResponseMessageType)     MessageType expectedResponseMessageType)
Line 1533 
Line 1114 
             //             //
             if (response->getCloseConnect() == true)             if (response->getCloseConnect() == true)
             {             {
                 _disconnect(true);                  _disconnect();
                 _doReconnect = true;                 _doReconnect = true;
                 response->setCloseConnect(false);                 response->setCloseConnect(false);
             }             }
Line 1716 
Line 1297 
     perfDataStore.setClassRegistered(false);     perfDataStore.setClassRegistered(false);
 } }
  
   
 /*  
     Implementation of the Trace mechanism  
 */  
   
 // static variables to store the display state for input and output.  
 Uint32 ClientTrace::inputState;  
 Uint32 ClientTrace::outputState;  
   
 ClientTrace::TraceType ClientTrace::selectType(const String& str)  
 {  
     if (str == "con")  
     {  
         return TRACE_CON;  
     }  
     if (str == "log")  
     {  
         return TRACE_LOG;  
     }  
     if (str == "both")  
     {  
         return TRACE_BOTH;  
     }  
     return TRACE_NONE;  
 }  
   
 Boolean ClientTrace::displayOutput(TraceType tt)  
 {  
     return (tt & outputState);  
 }  
   
 Boolean ClientTrace::displayInput(TraceType tt)  
 {  
     return (tt & inputState);  
 }  
   
 // Set up the input and output state variables from the input  
 // environment variable.  
 void ClientTrace::setup()  
 {  
     String input;  
     if (char * envVar = getenv("PEGASUS_CLIENT_TRACE"))  
     {  
         input = envVar;  
         input.toLower();  
         String in;  
         String out;  
         Uint32 pos = input.find(':');  
   
         // if no colon found, input and output have same mask  
         if (pos == PEG_NOT_FOUND)  
         {  
             in = input;  
             out = input;  
         }  
         else  
         {  
             // if string starts with colon, input empty, else  
             // either both or output empty  
             if (input[0] == ':')  
             {  
                 in = "";  
                 out = input.subString(1);  
             }  
             else  
             {  
                 in = input.subString(0,pos);  
                 if (pos == (input.size() - 1))  
                 {  
                     out = "";  
                 }  
                 else  
                 {  
                     out =input.subString(pos + 1);  
                 }  
             }  
         }  
   
         // set the state variables  
         outputState = ClientTrace::selectType(out);  
         inputState = ClientTrace::selectType(in);  
   
         // Test for logging requested and if so set log parameters  
         if (((outputState| inputState) & TRACE_LOG) != 0)  
         {  
             Logger::setlogLevelMask("");  
         }  
     }  
 }  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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