XmlRpc::XmlRpcClient Class Reference

A class to send XML RPC requests to a server and return the results. More...

#include <XmlRpcClient.h>

Inheritance diagram for XmlRpc::XmlRpcClient:

Public Member Functions
	XmlRpcClient (const char *host, int port, const char *uri=0)
virtual	~XmlRpcClient ()
	Destructor.
bool	execute (const char *method, XmlRpcValue const &params, XmlRpcValue &result)
bool	isFault () const
	Returns true if the result of the last execute() was a fault response.
virtual void	close ()
	Close the connection.
virtual unsigned	handleEvent (unsigned eventType)
Public Member Functions inherited from XmlRpc::XmlRpcSource
	XmlRpcSource (int fd=-1, bool deleteOnClose=false)
virtual	~XmlRpcSource ()
	Destructor.
int	getfd () const
	Return the file descriptor being monitored.
void	setfd (int fd)
	Specify the file descriptor to monitor.
bool	getKeepOpen () const
	Return whether the file descriptor should be kept open if it is no longer monitored.
void	setKeepOpen (bool b=true)
	Specify whether the file descriptor should be kept open if it is no longer monitored.

Static Public Attributes
static const char	REQUEST_BEGIN []
static const char	REQUEST_END_METHODNAME [] = "</methodName>\r\n"
static const char	PARAMS_TAG [] = "<params>"
static const char	PARAMS_ETAG [] = "</params>"
static const char	PARAM_TAG [] = "<param>"
static const char	PARAM_ETAG [] = "</param>"
static const char	REQUEST_END [] = "</methodCall>\r\n"
static const char	METHODRESPONSE_TAG [] = "<methodResponse>"
static const char	FAULT_TAG [] = "<fault>"

Protected Types
enum	ClientConnectionState {   NO_CONNECTION , CONNECTING , WRITE_REQUEST , READ_HEADER ,   READ_RESPONSE , IDLE }

Protected Member Functions
virtual bool	doConnect ()
virtual bool	setupConnection ()
virtual bool	generateRequest (const char *method, XmlRpcValue const &params)
virtual std::string	generateHeader (std::string const &body)
virtual bool	writeRequest ()
virtual bool	readHeader ()
virtual bool	readResponse ()
virtual bool	parseResponse (XmlRpcValue &result)

Protected Attributes
ClientConnectionState	_connectionState
std::string	_host
std::string	_uri
int	_port
std::string	_request
std::string	_header
std::string	_response
int	_sendAttempts
int	_bytesWritten
bool	_executing
bool	_eof
bool	_isFault
int	_contentLength
XmlRpcDispatch	_disp

Detailed Description

A class to send XML RPC requests to a server and return the results.

Definition at line 24 of file XmlRpcClient.h.

Member Enumeration Documentation

ClientConnectionState

enum XmlRpc::XmlRpcClient::ClientConnectionState

protected

Enumerator
NO_CONNECTION
CONNECTING
WRITE_REQUEST
READ_HEADER
READ_RESPONSE
IDLE

Definition at line 84 of file XmlRpcClient.h.

                               {
      NO_CONNECTION,
      CONNECTING,
      WRITE_REQUEST,
      READ_HEADER,
      READ_RESPONSE,
      IDLE
    };

Constructor & Destructor Documentation

XmlRpcClient()

XmlRpcClient::XmlRpcClient	(	const char *	host,
		int	port,
		const char *	uri = 0 )

Construct a client to connect to the server at the specified host:port address

Parameters

host	The name of the remote machine hosting the server
port	The port on the remote machine where the server is listening
uri	An optional string to be sent as the URI in the HTTP GET header

Definition at line 27 of file XmlRpcClient.cpp.

                                                                          {
  XmlRpcUtil::log( 1, "XmlRpcClient new client: host %s, port %d.", host, port );
 
  _host = host;
  _port = port;
  if ( uri ) _uri = uri;
  else _uri = "/RPC2";
  _connectionState = NO_CONNECTION;
  _executing       = false;
  _eof             = false;
 
  // Default to keeping the connection open until an explicit close is done
  setKeepOpen();
}

