~ubuntu-branches/ubuntu/quantal/aria2/quantal

:man version: 1.11.1

   '#rpc', '#experimental', '#all'

  The format of PROXY is [\\http://][USER:PASSWORD@]HOST[:PORT].

  See also *<<_environment, ENVIRONMENT>>* section.

  See also *<<aria2_optref_retry_wait, --retry-wait>>*.

[[aria2_optref_retry_wait]]*--retry-wait*=SEC::

 

  Set the seconds to wait between retries. With SEC > 0, aria2 will

  retry download when the HTTP server returns 503 response. Default:

  '0'

 

  Print file listing of .torrent, .meta4 and .metalink file and exit.

  If 'true' or 'mem' is specified, when a file whose suffix is ".meta4" or ".metalink" or content

  type of "application/metalink4+xml" or "application/metalink+xml" is downloaded, aria2 parses it as a metalink

  The file path to .meta4 and .metalink file. Reads input from stdin when '-' is

RPC Options

~~~~~~~~~~~

 

[[aria2_optref_enable_rpc]]*--enable-rpc*[='true'|'false']::

  Enable JSON-RPC/XML-RPC server.  It is strongly recommended to set username

  and password using *<<aria2_optref_rpc_user, --rpc-user>>* and *<<aria2_optref_rpc_passwd, --rpc-passwd>>*

  option. See also *<<aria2_optref_rpc_listen_port, --rpc-listen-port>>* option.  Default: 'false'

 

[[aria2_optref_rpc_listen_all]]*--rpc-listen-all*[='true'|'false']::

 

  Listen incoming JSON-RPC/XML-RPC requests on all network interfaces. If false

[[aria2_optref_rpc_listen_port]]*--rpc-listen-port*=PORT::

  Specify a port number for JSON-RPC/XML-RPC server to listen to.  Possible

[[aria2_optref_rpc_max_request_size]]*--rpc-max-request-size*=SIZE::

  Set max size of JSON-RPC/XML-RPC request. If aria2 detects the request is

[[aria2_optref_rpc_passwd]]*--rpc-passwd*=PASSWD::

  Set JSON-RPC/XML-RPC password.

[[aria2_optref_rpc_user]]*--rpc-user*=USER::

  Set JSON-RPC/XML-RPC user.

[[aria2_optref_async_dns_server]]*--async-dns-server*=IPADDRESS[,...]::

 

  Comma separated list of DNS server address used in asynchronous DNS

  resolver. Usually asynchronous DNS resolver reads DNS server

  addresses from '/etc/resolv.conf'. When this option is used, it uses

  DNS servers specified in this option instead of ones in

  '/etc/resolv.conf'. You can specify both IPv4 and IPv6 address. This

  option is useful when the system does not have '/etc/resolv.conf' and

  user does not have the permission to create it.

 

  filename part in URI if *<<aria2_optref_out, --out>>* is not specified.

  To overwrite existing file, *<<aria2_optref_allow_overwrite, --allow-overwrite>>* is required.

  Default: 'false'

[[aria2_optref_show_console_readout]]*--show-console-readout*[='true'|'false']::

 

  Show console readout. Default: 'true'

 

  downloads added by *<<aria2_rpc_aria2_addTorrent, aria2.addTorrent>>* and

  *<<aria2_rpc_aria2_addMetalink, aria2.addMetalink>>*

  RPC method and whose metadata could not be saved as a file are not saved.

*<<aria2_rpc_aria2_getFiles, aria2.getFiles>>*

RPC method.

If you want to get all file paths, consider to use JSON-RPC/XML-RPC.  Please

*29*::

 

  If the remote server was unable to handle the request due to a

  temporary overloading or maintenance.

 

*30*::

 

  If aria2 could not parse JSON-RPC request.

 

[NOTE]

 

Although aria2 accepts ftp:// and https:// scheme in proxy URI, it

simply assumes that http:// is specified and does not change its

behavior based on the specified scheme.

 

* *<<aria2_optref_retry_wait, retry-wait>>*

RPC INTERFACE

-------------

 

aria2 provides both JSON-RPC and XML-RPC and they basically have the

same functionality.

 

The request path of JSON-RPC interface is '/jsonrpc'.

The request path of XML-RPC interface is '/rpc'.

 

The implemented JSON-RPC is based on http://groups.google.com/group/json-rpc/web/json-rpc-2-0[JSON-RPC 2.0 Specification (2010-03-26)] and supports HTTP POST and GET (JSONP).

 

The JSON-RPC interface does not support notification. It also

does not support floating point number. The character encoding must be

UTF-8.

 

When reading following document for JSON-RPC, interpret struct as JSON

object.

[[aria2_rpc_aria2_addUri]]

members are a pair of option name and value. See *<<aria2_rpc_options, Options>>* below for

JSON-RPC Example

++++++++++++++++

 

The following example adds \http://example.org/file to aria2:

 

------------------------------------------------------------------

>>> import urllib2, json

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.addUri',

...                       'params':[['http://example.org/file']]})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> c.read()

