xmlrpc

README

Overview

xmlrpc is an implementation of client side part of XMLRPC protocol in Go language.

Status

This project is in minimal maintenance mode with no further development. Bug fixes are accepted, but it might take some time until they will be merged.

Installation

To install xmlrpc package run go get github.com/kolo/xmlrpc. To use it in application add "github.com/kolo/xmlrpc" string to import statement.

Usage

client, _ := xmlrpc.NewClient("https://bugzilla.mozilla.org/xmlrpc.cgi", nil)
result := struct{
  Version string `xmlrpc:"version"`
}{}
client.Call("Bugzilla.version", nil, &result)
fmt.Printf("Version: %s\n", result.Version) // Version: 4.2.7+

Second argument of NewClient function is an object that implements http.RoundTripper interface, it can be used to get more control over connection options. By default it initialized by http.DefaultTransport object.

Arguments encoding

xmlrpc package supports encoding of native Go data types to method arguments.

Data types encoding rules:

• int, int8, int16, int32, int64 encoded to int;
• float32, float64 encoded to double;
• bool encoded to boolean;
• string encoded to string;
• time.Time encoded to datetime.iso8601;
• xmlrpc.Base64 encoded to base64;
• slice encoded to array;

Structs encoded to struct by following rules:

• all public field become struct members;
• field name become member name;
• if field has xmlrpc tag, its value become member name.
• for fields tagged with ",omitempty", empty values are omitted;

Server method can accept few arguments, to handle this case there is special approach to handle slice of empty interfaces ([]interface{}). Each value of such slice encoded as separate argument.

Result decoding

Result of remote function is decoded to native Go data type.

Data types decoding rules:

• int, i4 decoded to int, int8, int16, int32, int64;
• double decoded to float32, float64;
• boolean decoded to bool;
• string decoded to string;
• array decoded to slice;
• structs decoded following the rules described in previous section;
• datetime.iso8601 decoded as time.Time data type;
• base64 decoded to string.

Implementation details

xmlrpc package contains clientCodec type, that implements rpc.ClientCodec interface of net/rpc package.

xmlrpc package works over HTTP protocol, but some internal functions and data type were made public to make it easier to create another implementation of xmlrpc that works over another protocol. To encode request body there is EncodeMethodCall function. To decode server response Response data type can be used.

Contribution

See project status.

Authors

Dmitry Maksimov (dmtmax@gmail.com)

Documentation

Index

• Variables
• func EncodeMethodCall(method string, args ...interface{}) ([]byte, error)
• func NewRequest(url string, method string, args interface{}) (*http.Request, error)
• type Base64
• type Client
  • func NewClient(requrl string, transport http.RoundTripper) (*Client, error)
  • func (c Client) Multicall(calls []MulticallArg, outs ...interface{}) error
• type FaultError
  • func (e FaultError) Error() string
• type MulticallArg
  • func NewMulticallArg(method string, args interface{}) MulticallArg
• type MulticallFault
  • func (m MulticallFault) Error() string
• type Response
  • func (r Response) Err() error
  • func (r Response) Unmarshal(v interface{}) error
• type TypeMismatchError
  • func (e TypeMismatchError) Error() string

Variables

var (
	// CharsetReader is a function to generate reader which converts a non UTF-8
	// charset into UTF-8.
	CharsetReader func(string, io.Reader) (io.Reader, error)
)

Functions

func EncodeMethodCall

func EncodeMethodCall(method string, args ...interface{}) ([]byte, error)

func NewRequest

func NewRequest(url string, method string, args interface{}) (*http.Request, error)

Types

type Base64

type Base64 string

Base64 represents value in base64 encoding

type Client

type Client struct {
	*rpc.Client
}

func NewClient

func NewClient(requrl string, transport http.RoundTripper) (*Client, error)

NewClient returns instance of rpc.Client object, that is used to send request to xmlrpc service.

func (Client) Multicall

func (c Client) Multicall(calls []MulticallArg, outs ...interface{}) error

Multicall performs a multicall request. `calls` should be constructed with `NewMulticallArg` and `outs` must be a slice of pointers. If the response contains at least one fault, the first is returned as a `MulticallFault` error.

type FaultError

type FaultError struct {
	Code   int    `xmlrpc:"faultCode"`
	String string `xmlrpc:"faultString"`
}

FaultError is returned from the server when an invalid call is made

func (FaultError) Error

func (e FaultError) Error() string

Error implements the error interface

type MulticallArg

type MulticallArg struct {
	MethodName string        `xmlrpc:"methodName"`
	Params     []interface{} `xmlrpc:"params"` // 1-sized list containing the real arguments
}

MulticallArg stores one call

func NewMulticallArg

func NewMulticallArg(method string, args interface{}) MulticallArg

type MulticallFault

type MulticallFault struct {
	FaultError
	Index int // 0 based
	// contains filtered or unexported fields
}

MulticallFault tracks the position of the fault.

func (MulticallFault) Error

func (m MulticallFault) Error() string

type Response

type Response []byte

func (Response) Err

func (r Response) Err() error

func (Response) Unmarshal

func (r Response) Unmarshal(v interface{}) error

type TypeMismatchError

type TypeMismatchError string

func (TypeMismatchError) Error

func (e TypeMismatchError) Error() string