~XmlRpcClient()

XmlRpcClient::~XmlRpcClient ( )

virtual

Destructor.

Definition at line 42 of file XmlRpcClient.cpp.

{}

Member Function Documentation

close()

void XmlRpcClient::close ( )

virtual

Close the connection.

Reimplemented from XmlRpc::XmlRpcSource.

Definition at line 45 of file XmlRpcClient.cpp.

                         {
  XmlRpcUtil::log( 4, "XmlRpcClient::close: fd %d.", getfd() );
  _connectionState = NO_CONNECTION;
  _disp.exit();
  _disp.removeSource( this );
  XmlRpcSource::close();
}

Referenced by doConnect(), and setupConnection().

doConnect()

bool XmlRpcClient::doConnect ( )

protectedvirtual

Definition at line 149 of file XmlRpcClient.cpp.

                             {
  int fd = XmlRpcSocket::socket();
  if ( fd < 0 )
  {
    XmlRpcUtil::error( "Error in XmlRpcClient::doConnect: Could not create socket (%s).",
                       XmlRpcSocket::getErrorMsg().c_str() );
    return false;
  }
 
  XmlRpcUtil::log( 3, "XmlRpcClient::doConnect: fd %d.", fd );
  this->setfd( fd );
 
  // Don't block on connect/reads/writes
  if ( !XmlRpcSocket::setNonBlocking( fd ) )
  {
    this->close();
    XmlRpcUtil::error(
        "Error in XmlRpcClient::doConnect: Could not set socket to non-blocking IO mode (%s).",
        XmlRpcSocket::getErrorMsg().c_str() );
    return false;
  }
 
  if ( !XmlRpcSocket::connect( fd, _host, _port ) )
  {
    this->close();
    XmlRpcUtil::error( "Error in XmlRpcClient::doConnect: Could not connect to server (%s).",
                       XmlRpcSocket::getErrorMsg().c_str() );
    return false;
  }
 
  return true;
}

Referenced by setupConnection().

execute()

bool XmlRpcClient::execute	(	const char *	method,
		XmlRpcValue const &	params,
		XmlRpcValue &	result )

Execute the named procedure on the remote server.

Parameters

method	The name of the remote procedure to execute
params	An array of the arguments for the method
result	The result value to be returned to the client

Returns

true if the request was sent and a result received (although the result might be a fault).

Currently this is a synchronous (blocking) implementation (execute does not return until it receives a response or an error). Use isFault() to determine whether the result is a fault response.

Definition at line 64 of file XmlRpcClient.cpp.

                                                  {
  XmlRpcUtil::log( 1, "XmlRpcClient::execute: method %s (_connectionState %d).", method,
                   _connectionState );
  // std::cout<< "_connectionState   "<<_connectionState << std::endl;//yzhang debug
  //  This is not a thread-safe operation, if you want to do multithreading, use separate
  //  clients for each thread. If you want to protect yourself from multiple threads
  //  accessing the same client, replace this code with a real mutex.
  if ( _executing ) return false;
 
  _executing = true;
  ClearFlagOnExit cf( _executing );
 
  _sendAttempts = 0;
  _isFault      = false;
 
  if ( !setupConnection() ) return false;
 
  if ( !generateRequest( method, params ) ) return false;
  result.clear();
  double msTime = 5.; // Process until exit is called //yzhang change
  // double msTime = -1.0;   // Process until exit is called //yzhang delete
  _disp.work( msTime );
 
  if ( _connectionState != IDLE ) // yzhang add
    // if (_connectionState != IDLE || ! parseResponse(result))//yzhang delete
    return false; // yzhang delete
 
  XmlRpcUtil::log( 1, "XmlRpcClient::execute: method %s completed.", method );
  _response = "";
  return true;
}

Referenced by getFnamesAtBkk(), main(), and JobInfoSvc::xmlrpc().

generateHeader()

std::string XmlRpcClient::generateHeader ( std::string const & body )

protectedvirtual