'{"id":"qwer","jsonrpc":"2.0","result":"1"}'

------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

>>> s.aria2.addUri(['http://example.org/file', 'http://mirror/file'],

                    dict(dir="/tmp"))

[[aria2_rpc_aria2_addTorrent]]

you want to add BitTorrent Magnet URI, use *<<aria2_rpc_aria2_addUri, aria2.addUri>>* method

and value. See *<<aria2_rpc_options, Options>>* below for more details.  If 'position' is

The uploaded data is saved as a file named hex string of SHA-1 hash of data

plus ".torrent" in the directory specified by *<<aria2_optref_dir, --dir>>*

option.

The example of filename is 0a3893293e27ac0490424c06de4d09242215f0a6.torrent.

If same file already exists, it is overwritten.

If the file cannot be saved successfully,

the downloads added by this method are not saved by

JSON-RPC Example

++++++++++++++++

 

The following example adds local file file.torrent to aria2:

 

---------------------------------------------------------------------------

>>> import urllib2, json, base64

>>> torrent = base64.b64encode(open('file.torrent').read())

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'asdf',

...                       'method':'aria2.addTorrent', 'params':[torrent]})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> c.read()

'{"id":"asdf","jsonrpc":"2.0","result":"6"}'

---------------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

[[aria2_rpc_aria2_addMetalink]]

option name and value. See *<<aria2_rpc_options, Options>>* below for more details.  If

registered download.

The uploaded data is saved as a file named hex string of SHA-1 hash of data

plus ".metalink" in the directory specified by *<<aria2_optref_dir, --dir>>*

option.

The example of filename is 0a3893293e27ac0490424c06de4d09242215f0a6.metalink.

If same file already exists, it is overwritten.

If the file cannot be saved successfully,

the downloads added by this method are not saved by

*<<aria2_optref_save_session, --save-session>>*.

 

JSON-RPC Example

++++++++++++++++

 

The following example adds local file file.meta4 to aria2:

 

-----------------------------------------------------------------------------

>>> import urllib2, json, base64

>>> metalink = base64.b64encode(open('file.meta4').read())

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.addMetalink', 'params':[metalink]})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> c.read()

'{"id":"qwer","jsonrpc":"2.0","result":["8"]}'

-----------------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

[[aria2_rpc_aria2_remove]]

JSON-RPC Example

++++++++++++++++

 

The following example removes download whose GID is "3":

 

-----------------------------------------------------------------------------

>>> import urllib2, json

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.remove', 'params':['3']})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> c.read()

'{"id":"qwer","jsonrpc":"2.0","result":"3"}'

-----------------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

[[aria2_rpc_aria2_forceRemove]]

behaves just like *<<aria2_rpc_aria2_remove, aria2.remove>>* except that this method removes

[[aria2_rpc_aria2_pause]]

started.  To change status to "waiting", use *<<aria2_rpc_aria2_unpause, aria2.unpause>>* method.

[[aria2_rpc_aria2_pauseAll]]

This method is equal to calling *<<aria2_rpc_aria2_pause, aria2.pause>>* for every active/waiting

[[aria2_rpc_aria2_forcePause]]

behaves just like *<<aria2_rpc_aria2_pause, aria2.pause>>* except that this method pauses

[[aria2_rpc_aria2_forcePauseAll]]

This method is equal to calling *<<aria2_rpc_aria2_forcePause, aria2.forcePause>>* for every

[[aria2_rpc_aria2_unpause]]

[[aria2_rpc_aria2_unpauseAll]]

This method is equal to calling *<<aria2_rpc_aria2_unpause, aria2.unpause>>* for every active/waiting

[[aria2_rpc_aria2_tellStatus]]

transfers. For example, *<<aria2_rpc_aria2_tellStatus, aria2.tellStatus>>*("1", ["gid", "status"])

  used in *<<aria2_rpc_aria2_getFiles, aria2.getFiles>>* method.

JSON-RPC Example

++++++++++++++++

 

The following example gets information about download whose GID is

"1":

 

---------------------------------------------------------------------------

>>> import urllib2, json

