[[xmlrpc-component]]
= XML RPC Component (deprecated)

*Available as of Camel version 2.11*


This component provides a dataformat for xml, which allows serialization
and deserialization of request messages and response message using
Apache XmlRpc's binary dataformat. You can also invoke the XMLRPC
Service through the camel-xmlrpc producer.

Maven users will need to add the following dependency to their `pom.xml`
for this component:

[source,xml]
------------------------------------------------------------
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-xmlrpc</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
------------------------------------------------------------

== XmlRpc Overview

It's a http://xmlrpc.scripting.com/spec[spec] and a set of
implementations that allow software running on disparate operating
systems, running in different environments to make procedure calls over
the Internet.

It's remote procedure calling using HTTP as the transport and XML as the
encoding. XML-RPC is designed to be as simple as possible, while
allowing complex data structures to be transmitted, processed and
returned.

An example of a typical XML-RPC request would be:

[source,java]
------------------------------------------------
<?xml version="1.0"?>
<methodCall>
  <methodName>examples.getStateName</methodName>
  <params>
    <param>
        <value><i4>40</i4></value>
    </param>
  </params>
</methodCall>
------------------------------------------------

An example of a typical XML-RPC response would be:

[source,java]
----------------------------------------------------
<?xml version="1.0"?>
<methodResponse>
  <params>
    <param>
        <value><string>South Dakota</string></value>
    </param>
  </params>
</methodResponse>
----------------------------------------------------

A typical XML-RPC fault would be:

[source,java]
--------------------------------------------------------------
<?xml version="1.0"?>
<methodResponse>
  <fault>
    <value>
      <struct>
        <member>
          <name>faultCode</name>
          <value><int>4</int></value>
        </member>
        <member>
          <name>faultString</name>
          <value><string>Too many parameters.</string></value>
        </member>
      </struct>
    </value>
  </fault>
</methodResponse>
--------------------------------------------------------------

== URI format

[source,java]
----------------------------
xmlrpc://serverUri[?options]
----------------------------

== Options


// component options: START
The XML RPC component has no options.
// component options: END



// endpoint options: START
The XML RPC endpoint is configured using URI syntax:

----
xmlrpc:address
----

with the following path and query parameters:

=== Path Parameters (1 parameters):


[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
| *address* | *Required* The server url |  | String
|===


=== Query Parameters (18 parameters):


[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
| *basicEncoding* (producer) | Sets the encoding for basic authentication, null means UTF-8 is chosen. |  | String
| *connectionTimeout* (producer) | Set the connection timeout in milliseconds, 0 is to disable it |  | int
| *contentLengthOptional* (producer) | Whether a Content-Length header may be omitted. The XML-RPC specification demands, that such a header be present. | false | boolean
| *defaultMethodName* (producer) | The method name which would be used for the xmlrpc requests by default, if the Message header CamelXmlRpcMethodName is not set. |  | String
| *enabledForExceptions* (producer) | Whether the response should contain a faultCause element in case of errors. The faultCause is an exception, which the server has trapped and written into a byte stream as a serializable object. | false | boolean
| *enabledForExtensions* (producer) | Whether extensions are enabled. By default, the client or server is strictly compliant to the XML-RPC specification and extensions are disabled. | false | boolean
| *encoding* (producer) | Sets the requests encoding, null means UTF-8 is chosen. |  | String
| *gzipCompressing* (producer) | Whether gzip compression is being used for transmitting the request. | false | boolean
| *gzipRequesting* (producer) | Whether gzip compression is being used for transmitting the request. | false | boolean
| *replyTimeout* (producer) | Set the reply timeout in milliseconds, 0 is to disable it. |  | int
| *clientConfig* (advanced) | To use the given XmlRpcClientConfigImpl as configuration for the client. |  | XmlRpcClientConfig Impl
| *clientConfigurer* (advanced) | To use a custom XmlRpcClientConfigurer to configure the client |  | XmlRpcClientConfigurer
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
| *timeZone* (advanced) | The timezone, which is used to interpret date/time. Defaults to TimeZone#getDefault(). |  | TimeZone
| *userAgent* (advanced) | The http user agent header to set when doing xmlrpc requests |  | String
| *xmlRpcServer* (advanced) | To use a custom XmlRpcRequestProcessor as server. |  | XmlRpcRequestProcessor
| *basicPassword* (security) | The password for basic authentication. |  | String
| *basicUserName* (security) | The user name for basic authentication. |  | String
|===
// endpoint options: END
// spring-boot-auto-configure options: START
== Spring Boot Auto-Configuration

When using Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel</groupId>
  <artifactId>camel-xmlrpc-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 5 options, which are listed below.



[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
| *camel.component.xmlrpc.enabled* | Enable xmlrpc component | true | Boolean
| *camel.component.xmlrpc.resolve-property-placeholders* | Whether the component should resolve property placeholders on itself when starting. Only properties which are of String type can use property placeholders. | true | Boolean
| *camel.dataformat.xmlrpc.content-type-header* | Whether the data format should set the Content-Type header with the type from the data format if the data format is capable of doing so. For example application/xml for data formats marshalling to XML, or application/json for data formats marshalling to JSon etc. | false | Boolean
| *camel.dataformat.xmlrpc.enabled* | Enable xmlrpc dataformat | true | Boolean
| *camel.dataformat.xmlrpc.request* | Whether to marshal/unmarshal request or response Is by default false | false | Boolean
|===
// spring-boot-auto-configure options: END



== Message Headers

Camel XmlRpc uses these headers.

[width="100%",cols="10%,90%",options="header",]
|=======================================================================
|Header |Description

|`CamelXmlRpcMethodName` |The XmlRpc method name which will be use for invoking the XmlRpc server.
|=======================================================================

== Using the XmlRpc data format

As the XmlRpc message could be request or response, when you use the
XmlRpcDataFormat, you need to specify the dataformat is for request or
not.

== Invoke XmlRpc Service from Client

To invoke the XmlRpc service, you need to specify the methodName on the
message header and put the parameters into the message body like below
code, then you can get the result message as you want. If the fault
message is return, you should get an exception which cause if
XmlRpcException.

[source,java]
-------------------------------------------------------------------------------------------------------------------------------------------------
   String response = template.requestBodyAndHeader(xmlRpcServiceAddress, new Object[]{"me"}, XmlRpcConstants.METHOD_NAME, "hello", String.class);
-------------------------------------------------------------------------------------------------------------------------------------------------

== How to configure the XmlRpcClient with Java code

camel-xmlrpc provides a pluggable strategy for configuring the
XmlRpcClient used by the component, user just to implement the
*XmlRpcClientConfigurer* interface and can configure the XmlRpcClient as
he wants. The clientConfigure instance reference can be set through the
uri option clientConfigure.