Definition at line 222 of file XmlRpcClient.cpp.

                                                              {
  std::string header = "POST " + _uri +
                       " HTTP/1.1\r\n"
                       "User-Agent: ";
  header += XMLRPC_VERSION;
  header += "\r\nHost: ";
  header += _host;
 
  char buff[40];
  sprintf( buff, ":%d\r\n", _port );
 
  header += buff;
  header += "Content-Type: text/xml\r\nContent-length: ";
 
  sprintf( buff, "%d\r\n\r\n", body.size() );
 
  return header + buff;
}

Referenced by generateRequest().

generateRequest()

bool XmlRpcClient::generateRequest ( const char * method, XmlRpcValue const & params )

protectedvirtual

Definition at line 183 of file XmlRpcClient.cpp.

                                                                                      {
  std::string body = REQUEST_BEGIN;
  body += methodName;
  body += REQUEST_END_METHODNAME;
 
  // If params is an array, each element is a separate parameter
  if ( params.valid() )
  {
    body += PARAMS_TAG;
    if ( params.getType() == XmlRpcValue::TypeArray )
    {
      for ( int i = 0; i < params.size(); ++i )
      {
        body += PARAM_TAG;
        body += params[i].toXml();
        body += PARAM_ETAG;
      }
    }
    else
    {
      body += PARAM_TAG;
      body += params.toXml();
      body += PARAM_ETAG;
    }
 
    body += PARAMS_ETAG;
  }
  body += REQUEST_END;
 
  std::string header = generateHeader( body );
  XmlRpcUtil::log( 4,
                   "XmlRpcClient::generateRequest: header is %d bytes, content-length is %d.",
                   header.length(), body.length() );
 
  _request = header + body;
  return true;
}

Referenced by execute().

handleEvent()

unsigned XmlRpcClient::handleEvent ( unsigned eventType )

virtual

Handle server responses. Called by the event dispatcher during execute.

Parameters

eventType

The type of event that occurred.

See also

XmlRpcDispatch::EventType

Implements XmlRpc::XmlRpcSource.

Definition at line 99 of file XmlRpcClient.cpp.

                                                       {
  if ( eventType == XmlRpcDispatch::Exception )
  {
    if ( _connectionState == WRITE_REQUEST && _bytesWritten == 0 )
      XmlRpcUtil::error(
          "Error in XmlRpcClient::handleEvent: could not connect to server (%s).",
          XmlRpcSocket::getErrorMsg().c_str() );
    else
      XmlRpcUtil::error( "Error in XmlRpcClient::handleEvent (state %d): %s.",
                         _connectionState, XmlRpcSocket::getErrorMsg().c_str() );
    return 0;
  }
 
  if ( _connectionState == WRITE_REQUEST )
    if ( !writeRequest() ) return 0;
 
  if ( _connectionState == READ_HEADER )
    if ( !readHeader() ) return 0;
 
  if ( _connectionState == READ_RESPONSE )
    if ( !readResponse() ) return 0;
 
  // This should probably always ask for Exception events too
  return ( _connectionState == WRITE_REQUEST ) ? XmlRpcDispatch::WritableEvent
                                               : XmlRpcDispatch::ReadableEvent;
}

isFault()

bool XmlRpc::XmlRpcClient::isFault ( ) const

inline

Returns true if the result of the last execute() was a fault response.

Definition at line 60 of file XmlRpcClient.h.

{ return _isFault; }

Referenced by getFnamesAtBkk(), and main().

parseResponse()

bool XmlRpcClient::parseResponse ( XmlRpcValue & result )

protectedvirtual