>>> from pprint import pprint

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.tellStatus', 'params':['1']})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer',

 u'jsonrpc': u'2.0',

 u'result': {u'bitfield': u'0000000000',

             u'completedLength': u'901120',

             u'connections': u'1',

             u'dir': u'/downloads',

             u'downloadSpeed': u'15158',

             u'files': [{u'index': u'1',

                         u'length': u'34896138',

                         u'path': u'/downloads/file',

                         u'selected': u'true',

                         u'uris': [{u'status': u'used',

                                    u'uri': u'http://example.org/file'}]}],

             u'gid': u'1',

             u'numPieces': u'34',

             u'pieceLength': u'1048576',

             u'status': u'active',

             u'totalLength': u'34896138',

             u'uploadLength': u'0',

             u'uploadSpeed': u'0'}}

---------------------------------------------------------------------------

 

The following example gets information specifying keys you are

interested in:

 

--------------------------------------------------------------------------

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.tellStatus',

...                       'params':['1', ['gid',

...                                       'totalLength',

...                                       'completedLength']]})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer',

 u'jsonrpc': u'2.0',

 u'result': {u'completedLength': u'5701632',

             u'gid': u'1',

             u'totalLength': u'34896138'}}

--------------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

[[aria2_rpc_aria2_getUris]]

JSON-RPC Example

++++++++++++++++

 

--------------------------------------------------------------------

>>> import urllib2, json

>>> from pprint import pprint

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.getUris', 'params':['1']})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer',

 u'jsonrpc': u'2.0',

 u'result': [{u'status': u'used',

              u'uri': u'http://example.org/file'}]}

--------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

[[aria2_rpc_aria2_getFiles]]

  same struct used in *<<aria2_rpc_aria2_getUris, aria2.getUris>>* method.

 

JSON-RPC Example

++++++++++++++++

 

---------------------------------------------------------------------

>>> import urllib2, json

>>> from pprint import pprint

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.getFiles', 'params':['1']})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer',

 u'jsonrpc': u'2.0',

 u'result': [{u'index': u'1',

              u'length': u'34896138',

              u'path': u'/downloads/file',

              u'selected': u'true',

              u'uris': [{u'status': u'used',

                         u'uri': u'http://example.org/file'}]}]}

---------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

[[aria2_rpc_aria2_getPeers]]

JSON-RPC Example

++++++++++++++++

 

-----------------------------------------------------------------------

>>> import urllib2, json

>>> from pprint import pprint

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.getPeers', 'params':['1']})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer',

 u'jsonrpc': u'2.0',

 u'result': [{u'amChoking': u'true',

              u'bitfield': u'ffffffffffffffffffffffffffffffffffffffff',

              u'downloadSpeed': u'10602',

              u'ip': u'10.0.0.9',

              u'peerChoking': u'false',

              u'peerId': u'aria2%2F1%2E10%2E5%2D%87%2A%EDz%2F%F7%E6',

              u'port': u'6881',

              u'seeder': u'true',

              u'uploadSpeed': u'0'},

             {u'amChoking': u'false',

              u'bitfield': u'ffffeff0fffffffbfffffff9fffffcfff7f4ffff',

              u'downloadSpeed': u'8654',

              u'ip': u'10.0.0.30',

              u'peerChoking': u'false',

              u'peerId': u'bittorrent client758',

              u'port': u'37842',

              u'seeder': u'false',

              u'uploadSpeed': u'6890'}]}

-----------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

[[aria2_rpc_aria2_getServers]]

JSON-RPC Example

++++++++++++++++

 

-----------------------------------------------------------------------

>>> import urllib2, json

>>> from pprint import pprint

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.getServers', 'params':['1']})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer',

 u'jsonrpc': u'2.0',

 u'result': [{u'index': u'1',

              u'servers': [{u'currentUri': u'http://example.org/file',

                            u'downloadSpeed': u'10467',

                            u'uri': u'http://example.org/file'}]}]}

-----------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

[[aria2_rpc_aria2_tellActive]]

*<<aria2_rpc_aria2_tellStatus, aria2.tellStatus>>* method. For 'keys' parameter, please refer to

*<<aria2_rpc_aria2_tellStatus, aria2.tellStatus>>* method.

[[aria2_rpc_aria2_tellWaiting]]

parameter, please refer to *<<aria2_rpc_aria2_tellStatus, aria2.tellStatus>>* method.

returned by *<<aria2_rpc_aria2_tellStatus, aria2.tellStatus>>* method.

[[aria2_rpc_aria2_tellStopped]]

For 'keys' parameter, please refer to *<<aria2_rpc_aria2_tellStatus, aria2.tellStatus>>* method.

'offset' and 'num' have the same semantics as *<<aria2_rpc_aria2_tellWaiting, aria2.tellWaiting>>*