Definition at line 375 of file XmlRpcClient.cpp.

                                                      {
  // Parse response xml into result
  int offset = 0;
  if ( !XmlRpcUtil::findTag( METHODRESPONSE_TAG, _response, &offset ) )
  {
    XmlRpcUtil::error( "Error in XmlRpcClient::parseResponse: Invalid response - no "
                       "methodResponse. Response:\n%s",
                       _response.c_str() );
    return false;
  }
 
  // Expect either <params><param>... or <fault>...
  if ( ( XmlRpcUtil::nextTagIs( PARAMS_TAG, _response, &offset ) &&
         XmlRpcUtil::nextTagIs( PARAM_TAG, _response, &offset ) )
       // || XmlRpcUtil::nextTagIs(FAULT_TAG,_response,&offset) //yzhang delete
       && ( _isFault = true ) )
  {
    if ( !result.fromXml( _response, &offset ) )
    {
      XmlRpcUtil::error(
          "Error in XmlRpcClient::parseResponse: Invalid response value. Response:\n%s",
          _response.c_str() );
      _response = "";
      return false;
    }
  }
  else
  {
    XmlRpcUtil::error( "Error in XmlRpcClient::parseResponse: Invalid response - no param or "
                       "fault tag. Response:\n%s",
                       _response.c_str() );
    _response = "";
    return false;
  }
 
  _response = "";
  return result.valid();
}

readHeader()

bool XmlRpcClient::readHeader ( )

protectedvirtual

Definition at line 268 of file XmlRpcClient.cpp.

                              {
  // Read available data
  if ( !XmlRpcSocket::nbRead( this->getfd(), _header, &_eof ) ||
       ( _eof && _header.length() == 0 ) )
  {
 
    // If we haven't read any data yet and this is a keep-alive connection, the server may
    // have timed out, so we try one more time.
    if ( getKeepOpen() && _header.length() == 0 && _sendAttempts++ == 0 )
    {
      XmlRpcUtil::log( 4, "XmlRpcClient::readHeader: re-trying connection" );
      XmlRpcSource::close();
      _connectionState = NO_CONNECTION;
      _eof             = false;
      return setupConnection();
    }
 
    XmlRpcUtil::error(
        "Error in XmlRpcClient::readHeader: error while reading header (%s) on fd %d.",
        XmlRpcSocket::getErrorMsg().c_str(), getfd() );
    return false;
  }
 
  XmlRpcUtil::log( 4, "XmlRpcClient::readHeader: client has read %d bytes", _header.length() );
 
  char* hp = (char*)_header.c_str(); // Start of header
  char* ep = hp + _header.length();  // End of string
  char* bp = 0;                      // Start of body
  char* lp = 0;                      // Start of content-length value
 
  for ( char* cp = hp; ( bp == 0 ) && ( cp < ep ); ++cp )
  {
    if ( ( ep - cp > 16 ) && ( strncasecmp( cp, "Content-length: ", 16 ) == 0 ) ) lp = cp + 16;
    else if ( ( ep - cp > 4 ) && ( strncmp( cp, "\r\n\r\n", 4 ) == 0 ) ) bp = cp + 4;
    else if ( ( ep - cp > 2 ) && ( strncmp( cp, "\n\n", 2 ) == 0 ) ) bp = cp + 2;
  }
 
  // If we haven't gotten the entire header yet, return (keep reading)
  if ( bp == 0 )
  {
    if ( _eof ) // EOF in the middle of a response is an error
    {
      XmlRpcUtil::error( "Error in XmlRpcClient::readHeader: EOF while reading header" );
      return false; // Close the connection
    }
 
    return true; // Keep reading
  }
 
  // Decode content length
  if ( lp == 0 )
  {
    XmlRpcUtil::error( "Error XmlRpcClient::readHeader: No Content-length specified" );
    return false; // We could try to figure it out by parsing as we read, but for now...
  }
 
  _contentLength = atoi( lp );
  if ( _contentLength <= 0 )
  {
    XmlRpcUtil::error(
        "Error in XmlRpcClient::readHeader: Invalid Content-length specified (%d).",
        _contentLength );
    return false;
  }
 
  XmlRpcUtil::log( 4, "client read content length: %d", _contentLength );
 
  // Otherwise copy non-header data to response buffer and set state to read response.
  _response = bp;
  _header   = ""; // should parse out any interesting bits from the header (connection, etc)...
  _connectionState = READ_RESPONSE;
  return true; // Continue monitoring this source
}

Referenced by handleEvent().

readResponse()

bool XmlRpcClient::readResponse ( )

protectedvirtual

Definition at line 342 of file XmlRpcClient.cpp.

                                {
  // If we dont have the entire response yet, read available data
  if ( int( _response.length() ) < _contentLength )
  {
    if ( !XmlRpcSocket::nbRead( this->getfd(), _response, &_eof ) )
    {
      XmlRpcUtil::error( "Error in XmlRpcClient::readResponse: read error (%s).",
                         XmlRpcSocket::getErrorMsg().c_str() );
      return false;
    }
 
    // If we haven't gotten the entire _response yet, return (keep reading)
    if ( int( _response.length() ) < _contentLength )
    {
      if ( _eof )
      {
        XmlRpcUtil::error( "Error in XmlRpcClient::readResponse: EOF while reading response" );
        return false;
      }
      return true;
    }
  }
 
  // Otherwise, parse and return the result
  XmlRpcUtil::log( 3, "XmlRpcClient::readResponse (read %d bytes)", _response.length() );
  XmlRpcUtil::log( 5, "response:\n%s", _response.c_str() );
 
  _connectionState = IDLE;
 
  return false; // Stop monitoring this source (causes return from work)
}

Referenced by handleEvent().

setupConnection()

bool XmlRpcClient::setupConnection ( )

protectedvirtual

Definition at line 127 of file XmlRpcClient.cpp.

                                   {
  // If an error occurred last time through, or if the server closed the connection, close our
  // end
  if ( ( _connectionState != NO_CONNECTION && _connectionState != IDLE ) || _eof ) close();
 
  _eof = false;
  if ( _connectionState == NO_CONNECTION )
    if ( !doConnect() ) return false;
 
  // Prepare to write the request
  _connectionState = WRITE_REQUEST;
  _bytesWritten    = 0;
 
  // Notify the dispatcher to listen on this source (calls handleEvent when the socket is
  // writable)
  _disp.removeSource( this ); // Make sure nothing is left over
  _disp.addSource( this, XmlRpcDispatch::WritableEvent | XmlRpcDispatch::Exception );
 
  return true;
}

Referenced by execute(), and readHeader().

writeRequest()

bool XmlRpcClient::writeRequest ( )

protectedvirtual

Definition at line 241 of file XmlRpcClient.cpp.

                                {
  if ( _bytesWritten == 0 )
    XmlRpcUtil::log( 5, "XmlRpcClient::writeRequest (attempt %d):\n%s\n", _sendAttempts + 1,
                     _request.c_str() );
 
  // Try to write the request
  if ( !XmlRpcSocket::nbWrite( this->getfd(), _request, &_bytesWritten ) )
  {
    XmlRpcUtil::error( "Error in XmlRpcClient::writeRequest: write error (%s).",
                       XmlRpcSocket::getErrorMsg().c_str() );
    return false;
  }
 
  XmlRpcUtil::log( 3, "XmlRpcClient::writeRequest: wrote %d of %d bytes.", _bytesWritten,
                   _request.length() );
 
  // Wait for the result
  if ( _bytesWritten == int( _request.length() ) )
  {
    _header          = "";
    _response        = "";
    _connectionState = READ_HEADER;
  }
  return true;
}

Referenced by handleEvent().

Member Data Documentation

_bytesWritten

int XmlRpc::XmlRpcClient::_bytesWritten

protected

Definition at line 108 of file XmlRpcClient.h.

Referenced by handleEvent(), setupConnection(), and writeRequest().

_connectionState

ClientConnectionState XmlRpc::XmlRpcClient::_connectionState

protected

Definition at line 92 of file XmlRpcClient.h.

Referenced by close(), execute(), handleEvent(), readHeader(), readResponse(), setupConnection(), writeRequest(), and XmlRpcClient().

_contentLength

int XmlRpc::XmlRpcClient::_contentLength

protected

Definition at line 121 of file XmlRpcClient.h.

Referenced by readHeader(), and readResponse().

_disp

XmlRpcDispatch XmlRpc::XmlRpcClient::_disp