returned by *<<aria2_rpc_aria2_tellStatus, aria2.tellStatus>>* method.

[[aria2_rpc_aria2_changePosition]]

JSON-RPC Example

++++++++++++++++

 

The following example moves the download whose GID is "3" to the

front of the waiting queue:

 

-----------------------------------------------------------------

>>> import urllib2, json

>>> from pprint import pprint

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.changePosition',

...                       'params':['3', 0, 'POS_SET']})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer', u'jsonrpc': u'2.0', u'result': 0}

-----------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

[[aria2_rpc_aria2_changeUri]]

JSON-RPC Example

++++++++++++++++

 

The following example adds 1 URI \http://example.org/file to the file

whose index is "1" and belongs to the download whose GID is "2":

 

------------------------------------------------------------------------------

>>> import urllib2, json

>>> from pprint import pprint

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.changeUri',

...                       'params':['2', 1, [], ['http://example.org/file']]})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer', u'jsonrpc': u'2.0', u'result': [0, 1]}

------------------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

[[aria2_rpc_aria2_getOption]]

JSON-RPC Example

++++++++++++++++

 

The following example gets options of the download whose GID is "1":

 

----------------------------------------------------------------------

>>> import urllib2, json

>>> from pprint import pprint

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.getOption', 'params':['1']})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer',

 u'jsonrpc': u'2.0',

 u'result': {u'allow-overwrite': u'false',

             u'allow-piece-length-change': u'false',

             u'always-resume': u'true',

             u'async-dns': u'true',

 ...

----------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

[[aria2_rpc_aria2_changeOption]]

JSON-RPC Example

++++++++++++++++

 

The following example sets

*<<aria2_optref_max_download_limit, max-download-limit>>* option to "20K" for

the download whose GID is "1".

 

------------------------------------------------------------------------

>>> import urllib2, json

>>> from pprint import pprint

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.changeOption',

...                       'params':['1', {'max-download-limit':'10K'}]})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer', u'jsonrpc': u'2.0', u'result': u'OK'}

------------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

[[aria2_rpc_aria2_getGlobalOption]]

*<<aria2_rpc_aria2_getOption, aria2.getOption>>* method.

[[aria2_rpc_aria2_changeGlobalOption]]

[[aria2_rpc_aria2_purgeDownloadResult]]

[[aria2_rpc_aria2_removeDownloadResult]]

*aria2.removeDownloadResult* ('gid')

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 

Description

+++++++++++

 

This method removes completed/error/removed download denoted by 'gid'

from memory. This method returns "OK" for success.

 

JSON-RPC Example

++++++++++++++++

 

The following example removes the download result of the download

whose GID is "1".

 

------------------------------------------------------------------

>>> import urllib2, json

>>> from pprint import pprint

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.removeDownloadResult',

...                       'params':['1']})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer', u'jsonrpc': u'2.0', u'result': u'OK'}

------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

 

The following example removes the download result of the download

whose GID is "1".

 

--------------------------------------------------------------------

>>> import xmlrpclib

>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')

>>> s.aria2.removeDownloadResult('1')

'OK'

--------------------------------------------------------------------

 

[[aria2_rpc_aria2_getVersion]]

JSON-RPC Example

++++++++++++++++

 

------------------------------------------------------------------

>>> import urllib2, json

>>> from pprint import pprint

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.getVersion'})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer',

 u'jsonrpc': u'2.0',

 u'result': {u'enabledFeatures': [u'Async DNS',

                                  u'BitTorrent',

                                  u'Firefox3 Cookie',

                                  u'GZip',

                                  u'HTTPS',

                                  u'Message Digest',

                                  u'Metalink',

                                  u'XML-RPC'],

             u'version': u'1.11.0'}}

------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

 'version': '1.11.0'}

[[aria2_rpc_aria2_getSessionInfo]]

JSON-RPC Example

++++++++++++++++

 

------------------------------------------------------------------------

>>> import urllib2, json

>>> from pprint import pprint

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'aria2.getSessionInfo'})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer',

 u'jsonrpc': u'2.0',

 u'result': {u'sessionId': u'cd6a3bc6a1de28eb5bfa181e5f6b916d44af31a9'}}

------------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

[[aria2_rpc_aria2_shutdown]]

[[aria2_rpc_aria2_forceShutdown]]

This method shutdowns aria2. This method behaves like *<<aria2_rpc_aria2_shutdown, aria2.shutdown>>*

[[aria2_rpc_system_multicall]]

JSON-RPC Example

++++++++++++++++

 

In the following example, we add 2 downloads. First one is

\http://example.org/file and second one is file.torrent:

 

---------------------------------------------------------------------------------------------------

>>> import urllib2, json, base64

>>> from pprint import pprint

>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',

...                       'method':'system.multicall',

...                       'params':[[{'methodName':'aria2.addUri',

...                                   'params':[['http://example.org']]},

...                                  {'methodName':'aria2.addTorrent',

...                                   'params':[base64.b64encode(open('file.torrent').read())]}]]})

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

{u'id': u'qwer', u'jsonrpc': u'2.0', u'result': [[u'1'], [u'2']]}

---------------------------------------------------------------------------------------------------

 

JSON-RPC also supports Batch request described in JSON-RPC 2.0 Specification:

 

----------------------------------------------------------------------------------------

>>> jsonreq = json.dumps([{'jsonrpc':'2.0', 'id':'qwer',

...                        'method':'aria2.addUri',

...                        'params':[['http://example.org']]},

...                       {'jsonrpc':'2.0', 'id':'asdf',

...                        'method':'aria2.addTorrent',

...                        'params':[base64.b64encode(open('file.torrent').read())]}])

>>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)

>>> pprint(json.loads(c.read()))

[{u'id': u'qwer', u'jsonrpc': u'2.0', u'result': u'1'},

 {u'id': u'asdf', u'jsonrpc': u'2.0', u'result': u'2'}]

----------------------------------------------------------------------------------------

 

XML-RPC Example

+++++++++++++++

In JSON-RPC, aria2 returns JSON object which contains error code in

code and the error message in message.

 

In XML-RPC, aria2 returns faultCode=1 and the error message in

[[aria2_rpc_options]]

JSON-RPC Example

^^^^^^^^^^^^^^^^

 

----------------------------------------------

{'split':'1', 'http-proxy':'http://proxy/'}

----------------------------------------------

 

XML-RPC Example

^^^^^^^^^^^^^^^

 

JSON-RPC Example

^^^^^^^^^^^^^^^^

 

-------------------------------------------------------------

{'header':['Accept-Language: ja', 'Accept-Charset: utf-8']}

-------------------------------------------------------------

 

XML-RPC Example

^^^^^^^^^^^^^^^

 

JSON-RPC using HTTP GET

~~~~~~~~~~~~~~~~~~~~~~~

 

The JSON-RPC interface also supports request via HTTP GET.

The encoding scheme in GET parameters is based on http://groups.google.com/group/json-rpc/web/json-rpc-over-http[JSON-RPC over HTTP Specification (2008-1-15(RC1))].

The encoding of GET parameters are follows:

 

--------------------------------------------------------------

/jsonrpc?method=METHOD_NAME&id=ID&params=BASE64_ENCODED_PARAMS

--------------------------------------------------------------

 

The 'method' and 'id' are always treated as JSON string and their

encoding must be UTF-8.

 

For example, The encoded string of aria2.tellStatus('3') with id='foo'

looks like this:

 

---------------------------------------------------------

/jsonrpc?method=aria2.tellStatus&id=foo&params=WyIzIl0%3D

---------------------------------------------------------

 

The 'params' parameter is Base64-encoded JSON array which usually

appears in 'params' attribute in JSON-RPC request object.  In the

above example, the params is ['3'], therefore:

 

-------------------------------------------------------------

['3'] --(Base64)--> WyIzIl0= --(Percent Encode)--> WyIzIl0%3D

-------------------------------------------------------------

 

The JSON-RPC interface supports JSONP. You can specify the callback

function in 'jsoncallback' parameter.

 

-------------------------------------------------------------------------

/jsonrpc?method=aria2.tellStatus&id=foo&params=WyIzIl0%3D&jsoncallback=cb

-------------------------------------------------------------------------

 

For Batch request, 'method' and 'id' parameter must not be specified.

Whole request must be specified in 'params' parameter. For example,

Batch request

 

-------------------------------------------------------------

[{'jsonrpc':'2.0', 'id':'qwer', 'method':'aria2.getVersion'},

 {'jsonrpc':'2.0', 'id':'asdf', 'method':'aria2.tellActive'}]

-------------------------------------------------------------

 

will be encoded like this:

 

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

/jsonrpc?params=W3sianNvbnJwYyI6ICIyLjAiLCAiaWQiOiAicXdlciIsICJtZXRob2QiOiAiYXJpYTIuZ2V0VmVyc2lvbiJ9LCB7Impzb25ycGMiOiAiMi4wIiwgImlkIjogImFzZGYiLCAibWV0aG9kIjogImFyaWEyLnRlbGxBY3RpdmUifV0%3D

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

Copyright (C) 2006, 2011 Tatsuhiro Tsujikawa