protected

Definition at line 124 of file XmlRpcClient.h.

Referenced by close(), execute(), and setupConnection().

_eof

bool XmlRpc::XmlRpcClient::_eof

protected

Definition at line 115 of file XmlRpcClient.h.

Referenced by readHeader(), readResponse(), setupConnection(), and XmlRpcClient().

_executing

bool XmlRpc::XmlRpcClient::_executing

protected

Definition at line 112 of file XmlRpcClient.h.

Referenced by execute(), and XmlRpcClient().

_header

std::string XmlRpc::XmlRpcClient::_header

protected

Definition at line 101 of file XmlRpcClient.h.

Referenced by readHeader(), and writeRequest().

_host

std::string XmlRpc::XmlRpcClient::_host

protected

Definition at line 95 of file XmlRpcClient.h.

Referenced by doConnect(), generateHeader(), and XmlRpcClient().

_isFault

bool XmlRpc::XmlRpcClient::_isFault

protected

Definition at line 118 of file XmlRpcClient.h.

Referenced by execute(), isFault(), and parseResponse().

_port

int XmlRpc::XmlRpcClient::_port

protected

Definition at line 97 of file XmlRpcClient.h.

Referenced by doConnect(), generateHeader(), and XmlRpcClient().

_request

std::string XmlRpc::XmlRpcClient::_request

protected

Definition at line 100 of file XmlRpcClient.h.

Referenced by generateRequest(), and writeRequest().

_response

std::string XmlRpc::XmlRpcClient::_response

protected

Definition at line 102 of file XmlRpcClient.h.

Referenced by execute(), parseResponse(), readHeader(), readResponse(), and writeRequest().

_sendAttempts

int XmlRpc::XmlRpcClient::_sendAttempts

protected

Definition at line 105 of file XmlRpcClient.h.

Referenced by execute(), readHeader(), and writeRequest().

_uri

std::string XmlRpc::XmlRpcClient::_uri

protected

Definition at line 96 of file XmlRpcClient.h.

Referenced by generateHeader(), and XmlRpcClient().

FAULT_TAG

const char XmlRpcClient::FAULT_TAG = "<fault>"

static

Definition at line 36 of file XmlRpcClient.h.

METHODRESPONSE_TAG

const char XmlRpcClient::METHODRESPONSE_TAG = "<methodResponse>"

static

Definition at line 35 of file XmlRpcClient.h.

Referenced by parseResponse().

PARAM_ETAG

const char XmlRpcClient::PARAM_ETAG = "</param>"

static

Definition at line 32 of file XmlRpcClient.h.

Referenced by generateRequest().

PARAM_TAG

const char XmlRpcClient::PARAM_TAG = "<param>"

static

Definition at line 31 of file XmlRpcClient.h.

Referenced by generateRequest(), and parseResponse().

PARAMS_ETAG

const char XmlRpcClient::PARAMS_ETAG = "</params>"

static

Definition at line 30 of file XmlRpcClient.h.

Referenced by generateRequest().

PARAMS_TAG

const char XmlRpcClient::PARAMS_TAG = "<params>"

static

Definition at line 29 of file XmlRpcClient.h.

Referenced by generateRequest(), and parseResponse().

REQUEST_BEGIN

const char XmlRpcClient::REQUEST_BEGIN

static

Initial value:

= "<?xml version=\"1.0\"?>\r\n"
    "<methodCall><methodName>"

Definition at line 27 of file XmlRpcClient.h.

Referenced by generateRequest().

REQUEST_END

const char XmlRpcClient::REQUEST_END = "</methodCall>\r\n"

static

Definition at line 33 of file XmlRpcClient.h.

Referenced by generateRequest().

REQUEST_END_METHODNAME

const char XmlRpcClient::REQUEST_END_METHODNAME = "</methodName>\r\n"

static

Definition at line 28 of file XmlRpcClient.h.

Referenced by generateRequest().

---

The documentation for this class was generated from the following files:

• XmlRpcClient.h
• XmlRpcClient.cpp