mirror of https://github.com/aria2/aria2
4021 lines
134 KiB
ReStructuredText
4021 lines
134 KiB
ReStructuredText
|
aria2c(1)
|
||
|
|
=========
|
||
|
|
|
||
|
|
Linha de COMANDO
|
||
|
|
----------------
|
||
|
|
|
||
|
|
**aria2c** [<OPÇÕES>] [<URI>|<MAGNET>|<ARQUIVO_TORRENT>|<ARQUIVO_METALINK>] ...
|
||
|
|
|
||
|
|
DESCRIÇÃO
|
||
|
|
---------
|
||
|
|
|
||
|
|
Observação: Para executar o aria2 em um terminal ou prompt do dos utilize
|
||
|
|
o comando aria2c
|
||
|
|
|
||
|
|
aria2 é um utilitário para download de arquivos. Os protocolos suportados são
|
||
|
|
HTTP, HTTPS, FTP, BitTorrent e Metalink. aria2 pode efetuar download de arquivos
|
||
|
|
a partir de múltiplas fontes e protocolos e tenta utilizar a máxima capacidade
|
||
|
|
de banda. Há suporte para download de arquivos que tem origem em HTTP, HTTPS,
|
||
|
|
FTP, BitTorrent e Metalink enquanto que os dados baixados podem ser
|
||
|
|
compartilhados pelo BitTorrent. Usando conferência / aferição (checksum) nos
|
||
|
|
Metalinks aria2 automaticamente valida o conteúdo dos dados enquanto faz
|
||
|
|
o download do arquivo como BitTorrent.
|
||
|
|
|
||
|
|
|
||
|
|
OPÇÕES para Uso no aria2
|
||
|
|
------------------------
|
||
|
|
|
||
|
|
Básicas
|
||
|
|
~~~~~~~
|
||
|
|
.. option:: -d, --dir=<DIR>
|
||
|
|
|
||
|
|
O diretório onde será armazenado o arquivo baixado.
|
||
|
|
|
||
|
|
.. option:: -i, --input-file=<ARQUIVO>
|
||
|
|
|
||
|
|
Executa download da(s) URI encontradas no ARQUIVO. Podem ser especificados
|
||
|
|
múltiplos URI para uma simples entidade: separe URI na mesma linha com
|
||
|
|
um caracter TAB (tabulação).
|
||
|
|
Quando desejar ler a entrada padrão (stdin) especificar ``-`` (hífen).
|
||
|
|
Adicionalmente, diversas opções podem ser especificadas após cada linha de URI.
|
||
|
|
Esta(s) linha(s) opcional(s) deve(m) começar(em) com um ou mais espaços em
|
||
|
|
branco e possuir(em) apenas uma opção em cada linha.
|
||
|
|
Ver subseção `Arquivo de Entrada`_ para mais detalhes.
|
||
|
|
Ver também opção :option:`--deferred-input`.
|
||
|
|
|
||
|
|
.. option:: -l, --log=<LOG>
|
||
|
|
|
||
|
|
O nome do arquivo de log. Se ``-`` for especificado (entrada padrão), log é
|
||
|
|
gravado em stdout (saída padrão). Se uma string vazia("") é especificada, log
|
||
|
|
não será gravado em arquivo.
|
||
|
|
|
||
|
|
.. option:: -j, --max-concurrent-downloads=<N>
|
||
|
|
|
||
|
|
Configura o número máximo de downloads paralelos para cada URI (HTTP,
|
||
|
|
HTTPS, FTP), Torrent e Metalink. Ver também opção :option:`--split <-s>`.
|
||
|
|
Padrão: ``5``
|
||
|
|
|
||
|
|
.. option:: -V, --check-integrity[=true|false]
|
||
|
|
|
||
|
|
Verifica a integridade do arquivo validando pedaços hashes ou um hash do
|
||
|
|
arquivo inteiro. Essa opção tem efeito só em downloads BitTorrent, Metalink
|
||
|
|
com checksums ou HTTP, HTTPS e FTP com a opção :option:`--checksum`. Se pedaços
|
||
|
|
de hashes são providos, essa opção pode detectar porções danificadas de um
|
||
|
|
arquivo e efetuar novamente o download desses pedaços. Se especificar hash
|
||
|
|
do arquivo inteiro, a verificação do hash ocorrerá só ao final do download,
|
||
|
|
validação que leva em conta o tamanho do arquivo, e o download reinicirá a
|
||
|
|
partir do início. Se houver especificação de ambos métodos de hash será
|
||
|
|
utilizado o hash de pedações.
|
||
|
|
Padrão:
|
||
|
|
``false``
|
||
|
|
|
||
|
|
.. option:: -c, --continue[=true|false]
|
||
|
|
|
||
|
|
Continua o download a partir de um download parcial, anteriormente
|
||
|
|
interrompido. Use esta opção para retormar um download iniciado a partir
|
||
|
|
de um browser (navegador) ou outro programa que faz baixa de arquivos
|
||
|
|
sequencialmente desde o início.
|
||
|
|
Atualmente esta opção só é aplicavel a download de HTTP, HTTPS e FTP.
|
||
|
|
|
||
|
|
.. option:: -h, --help[=<TÓPICO>|<PALAVRA-CHAVE>]
|
||
|
|
|
||
|
|
As mensagens de Ajuda são classificadas em tópicos. Um tópico inicia com
|
||
|
|
``#``. Por exemplo, digitar ``--help=#http`` para obter o uso das opções
|
||
|
|
do tópico ``#http``. Se digitar um termo que não é tópico, haverá exibição
|
||
|
|
das opções que incluem o termo informado.
|
||
|
|
Valores disponíveis para tópicos podem ser: ``#basic``, ``#advanced``,
|
||
|
|
``#http``, ``#https``, ``#ftp``,
|
||
|
|
``#metalink``, ``#bittorrent``, ``#cookie``, ``#hook``, ``#file``, ``#rpc``,
|
||
|
|
``#checksum``, ``#experimental``, ``#deprecated``, ``#help``, ``#all``
|
||
|
|
Padrão: ``#basic``
|
||
|
|
|
||
|
|
HTTP/FTP
|
||
|
|
~~~~~~~~
|
||
|
|
.. option:: --all-proxy=<PROXY>
|
||
|
|
|
||
|
|
Usar este servidor proxy para todos protocolos. Para limpar proxy
|
||
|
|
previamente definido, use "". Esta configuração pode ser sobreposta através
|
||
|
|
da especificação de um servidor proxy para um determinado protocolo usando
|
||
|
|
opções :option:`--http-proxy`, :option:`--https-proxy` e :option:`--ftp-proxy`.
|
||
|
|
Isto afeta todas as URIs.
|
||
|
|
O formato da opção PROXY é ``[http://][USUÁRIO:SENHA@]SERVIDOR[:PORTA]``.
|
||
|
|
Ver também seção `VARIÁVEIS DE AMBIENTE`_ section.
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Se usuário e senha são embutidos na URI do proxy eles também podem ser
|
||
|
|
especificados através das opções
|
||
|
|
*--{http,https,ftp,all}-proxy-{usuário,senha}*,
|
||
|
|
aqueles que aparecerem por último assumem a precedência. Por exemplo,
|
||
|
|
quando temos ``http-proxy-user=meunome``, ``http-proxy-passwd=minhasenha``
|
||
|
|
em aria2.conf e especificamos ``--http-proxy="http://svrproxy"`` na
|
||
|
|
linha de comando, então obtemos como proxy HTTP ``http://svrproxy``
|
||
|
|
com o usuário ``meunome`` e senha ``minhasenha``.
|
||
|
|
|
||
|
|
Outro exemplo: quando especificamos na linha de comando
|
||
|
|
``--http-proxy="http://usuário:senha@svrproxy" --http-proxy-user="meunome"
|
||
|
|
--http-proxy-passwd="minhasenha"``, então obtemos proxy HTTP
|
||
|
|
``http://svrproxy`` com usuário ``meunome`` e senha ``minhasenha``.
|
||
|
|
|
||
|
|
Mais um exemplo: se especificamos na linha de comando
|
||
|
|
``--http-proxy-user="meunome" --http-proxy-passwd="minhasenha"
|
||
|
|
--http-proxy="http://utilizador:acesso@svrproxy"``, então obtemos o proxy HTTP
|
||
|
|
``http://svrproxy`` com o usuário ``utilizador`` e a senha ``acesso``.
|
||
|
|
|
||
|
|
.. option:: --all-proxy-passwd=<SENHA>
|
||
|
|
|
||
|
|
Define senha para a opção :option:`--all-proxy`.
|
||
|
|
|
||
|
|
.. option:: --all-proxy-user=<USUÁRIO>
|
||
|
|
|
||
|
|
Define usuário para opção :option:`--all-proxy`.
|
||
|
|
|
||
|
|
.. option:: --checksum=<TIPO>=<ALGORITMO>
|
||
|
|
|
||
|
|
Define verificação (checksum). TIPO é o tipo de algoritmo(hash). Os tipos de
|
||
|
|
algoritmos estão listados em ``Algoritmos de Hash`` e podem ser obtidos
|
||
|
|
através do do comando ``aria2c -v``. DIGEST é o código hexadecimal. Por
|
||
|
|
examplo, definindo sha-1 o resultado parece com:
|
||
|
|
``sha-1=0192ba11326fe2298c8cb4de616f4d4140213838`` Essa opção aplica-se
|
||
|
|
apenas para downloads HTTP, HTTPS e FTP.
|
||
|
|
|
||
|
|
.. option:: --connect-timeout=<SEGUNDOS>
|
||
|
|
|
||
|
|
Define o tempo de espera em segundos para estabelecer a conexão com o servidor
|
||
|
|
proxy. Após o estabelecimento da conexão, esta opção não tem mais efeito, mas
|
||
|
|
a opção :option:`--timeout <-t>` será utilizada.
|
||
|
|
Padrão: ``60``
|
||
|
|
|
||
|
|
.. option:: --dry-run[=true|false]
|
||
|
|
|
||
|
|
Se ``true`` é informado, aria2 apenas verifica se o arquivo remoto está
|
||
|
|
disponível para download dos dados. Esta opção tem efeito em downloads de
|
||
|
|
servidores HTTP, HTTPS e FTP. Downloads BitTorrent serão cancelados se for
|
||
|
|
especificado ``true``.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --lowest-speed-limit=<VELOCIDADE>
|
||
|
|
|
||
|
|
Fecha a conexão se a velocidade de download é menor ou igual ao valor
|
||
|
|
especificado, bytes por segundo.
|
||
|
|
``0`` significa que aria2 não levará em conta limite de velocidade mínima.
|
||
|
|
Pode ser anexado ``K`` ou ``M`` (1K = 1024, 1M = 1024K).
|
||
|
|
Esta opção não abrange downloads do tipo BitTorrent.
|
||
|
|
Padrão: ``0``
|
||
|
|
|
||
|
|
.. option:: -x, --max-connection-per-server=<NÚMERO>
|
||
|
|
|
||
|
|
O número máximo de conexões para um servidor em cada download.
|
||
|
|
Padrão: ``1``
|
||
|
|
|
||
|
|
.. option:: --max-file-not-found=<NÚMERO>
|
||
|
|
|
||
|
|
Se aria2 recebe çódigo de retorno "arquivo não encontrado" de um servidor
|
||
|
|
remoto de HTTP / FTP um NÚMERO de vezes sem obter nenhum byte, então o
|
||
|
|
download é forçado a falhar.
|
||
|
|
Especificar ``0`` para desabilitar esta opção. Esta opção só é válida
|
||
|
|
para servidores HTTP / FTP.
|
||
|
|
Padrão: ``0``
|
||
|
|
|
||
|
|
.. option:: -m, --max-tries=<NÚMERO>
|
||
|
|
|
||
|
|
Define o número de tentativas. ``0`` significa ilimitadas.
|
||
|
|
See also :option:`--retry-wait`.
|
||
|
|
Padrão: ``5``
|
||
|
|
|
||
|
|
.. option:: -k, --min-split-size=<TAMANHO>
|
||
|
|
|
||
|
|
aria2 não divide menos que 2 * TAMANHO o intervalo de bytes. Por exemplo,
|
||
|
|
considere download de um arquivo de 20MiB. Se o TAMANHO é 10M, aria2 pode
|
||
|
|
dividir o arquivo em 2 intervalos de [0-10MiB) e [10MiB-20MiB) e executar o
|
||
|
|
download usando 2 fontes (logicamente se a opção :option:`--split <-s>` >= 2).
|
||
|
|
Se o TAMANHO é 15M, desde que 2 * 15M > 20Mib, aria2 não dividirá o arquivo e
|
||
|
|
fará o download de 1 fonte. Pde ser anexado ``K`` ou ``M``
|
||
|
|
(1K = 1024, 1M = 1024K).
|
||
|
|
Valores Possíveis: ``1M`` -``1024M``
|
||
|
|
Padrão: ``20M``
|
||
|
|
|
||
|
|
.. option:: -n, --no-netrc[=true|false]
|
||
|
|
|
||
|
|
Desabilita suporte netrc.
|
||
|
|
Padrão: Suporte a netrc é habilitado por padrão.
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
arquivo netrc é lido somente no início se a opção :option:`--no-netrc <-n>` é
|
||
|
|
``false``.
|
||
|
|
Portanto se a opção :option:`--no-netrc <-n>` é ``true`` no início, não haverá
|
||
|
|
netrc disponível durante toda a sessão, mesmo que seja utilizada a opção
|
||
|
|
:func:`aria2.changeGlobalOption` para executar a opção :option:
|
||
|
|
`--no-netrc=false <-n>`.
|
||
|
|
.
|
||
|
|
|
||
|
|
.. option:: --no-proxy=<DOMÍNIOS>
|
||
|
|
|
||
|
|
Especifica nomes de servidores, domínios e endereços de redes com ou sem blocos
|
||
|
|
CIDR para os quais não serão utilizados proxy.
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Para endereço de rede com blocos CIDR, ambos endereços IPv4 ou IPv6 funcionam.
|
||
|
|
Implementação atual, não resolve nome host em URI para comparar com endereço
|
||
|
|
especificado na opção :option:`--no-proxy`. Portanto só será efetiva se a URI
|
||
|
|
possuir números de endereço IP.
|
||
|
|
|
||
|
|
.. option:: -o, --out=<ARQUIVO>
|
||
|
|
|
||
|
|
O nome do arquivo baixado. Quando a opção :option:`--force-sequential <-Z>` é
|
||
|
|
utilizada esta opção será ignorada.
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Em um download Metalink ou BitTorrent não poderá ser especificado o nome
|
||
|
|
do arquivo. O nome do arquivo especificado aqui é usado quando através
|
||
|
|
da linha de comando é informada para o aria2 sem a utilização da opção
|
||
|
|
:option:`--input-file <-i>`, :option:`--force-sequential <-Z>`.
|
||
|
|
Por exemplo:
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c -o meuarquivo.zip "http://server1/arquivo.zip" "http://server2/arquivo.zip"
|
||
|
|
|
||
|
|
.. option:: --proxy-method=<MÉTODO>
|
||
|
|
|
||
|
|
Define o método utilizado para requisições de proxy. MÉTODO é ``get`` ou
|
||
|
|
``tunnel``. Downloads HTTPS sempre utiliza ``tunnel``, independentemente
|
||
|
|
desta opção.
|
||
|
|
Padrão: ``get``
|
||
|
|
|
||
|
|
.. option:: -R, --remote-time[=true|false]
|
||
|
|
|
||
|
|
Recuperar timestamp do arquivo remoto a partir do servidor remoto HTTP / FTP
|
||
|
|
e se disponível, aplicá-lo ao arquivo local.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --reuse-uri[=true|false]
|
||
|
|
|
||
|
|
Reutilizar uma URI já utilizada. Se não habilitada as URIs já utilizadas serão
|
||
|
|
abandonadas.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --retry-wait=<SEGUNDOS>
|
||
|
|
|
||
|
|
Define quantos segundos haverá entre as tentativas. Com SEGUNDOS > 0, aria2 irá
|
||
|
|
tentará fazer o download quando o servidor HTTP retornar código resposta 503.
|
||
|
|
Padrão: ``0``
|
||
|
|
|
||
|
|
.. option:: --server-stat-of=<ARQUIVO>
|
||
|
|
|
||
|
|
Define o nome do arquivo no qual será salvo o perfil de performance de um
|
||
|
|
ou mais servidores acessados.
|
||
|
|
Para carregar dados já salvos utilizar opção :option:`--server-stat-if`.
|
||
|
|
Ver subseção `Perfil Performance Servidor`_ abaixo,
|
||
|
|
para o formato do arquivo.
|
||
|
|
|
||
|
|
|
||
|
|
.. option:: --server-stat-if=<ARQUIVO>
|
||
|
|
|
||
|
|
Specify the filename to load performance profile of the servers. The
|
||
|
|
loaded data will be used in some URI selector such as ``feedback``.
|
||
|
|
See also :option:`--uri-selector` option. See
|
||
|
|
`Perfil Performance Servidor`_
|
||
|
|
subsection below for file format.
|
||
|
|
|
||
|
|
.. option:: --server-stat-timeout=<SEGUNDOS>
|
||
|
|
|
||
|
|
Specifies timeout in seconds to invalidate performance profile of
|
||
|
|
the servers since the last contact to them.
|
||
|
|
Padrão: ``86400`` (24hours)
|
||
|
|
|
||
|
|
.. option:: -s, --split=<N>
|
||
|
|
|
||
|
|
Download a file using N connections. If more than N URIs are given,
|
||
|
|
first N URIs are used and remaining URIs are used for backup. If
|
||
|
|
less than N URIs are given, those URIs are used more than once so
|
||
|
|
that N connections total are made simultaneously. The number of
|
||
|
|
connections to the same host is restricted by
|
||
|
|
:option:`--max-connection-per-server <-x>` option.
|
||
|
|
See also :option:`--min-split-size <-k>` option.
|
||
|
|
Padrão: ``5``
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Some Metalinks regulate the number of servers to connect. aria2
|
||
|
|
strictly respects them. This means that if Metalink defines the
|
||
|
|
maxconnections attribute lower than N, then aria2 uses the
|
||
|
|
value of maxconnections attribute instead of N.
|
||
|
|
|
||
|
|
.. option:: --stream-piece-selector=<SELECTOR>
|
||
|
|
|
||
|
|
Specify piece selection algorithm used in HTTP e FTP download. Piece
|
||
|
|
means fixed length segment which is downloaded in parallel in
|
||
|
|
segmented download. If ``default`` is given, aria2 selects piece so
|
||
|
|
that it reduces the number of establishing connection. This is
|
||
|
|
reasonable default behaviour because establishing connection is an
|
||
|
|
expensive operation. If ``inorder`` is given, aria2 selects piece
|
||
|
|
which has minimum index. Index=0 means first of the file. This will
|
||
|
|
be useful to view movie while downloading it.
|
||
|
|
:option:`--enable-http-pipelining` option may
|
||
|
|
be useful to reduce reconnection overhead. Please note that aria2
|
||
|
|
honors
|
||
|
|
:option:`--min-split-size <-k>` option,
|
||
|
|
so it will be necessary to specify a reasonable value to
|
||
|
|
:option:`--min-split-size <-k>` option.
|
||
|
|
If ``geom`` is given, at the beginning aria2 selects piece which has
|
||
|
|
minimum index like ``inorder``, but it exponentially increasingly
|
||
|
|
keeps space from previously selected piece. This will reduce the
|
||
|
|
number of establishing connection and at the same time it will
|
||
|
|
download the beginning part of the file first. This will be useful
|
||
|
|
to view movie while downloading it.
|
||
|
|
Padrão: ``default``
|
||
|
|
|
||
|
|
.. option:: -t, --timeout=<SEGUNDOS>
|
||
|
|
|
||
|
|
Set timeout in seconds.
|
||
|
|
Padrão: ``60``
|
||
|
|
|
||
|
|
.. option:: --uri-selector=<SELECTOR>
|
||
|
|
|
||
|
|
Specify URI selection algorithm. The possible values are ``inorder``,
|
||
|
|
``feedback`` and ``adaptive``. If ``inorder`` is given, URI is tried in
|
||
|
|
the order appeared in the URI list. If ``feedback`` is given, aria2
|
||
|
|
uses download speed observed in the previous downloads and choose
|
||
|
|
fastest server in the URI list. This also effectively skips dead
|
||
|
|
mirrors. The observed download speed is a part of performance
|
||
|
|
profile of servers mentioned in :option:`--server-stat-of` and
|
||
|
|
:option:`--server-stat-if` options. If ``adaptive`` is given, selects one of
|
||
|
|
the best mirrors for the first and reserved connections. For
|
||
|
|
supplementary ones, it returns mirrors which has not been tested
|
||
|
|
yet, and if each of them has already been tested, returns mirrors
|
||
|
|
which has to be tested again. Otherwise, it doesn't select anymore
|
||
|
|
mirrors. Like ``feedback``, it uses a performance profile of servers.
|
||
|
|
Padrão: ``feedback``
|
||
|
|
|
||
|
|
Específicas de HTTP
|
||
|
|
~~~~~~~~~~~~~~~~~~~
|
||
|
|
.. option:: --ca-certificate=<ARQUIVO>
|
||
|
|
|
||
|
|
Utilizar o certificado do ARQUIVO FILE para verificar os Servidores.
|
||
|
|
O certificado precisa estar no formato PEM e pode conter múltiplos
|
||
|
|
certificados CA.
|
||
|
|
|
||
|
|
Utilizar a opção :option:`--check-certificate` para habilitar a verificação.
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Se aria2 foi compilado com OpenSSL ou versão mais recente de GnuTLS a qual
|
||
|
|
tem a função ``gnutls_certificate_set_x509_system_trust()`` e a biblioteca
|
||
|
|
foi adequadamente configurada para localizar o certificado CA existente
|
||
|
|
aria2 irá carregar automaticamente estes certificados no início.
|
||
|
|
|
||
|
|
.. option:: --certificate=<ARQUIVO>
|
||
|
|
|
||
|
|
Usar arquivo com certificado cliente.
|
||
|
|
O certificado deve estar no formato PEM.
|
||
|
|
Pode ser usada a opção :option:`--private-key` para especificar uma chave
|
||
|
|
particular.
|
||
|
|
|
||
|
|
.. option:: --check-certificate[=true|false]
|
||
|
|
|
||
|
|
Verifica o se o peer esta usando o certificado especificado na opção
|
||
|
|
:option:`--ca-certificate`.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --http-accept-gzip[=true|false]
|
||
|
|
|
||
|
|
Envia cabeçalho requisição ``Accept: deflate, gzip`` e faz (inflate) se
|
||
|
|
o servidor remoto responder com ``Content-Encoding: gzip`` ou
|
||
|
|
``Content-Encoding: deflate``. Padrão: ``false``
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Alguns servidores respondem com ``Content-Encoding: gzip`` para arquivos
|
||
|
|
que são gzip. aria2 faz inflate destes por causa do cabeçalho de resposta.
|
||
|
|
|
||
|
|
.. option:: --http-auth-challenge[=true|false]
|
||
|
|
|
||
|
|
Envia cabeçalho de autorização HTTP só quando requisitado pelo servidor.
|
||
|
|
Se ``false`` é habilitado, então o cabeçalho de autorização sempre será
|
||
|
|
enviado ao servidor. Há uma exceção: se o nome do usuário de senha são
|
||
|
|
embutidas na URI, o cabeçalho de autorização sempre será enviado ao servidor
|
||
|
|
independente desta opção. Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --http-no-cache[=true|false]
|
||
|
|
|
||
|
|
Envia Cache-Control: no-cache e Pragma: cabeçalho no-cache para evitar
|
||
|
|
conteúdo do cache. Se ``false`` é fornecido, esses cabeçalhos não serão
|
||
|
|
enviados e poderá ser adicionado o cabeçalho de Cache-Control com a diretiva
|
||
|
|
desejada usando a opção :option:`--header`. Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --http-user=<USUÁRIO>
|
||
|
|
|
||
|
|
Define usuário HTTP. Isto afeta todas as URIs.
|
||
|
|
|
||
|
|
.. option:: --http-passwd=<PASSWD>
|
||
|
|
|
||
|
|
Define senha HTTP. Isto afeta todas as URIs.
|
||
|
|
|
||
|
|
.. option:: --http-proxy=<PROXY>
|
||
|
|
|
||
|
|
Usar este servidor proxy para HTTP. Para limpar o proxy anteriormente
|
||
|
|
definido use "". Ver também opção :option:`--all-proxy`. Isto afeta todas
|
||
|
|
URIs. O formato de PROXY é ``[http://][USUÁRIO:SENHA@]SERVIDOR[:PORTA]``
|
||
|
|
|
||
|
|
.. option:: --http-proxy-passwd=<SENHA>
|
||
|
|
|
||
|
|
Define a senha para opção :option:`--http-proxy`.
|
||
|
|
|
||
|
|
.. option:: --http-proxy-user=<USUÁRIO>
|
||
|
|
|
||
|
|
Define o usuário para a opção :option:`--http-proxy`.
|
||
|
|
|
||
|
|
.. option:: --https-proxy=<PROXY>
|
||
|
|
|
||
|
|
Usar este servidor proxy para HTTPS. Para limpar o proxy anteriormente,
|
||
|
|
use "". Ver também opção :option:`--all-proxy`. Isto afeta todas URIs. O
|
||
|
|
formato de PROXY é ``[https://][USUÁRIO:SENHA@]SERVIDOR[:PORTA]``
|
||
|
|
|
||
|
|
.. option:: --https-proxy-passwd=<PASSWD>
|
||
|
|
|
||
|
|
Set password for :option:`--https-proxy` option.
|
||
|
|
|
||
|
|
.. option:: --https-proxy-user=<USUÁRIO>
|
||
|
|
|
||
|
|
Set user for :option:`--https-proxy` option.
|
||
|
|
|
||
|
|
.. option:: --private-key=<ARQUIVO>
|
||
|
|
|
||
|
|
Use the private key in FILE.
|
||
|
|
The private key must be decrypted and in PEM format.
|
||
|
|
The behavior when encrypted one is given is undefined.
|
||
|
|
See also :option:`--certificate` option.
|
||
|
|
|
||
|
|
.. option:: --referer=<REFERER>
|
||
|
|
|
||
|
|
Set Referer. This affects all URIs.
|
||
|
|
|
||
|
|
.. option:: --enable-http-keep-alive[=true|false]
|
||
|
|
|
||
|
|
Enable HTTP/1.1 persistent connection.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --enable-http-pipelining[=true|false]
|
||
|
|
|
||
|
|
Habilita pipelining para HTTP/1.1.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Da perspectiva de performance, não há vantagem em habilitar esta opção.
|
||
|
|
|
||
|
|
.. option:: --header=<HEADER>
|
||
|
|
|
||
|
|
Append HEADER to HTTP request header.
|
||
|
|
You can use this option repeatedly to specify more than one header:
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --header="X-A: b78" --header="X-B: 9J1" "http://host/file"
|
||
|
|
|
||
|
|
.. option:: --load-cookies=<ARQUIVO>
|
||
|
|
|
||
|
|
Load Cookies from FILE using the Firefox3 format (SQLite3),
|
||
|
|
Chromium/Google Chrome (SQLite3) and the
|
||
|
|
Mozilla/Firefox(1.x/2.x)/Netscape format.
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
If aria2 is built without libsqlite3, then it doesn't support Firefox3
|
||
|
|
and Chromium/Google Chrome cookie format.
|
||
|
|
|
||
|
|
.. option:: --save-cookies=<ARQUIVO>
|
||
|
|
|
||
|
|
Save Cookies to FILE in Mozilla/Firefox(1.x/2.x)/ Netscape
|
||
|
|
format. If FILE already exists, it is overwritten. Session Cookies
|
||
|
|
are also saved and their expiry values are treated as 0. Possible
|
||
|
|
Values: ``/path/to/file``
|
||
|
|
|
||
|
|
.. option:: --use-head[=true|false]
|
||
|
|
|
||
|
|
Use HEAD method for the first request to the HTTP server.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
|
||
|
|
.. option:: -U, --user-agent=<AGENTE_USUÁRIO>
|
||
|
|
|
||
|
|
Set user agent for HTTP, HTTPS, downloads.
|
||
|
|
Padrão: ``aria2/$VERSION``, $VERSION is replaced by package version.
|
||
|
|
|
||
|
|
Específicas de FTP
|
||
|
|
~~~~~~~~~~~~~~~~~~
|
||
|
|
.. option:: --ftp-user=<USUÁRIO>
|
||
|
|
|
||
|
|
Definir o usuário FTP. Isto afeta todas as URIs.
|
||
|
|
Padrão: ``anonymous``
|
||
|
|
|
||
|
|
.. option:: --ftp-passwd=<SENHA_FTP>
|
||
|
|
|
||
|
|
Definir senha FTP. Isto afeta todas as URIs.
|
||
|
|
Se o nome existe, mas a senha esta ausente, para login em uma URI, aria2
|
||
|
|
tenta obter a senha usando o arquivo .netrc, caso exista senha declarada no
|
||
|
|
.netrc. Se não existir será utilizada a senha declarada nesta opção.
|
||
|
|
Padrão: ``ARIA2USER@``
|
||
|
|
|
||
|
|
.. option:: -p, --ftp-pasv[=true|false]
|
||
|
|
|
||
|
|
Use the passive mode in FTP.
|
||
|
|
If ``false`` is given, the active mode will be used.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --ftp-proxy=<PROXY>
|
||
|
|
|
||
|
|
Use this proxy server for FTP. To erase previously defined proxy,
|
||
|
|
use "". See also :option:`--all-proxy` option. This affects all URIs. The
|
||
|
|
format of PROXY is ``[http://][USER:PASSWORD@]HOST[:PORT]``
|
||
|
|
|
||
|
|
.. option:: --ftp-proxy-passwd=<PASSWD>
|
||
|
|
|
||
|
|
Set password for :option:`--ftp-proxy` option.
|
||
|
|
|
||
|
|
.. option:: --ftp-proxy-user=<USUÁRIO>
|
||
|
|
|
||
|
|
Set user for :option:`--ftp-proxy` option.
|
||
|
|
|
||
|
|
.. option:: --ftp-type=<TYPE>
|
||
|
|
|
||
|
|
Set FTP transfer type. TYPE is either ``binary`` or ``ascii``.
|
||
|
|
Padrão: ``binary``
|
||
|
|
|
||
|
|
.. option:: --ftp-reuse-connection[=true|false]
|
||
|
|
|
||
|
|
Reuse connection in FTP.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
Comuns de BitTorrent / Metalink
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
.. option:: --select-file=<INDEX>...
|
||
|
|
|
||
|
|
Set file to download by specifying its index.
|
||
|
|
You can find the file index using the :option:`--show-files <-S>` option.
|
||
|
|
Multiple indexes can be specified by using ``,``, for example: ``3,6``.
|
||
|
|
You can also use ``-`` to specify a range: ``1-5``.
|
||
|
|
``,`` and ``-`` can be used together: ``1-5,8,9``.
|
||
|
|
When used with the -M option, index may vary depending on the query
|
||
|
|
(see *--metalink-\** options).
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
In multi file torrent, the adjacent files specified by this option may
|
||
|
|
also be downloaded. This is by design, not a bug.
|
||
|
|
A single piece may include several files or part of files, and aria2
|
||
|
|
writes the piece to the appropriate files.
|
||
|
|
|
||
|
|
.. option:: -S, --show-files[=true|false]
|
||
|
|
|
||
|
|
Print file listing of ".torrent", ".meta4" and ".metalink" file and exit.
|
||
|
|
In case of ".torrent" file, additional information
|
||
|
|
(infohash, piece length, etc) is also printed.
|
||
|
|
|
||
|
|
Específicas de BitTorrent
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
.. option:: --bt-enable-lpd[=true|false]
|
||
|
|
|
||
|
|
Enable Local Peer Discovery. If a private flag is set in a torrent,
|
||
|
|
aria2 doesn't use this feature for that download even if ``true`` is
|
||
|
|
given. Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --bt-exclude-tracker=<URI>[,...]
|
||
|
|
|
||
|
|
Comma separated list of BitTorrent tracker's announce URI to
|
||
|
|
remove. You can use special value ``*`` which matches all URIs, thus
|
||
|
|
removes all announce URIs. When specifying ``*`` in shell
|
||
|
|
command-line, don't forget to escape or quote it. See also
|
||
|
|
:option:`--bt-tracker` option.
|
||
|
|
|
||
|
|
.. option:: --bt-external-ip=<IPADDRESS>
|
||
|
|
|
||
|
|
Specify the external IP address to report to a BitTorrent
|
||
|
|
tracker. Although this function is named ``external``, it can accept
|
||
|
|
any kind of IP addresses. IPADDRESS must be a numeric IP address.
|
||
|
|
|
||
|
|
.. option:: --bt-hash-check-seed[=true|false]
|
||
|
|
|
||
|
|
If ``true`` is given, after hash check using :option:`--check-integrity <-V>`
|
||
|
|
option and file is complete, continue to seed file. If you want to check file
|
||
|
|
and download it only when it is damaged or incomplete, set this
|
||
|
|
option to ``false``. This option has effect only on BitTorrent download.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --bt-lpd-interface=<INTERFACE>
|
||
|
|
|
||
|
|
Use given interface for Local Peer Discovery. If this option is not
|
||
|
|
specified, the default interface is chosen. You can specify
|
||
|
|
interface name and IP address. Possible Values: interface, IP
|
||
|
|
addres
|
||
|
|
|
||
|
|
.. option:: --bt-max-open-files=<NÚMERO>
|
||
|
|
|
||
|
|
Specify maximum number of files to open in each BitTorrent download.
|
||
|
|
Padrão: ``100``
|
||
|
|
|
||
|
|
.. option:: --bt-max-peers=<NÚMERO>
|
||
|
|
|
||
|
|
Specify the maximum number of peers per torrent. ``0`` means
|
||
|
|
unlimited. See also :option:`--bt-request-peer-speed-limit` option.
|
||
|
|
Padrão: ``55``
|
||
|
|
|
||
|
|
.. option:: --bt-metadata-only[=true|false]
|
||
|
|
|
||
|
|
Download metadata only. The file(s) described in metadata will not
|
||
|
|
be downloaded. This option has effect only when BitTorrent Magnet
|
||
|
|
URI is used. See also :option:`--bt-save-metadata` option. Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --bt-min-crypto-level=plain|arc4
|
||
|
|
|
||
|
|
Set minimum level of encryption method.
|
||
|
|
If several encryption methods are provided by a peer, aria2 chooses the lowest
|
||
|
|
one which satisfies the given level.
|
||
|
|
Padrão: ``plain``
|
||
|
|
|
||
|
|
.. option:: --bt-prioritize-piece=head[=<TAMANHO>],tail[=<TAMANHO>]
|
||
|
|
|
||
|
|
Try to download first and last pieces of each file first. This is
|
||
|
|
useful for previewing files. The argument can contain 2 keywords:
|
||
|
|
``head`` and ``tail``. To include both keywords, they must be separated
|
||
|
|
by comma. These keywords can take one parameter, SIZE. For example,
|
||
|
|
if ``head=<TAMANHO>`` is specified, pieces in the range of first SIZE bytes
|
||
|
|
of each file get higher priority. ``tail=<TAMANHO>`` means the range of
|
||
|
|
last SIZE bytes of each file. SIZE can include ``K`` or ``M`` (1K = 1024,
|
||
|
|
1M = 1024K). If SIZE is omitted, SIZE=1M is used.
|
||
|
|
|
||
|
|
.. option:: --bt-remove-unselected-file[=true|false]
|
||
|
|
|
||
|
|
Removes the unselected files when download is completed in
|
||
|
|
BitTorrent. To select files, use
|
||
|
|
:option:`--select-file` option. If it is
|
||
|
|
not used, all files are assumed to be selected. Please use this
|
||
|
|
option with care because it will actually remove files from your
|
||
|
|
disk.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --bt-require-crypto[=true|false]
|
||
|
|
|
||
|
|
If true is given, aria2 doesn't accept and establish connection with legacy
|
||
|
|
BitTorrent handshake(\19BitTorrent protocol).
|
||
|
|
Thus aria2 always uses Obfuscation handshake.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --bt-request-peer-speed-limit=<SPEED>
|
||
|
|
|
||
|
|
If the whole download speed of every torrent is lower than SPEED,
|
||
|
|
aria2 temporarily increases the number of peers to try for more
|
||
|
|
download speed. Configuring this option with your preferred download
|
||
|
|
speed can increase your download speed in some cases.
|
||
|
|
You can append ``K`` or ``M`` (1K = 1024, 1M = 1024K).
|
||
|
|
Padrão: ``50K``
|
||
|
|
|
||
|
|
.. option:: --bt-save-metadata[=true|false]
|
||
|
|
|
||
|
|
Save metadata as ".torrent" file. This option has effect only when
|
||
|
|
BitTorrent Magnet URI is used. The filename is hex encoded info
|
||
|
|
hash with suffix ".torrent". The directory to be saved is the same
|
||
|
|
directory where download file is saved. If the same file already
|
||
|
|
exists, metadata is not saved. See also :option:`--bt-metadata-only`
|
||
|
|
option. Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --bt-seed-unverified[=true|false]
|
||
|
|
|
||
|
|
Seed previously downloaded files without verifying piece hashes.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --bt-stop-timeout=<SEGUNDOS>
|
||
|
|
|
||
|
|
Stop BitTorrent download if download speed is 0 in consecutive SEC
|
||
|
|
seconds. If ``0`` is given, this feature is disabled. Padrão: ``0``
|
||
|
|
|
||
|
|
.. option:: --bt-tracker=<URI>[,...]
|
||
|
|
|
||
|
|
Comma separated list of additional BitTorrent tracker's announce
|
||
|
|
URI. These URIs are not affected by :option:`--bt-exclude-tracker` option
|
||
|
|
because they are added after URIs in :option:`--bt-exclude-tracker` option are
|
||
|
|
removed.
|
||
|
|
|
||
|
|
.. option:: --bt-tracker-connect-timeout=<SEGUNDOS>
|
||
|
|
|
||
|
|
Set the connect timeout in seconds to establish connection to
|
||
|
|
tracker. After the connection is established, this option makes no
|
||
|
|
effect and :option:`--bt-tracker-timeout` option is used instead. Padrão:
|
||
|
|
``60``
|
||
|
|
|
||
|
|
.. option:: --bt-tracker-interval=<SEGUNDOS>
|
||
|
|
|
||
|
|
Set the interval in seconds between tracker requests. This
|
||
|
|
completely overrides interval value and aria2 just uses this value
|
||
|
|
and ignores the min interval and interval value in the response of
|
||
|
|
tracker. If ``0`` is set, aria2 determines interval based on the
|
||
|
|
response of tracker and the download progress. Padrão: ``0``
|
||
|
|
|
||
|
|
.. option:: --bt-tracker-timeout=<SEGUNDOS>
|
||
|
|
|
||
|
|
Set timeout in seconds. Padrão: ``60``
|
||
|
|
|
||
|
|
.. option:: --dht-entry-point=<HOST>:<PORT>
|
||
|
|
|
||
|
|
Set host and port as an entry point to IPv4 DHT network.
|
||
|
|
|
||
|
|
.. option:: --dht-entry-point6=<HOST>:<PORT>
|
||
|
|
|
||
|
|
Set host and port as an entry point to IPv6 DHT network.
|
||
|
|
|
||
|
|
.. option:: --dht-file-path=<PATH>
|
||
|
|
|
||
|
|
Change the IPv4 DHT routing table file to PATH.
|
||
|
|
Padrão: ``$HOME/.aria2/dht.dat``
|
||
|
|
|
||
|
|
.. option:: --dht-file-path6=<PATH>
|
||
|
|
|
||
|
|
Change the IPv6 DHT routing table file to PATH.
|
||
|
|
Padrão: ``$HOME/.aria2/dht6.dat``
|
||
|
|
|
||
|
|
.. option:: --dht-listen-addr6=<ADDR>
|
||
|
|
|
||
|
|
Specify address to bind socket for IPv6 DHT. It should be a global
|
||
|
|
unicast IPv6 address of the host.
|
||
|
|
|
||
|
|
.. option:: --dht-listen-port=<PORT>...
|
||
|
|
|
||
|
|
Set UDP listening port for both IPv4 and IPv6 DHT.
|
||
|
|
Multiple ports can be specified by using ``,``, for example: ``6881,6885``.
|
||
|
|
You can also use ``-`` to specify a range: ``6881-6999``. ``,`` and ``-``
|
||
|
|
can be used together.
|
||
|
|
Padrão: ``6881-6999``
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Make sure that the specified ports are open for incoming UDP traffic.
|
||
|
|
|
||
|
|
.. option:: --dht-message-timeout=<SEGUNDOS>
|
||
|
|
|
||
|
|
Set timeout in seconds. Padrão: ``10``
|
||
|
|
|
||
|
|
.. option:: --enable-dht[=true|false]
|
||
|
|
|
||
|
|
Enable IPv4 DHT functionality. If a private flag is set in a
|
||
|
|
torrent, aria2 doesn't use DHT for that download even if ``true`` is
|
||
|
|
given. Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --enable-dht6[=true|false]
|
||
|
|
|
||
|
|
Enable IPv6 DHT functionality. If a private flag is set in a
|
||
|
|
torrent, aria2 doesn't use DHT for that download even if ``true`` is
|
||
|
|
given. Use :option:`--dht-listen-port` option to specify port number to
|
||
|
|
listen on. See also :option:`--dht-listen-addr6` option.
|
||
|
|
|
||
|
|
.. option:: --enable-peer-exchange[=true|false]
|
||
|
|
|
||
|
|
Enable Peer Exchange extension. If a private flag is set in a torrent, this
|
||
|
|
feature is disabled for that download even if ``true`` is given.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --follow-torrent=true|false|mem
|
||
|
|
|
||
|
|
If ``true`` or ``mem`` is specified, when a file whose suffix is ``.torrent`` or content
|
||
|
|
type is ``application/x-bittorrent`` is downloaded, aria2 parses it as a torrent
|
||
|
|
file and downloads files mentioned in it.
|
||
|
|
If ``mem`` is specified, a torrent file is not written to the disk, but is just
|
||
|
|
kept in memory.
|
||
|
|
If ``false`` is specified, the action mentioned above is not taken.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: -O, --index-out=<INDEX>=<PATH>
|
||
|
|
|
||
|
|
Set file path for file with index=INDEX. You can find the file index
|
||
|
|
using the :option:`--show-files <-S>` option. PATH is a relative path to the
|
||
|
|
path specified in :option:`--dir <-d>` option. You can use this option multiple
|
||
|
|
times. Using this option, you can specify the output filenames of
|
||
|
|
BitTorrent downloads.
|
||
|
|
|
||
|
|
.. option:: --listen-port=<PORT>...
|
||
|
|
|
||
|
|
Set TCP port number for BitTorrent downloads.
|
||
|
|
Multiple ports can be specified by using ``,``, for example: ``6881,6885``.
|
||
|
|
You can also use ``-`` to specify a range: ``6881-6999``.
|
||
|
|
``,`` and ``-`` can be used together: ``6881-6889,6999``.
|
||
|
|
Padrão: ``6881-6999``
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Make sure that the specified ports are open for incoming TCP traffic.
|
||
|
|
|
||
|
|
.. option:: --max-overall-upload-limit=<SPEED>
|
||
|
|
|
||
|
|
Set max overall upload speed in bytes/sec. ``0`` means unrestricted.
|
||
|
|
You can append ``K`` or ``M`` (1K = 1024, 1M = 1024K).
|
||
|
|
Para limitar a velocidade de upload por torrent, usar opção
|
||
|
|
:option:`--max-upload-limit <-u>`.
|
||
|
|
Padrão: ``0``
|
||
|
|
|
||
|
|
.. option:: -u, --max-upload-limit=<SPEED>
|
||
|
|
|
||
|
|
Set max upload speed per each torrent in bytes/sec.
|
||
|
|
``0`` means unrestricted.
|
||
|
|
You can append ``K`` or ``M`` (1K = 1024, 1M = 1024K).
|
||
|
|
To limit the overall upload speed, use :option:`--max-overall-upload-limit` option.
|
||
|
|
Padrão: ``0``
|
||
|
|
|
||
|
|
.. option:: --peer-id-prefix=<PEER_ID_PREFIX>
|
||
|
|
|
||
|
|
Specify the prefix of peer ID. The peer ID in
|
||
|
|
BitTorrent is 20 byte length. If more than 20
|
||
|
|
bytes are specified, only first 20 bytes are
|
||
|
|
used. If less than 20 bytes are specified, random
|
||
|
|
byte data are added to make its length 20 bytes.
|
||
|
|
Padrão: ``aria2/$VERSION-``, $VERSION is replaced by package version.
|
||
|
|
|
||
|
|
.. option:: --seed-ratio=<RATIO>
|
||
|
|
|
||
|
|
Specify share ratio. Seed completed torrents until share ratio reaches
|
||
|
|
RATIO.
|
||
|
|
You are strongly encouraged to specify equals or more than ``1.0`` here.
|
||
|
|
Specify ``0.0`` if you intend to do seeding regardless of share ratio.
|
||
|
|
If :option:`--seed-time` option is specified along with this option,
|
||
|
|
seeding ends when at least one of the conditions is satisfied.
|
||
|
|
Padrão: ``1.0``
|
||
|
|
|
||
|
|
.. option:: --seed-time=<MINUTES>
|
||
|
|
|
||
|
|
Specify seeding time in minutes. Also see the :option:`--seed-ratio` option.
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Specifying :option:`--seed-time=0 <--seed-time>` disables seeding
|
||
|
|
after download completed.
|
||
|
|
|
||
|
|
.. option:: -T, --torrent-file=<TORRENT_FILE>
|
||
|
|
|
||
|
|
The path to the ".torrent" file. You are not required to use this
|
||
|
|
option because you can specify ".torrent" files without :option:`--torrent-file <-T>`.
|
||
|
|
|
||
|
|
Específicas de Metalink
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
.. option:: --follow-metalink=true|false|mem
|
||
|
|
|
||
|
|
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
|
||
|
|
file and downloads files mentioned in it.
|
||
|
|
If ``mem`` is specified, a metalink file is not written to the disk, but is just
|
||
|
|
kept in memory.
|
||
|
|
If ``false`` is specified, the action mentioned above is not taken.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --metalink-base-uri=<URI>
|
||
|
|
|
||
|
|
Specify base URI to resolve relative URI in metalink:url and
|
||
|
|
metalink:metaurl element in a metalink file stored in local disk. If
|
||
|
|
URI points to a directory, URI must end with ``/``.
|
||
|
|
|
||
|
|
.. option:: -M, --metalink-file=<METALINK_FILE>
|
||
|
|
|
||
|
|
The file path to ".meta4" and ".metalink" file. Reads input from stdin when ``-`` is
|
||
|
|
specified. You are not required to use this option because you can
|
||
|
|
specify ".metalink" files without :option:`--metalink-file <-M>`.
|
||
|
|
|
||
|
|
.. option:: --metalink-language=<LANGUAGE>
|
||
|
|
|
||
|
|
The language of the file to download.
|
||
|
|
|
||
|
|
.. option:: --metalink-location=<LOCATION>[,...]
|
||
|
|
|
||
|
|
The location of the preferred server.
|
||
|
|
A comma-delimited list of locations is acceptable, for example, ``jp,us``.
|
||
|
|
|
||
|
|
.. option:: --metalink-os=<OS>
|
||
|
|
|
||
|
|
The operating system of the file to download.
|
||
|
|
|
||
|
|
.. option:: --metalink-version=<VERSION>
|
||
|
|
|
||
|
|
The version of the file to download.
|
||
|
|
|
||
|
|
.. option:: --metalink-preferred-protocol=<PROTO>
|
||
|
|
|
||
|
|
Specify preferred protocol.
|
||
|
|
The possible values are ``http``, ``https``, ``ftp`` and ``none``.
|
||
|
|
Specify ``none`` to disable this feature.
|
||
|
|
Padrão: ``none``
|
||
|
|
|
||
|
|
.. option:: --metalink-enable-unique-protocol[=true|false]
|
||
|
|
|
||
|
|
If ``true`` is given and several protocols are available for a mirror in a
|
||
|
|
metalink file, aria2 uses one of them.
|
||
|
|
Use :option:`--metalink-preferred-protocol` option to specify the preference of
|
||
|
|
protocol.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
De RPC
|
||
|
|
~~~~~~
|
||
|
|
|
||
|
|
.. option:: --enable-rpc[=true|false]
|
||
|
|
|
||
|
|
Enable JSON-RPC/XML-RPC server. It is strongly recommended to set username
|
||
|
|
and password using :option:`--rpc-user` and :option:`--rpc-passwd`
|
||
|
|
option. See also :option:`--rpc-listen-port` option. Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --pause[=true|false]
|
||
|
|
|
||
|
|
Pause download after added. This option is effective only when
|
||
|
|
:option:`--enable-rpc=true <--enable-rpc>` is given.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
|
||
|
|
.. option:: --rpc-allow-origin-all[=true|false]
|
||
|
|
|
||
|
|
Add Access-Control-Allow-Origin header field with value ``*`` to the
|
||
|
|
RPC response.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --rpc-listen-all[=true|false]
|
||
|
|
|
||
|
|
Listen incoming JSON-RPC/XML-RPC requests on all network interfaces. If false
|
||
|
|
is given, listen only on local loopback interface. Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --rpc-listen-port=<PORT>
|
||
|
|
|
||
|
|
Specify a port number for JSON-RPC/XML-RPC server to listen to. Possible
|
||
|
|
Values: ``1024`` -``65535`` Padrão: ``6800``
|
||
|
|
|
||
|
|
.. option:: --rpc-max-request-size=<TAMANHO>
|
||
|
|
|
||
|
|
Set max size of JSON-RPC/XML-RPC request. If aria2 detects the request is
|
||
|
|
more than SIZE bytes, it drops connection. Padrão: ``2M``
|
||
|
|
|
||
|
|
.. option:: --rpc-passwd=<PASSWD>
|
||
|
|
|
||
|
|
Set JSON-RPC/XML-RPC password.
|
||
|
|
|
||
|
|
.. option:: --rpc-user=<USUÁRIO>
|
||
|
|
|
||
|
|
Set JSON-RPC/XML-RPC user.
|
||
|
|
|
||
|
|
Avançadas
|
||
|
|
~~~~~~~~~
|
||
|
|
.. option:: --allow-overwrite[=true|false]
|
||
|
|
|
||
|
|
Restart download from scratch if the corresponding control file
|
||
|
|
doesn't exist. See also :option:`--auto-file-renaming` option. Padrão:
|
||
|
|
``false``
|
||
|
|
|
||
|
|
.. option:: --allow-piece-length-change[=true|false]
|
||
|
|
|
||
|
|
If false is given, aria2 aborts download when a piece length is different
|
||
|
|
from one in a control file.
|
||
|
|
If true is given, you can proceed but some download progress will be lost.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --always-resume[=true|false]
|
||
|
|
|
||
|
|
Always resume download. If ``true`` is given, aria2 always tries to
|
||
|
|
resume download and if resume is not possible, aborts download. If
|
||
|
|
``false`` is given, when all given URIs do not support resume or aria2
|
||
|
|
encounters ``N`` URIs which does not support resume (``N`` is the value
|
||
|
|
specified using :option:`--max-resume-failure-tries` option), aria2
|
||
|
|
downloads file from scratch. See :option:`--max-resume-failure-tries`
|
||
|
|
option. Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --async-dns[=true|false]
|
||
|
|
|
||
|
|
Enable asynchronous DNS.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --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.
|
||
|
|
|
||
|
|
.. option:: --auto-file-renaming[=true|false]
|
||
|
|
|
||
|
|
Rename file name if the same file already exists.
|
||
|
|
This option works only in HTTP, HTTPS e FTP download.
|
||
|
|
The new file name has a dot and a number(1..9999) appended.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --auto-save-interval=<SEGUNDOS>
|
||
|
|
|
||
|
|
Save a control file(\*.aria2) every SEC seconds.
|
||
|
|
If ``0`` is given, a control file is not saved during download. aria2 saves a
|
||
|
|
control file when it stops regardless of the value.
|
||
|
|
The possible values are between ``0`` to ``600``.
|
||
|
|
Padrão: ``60``
|
||
|
|
|
||
|
|
.. option:: --conditional-get[=true|false]
|
||
|
|
|
||
|
|
Download file only when the local file is older than remote
|
||
|
|
file. This function only works with HTTP, HTTPS, downloads only. It does
|
||
|
|
not work if file size is specified in Metalink. It also ignores
|
||
|
|
Content-Disposition header. If a control file exists, this option
|
||
|
|
will be ignored. This function uses If-Modified-Since header to get
|
||
|
|
only newer file conditionally. When getting modification time of
|
||
|
|
local file, it uses user supplied filename(see :option:`--out <-o>` option) or
|
||
|
|
filename part in URI if :option:`--out <-o>` is not specified.
|
||
|
|
To overwrite existing file, :option:`--allow-overwrite` is required.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --conf-path=<PATH>
|
||
|
|
|
||
|
|
Change the configuration file path to PATH.
|
||
|
|
Padrão: ``$HOME/.aria2/aria2.conf``
|
||
|
|
|
||
|
|
.. option:: -D, --daemon[=true|false]
|
||
|
|
|
||
|
|
Run as daemon. The current working directory will be changed to ``/``
|
||
|
|
and standard input, standard output and standard error will be
|
||
|
|
redirected to ``/dev/null``. Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --deferred-input[=true|false]
|
||
|
|
|
||
|
|
If ``true`` is given, aria2 does not read all URIs and options from file
|
||
|
|
specified by :option:`--input-file <-i>` option at startup,
|
||
|
|
but it reads one by one when it
|
||
|
|
needs later. This may reduce memory usage if input file contains a
|
||
|
|
lot of URIs to download. If ``false`` is given, aria2 reads all URIs
|
||
|
|
and options at startup.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --disable-ipv6[=true|false]
|
||
|
|
|
||
|
|
Disable IPv6. This is useful if you have to use broken DNS and want
|
||
|
|
to avoid terribly slow AAAA record lookup. Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --download-result=<OPT>
|
||
|
|
|
||
|
|
This option changes the way ``Download Results`` is formatted. If OPT
|
||
|
|
is ``default``, print GID, status, average download speed and
|
||
|
|
path/URI. If multiple files are involved, path/URI of first
|
||
|
|
requested file is printed and remaining ones are omitted. If OPT is
|
||
|
|
``full``, print GID, status, average download speed, percentage of
|
||
|
|
progress and path/URI. The percentage of progress and path/URI are
|
||
|
|
printed for each requested file in each row.
|
||
|
|
Padrão: ``default``
|
||
|
|
|
||
|
|
.. option:: --enable-async-dns6[=true|false]
|
||
|
|
|
||
|
|
Enable IPv6 name resolution in asynchronous DNS resolver. This
|
||
|
|
option will be ignored when :option:`--async-dns=false. <--async-dns>`
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --enable-mmap[=true|false]
|
||
|
|
|
||
|
|
Map files into memory. This option may not work if the file space
|
||
|
|
is not pre-allocated. See :option:`--file-allocation`.
|
||
|
|
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --event-poll=<POLL>
|
||
|
|
|
||
|
|
Specify the method for polling events. The possible values are
|
||
|
|
``epoll``, ``kqueue``, ``port``, ``poll`` and ``select``. For each ``epoll``,
|
||
|
|
``kqueue``, ``port`` and ``poll``, it is available if system supports it.
|
||
|
|
``epoll`` is available on recent Linux. ``kqueue`` is available on
|
||
|
|
various \*BSD systems including Mac OS X. ``port`` is available on Open
|
||
|
|
Solaris. The default value may vary depending on the system you use.
|
||
|
|
|
||
|
|
.. option:: --file-allocation=<METHOD>
|
||
|
|
|
||
|
|
Specify file allocation method.
|
||
|
|
``none`` doesn't pre-allocate file space. ``prealloc`` pre-allocates file space
|
||
|
|
before download begins. This may take some time depending on the size of the
|
||
|
|
file.
|
||
|
|
If you are using newer file systems such as ext4
|
||
|
|
(with extents support), btrfs, xfs or NTFS(MinGW build only), ``falloc`` is
|
||
|
|
your best choice. It allocates large(few GiB)
|
||
|
|
files almost instantly. Don't use ``falloc`` with
|
||
|
|
legacy file systems such as ext3 and FAT32 because it takes
|
||
|
|
almost same time as ``prealloc`` and it blocks aria2
|
||
|
|
entirely until allocation finishes. ``falloc`` may
|
||
|
|
not be available if your system doesn't have
|
||
|
|
:manpage:`posix_fallocate(3)` function.
|
||
|
|
``trunc`` uses :manpage:`ftruncate(2)` system call or
|
||
|
|
platform-specific counterpart to truncate a file to a specified
|
||
|
|
length.
|
||
|
|
|
||
|
|
Possible Values: ``none``, ``prealloc``, ``trunc``, ``falloc``
|
||
|
|
Padrão: ``prealloc``
|
||
|
|
|
||
|
|
.. option:: --hash-check-only[=true|false]
|
||
|
|
|
||
|
|
If ``true`` is given, after hash check using
|
||
|
|
:option:`--check-integrity <-V>` option,
|
||
|
|
abort download whether or not download is complete.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --human-readable[=true|false]
|
||
|
|
|
||
|
|
Print sizes and speed in human readable format (e.g., 1.2Ki, 3.4Mi)
|
||
|
|
in the console readout. Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --interface=<INTERFACE>
|
||
|
|
|
||
|
|
Bind sockets to given interface. You can specify interface name, IP
|
||
|
|
address and hostname.
|
||
|
|
Possible Values: interface, IP address, hostname
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
If an interface has multiple addresses, it is highly recommended to
|
||
|
|
specify IP address explicitly. See also :option:`--disable-ipv6`. If your
|
||
|
|
system doesn't have :manpage:`getifaddrs(3)`, this option doesn't accept interface
|
||
|
|
name.
|
||
|
|
|
||
|
|
.. option:: --max-download-result=<NÚMERO>
|
||
|
|
|
||
|
|
Set maximum number of download result kept in memory. The download
|
||
|
|
results are completed/error/removed downloads. The download results
|
||
|
|
are stored in FIFO queue and it can store at most NUM download
|
||
|
|
results. When queue is full and new download result is created,
|
||
|
|
oldest download result is removed from the front of the queue and
|
||
|
|
new one is pushed to the back. Setting big number in this option may
|
||
|
|
result high memory consumption after thousands of
|
||
|
|
downloads. Specifying 0 means no download result is kept. Padrão:
|
||
|
|
``1000``
|
||
|
|
|
||
|
|
.. option:: --max-resume-failure-tries=<N>
|
||
|
|
|
||
|
|
When used with :option:`--always-resume=false, <--always-resume>` aria2 downloads file from
|
||
|
|
scratch when aria2 detects N number of URIs that does not support
|
||
|
|
resume. If N is ``0``, aria2 downloads file from scratch when all
|
||
|
|
given URIs do not support resume. See :option:`--always-resume` option.
|
||
|
|
Padrão: ``0``
|
||
|
|
|
||
|
|
.. option:: --log-level=<LEVEL>
|
||
|
|
|
||
|
|
Set log level to output.
|
||
|
|
LEVEL is either ``debug``, ``info``, ``notice``, ``warn`` or ``error``.
|
||
|
|
Padrão: ``debug``
|
||
|
|
|
||
|
|
.. option:: --on-bt-download-complete=<COMMAND>
|
||
|
|
|
||
|
|
For BitTorrent, a command specified in :option:`--on-download-complete` is
|
||
|
|
called after download completed and seeding is over. On the other
|
||
|
|
hand, this option set the command to be executed after download
|
||
|
|
completed but before seeding.
|
||
|
|
See `Interação com Eventos (Hook)`_ for more details about COMMAND.
|
||
|
|
Possible Values: ``/path/to/command``
|
||
|
|
|
||
|
|
.. option:: --on-download-complete=<COMMAND>
|
||
|
|
|
||
|
|
Set the command to be executed after download completed. See
|
||
|
|
See `Interação com Eventos (Hook)`_ for more details about COMMAND.
|
||
|
|
See also :option:`--on-download-stop` option.
|
||
|
|
Possible Values: ``/path/to/command``
|
||
|
|
|
||
|
|
.. option:: --on-download-error=<COMMAND>
|
||
|
|
|
||
|
|
Set the command to be executed after download aborted due to error.
|
||
|
|
See `Interação com Eventos (Hook)`_ for more details about COMMAND.
|
||
|
|
See also :option:`--on-download-stop` option. Possible Values:
|
||
|
|
``/path/to/command``
|
||
|
|
|
||
|
|
.. option:: --on-download-pause=<COMMAND>
|
||
|
|
|
||
|
|
Set the command to be executed after download was paused.
|
||
|
|
See `Interação com Eventos (Hook)`_ for more details about COMMAND.
|
||
|
|
Possible Values: ``/path/to/command``
|
||
|
|
|
||
|
|
.. option:: --on-download-start=<COMMAND>
|
||
|
|
|
||
|
|
Set the command to be executed after download got started.
|
||
|
|
See `Interação com Eventos (Hook)`_ for more details about COMMAND.
|
||
|
|
Possible Values: ``/path/to/command``
|
||
|
|
|
||
|
|
.. option:: --on-download-stop=<COMMAND>
|
||
|
|
|
||
|
|
Set the command to be executed after download stopped. You can override
|
||
|
|
the command to be executed for particular download result using
|
||
|
|
:option:`--on-download-complete` and :option:`--on-download-error`. If they are
|
||
|
|
specified, command specified in this option is not executed.
|
||
|
|
See `Interação com Eventos (Hook)`_ for more details about COMMAND.
|
||
|
|
Possible Values: ``/path/to/command``
|
||
|
|
|
||
|
|
.. option:: --piece-length=<LENGTH>
|
||
|
|
|
||
|
|
Set a piece length for HTTP e FTP downloads. This is the boundary when
|
||
|
|
aria2 splits a file. All splits occur at multiple of this
|
||
|
|
length. This option will be ignored in BitTorrent downloads. It
|
||
|
|
will be also ignored if Metalink file contains piece hashes.
|
||
|
|
Padrão: ``1M``
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
The possible usecase of :option:`--piece-length`
|
||
|
|
option is change the request range in one HTTP pipelined request.
|
||
|
|
To enable HTTP pipelining use
|
||
|
|
:option:`--enable-http-pipelining`.
|
||
|
|
|
||
|
|
.. option:: --show-console-readout[=true|false]
|
||
|
|
|
||
|
|
Show console readout. Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: --summary-interval=<SEGUNDOS>
|
||
|
|
|
||
|
|
Set interval in seconds to output download progress summary.
|
||
|
|
Setting ``0`` suppresses the output.
|
||
|
|
Padrão: ``60``
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
In multi file torrent downloads, the files adjacent forward to the specified files
|
||
|
|
are also allocated if they share the same piece.
|
||
|
|
|
||
|
|
.. option:: -Z, --force-sequential[=true|false]
|
||
|
|
|
||
|
|
Fetch URIs in the command-line sequentially and download each URI in a
|
||
|
|
separate session, like the usual command-line download utilities.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --max-overall-download-limit=<SPEED>
|
||
|
|
|
||
|
|
Set max overall download speed in bytes/sec. ``0`` means
|
||
|
|
unrestricted. You can append ``K`` or ``M`` (1K = 1024, 1M = 1024K). To
|
||
|
|
limit the download speed per download, use :option:`--max-download-limit`
|
||
|
|
option. Padrão: ``0``
|
||
|
|
|
||
|
|
.. option:: --max-download-limit=<SPEED>
|
||
|
|
|
||
|
|
Set max download speed per each download in bytes/sec. ``0`` means
|
||
|
|
unrestricted. You can append ``K`` or ``M`` (1K = 1024, 1M = 1024K). To
|
||
|
|
limit the overall download speed, use :option:`--max-overall-download-limit`
|
||
|
|
option. Padrão: ``0``
|
||
|
|
|
||
|
|
.. option:: --no-conf[=true|false]
|
||
|
|
|
||
|
|
Disable loading aria2.conf file.
|
||
|
|
|
||
|
|
.. option:: --no-file-allocation-limit=<TAMANHO>
|
||
|
|
|
||
|
|
No file allocation is made for files whose size is smaller than SIZE.
|
||
|
|
You can append ``K`` or ``M`` (1K = 1024, 1M = 1024K).
|
||
|
|
Padrão: ``5M``
|
||
|
|
|
||
|
|
.. option:: -P, --parameterized-uri[=true|false]
|
||
|
|
|
||
|
|
Enable parameterized URI support.
|
||
|
|
You can specify set of parts: ``http://{sv1,sv2,sv3}/foo.iso``.
|
||
|
|
Also you can specify numeric sequences with step counter:
|
||
|
|
``http://host/image[000-100:2].img``.
|
||
|
|
A step counter can be omitted.
|
||
|
|
If all URIs do not point to the same file, such as the second example above,
|
||
|
|
-Z option is required.
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: -q, --quiet[=true|false]
|
||
|
|
|
||
|
|
Make aria2 quiet (no console output).
|
||
|
|
Padrão: ``false``
|
||
|
|
|
||
|
|
.. option:: --realtime-chunk-checksum[=true|false]
|
||
|
|
|
||
|
|
Validate chunk of data by calculating checksum while downloading a file if
|
||
|
|
chunk checksums are provided.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
|
||
|
|
.. option:: --remove-control-file[=true|false]
|
||
|
|
|
||
|
|
Remove control file before download. Using with
|
||
|
|
:option:`--allow-overwrite=true, <--allow-overwrite>` download always starts from
|
||
|
|
scratch. This will be useful for users behind proxy server which
|
||
|
|
disables resume.
|
||
|
|
|
||
|
|
.. option:: --save-session=<ARQUIVO>
|
||
|
|
|
||
|
|
Save error/unfinished downloads to FILE on exit. You can pass this
|
||
|
|
output file to aria2c with :option:`--input-file <-i>` option on restart. Please note that
|
||
|
|
downloads added by :func:`aria2.addTorrent` and
|
||
|
|
:func:`aria2.addMetalink`
|
||
|
|
RPC method and whose metadata could not be saved as a file are not saved.
|
||
|
|
Downloads removed using
|
||
|
|
:func:`aria2.remove` and
|
||
|
|
:func:`aria2.forceRemove`
|
||
|
|
will not be saved.
|
||
|
|
|
||
|
|
.. option:: --stop=<SEGUNDOS>
|
||
|
|
|
||
|
|
Stop application after SEC seconds has passed.
|
||
|
|
If ``0`` is given, this feature is disabled.
|
||
|
|
Padrão: ``0``
|
||
|
|
|
||
|
|
.. option:: --stop-with-process=<PID>
|
||
|
|
|
||
|
|
Stop application when process PID is not running. This is useful if
|
||
|
|
aria2 process is forked from a parent process. The parent process
|
||
|
|
can fork aria2 with its own pid and when parent process exits for
|
||
|
|
some reason, aria2 can detect it and shutdown itself.
|
||
|
|
|
||
|
|
.. option:: --truncate-console-readout[=true|false]
|
||
|
|
|
||
|
|
Truncate console readout to fit in a single line.
|
||
|
|
Padrão: ``true``
|
||
|
|
|
||
|
|
.. option:: -v, --version
|
||
|
|
|
||
|
|
Print the version number, copyright and the configuration information and
|
||
|
|
exit.
|
||
|
|
|
||
|
|
Argumento(s) Opcional(is)
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
The options that have its argument surrounded by square brackets([])
|
||
|
|
take an optional argument. Usually omiting the argument is evaluated to ``true``.
|
||
|
|
If you use short form of these options(such as ``-V``) and give
|
||
|
|
an argument, then the option name and its argument should be concatenated(e.g.
|
||
|
|
``-Vfalse``). If any spaces are inserted between the option name and the argument,
|
||
|
|
the argument will be treated as URI and usually this is not what you expect.
|
||
|
|
|
||
|
|
URI, MAGNET, TORRENT_FILE, METALINK_FILE
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
Pode-se especificar múltiplas URIs em uma linha de comando. A menos que seja
|
||
|
|
especificada a opção :option:`--force-sequential <-Z>`, todas as URIs devem
|
||
|
|
apontar para o mesmo arquivo que será baixado ou o download falhará.
|
||
|
|
|
||
|
|
Pode-se especificar um número arbitrátio de URIs de BitTorrent Magnet URI.
|
||
|
|
Nove que eles sempre serão tratados como downloads separados.
|
||
|
|
São suportados Hash de Info de 40 characters e Hast de Info Base32 de 32
|
||
|
|
characters. Múltiplos parâmetros ``tr`` são suportados. Devido a URI
|
||
|
|
BitTorrent Magnet poder conter o caracter ``&``, é altamente recomendável
|
||
|
|
delimitar a URI com apóstrofo single(``'``) ou aspas double(``"``).
|
||
|
|
É altamente recomendável habilitar DHT especialmente quando ``tr`` o parâmetro
|
||
|
|
estiver ausente. Ver http://www.bittorrent.org/beps/bep_0009.html
|
||
|
|
para maiores detalhes sobre URI BitTorrent Magnet.
|
||
|
|
|
||
|
|
Pode-se também especificar um número arbitrário de arquivos torrent e
|
||
|
|
Documentos Metalink armazenados em um dispositivo local. Note que sempre serão
|
||
|
|
tratados como download distintos. Tanto Metalink4 quanto Metalink da versão 3
|
||
|
|
são suportados.
|
||
|
|
|
||
|
|
Pode-se especificar arquivo torrent usando a opção -T e URI. Fazendo isso
|
||
|
|
o download será baixado do servidor swarm e HTTP, HTTPS e FTP ao mesmo tempo,
|
||
|
|
enquanto os dados do HTTP, HTTPS e FTP serão uploaded para o swarm torrent.
|
||
|
|
Para torrent de um arquivo a URI deve ser completa e apontar inclusive o
|
||
|
|
recurso ou se a URI terminar com / o nome do torrent será adicionado. Para
|
||
|
|
múltiplos torrents, name e caminho serão adicionados para formar a URI, para
|
||
|
|
cada um dos arquivos.
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Certifique-se que a URI seja delimitada por apóstrofo single(``'``) ou
|
||
|
|
aspas double(``"``) se a URI contiver ``&`` ou qualquer outro caracter que
|
||
|
|
tenha significado especial para o shell.
|
||
|
|
|
||
|
|
Continuar Download Interrompido
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
Normalmente pode-se retomar uma transferência apenas executando-se o comando
|
||
|
|
aria2c URI, caso a transferência anterior estava sendo feita pelo aria2.
|
||
|
|
|
||
|
|
Caso a transferência anterior estava sendo feita por um navegador ou wget de
|
||
|
|
maneira sequencial, então utilize a opção :option:`--continue <-c>` para
|
||
|
|
retomar do ponto onde foi interrompida a transferência.
|
||
|
|
|
||
|
|
Interação com Eventos (Hook)
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
aria2 possui opções para especificar comando arbitrário após um evento
|
||
|
|
específico ocorrer. Atualmente as seguintes opções estão disponíveis:
|
||
|
|
|
||
|
|
:option:`--on-bt-download-complete`,
|
||
|
|
:option:`--on-download-pause`,
|
||
|
|
:option:`--on-download-complete`.
|
||
|
|
:option:`--on-download-start`,
|
||
|
|
:option:`--on-download-error`,
|
||
|
|
:option:`--on-download-stop`.
|
||
|
|
|
||
|
|
aria2 passa 3 argumentos para um comando especificado quando este comando for
|
||
|
|
executado. Estes argumentos são: GID, o número de arquivos e o caminho dos
|
||
|
|
arquivos. Para downloads HTTP, HTTPS e FTP normalmente o número de arquivos é 1.
|
||
|
|
BitTorrent podem conter múltiplos arquivos. Se o número de arquivos é maior
|
||
|
|
que 1, o caminho do arquivo é o primeiro. Em outras palavras, este é o valor
|
||
|
|
da chave path da primeira estrutura se aquela chave for verdadeira como
|
||
|
|
resposta do método da função :func:`aria2.getFiles` RPC .
|
||
|
|
Se for necessário todos os caminhos dos arquivos, considere usar o método
|
||
|
|
JSON-RPC/XML-RPC. Lembre-se que o caminho do arquivo pode ser modificado
|
||
|
|
durante o download no HTTP por causa do redirecionamento ou Disposição do
|
||
|
|
Conteúdo do Cabeçalho.
|
||
|
|
|
||
|
|
Observemos um exemplo de como são passados argumentos para um comando:
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ cat hook.sh
|
||
|
|
#!/bin/sh
|
||
|
|
echo "chamado com [$1] [$2] [$3]"
|
||
|
|
$ aria2c --on-download-complete hook.sh http://dobrasil.org/arquivo.iso
|
||
|
|
chamado com [1] [1] [/caminho/para/arquivo.iso]
|
||
|
|
|
||
|
|
|
||
|
|
CÓDIGO DE RETORNO
|
||
|
|
-----------------
|
||
|
|
|
||
|
|
Como aria2 pode manipular múltiplos downloads concomitantemente, podem ser
|
||
|
|
encontrados vários erros durante uma sessão. aria2 retorna os códigos de
|
||
|
|
retorno ou saída com base no último erro encontrado.
|
||
|
|
|
||
|
|
0
|
||
|
|
Se todos os downloads terminam com sucesso.
|
||
|
|
|
||
|
|
1
|
||
|
|
Erro desconhecido ocorreu.
|
||
|
|
|
||
|
|
2
|
||
|
|
Tempo transcorrido (time out).
|
||
|
|
|
||
|
|
3
|
||
|
|
Recurso não encontrado.
|
||
|
|
|
||
|
|
4
|
||
|
|
Se aria2 tentou um número especificado de vezes e obteve "recurso não encontrado".
|
||
|
|
Ver opção :option:`--max-file-not-found`.
|
||
|
|
|
||
|
|
5
|
||
|
|
Se download interrompido porque a velocidade de download é muito baixa.
|
||
|
|
Ver opção :option:`--lowest-speed-limit`
|
||
|
|
|
||
|
|
6
|
||
|
|
Erro na rede (network).
|
||
|
|
|
||
|
|
7
|
||
|
|
Se existem downloads não concluidos. Esse erro é reportado somente se
|
||
|
|
todos os downloads foram concluídos com sucesso mas existe uma fila quando
|
||
|
|
aria2 foi interrompido por quando foi pressionado :kbd:`Ctrl-C` pelo usuário
|
||
|
|
ou enviado o sinal TERM ou INT.
|
||
|
|
|
||
|
|
8
|
||
|
|
Se o servidor remoto não suporta retomar um download que deve ser completado.
|
||
|
|
|
||
|
|
9
|
||
|
|
Não há espaço em disco suficiente para os downloads.
|
||
|
|
|
||
|
|
10
|
||
|
|
Se o tamanho do pedaço (piece) foi diferente do arquivo de controle .aria2.
|
||
|
|
Ver opção :option:`--allow-piece-length-change`.
|
||
|
|
|
||
|
|
11
|
||
|
|
Se aria2 estava fazendo o download do mesmo arquivo no momento.
|
||
|
|
|
||
|
|
12
|
||
|
|
If aria2 estava fazendo o download do mesmo, hash do torrent, no momento.
|
||
|
|
|
||
|
|
13
|
||
|
|
Se o arquivo já existe. Ver opção :option:`--allow-overwrite`.
|
||
|
|
|
||
|
|
14
|
||
|
|
Se renomer o arquivo falhou. Ver opção :option:`--auto-file-renaming`.
|
||
|
|
|
||
|
|
15
|
||
|
|
Se aria2 não pode abrir o arquivo existente.
|
||
|
|
|
||
|
|
16
|
||
|
|
Se aria2 não pode criar novo arquivo ou truncar um arquivo já existente.
|
||
|
|
|
||
|
|
17
|
||
|
|
Se ocorreu erro de I/O no arquivo.
|
||
|
|
|
||
|
|
18
|
||
|
|
Se aria2 não pode criar diretório.
|
||
|
|
|
||
|
|
19
|
||
|
|
Se resolução de nomes falhou.
|
||
|
|
|
||
|
|
20
|
||
|
|
Se aria2 não pode passar documento Metalink.
|
||
|
|
|
||
|
|
21
|
||
|
|
Se comando FTP falhou.
|
||
|
|
|
||
|
|
22
|
||
|
|
Se cabeçalho de resposta HTTP está errado ou inesperado.
|
||
|
|
|
||
|
|
23
|
||
|
|
Se muitos redirecionamentos ocorreram.
|
||
|
|
|
||
|
|
24
|
||
|
|
Se autorização HTTP falhou.
|
||
|
|
|
||
|
|
25
|
||
|
|
Se aria2 não pode passar arquivo bencoded file (normalmente arq. ".torrent").
|
||
|
|
|
||
|
|
26
|
||
|
|
Se arquivo ".torrent" estava corrompido ou inexistem informações que aria2
|
||
|
|
necessita.
|
||
|
|
|
||
|
|
27
|
||
|
|
Se URI Magnet URI está errada.
|
||
|
|
|
||
|
|
28
|
||
|
|
Se opção está errada ou não é reconhecida ou argumento inválido de uma opção
|
||
|
|
foi informado.
|
||
|
|
|
||
|
|
29
|
||
|
|
Se o servidor remoto não pode manusear uma requisição devido a sobrecarga
|
||
|
|
temporária ou manutenção.
|
||
|
|
|
||
|
|
30
|
||
|
|
Se aria2 não pode passar uma requisição JSON-RPC.
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Um erro ocorrido em um download completado não será reportado como um
|
||
|
|
status de saida (exit status).
|
||
|
|
|
||
|
|
VARIÁVEIS DE AMBIENTE
|
||
|
|
---------------------
|
||
|
|
aria2 reconhece as seguintes variáveis de ambiente.
|
||
|
|
|
||
|
|
``http_proxy [http://][USUÁRIO:SENHA@]SERVIDOR[:PORTA]``
|
||
|
|
Especifica o servidor para uso do HTTP.
|
||
|
|
Sobrepõe o valor do http-proxy do arquivo de configuração.
|
||
|
|
A opção linha de comando :option:`--http-proxy` sobrepõe este valor.
|
||
|
|
|
||
|
|
``https_proxy [http://][USUÁRIO:SENHA@]SERVIDOR[:PORTA]``
|
||
|
|
Especifica o servidor proxy para uso do HTTPS.
|
||
|
|
Sobrepõe o valor do https-proxy do arquivo de configuração.
|
||
|
|
A opção linha de comando :option:`--https-proxy` sobrepõe este valor.
|
||
|
|
|
||
|
|
``ftp_proxy [http://][USUÁRIO:SENHA@]SERVIDOR[:PORTA]``
|
||
|
|
Especifica o servidor proxy para uso do FTP.
|
||
|
|
Sobrepõe o valor do http-proxy do arquivo de configuração.
|
||
|
|
A opção linha de comando :option:`--ftp-proxy` sobrepõe este valor.
|
||
|
|
|
||
|
|
``all_proxy [http://][USUÁRIO:SENHA@]SERVIDOR[:PORTA]``
|
||
|
|
Especifica o servidor proxy para uso se nenhum protocolo-específico de proxy
|
||
|
|
é informado.
|
||
|
|
Sobrepõe o valor all-proxy do arquivo de configuração.
|
||
|
|
A opção linha de comando :option:`--all-proxy` sobrepõe este valor.
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Apesar de aria2 aceitar os esquemas ``ftp://`` e ``https://`` para proxy de
|
||
|
|
URI, aria2 assume que ``http://`` é especificado e não troca o comportamento
|
||
|
|
com base no esquema especificado.
|
||
|
|
|
||
|
|
``no_proxy [DOMÍNIO,...]``
|
||
|
|
Especifica nome de servidores, separados por vírgula, domínios e endereços
|
||
|
|
de rede com ou sem blocos CIDR para os quais não será usado proxy.
|
||
|
|
Sobrepõe o valor no-proxy do arquivo de configuração.
|
||
|
|
A opção linha de comando :option:`--no-proxy` sobrepõe este valor.
|
||
|
|
|
||
|
|
ARQUIVOS
|
||
|
|
--------
|
||
|
|
aria2.conf
|
||
|
|
~~~~~~~~~~
|
||
|
|
|
||
|
|
Por padrão, aria2 utiliza ``$HOME/.aria2/aria2.conf`` como arquivo de
|
||
|
|
configuração. Pode ser especificado o caminho do arquivo usando-se a opção
|
||
|
|
:option:`--conf-path`. Se não desejar usar a configuração de arquivo utilize
|
||
|
|
a opção :option:`--no-conf`.
|
||
|
|
|
||
|
|
O arquivo de configuração é um arquivo texto e possui uma opção por linha.
|
||
|
|
Em cada linha, deve haver um par (nome-valor), no formato:
|
||
|
|
``NOME=VALOR``, onde nome é o nome longo da linha de comando sem o prefixo
|
||
|
|
``--``. Pode ser usada a mesma sintaxe da opção da linha de comando.
|
||
|
|
Linhas que começam com ``#`` são tratados como comentários::
|
||
|
|
|
||
|
|
# arquivo de simples configuração para aria2c
|
||
|
|
listen-port=60000
|
||
|
|
dht-listen-port=60000
|
||
|
|
seed-ratio=1.0
|
||
|
|
max-upload-limit=50K
|
||
|
|
ftp-pasv=true
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Informações confidenciais como usuário/senha podem ser incluídas no arquivo
|
||
|
|
de configuração, mas recomenda-se trocar os bits de seu modo de acesso
|
||
|
|
(por exemplo: ``chmod 600 aria2.conf``), dessa maneira nenhum outro usuário
|
||
|
|
consegue ver o conteúdo desse arquivo de configuração.
|
||
|
|
|
||
|
|
dht.dat
|
||
|
|
~~~~~~~~
|
||
|
|
|
||
|
|
Por padrão, a tabela de rota do IPv4 DHT está em ``$HOME/.aria2/dht.dat`` e a
|
||
|
|
tabela de rota do IPv6 DHT existe está em ``$HOME/.aria2/dht6.dat``.
|
||
|
|
|
||
|
|
Netrc
|
||
|
|
~~~~~
|
||
|
|
|
||
|
|
Por padrão, o suporte a Netrc está habilitado para HTTP, HTTPS e FTP. Para
|
||
|
|
desabilitar o suporte a netrc especificar :option:`--no-netrc <-n>`. Seu
|
||
|
|
arquivo .netrc precisa ter as permissões corretas (600).
|
||
|
|
|
||
|
|
Se o nome do servidor inicia com ``.``, aria2 executa pesquisa domínio ao
|
||
|
|
invés de pesquisa exata. Isto é uma extensão de aria2. Exemplo de pesquisa
|
||
|
|
de domínio, imagine as seguinte entrada no arquivo .netrc::
|
||
|
|
|
||
|
|
machine .dobrasil.org login meuid password minhasenha
|
||
|
|
|
||
|
|
|
||
|
|
``aria2.dobrasil.org`` pesquisa domínio ``.dobrasil.org`` e usa ``meuid`` e
|
||
|
|
``minhasenha``.
|
||
|
|
|
||
|
|
Mais exemplos de pesquisa domínio: ``nobrasil.net`` não executa pesquisa
|
||
|
|
domínio ``.nobrasil.net``. ``dobrasil.org`` não faz pesquisa domínio ``.dobrasil.org``
|
||
|
|
pois tem maior amplitude hierárquica por causa do ponto precedente ``.``. Se
|
||
|
|
desejar utilizar ``dobrasil.org``, especificar ``dobrasil.org``.
|
||
|
|
|
||
|
|
Arquivo de Controle
|
||
|
|
~~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
aria2 utiliza um arquivo de controle para rastrear o progresso
|
||
|
|
de um download. Este arquivo é gravado no mesmo diretório do
|
||
|
|
arquivo que está sendo baixado e possui o sufixo ``.aria2``.
|
||
|
|
Por exemplo,se está baixando arquivo.zip, então o arquivo de controle
|
||
|
|
será arquivo.zip.aria2. (Existe apenas uma exceção para essa convenção
|
||
|
|
que é quando você está baixando um multi torrent, o arquivo de controle
|
||
|
|
estará no "diretório topo" do torrent com o sufixo ``.aria2``. O nome do
|
||
|
|
"diretório topo" é o valor da chave "name" no diretório "info" do arquivo
|
||
|
|
torrent).
|
||
|
|
|
||
|
|
Normalmente um arquivo controle é apagado quando o download se completa. Se
|
||
|
|
aria2 detecta que o download não pode ser retomado (por exemplo, quando faz
|
||
|
|
download de um servidor HTTP que não suporta retomar o processamento de um
|
||
|
|
ponto mas sempre do início), o arquivo de controle não será criado.
|
||
|
|
|
||
|
|
Se você perder o arquivo de controle, não será possivel retomar o download do
|
||
|
|
ponto onde estava. Mas se há um torrent ou metalink com checksum (verificação) do
|
||
|
|
arquivo, poderá ser retomado do último ponto especificando a opção -V na linha
|
||
|
|
de comando.
|
||
|
|
|
||
|
|
Arquivo de Entrada
|
||
|
|
~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
O arquivo de entrada pode conter uma lista de URIs para que o aria2 efetua
|
||
|
|
download. Podem ser especificados múltiplas URIs para cada simples entidade:
|
||
|
|
separar as entidades por um caracter TAB ou espaço.
|
||
|
|
|
||
|
|
Cada linha é tratada como se fosse especificada através de um argumento da linha
|
||
|
|
de comando. Entretando estas linhas são afetadas pela opção
|
||
|
|
:option:`--force-sequential <-Z>` e pela opção :option:`--parameterized-uri <-P>`
|
||
|
|
|
||
|
|
Quando as URIs do arquivo de entrada são diretamente lidas pelo aria2, as URIs
|
||
|
|
não precisam necessáriamente estarem delimitadas por apóstrofo (``'``) nem
|
||
|
|
aspas(``"``).
|
||
|
|
|
||
|
|
Linhas que começam com ``#`` são tratadas como comentário e desprezadas.
|
||
|
|
|
||
|
|
Adicionalmente, as seguintes opções podem ser especificadas após cada linha de
|
||
|
|
URI. Estas linhas opcionais precisam iniciar com um ou mais espaços.
|
||
|
|
|
||
|
|
|
||
|
|
.. hlist::
|
||
|
|
:columns: 3
|
||
|
|
|
||
|
|
* :option:`all-proxy <--all-proxy>`
|
||
|
|
* :option:`all-proxy-passwd <--all-proxy-passwd>`
|
||
|
|
* :option:`all-proxy-user <--all-proxy-user>`
|
||
|
|
* :option:`allow-overwrite <--allow-overwrite>`
|
||
|
|
* :option:`allow-piece-length-change <--allow-piece-length-change>`
|
||
|
|
* :option:`always-resume <--always-resume>`
|
||
|
|
* :option:`async-dns <--async-dns>`
|
||
|
|
* :option:`auto-file-renaming <--auto-file-renaming>`
|
||
|
|
* :option:`bt-enable-lpd <--bt-enable-lpd>`
|
||
|
|
* :option:`bt-exclude-tracker <--bt-exclude-tracker>`
|
||
|
|
* :option:`bt-external-ip <--bt-external-ip>`
|
||
|
|
* :option:`bt-hash-check-seed <--bt-hash-check-seed>`
|
||
|
|
* :option:`bt-max-open-files <--bt-max-open-files>`
|
||
|
|
* :option:`bt-max-peers <--bt-max-peers>`
|
||
|
|
* :option:`bt-metadata-only <--bt-metadata-only>`
|
||
|
|
* :option:`bt-min-crypto-level <--bt-min-crypto-level>`
|
||
|
|
* :option:`bt-prioritize-piece <--bt-prioritize-piece>`
|
||
|
|
* :option:`bt-remove-unselected-file <--bt-remove-unselected-file>`
|
||
|
|
* :option:`bt-request-peer-speed-limit <--bt-request-peer-speed-limit>`
|
||
|
|
* :option:`bt-require-crypto <--bt-require-crypto>`
|
||
|
|
* :option:`bt-save-metadata <--bt-save-metadata>`
|
||
|
|
* :option:`bt-seed-unverified <--bt-seed-unverified>`
|
||
|
|
* :option:`bt-stop-timeout <--bt-stop-timeout>`
|
||
|
|
* :option:`bt-tracker <--bt-tracker>`
|
||
|
|
* :option:`bt-tracker-connect-timeout <--bt-tracker-connect-timeout>`
|
||
|
|
* :option:`bt-tracker-interval <--bt-tracker-interval>`
|
||
|
|
* :option:`bt-tracker-timeout <--bt-tracker-timeout>`
|
||
|
|
* :option:`check-integrity <-V>`
|
||
|
|
* :option:`checksum <--checksum>`
|
||
|
|
* :option:`conditional-get <--conditional-get>`
|
||
|
|
* :option:`connect-timeout <--connect-timeout>`
|
||
|
|
* :option:`continue <-c>`
|
||
|
|
* :option:`dir <-d>`
|
||
|
|
* :option:`dry-run <--dry-run>`
|
||
|
|
* :option:`enable-async-dns6 <--enable-async-dns6>`
|
||
|
|
* :option:`enable-http-keep-alive <--enable-http-keep-alive>`
|
||
|
|
* :option:`enable-http-pipelining <--enable-http-pipelining>`
|
||
|
|
* :option:`enable-mmap <--enable-mmap>`
|
||
|
|
* :option:`enable-peer-exchange <--enable-peer-exchange>`
|
||
|
|
* :option:`file-allocation <--file-allocation>`
|
||
|
|
* :option:`follow-metalink <--follow-metalink>`
|
||
|
|
* :option:`follow-torrent <--follow-torrent>`
|
||
|
|
* :option:`ftp-passwd <--ftp-passwd>`
|
||
|
|
* :option:`ftp-pasv <-p>`
|
||
|
|
* :option:`ftp-proxy <--ftp-proxy>`
|
||
|
|
* :option:`ftp-proxy-passwd <--ftp-proxy-passwd>`
|
||
|
|
* :option:`ftp-proxy-user <--ftp-proxy-user>`
|
||
|
|
* :option:`ftp-reuse-connection <--ftp-reuse-connection>`
|
||
|
|
* :option:`ftp-type <--ftp-type>`
|
||
|
|
* :option:`ftp-user <--ftp-user>`
|
||
|
|
* :option:`hash-check-only <--hash-check-only>`
|
||
|
|
* :option:`header <--header>`
|
||
|
|
* :option:`http-accept-gzip <--http-accept-gzip>`
|
||
|
|
* :option:`http-auth-challenge <--http-auth-challenge>`
|
||
|
|
* :option:`http-no-cache <--http-no-cache>`
|
||
|
|
* :option:`http-passwd <--http-passwd>`
|
||
|
|
* :option:`http-proxy <--http-proxy>`
|
||
|
|
* :option:`http-proxy-passwd <--http-proxy-passwd>`
|
||
|
|
* :option:`http-proxy-user <--http-proxy-user>`
|
||
|
|
* :option:`http-user <--http-user>`
|
||
|
|
* :option:`https-proxy <--https-proxy>`
|
||
|
|
* :option:`https-proxy-passwd <--https-proxy-passwd>`
|
||
|
|
* :option:`https-proxy-user <--https-proxy-user>`
|
||
|
|
* :option:`index-out <-O>`
|
||
|
|
* :option:`lowest-speed-limit <--lowest-speed-limit>`
|
||
|
|
* :option:`max-connection-per-server <-x>`
|
||
|
|
* :option:`max-download-limit <--max-download-limit>`
|
||
|
|
* :option:`max-file-not-found <--max-file-not-found>`
|
||
|
|
* :option:`max-resume-failure-tries <--max-resume-failure-tries>`
|
||
|
|
* :option:`max-tries <-m>`
|
||
|
|
* :option:`max-upload-limit <-u>`
|
||
|
|
* :option:`metalink-base-uri <--metalink-base-uri>`
|
||
|
|
* :option:`metalink-enable-unique-protocol <--metalink-enable-unique-protocol>`
|
||
|
|
* :option:`metalink-language <--metalink-language>`
|
||
|
|
* :option:`metalink-location <--metalink-location>`
|
||
|
|
* :option:`metalink-os <--metalink-os>`
|
||
|
|
* :option:`metalink-preferred-protocol <--metalink-preferred-protocol>`
|
||
|
|
* :option:`metalink-version <--metalink-version>`
|
||
|
|
* :option:`min-split-size <-k>`
|
||
|
|
* :option:`no-file-allocation-limit <--no-file-allocation-limit>`
|
||
|
|
* :option:`no-netrc <-n>`
|
||
|
|
* :option:`no-proxy <--no-proxy>`
|
||
|
|
* :option:`out <-o>`
|
||
|
|
* :option:`parameterized-uri <-P>`
|
||
|
|
* :option:`pause <--pause>`
|
||
|
|
* :option:`piece-length <--piece-length>`
|
||
|
|
* :option:`proxy-method <--proxy-method>`
|
||
|
|
* :option:`realtime-chunk-checksum <--realtime-chunk-checksum>`
|
||
|
|
* :option:`referer <--referer>`
|
||
|
|
* :option:`remote-time <-R>`
|
||
|
|
* :option:`remove-control-file <--remove-control-file>`
|
||
|
|
* :option:`retry-wait <--retry-wait>`
|
||
|
|
* :option:`reuse-uri <--reuse-uri>`
|
||
|
|
* :option:`seed-ratio <--seed-ratio>`
|
||
|
|
* :option:`seed-time <--seed-time>`
|
||
|
|
* :option:`select-file <--select-file>`
|
||
|
|
* :option:`split <-s>`
|
||
|
|
* :option:`stream-piece-selector <--stream-piece-selector>`
|
||
|
|
* :option:`timeout <-t>`
|
||
|
|
* :option:`uri-selector <--uri-selector>`
|
||
|
|
* :option:`use-head <--use-head>`
|
||
|
|
* :option:`user-agent <-U>`
|
||
|
|
|
||
|
|
Estas opções possuem exatamente o mesmo significado das opções existentes na
|
||
|
|
linha de comando, mas aplicam-se apenas a URI a que pertencem.
|
||
|
|
Por favor perceba que dentro de um arquivo, elas não terão o prefixo ``--``.
|
||
|
|
|
||
|
|
Por exemplo, o conteúdo do arquivo uri.txt é::
|
||
|
|
|
||
|
|
http://servidor/arquivo.iso http://espelho/arquivo.iso
|
||
|
|
dir=/imagens_iso
|
||
|
|
out=arquivo.img
|
||
|
|
http://fu/ba
|
||
|
|
|
||
|
|
|
||
|
|
Se aria2 é executado com as opções ``-i uri.txt -d /tmp``, então
|
||
|
|
``arquivo.iso`` será salvo como ``/imagens_iso/arquivo.img`` e será baixado
|
||
|
|
de \http://servidor/arquivo.iso e \http://espelho/arquivo.iso. O arquivo
|
||
|
|
``ba`` e baixado de \http://fu/ba e salvo como ``/tmp/ba``.
|
||
|
|
|
||
|
|
Em alguns casos, o parâmetro :option:`out <-o>` não tem efeito.
|
||
|
|
Ver nota da opção :option:`--out <-o>` para entender as restrições.
|
||
|
|
|
||
|
|
Perfil Performance Servidor
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
Esta seção descreve o formato do perfil de performance do servidor, composto
|
||
|
|
por um arquivo de texto plano com cada linha contendo um par ``NOME=VALOR``,
|
||
|
|
delimitados por virgula. Atualmente esta é a lista de nomes reconhecidos:
|
||
|
|
|
||
|
|
``host``
|
||
|
|
Nome do servidor. Requerido.
|
||
|
|
|
||
|
|
``protocol``
|
||
|
|
Protocolo para este perfil, como ftp, http, https. http é requerido.
|
||
|
|
|
||
|
|
``dl_speed``
|
||
|
|
Velocidade média de download observada no download prévio, em bytes por
|
||
|
|
segundo. Requerido.
|
||
|
|
|
||
|
|
``sc_avg_speed``
|
||
|
|
The average download speed observed in the previous download in
|
||
|
|
bytes per sec. This value is only updated if the download is done in
|
||
|
|
single connection environment and only used by
|
||
|
|
AdaptiveURISelector. Optional.
|
||
|
|
|
||
|
|
``mc_avg_speed``
|
||
|
|
The average download speed observed in the previous download in
|
||
|
|
bytes per sec. This value is only updated if the download is done in
|
||
|
|
multi connection environment and only used by
|
||
|
|
AdaptiveURISelector. Optional.
|
||
|
|
|
||
|
|
``counter``
|
||
|
|
How many times the server is used. Currently this value is only used
|
||
|
|
by AdaptiveURISelector. Optional.
|
||
|
|
|
||
|
|
``last_updated``
|
||
|
|
Last contact time in GMT with this server, specified in the seconds
|
||
|
|
since the Epoch(00:00:00 on January 1, 1970, UTC). Required.
|
||
|
|
|
||
|
|
``status``
|
||
|
|
ERROR is set when server cannot be reached or out-of-service or
|
||
|
|
timeout occurred. Otherwise, OK is set.
|
||
|
|
|
||
|
|
Those fields must exist in one line. The order of the fields is not
|
||
|
|
significant. You can put pairs other than the above; they are simply
|
||
|
|
ignored.
|
||
|
|
|
||
|
|
An example follows::
|
||
|
|
|
||
|
|
host=localhost, protocol=http, dl_speed=32000, last_updated=1222491640, status=OK
|
||
|
|
host=localhost, protocol=ftp, dl_speed=0, last_updated=1222491632, status=ERROR
|
||
|
|
|
||
|
|
|
||
|
|
INTERFACE RPC
|
||
|
|
-------------
|
||
|
|
|
||
|
|
aria2 provê o serviço JSON-RPC sobre HTTP e XML-RPC sobre HTTP e eles
|
||
|
|
basicamente possuem a mesma funcionalidade. aria2 também provê JSON-RPC
|
||
|
|
sobre WebSocket o qual utiliza o mesmo formato do método e assinatura e
|
||
|
|
resposta do formato JSON-RPC sobre HTTP, mas adicionalmente possui notificações
|
||
|
|
iniciadas pelo servidor. Ver detalhes na seção `JSON-RPC sobre WebSocket`_ .
|
||
|
|
|
||
|
|
O caminho requisitado do interface JSON-RPC (para ambos sobre HTTP e sobre
|
||
|
|
WebSocket) é ``/jsonrpc``. O caminho requisitado do interface XML-RPC é
|
||
|
|
``/rpc``.
|
||
|
|
|
||
|
|
A URI WebSocket para JSON-RPC sobre WebSocket é ``ws://HOST:PORT/jsonrpc``.
|
||
|
|
|
||
|
|
A implementação JSON-RPC é baseada na especificação
|
||
|
|
JSON-RPC 2.0 <http://jsonrpc.org/specification>, e suporta
|
||
|
|
HTTP POST e GET (JSONP). Usando WebSocket como transporte é uma extensão
|
||
|
|
original do aria2.
|
||
|
|
|
||
|
|
A interface JSON-RPC não suporta notificação em HTTP, mas o servidor RPC irá
|
||
|
|
RPC enviar a notificação no WebSocket. Não é suportado número ponto flutuante
|
||
|
|
O codificação de página deve ser UTF-8.
|
||
|
|
|
||
|
|
Quanto a seguinte documentação do JSON-RPC, entenda estrutura JSON como objeto.
|
||
|
|
|
||
|
|
|
||
|
|
Terminologia
|
||
|
|
~~~~~~~~~~~~
|
||
|
|
|
||
|
|
GID
|
||
|
|
GID(or gid) é a chave para gerenciar cada download. Cada download tem um
|
||
|
|
único GID. Atualmente GID é um inteiro, mas não trate como inteiro pois
|
||
|
|
isto pode ser modificado em versões futuras.
|
||
|
|
Note que o GID é uma sessão local e o GID não será persistido quando o
|
||
|
|
aria2 for encerrado.
|
||
|
|
|
||
|
|
Métodos
|
||
|
|
~~~~~~~
|
||
|
|
|
||
|
|
São descritos em torno de 20 exemplos utilizando código fonte
|
||
|
|
com exemplos que usam interpretador Python2.7.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.addUri(uris[, options[, position]])
|
||
|
|
|
||
|
|
Esse método adiciona nova URI HTTP, HTTPS, FTP, BitTorrent Magnet. *uris* é
|
||
|
|
do tipo array e seus elementos são URI que são do tipo string. Para
|
||
|
|
BitTorrent Magnet URI, *uris* precisa ter só um elemente e deve ser
|
||
|
|
BitTorrent Magnet URI. URIs em *uris* precisam apontar para o mesmo arquivo.
|
||
|
|
If you mix other URIs which point to another file, aria2 does not
|
||
|
|
complain but download may fail. *options* is of type struct and its
|
||
|
|
members are a pair of option name and value. See :ref:`rpc_options` below for
|
||
|
|
more details. If *position* is given as an integer starting from 0,
|
||
|
|
the new download is inserted at *position* in the waiting queue. If
|
||
|
|
*position* is not given or *position* is larger than the size of the
|
||
|
|
queue, it is appended at the end of the queue. This method returns
|
||
|
|
GID of registered download.
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 0 JSON-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
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"}'
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 0 XML-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
The following example adds \http://example.org/file to aria2::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> s.aria2.addUri(['http://example.org/file'])
|
||
|
|
'1'
|
||
|
|
|
||
|
|
|
||
|
|
The following example adds 2 sources and some options::
|
||
|
|
|
||
|
|
>>> s.aria2.addUri(['http://example.org/file', 'http://mirror/file'],
|
||
|
|
dict(dir="/tmp"))
|
||
|
|
'2'
|
||
|
|
|
||
|
|
|
||
|
|
The following example adds a download and insert it to the front of
|
||
|
|
waiting downloads::
|
||
|
|
|
||
|
|
>>> s.aria2.addUri(['http://example.org/file'], {}, 0)
|
||
|
|
'3'
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.addTorrent(torrent[, uris[, options[, position]]])
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method adds BitTorrent download by uploading ".torrent" file. If
|
||
|
|
you want to add BitTorrent Magnet URI, use :func:`aria2.addUri` method
|
||
|
|
instead. *torrent* is of type base64 which contains Base64-encoded
|
||
|
|
".torrent" file. *uris* is of type array and its element is URI which
|
||
|
|
is of type string. *uris* is used for Web-seeding. For single file
|
||
|
|
torrents, URI can be a complete URI pointing to the resource or if URI
|
||
|
|
ends with /, name in torrent file is added. For multi-file torrents,
|
||
|
|
name and path in torrent are added to form a URI for each file.
|
||
|
|
*options* is of type struct and its members are a pair of option name
|
||
|
|
and value. See :ref:`rpc_options` below for more details. If *position* is
|
||
|
|
given as an integer starting from 0, the new download is inserted at
|
||
|
|
*position* in the waiting queue. If *position* is not given or
|
||
|
|
*position* is larger than the size of the queue, it is appended at the
|
||
|
|
end of the queue. This method returns GID of registered download.
|
||
|
|
The uploaded data is saved as a file named hex string of SHA-1 hash of data
|
||
|
|
plus ".torrent" in the directory specified by :option:`--dir <-d>`
|
||
|
|
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
|
||
|
|
:option:`--save-session`.
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 1 JSON-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
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"}'
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 1 XML-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
The following example adds local file file.torrent to aria2::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> s.aria2.addTorrent(xmlrpclib.Binary(open('file.torrent').read()))
|
||
|
|
'6'
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.addMetalink(metalink[, options[, position]])
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method adds Metalink download by uploading ".metalink" file.
|
||
|
|
*metalink* is of type base64 which contains Base64-encoded ".metalink"
|
||
|
|
file. *options* is of type struct and its members are a pair of
|
||
|
|
option name and value. See :ref:`rpc_options` below for more details. If
|
||
|
|
*position* is given as an integer starting from 0, the new download is
|
||
|
|
inserted at *position* in the waiting queue. If *position* is not
|
||
|
|
given or *position* is larger than the size of the queue, it is
|
||
|
|
appended at the end of the queue. This method returns array of GID of
|
||
|
|
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 :option:`--dir <-d>`
|
||
|
|
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
|
||
|
|
:option:`--save-session`.
|
||
|
|
|
||
|
|
**Exemplo 2 JSON-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
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"]}'
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 2 XML-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
The following example adds local file file.meta4 to aria2::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> s.aria2.addMetalink(xmlrpclib.Binary(open('file.meta4').read()))
|
||
|
|
['8']
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.remove(gid)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method removes the download denoted by *gid*. *gid* is of type
|
||
|
|
string. If specified download is in progress, it is stopped at
|
||
|
|
first. The status of removed download becomes ``"removed"``. This method
|
||
|
|
returns GID of removed download.
|
||
|
|
|
||
|
|
**Exemplo 3 JSON-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
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"}'
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 3 XML-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
The following example removes download whose GID is "3"::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> s.aria2.remove('3')
|
||
|
|
'3'
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.forceRemove(gid)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method removes the download denoted by *gid*. This method
|
||
|
|
behaves just like :func:`aria2.remove` except that this method removes
|
||
|
|
download without any action which takes time such as contacting
|
||
|
|
BitTorrent tracker.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.pause(gid)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method pauses the download denoted by *gid*. *gid* is of type
|
||
|
|
string. The status of paused download becomes ``"paused"``. If the
|
||
|
|
download is active, the download is placed on the first position of
|
||
|
|
waiting queue. As long as the status is ``"paused"``, the download is not
|
||
|
|
started. To change status to ``"waiting"``, use :func:`aria2.unpause` method.
|
||
|
|
This method returns GID of paused download.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.pauseAll()
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method is equal to calling :func:`aria2.pause` for every active/waiting
|
||
|
|
download. This methods returns ``"OK"`` for success.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.forcePause(pid)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method pauses the download denoted by *gid*. This method
|
||
|
|
behaves just like :func:`aria2.pause` except that this method pauses
|
||
|
|
download without any action which takes time such as contacting
|
||
|
|
BitTorrent tracker.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.forcePauseAll()
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method is equal to calling :func:`aria2.forcePause` for every
|
||
|
|
active/waiting download. This methods returns ``"OK"`` for success.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.unpause(gid)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method changes the status of the download denoted by *gid* from
|
||
|
|
``"paused"`` to ``"waiting"``. This makes the download eligible to restart.
|
||
|
|
*gid* is of type string. This method returns GID of unpaused
|
||
|
|
download.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.unpauseAll()
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method is equal to calling :func:`aria2.unpause` for every active/waiting
|
||
|
|
download. This methods returns ``"OK"`` for success.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.tellStatus(gid[, keys])
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method returns download progress of the download denoted by
|
||
|
|
*gid*. *gid* is of type string. *keys* is array of string. If it is
|
||
|
|
specified, the response contains only keys in *keys* array. If *keys*
|
||
|
|
is empty or not specified, the response contains all keys. This is
|
||
|
|
useful when you just want specific keys and avoid unnecessary
|
||
|
|
transfers. For example, ``aria2.tellStatus("1", ["gid", "status"])``
|
||
|
|
returns *gid* and 'status' key. The response is of type struct and it
|
||
|
|
contains following keys. The value type is string.
|
||
|
|
|
||
|
|
``gid``
|
||
|
|
GID of this download.
|
||
|
|
|
||
|
|
``status``
|
||
|
|
``"active"`` for currently downloading/seeding entry. ``"waiting"`` for the
|
||
|
|
entry in the queue; download is not started. ``"paused"`` for the
|
||
|
|
paused entry. ``"error"`` for the stopped download because of
|
||
|
|
error. ``"complete"`` for the stopped and completed download. ``"removed"``
|
||
|
|
for the download removed by user.
|
||
|
|
|
||
|
|
``totalLength``
|
||
|
|
Total length of this download in bytes.
|
||
|
|
|
||
|
|
``completedLength``
|
||
|
|
Completed length of this download in bytes.
|
||
|
|
|
||
|
|
``uploadLength``
|
||
|
|
Uploaded length of this download in bytes.
|
||
|
|
|
||
|
|
``bitfield``
|
||
|
|
Hexadecimal representation of the download progress. The highest bit
|
||
|
|
corresponds to piece index 0. The set bits indicate the piece is
|
||
|
|
available and unset bits indicate the piece is missing. The spare
|
||
|
|
bits at the end are set to zero. When download has not started yet,
|
||
|
|
this key will not be included in the response.
|
||
|
|
|
||
|
|
``downloadSpeed``
|
||
|
|
Download speed of this download measured in bytes/sec.
|
||
|
|
|
||
|
|
``uploadSpeed``
|
||
|
|
Upload speed of this download measured in bytes/sec.
|
||
|
|
|
||
|
|
``infoHash``
|
||
|
|
InfoHash. BitTorrent only.
|
||
|
|
|
||
|
|
``numSeeders``
|
||
|
|
The number of seeders the client has connected to. BitTorrent only.
|
||
|
|
|
||
|
|
``pieceLength``
|
||
|
|
Piece length in bytes.
|
||
|
|
|
||
|
|
``numPieces``
|
||
|
|
The number of pieces.
|
||
|
|
|
||
|
|
``connections``
|
||
|
|
The number of peers/servers the client has connected to.
|
||
|
|
|
||
|
|
``errorCode``
|
||
|
|
The last error code occurred in this download. The value is of type
|
||
|
|
string. The error codes are defined in `CÓDIGO DE RETORNO`_ section.
|
||
|
|
This value is only available for stopped/completed downloads.
|
||
|
|
|
||
|
|
``followedBy``
|
||
|
|
List of GIDs which are generated by the consequence of this
|
||
|
|
download. For example, when aria2 downloaded Metalink file, it
|
||
|
|
generates downloads described in it(see :option:`--follow-metalink`
|
||
|
|
option). This value is useful to track these auto generated
|
||
|
|
downloads. If there is no such downloads, this key will not
|
||
|
|
be included in the response.
|
||
|
|
|
||
|
|
``belongsTo``
|
||
|
|
GID of a parent download. Some downloads are a part of another
|
||
|
|
download. For example, if a file in Metalink has BitTorrent
|
||
|
|
resource, the download of ".torrent" is a part of that file. If this
|
||
|
|
download has no parent, this key will not be included in the
|
||
|
|
response.
|
||
|
|
|
||
|
|
``dir``
|
||
|
|
Directory to save files. This key is not available for stopped
|
||
|
|
downloads.
|
||
|
|
|
||
|
|
``files``
|
||
|
|
Returns the list of files. The element of list is the same struct
|
||
|
|
used in :func:`aria2.getFiles` method.
|
||
|
|
|
||
|
|
|
||
|
|
``bittorrent``
|
||
|
|
Struct which contains information retrieved from .torrent
|
||
|
|
file. BitTorrent only. It contains following keys.
|
||
|
|
|
||
|
|
``announceList``
|
||
|
|
List of lists of announce URI. If ".torrent" file contains announce
|
||
|
|
and no announce-list, announce is converted to announce-list
|
||
|
|
format.
|
||
|
|
|
||
|
|
``comment``
|
||
|
|
The comment for the torrent. comment.utf-8 is used if available.
|
||
|
|
|
||
|
|
``creationDate``
|
||
|
|
The creation time of the torrent. The value is an integer since
|
||
|
|
the Epoch, measured in seconds.
|
||
|
|
|
||
|
|
``mode``
|
||
|
|
File mode of the torrent. The value is either 'single' or 'multi'.
|
||
|
|
|
||
|
|
``info``
|
||
|
|
Struct which contains data from Info dictionary. It contains
|
||
|
|
following keys.
|
||
|
|
|
||
|
|
``name``
|
||
|
|
name in info dictionary. name.utf-8 is used if available.
|
||
|
|
|
||
|
|
**Exemplo 4 JSON-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
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'completedLength': 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'}}
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 4 XML-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
The following example gets information about download whose GID is
|
||
|
|
"1"::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> from pprint import pprint
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> r = s.aria2.tellStatus('1')
|
||
|
|
>>> pprint(r)
|
||
|
|
{'bitfield': 'ffff80',
|
||
|
|
'completedLength': '34896138',
|
||
|
|
'connections': '0',
|
||
|
|
'dir': '/downloads',
|
||
|
|
'downloadSpeed': '0',
|
||
|
|
'errorCode': '0',
|
||
|
|
'files': [{'index': '1',
|
||
|
|
'length': '34896138',
|
||
|
|
'completedLength': '34896138',
|
||
|
|
'path': '/downloads/file',
|
||
|
|
'selected': 'true',
|
||
|
|
'uris': [{'status': 'used',
|
||
|
|
'uri': 'http://example.org/file'}]}],
|
||
|
|
'gid': '1',
|
||
|
|
'numPieces': '17',
|
||
|
|
'pieceLength': '2097152',
|
||
|
|
'status': 'complete',
|
||
|
|
'totalLength': '34896138',
|
||
|
|
'uploadLength': '0',
|
||
|
|
'uploadSpeed': '0'}
|
||
|
|
|
||
|
|
|
||
|
|
The following example gets information specifying keys you are
|
||
|
|
interested in::
|
||
|
|
|
||
|
|
>>> r = s.aria2.tellStatus('1', ['gid', 'totalLength', 'completedLength'])
|
||
|
|
>>> pprint(r)
|
||
|
|
{'completedLength': '34896138', 'gid': '1', 'totalLength': '34896138'}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.getUris(gid)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method returns URIs used in the download denoted by *gid*. *gid*
|
||
|
|
is of type string. The response is of type array and its element is of
|
||
|
|
type struct and it contains following keys. The value type is string.
|
||
|
|
|
||
|
|
``uri``
|
||
|
|
URI
|
||
|
|
|
||
|
|
``status``
|
||
|
|
'used' if the URI is already used. 'waiting' if the URI is waiting
|
||
|
|
in the queue.
|
||
|
|
|
||
|
|
**Exemplo 5 JSON-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> 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'}]}
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 5 XML-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> from pprint import pprint
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> r = s.aria2.getUris('1')
|
||
|
|
>>> pprint(r)
|
||
|
|
[{'status': 'used', 'uri': 'http://example.org/file'}]
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.getFiles(gid)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method returns file list of the download denoted by *gid*. *gid*
|
||
|
|
is of type string. The response is of type array and its element is of
|
||
|
|
type struct and it contains following keys. The value type is string.
|
||
|
|
|
||
|
|
``index``
|
||
|
|
Index of file. Starting with 1. This is the same order with the
|
||
|
|
files in multi-file torrent.
|
||
|
|
|
||
|
|
``path``
|
||
|
|
File path.
|
||
|
|
|
||
|
|
``length``
|
||
|
|
File size in bytes.
|
||
|
|
|
||
|
|
``completedLength``
|
||
|
|
Completed length of this file in bytes. Please note that it is
|
||
|
|
possible that sum of completedLength is less than completedLength in
|
||
|
|
:func:`aria2.tellStatus` method.
|
||
|
|
This is because completedLength in
|
||
|
|
:func:`aria2.getFiles`
|
||
|
|
only calculates completed pieces. On the other hand, completedLength
|
||
|
|
in
|
||
|
|
:func:`aria2.tellStatus` takes into account
|
||
|
|
of partially completed piece.
|
||
|
|
|
||
|
|
``selected``
|
||
|
|
``"true"`` if this file is selected by :option:`--select-file` option. If
|
||
|
|
:option:`--select-file` is not specified or this is single torrent or no
|
||
|
|
torrent download, this value is always ``"true"``. Otherwise ``"false"``.
|
||
|
|
|
||
|
|
``uris``
|
||
|
|
Returns the list of URI for this file. The element of list is the
|
||
|
|
same struct used in :func:`aria2.getUris` method.
|
||
|
|
|
||
|
|
**Exemplo 6 JSON-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> 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'completedLength': u'34896138',
|
||
|
|
u'path': u'/downloads/file',
|
||
|
|
u'selected': u'true',
|
||
|
|
u'uris': [{u'status': u'used',
|
||
|
|
u'uri': u'http://example.org/file'}]}]}
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 6 XML-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> from pprint import pprint
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> r = s.aria2.getFiles('1')
|
||
|
|
>>> pprint(r)
|
||
|
|
[{'index': '1',
|
||
|
|
'length': '34896138',
|
||
|
|
'completedLength': '34896138',
|
||
|
|
'path': '/downloads/file',
|
||
|
|
'selected': 'true',
|
||
|
|
'uris': [{'status': 'used',
|
||
|
|
'uri': 'http://example.org/file'}]}]
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.getPeers(gid)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method returns peer list of the download denoted by *gid*. *gid*
|
||
|
|
is of type string. This method is for BitTorrent only. The response
|
||
|
|
is of type array and its element is of type struct and it contains
|
||
|
|
following keys. The value type is string.
|
||
|
|
|
||
|
|
``peerId``
|
||
|
|
Percent-encoded peer ID.
|
||
|
|
|
||
|
|
``ip``
|
||
|
|
IP address of the peer.
|
||
|
|
|
||
|
|
``port``
|
||
|
|
Port number of the peer.
|
||
|
|
|
||
|
|
``bitfield``
|
||
|
|
Hexadecimal representation of the download progress of the peer. The
|
||
|
|
highest bit corresponds to piece index 0. The set bits indicate the
|
||
|
|
piece is available and unset bits indicate the piece is missing. The
|
||
|
|
spare bits at the end are set to zero.
|
||
|
|
|
||
|
|
``amChoking``
|
||
|
|
``"true"`` if this client is choking the peer. Otherwise ``"false"``.
|
||
|
|
|
||
|
|
``peerChoking``
|
||
|
|
``"true"`` if the peer is choking this client. Otherwise ``"false"``.
|
||
|
|
|
||
|
|
``downloadSpeed``
|
||
|
|
Download speed (byte/sec) that this client obtains from the peer.
|
||
|
|
|
||
|
|
``uploadSpeed``
|
||
|
|
Upload speed(byte/sec) that this client uploads to the peer.
|
||
|
|
|
||
|
|
``seeder``
|
||
|
|
``"true"`` is this client is a seeder. Otherwise ``"false"``.
|
||
|
|
|
||
|
|
**Exemplo 7 JSON-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> 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'}]}
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 7 XML-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> from pprint import pprint
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> r = s.aria2.getPeers('1')
|
||
|
|
>>> pprint(r)
|
||
|
|
[{'amChoking': 'true',
|
||
|
|
'bitfield': 'ffffffffffffffffffffffffffffffffffffffff',
|
||
|
|
'downloadSpeed': '10602',
|
||
|
|
'ip': '10.0.0.9',
|
||
|
|
'peerChoking': 'false',
|
||
|
|
'peerId': 'aria2%2F1%2E10%2E5%2D%87%2A%EDz%2F%F7%E6',
|
||
|
|
'port': '6881',
|
||
|
|
'seeder': 'true',
|
||
|
|
'uploadSpeed': '0'},
|
||
|
|
{'amChoking': 'false',
|
||
|
|
'bitfield': 'ffffeff0fffffffbfffffff9fffffcfff7f4ffff',
|
||
|
|
'downloadSpeed': '8654',
|
||
|
|
'ip': '10.0.0.30',
|
||
|
|
'peerChoking': 'false',
|
||
|
|
'peerId': 'bittorrent client758',
|
||
|
|
'port': '37842',
|
||
|
|
'seeder': 'false,
|
||
|
|
'uploadSpeed': '6890'}]
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.getServers(gid)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method returns currently connected HTTP, HTTPS e FTP servers of the download denoted by *gid*. *gid* is of type string. The response
|
||
|
|
is of type array and its element is of type struct and it contains
|
||
|
|
following keys. The value type is string.
|
||
|
|
|
||
|
|
``index``
|
||
|
|
Index of file. Starting with 1. This is the same order with the
|
||
|
|
files in multi-file torrent.
|
||
|
|
|
||
|
|
``servers``
|
||
|
|
The list of struct which contains following keys.
|
||
|
|
|
||
|
|
``uri``
|
||
|
|
URI originally added.
|
||
|
|
|
||
|
|
``currentUri``
|
||
|
|
This is the URI currently used for downloading. If redirection is
|
||
|
|
involved, currentUri and uri may differ.
|
||
|
|
|
||
|
|
``downloadSpeed``
|
||
|
|
Download speed (byte/sec)
|
||
|
|
|
||
|
|
**Exemplo 8 JSON-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> 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'}]}]}
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 8 XML-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> from pprint import pprint
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> r = s.aria2.getServers('1')
|
||
|
|
>>> pprint(r)
|
||
|
|
[{'index': '1',
|
||
|
|
'servers': [{'currentUri': 'http://example.org/dl/file',
|
||
|
|
'downloadSpeed': '20285',
|
||
|
|
'uri': 'http://example.org/file'}]}]
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.tellActive([keys])
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method returns the list of active downloads. The response is of
|
||
|
|
type array and its element is the same struct returned by
|
||
|
|
:func:`aria2.tellStatus` method. For *keys* parameter, please refer to
|
||
|
|
:func:`aria2.tellStatus` method.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.tellWaiting(offset, num, [keys])
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method returns the list of waiting download, including paused
|
||
|
|
downloads. *offset* is of type integer and specifies the offset from
|
||
|
|
the download waiting at the front. *num* is of type integer and
|
||
|
|
specifies the number of downloads to be returned. For *keys*
|
||
|
|
parameter, please refer to :func:`aria2.tellStatus` method.
|
||
|
|
|
||
|
|
If *offset* is a positive integer, this method returns downloads in the
|
||
|
|
range of [*offset*, *offset* + *num*).
|
||
|
|
|
||
|
|
*offset* can be a negative integer. *offset* == -1 points last
|
||
|
|
download in the waiting queue and *offset* == -2 points the download
|
||
|
|
before the last download, and so on. The downloads in the response are
|
||
|
|
in reversed order.
|
||
|
|
|
||
|
|
For example, imagine that three downloads "A","B" and "C" are waiting
|
||
|
|
in this order. aria2.tellWaiting(0, 1) returns
|
||
|
|
["A"]. aria2.tellWaiting(1, 2) returns ["B", "C"].
|
||
|
|
aria2.tellWaiting(-1, 2) returns ["C", "B"].
|
||
|
|
|
||
|
|
The response is of type array and its element is the same struct
|
||
|
|
returned by :func:`aria2.tellStatus` method.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.tellStopped(offset, num, [keys])
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method returns the list of stopped download. *offset* is of type
|
||
|
|
integer and specifies the offset from the oldest download. *num* is of
|
||
|
|
type integer and specifies the number of downloads to be returned.
|
||
|
|
For *keys* parameter, please refer to :func:`aria2.tellStatus` method.
|
||
|
|
|
||
|
|
*offset* and *num* have the same semantics as :func:`aria2.tellWaiting`
|
||
|
|
method.
|
||
|
|
|
||
|
|
The response is of type array and its element is the same struct
|
||
|
|
returned by :func:`aria2.tellStatus` method.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.changePosition(gid, pos, how)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method changes the position of the download denoted by
|
||
|
|
*gid*. *pos* is of type integer. *how* is of type string. If *how* is
|
||
|
|
``"POS_SET"``, it moves the download to a position relative to the
|
||
|
|
beginning of the queue. If *how* is ``"POS_CUR"``, it moves the download
|
||
|
|
to a position relative to the current position. If *how* is ``"POS_END"``,
|
||
|
|
it moves the download to a position relative to the end of the
|
||
|
|
queue. If the destination position is less than 0 or beyond the end of
|
||
|
|
the queue, it moves the download to the beginning or the end of the
|
||
|
|
queue respectively. The response is of type integer and it is the
|
||
|
|
destination position.
|
||
|
|
|
||
|
|
For example, if GID#1 is placed in position 3, ``aria2.changePosition('1',
|
||
|
|
-1, 'POS_CUR')`` will change its position to 2. Additional
|
||
|
|
``aria2.changePosition('1', 0, 'POS_SET')`` will change its position to 0(the
|
||
|
|
beginning of the queue).
|
||
|
|
|
||
|
|
**Exemplo 9 JSON-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
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}
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 9 XML-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
The following example moves the download whose GID is "3" to the
|
||
|
|
front of the waiting queue::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> s.aria2.changePosition('3', 0, 'POS_SET')
|
||
|
|
0
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.changeUri(gid, fileIndex, delUris, addUris[, position])
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method removes URIs in *delUris* from and appends URIs in
|
||
|
|
*addUris* to download denoted by *gid*. *delUris* and *addUris* are
|
||
|
|
list of string. A download can contain multiple files and URIs are
|
||
|
|
attached to each file. *fileIndex* is used to select which file to
|
||
|
|
remove/attach given URIs. *fileIndex* is 1-based. *position* is used
|
||
|
|
to specify where URIs are inserted in the existing waiting URI
|
||
|
|
list. *position* is 0-based. When *position* is omitted, URIs are
|
||
|
|
appended to the back of the list. This method first execute removal
|
||
|
|
and then addition. *position* is the position after URIs are removed,
|
||
|
|
not the position when this method is called. When removing URI, if
|
||
|
|
same URIs exist in download, only one of them is removed for each URI
|
||
|
|
in *delUris*. In other words, there are three URIs
|
||
|
|
``http://example.org/aria2`` and you want remove them all, you have to
|
||
|
|
specify (at least) 3 ``http://example.org/aria2`` in *delUris*. This
|
||
|
|
method returns a list which contains 2 integers. The first integer is
|
||
|
|
the number of URIs deleted. The second integer is the number of URIs
|
||
|
|
added.
|
||
|
|
|
||
|
|
**Exemplo 10 JSON-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
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]}
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 10 XML-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
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 xmlrpclib
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> s.aria2.changeUri('2', 1, [], ['http://example.org/file'])
|
||
|
|
[0, 1]
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.getOption(gid)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method returns options of the download denoted by *gid*. The
|
||
|
|
response is of type struct. Its key is the name of option. The value
|
||
|
|
type is string. Note that this method does not return options which
|
||
|
|
have no default value and have not been set by the command-line
|
||
|
|
options, configuration files or RPC methods.
|
||
|
|
|
||
|
|
**Exemplo 11 JSON-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
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',
|
||
|
|
...
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 11 XML-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
The following example gets options of the download whose GID is "1"::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> from pprint import pprint
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> r = s.aria2.getOption('1')
|
||
|
|
>>> pprint(r)
|
||
|
|
{'allow-overwrite': 'false',
|
||
|
|
'allow-piece-length-change': 'false',
|
||
|
|
'always-resume': 'true',
|
||
|
|
'async-dns': 'true',
|
||
|
|
....
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.changeOption(gid, options)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method changes options of the download denoted by *gid*
|
||
|
|
dynamically. *gid* is of type string. *options* is of type struct.
|
||
|
|
The following options are available for active downloads:
|
||
|
|
|
||
|
|
* :option:`bt-max-peers <--bt-max-peers>`
|
||
|
|
* :option:`bt-request-peer-speed-limit <--bt-request-peer-speed-limit>`
|
||
|
|
* :option:`bt-remove-unselected-file <--bt-remove-unselected-file>`
|
||
|
|
* :option:`max-download-limit <--max-download-limit>`
|
||
|
|
* :option:`max-upload-limit <-u>`
|
||
|
|
|
||
|
|
For waiting or paused downloads, in addition to the above options,
|
||
|
|
options listed in `Arquivo de Entrada`_ subsection are available,
|
||
|
|
except for following options:
|
||
|
|
:option:`dry-run <--dry-run>`,
|
||
|
|
:option:`metalink-base-uri <--metalink-base-uri>`,
|
||
|
|
:option:`parameterized-uri <-P>`,
|
||
|
|
:option:`pause <--pause>` and
|
||
|
|
:option:`piece-length <--piece-length>`.
|
||
|
|
This method returns ``"OK"`` for success.
|
||
|
|
|
||
|
|
**Exemplo 12 JSON-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
The following example sets
|
||
|
|
:option:`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'}
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 12 XML-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
The following example sets
|
||
|
|
:option:`max-download-limit <--max-download-limit>` option to ``"20K"`` for
|
||
|
|
the download whose GID is "1"::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> s.aria2.changeOption('1', {'max-download-limit':'20K'})
|
||
|
|
'OK'
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.getGlobalOption()
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method returns global options. The response is of type
|
||
|
|
struct. Its key is the name of option. The value type is string.
|
||
|
|
Note that this method does not return options which have no default
|
||
|
|
value and have not been set by the command-line options, configuration
|
||
|
|
files or RPC methods. Because global options are used as a template
|
||
|
|
for the options of newly added download, the response contains keys
|
||
|
|
returned by :func:`aria2.getOption` method.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.changeGlobalOption(options)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method changes global options dynamically. *options* is of type
|
||
|
|
struct.
|
||
|
|
The following options are available:
|
||
|
|
|
||
|
|
* :option:`download-result <--download-result>`
|
||
|
|
* :option:`log <-l>`
|
||
|
|
* :option:`log-level <--log-level>`
|
||
|
|
* :option:`max-concurrent-downloads <-j>`
|
||
|
|
* :option:`max-download-result <--max-download-result>`
|
||
|
|
* :option:`max-overall-download-limit <--max-overall-download-limit>`
|
||
|
|
* :option:`max-overall-upload-limit <--max-overall-upload-limit>`
|
||
|
|
* :option:`save-cookies <--save-cookies>`
|
||
|
|
* :option:`save-session <--save-session>`
|
||
|
|
* :option:`server-stat-of <--server-stat-of>`
|
||
|
|
|
||
|
|
In addition to them, options listed in `Arquivo de Entrada`_ subsection
|
||
|
|
are available, except for following options:
|
||
|
|
:option:`checksum <--checksum>`,
|
||
|
|
:option:`index-out <-O>`,
|
||
|
|
:option:`out <-o>`,
|
||
|
|
:option:`pause <--pause>` and
|
||
|
|
:option:`select-file <--select-file>`.
|
||
|
|
|
||
|
|
Using :option:`log <-l>` option, you can dynamically start logging or
|
||
|
|
change log file. To stop logging, give empty string("") as a parameter
|
||
|
|
value. Note that log file is always opened in append mode. This method
|
||
|
|
returns ``"OK"`` for success.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.getGlobalStat()
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method returns global statistics such as overall download and
|
||
|
|
upload speed. The response is of type struct and contains following
|
||
|
|
keys. The value type is string.
|
||
|
|
|
||
|
|
``downloadSpeed``
|
||
|
|
Overall download speed (byte/sec).
|
||
|
|
|
||
|
|
``uploadSpeed``
|
||
|
|
Overall upload speed(byte/sec).
|
||
|
|
|
||
|
|
``numActive``
|
||
|
|
The number of active downloads.
|
||
|
|
|
||
|
|
``numWaiting``
|
||
|
|
The number of waiting downloads.
|
||
|
|
|
||
|
|
``numStopped``
|
||
|
|
The number of stopped downloads.
|
||
|
|
|
||
|
|
**Exemplo 13 JSON-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> import urllib2, json
|
||
|
|
>>> from pprint import pprint
|
||
|
|
>>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
|
||
|
|
... 'method':'aria2.getGlobalStat'})
|
||
|
|
>>> 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'downloadSpeed': u'21846',
|
||
|
|
u'numActive': u'2',
|
||
|
|
u'numStopped': u'0',
|
||
|
|
u'numWaiting': u'0',
|
||
|
|
u'uploadSpeed': u'0'}}
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 13 XML-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> from pprint import pprint
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> r = s.aria2.getGlobalStat()
|
||
|
|
>>> pprint(r)
|
||
|
|
{'downloadSpeed': '23136',
|
||
|
|
'numActive': '2',
|
||
|
|
'numStopped': '0',
|
||
|
|
'numWaiting': '0',
|
||
|
|
'uploadSpeed': '0'}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.purgeDownloadResult()
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method purges completed/error/removed downloads to free memory.
|
||
|
|
This method returns ``"OK"``.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.removeDownloadResult(gid)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method removes completed/error/removed download denoted by *gid*
|
||
|
|
from memory. This method returns ``"OK"`` for success.
|
||
|
|
|
||
|
|
**Exemplo 14 JSON-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
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'}
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 14 XML-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
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'
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.getVersion()
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method returns version of the program and the list of enabled
|
||
|
|
features. The response is of type struct and contains following keys.
|
||
|
|
|
||
|
|
``version``
|
||
|
|
Version number of the program in string.
|
||
|
|
|
||
|
|
``enabledFeatures``
|
||
|
|
List of enabled features. Each feature name is of type string.
|
||
|
|
|
||
|
|
**Exemplo 15 JSON-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> 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'}}
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 15 XML-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> from pprint import pprint
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> r = s.aria2.getVersion()
|
||
|
|
>>> pprint(r)
|
||
|
|
{'enabledFeatures': ['Async DNS',
|
||
|
|
'BitTorrent',
|
||
|
|
'Firefox3 Cookie',
|
||
|
|
'GZip',
|
||
|
|
'HTTPS',
|
||
|
|
'Message Digest',
|
||
|
|
'Metalink',
|
||
|
|
'XML-RPC'],
|
||
|
|
'version': '1.11.0'}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.getSessionInfo()
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method returns session information.
|
||
|
|
The response is of type struct and contains following key.
|
||
|
|
|
||
|
|
``sessionId``
|
||
|
|
Session ID, which is generated each time when aria2 is invoked.
|
||
|
|
|
||
|
|
**Exemplo 16 JSON-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> 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'}}
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 16 XML-RPC**
|
||
|
|
::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> s.aria2.getSessionInfo()
|
||
|
|
{'sessionId': 'cd6a3bc6a1de28eb5bfa181e5f6b916d44af31a9'}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.shutdown()
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method shutdowns aria2. This method returns ``"OK"``.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.forceShutdown()
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This method shutdowns :func:`aria2. This method behaves like aria2.shutdown`
|
||
|
|
except that any actions which takes time such as contacting BitTorrent
|
||
|
|
tracker are skipped. This method returns ``"OK"``.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: system.multicall(methods)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
This methods encapsulates multiple method calls in a single request.
|
||
|
|
*methods* is of type array and its element is struct. The struct
|
||
|
|
contains two keys: ``methodName`` and ``params``. ``methodName`` is the
|
||
|
|
method name to call and ``params`` is array containing parameters to the
|
||
|
|
method. This method returns array of responses. The element of array
|
||
|
|
will either be a one-item array containing the return value of each
|
||
|
|
method call or struct of fault element if an encapsulated method call
|
||
|
|
fails.
|
||
|
|
|
||
|
|
**Exemplo 17 JSON-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
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'}]
|
||
|
|
|
||
|
|
|
||
|
|
**Exemplo 17 XML-RPC**
|
||
|
|
|
||
|
|
|
||
|
|
In the following example, we add 2 downloads. First one is
|
||
|
|
\http://example.org/file and second one is file.torrent::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> mc = xmlrpclib.MultiCall(s)
|
||
|
|
>>> mc.aria2.addUri(['http://example.org/file'])
|
||
|
|
>>> mc.aria2.addTorrent(xmlrpclib.Binary(open('file.torrent').read()))
|
||
|
|
>>> r = mc()
|
||
|
|
>>> tuple(r)
|
||
|
|
('2', '3')
|
||
|
|
|
||
|
|
|
||
|
|
Tratamento de Erros
|
||
|
|
~~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
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
|
||
|
|
faultString.
|
||
|
|
|
||
|
|
.. _rpc_options:
|
||
|
|
|
||
|
|
Options
|
||
|
|
~~~~~~~
|
||
|
|
|
||
|
|
Same options for :option:`--input-file <-i>` list are available. See `Arquivo de Entrada`_ subsection for complete list of options.
|
||
|
|
|
||
|
|
In the option struct, name element is option name(without preceding
|
||
|
|
``--``) and value element is argument as string.
|
||
|
|
|
||
|
|
Exemplo JSON-RPC
|
||
|
|
^^^^^^^^^^^^^^^^
|
||
|
|
::
|
||
|
|
|
||
|
|
{'split':'1', 'http-proxy':'http://proxy/'}
|
||
|
|
|
||
|
|
|
||
|
|
Exemplo XML-RPC
|
||
|
|
^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: xml
|
||
|
|
|
||
|
|
<struct>
|
||
|
|
<member>
|
||
|
|
<name>split</name>
|
||
|
|
<value><string>1</string></value>
|
||
|
|
</member>
|
||
|
|
<member>
|
||
|
|
<name>http-proxy</name>
|
||
|
|
<value><string>http://proxy/</string></value>
|
||
|
|
</member>
|
||
|
|
</struct>
|
||
|
|
|
||
|
|
|
||
|
|
:option:`header <--header>` and :option:`index-out <-O>`
|
||
|
|
option are allowed multiple times in
|
||
|
|
command-line. Since name should be unique in struct(many XML-RPC
|
||
|
|
library implementation uses hash or dict for struct), single string is
|
||
|
|
not enough. To overcome this situation, they can take array as value
|
||
|
|
as well as string.
|
||
|
|
|
||
|
|
Exemplos JSON-RPC
|
||
|
|
^^^^^^^^^^^^^^^^^
|
||
|
|
::
|
||
|
|
|
||
|
|
{'header':['Accept-Language: ja', 'Accept-Charset: utf-8']}
|
||
|
|
|
||
|
|
|
||
|
|
Exemplos XML-RPC
|
||
|
|
^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: xml
|
||
|
|
|
||
|
|
<struct>
|
||
|
|
<member>
|
||
|
|
<name>header</name>
|
||
|
|
<value>
|
||
|
|
<array>
|
||
|
|
<data>
|
||
|
|
<value><string>Accept-Language: ja</string></value>
|
||
|
|
<value><string>Accept-Charset: utf-8</string></value>
|
||
|
|
</data>
|
||
|
|
</array>
|
||
|
|
</value>
|
||
|
|
</member>
|
||
|
|
</struct>
|
||
|
|
|
||
|
|
|
||
|
|
Following example adds a download with 2 options: dir and header.
|
||
|
|
header option has 2 values, so it uses a list::
|
||
|
|
|
||
|
|
>>> import xmlrpclib
|
||
|
|
>>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
|
||
|
|
>>> opts = dict(dir='/tmp',
|
||
|
|
... header=['Accept-Language: ja',
|
||
|
|
... 'Accept-Charset: utf-8'])
|
||
|
|
>>> s.aria2.addUri(['http://example.org/file'], opts)
|
||
|
|
'1'
|
||
|
|
|
||
|
|
|
||
|
|
JSON-RPC usando HTTP GET
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
The JSON-RPC interface also supports request via HTTP GET.
|
||
|
|
The encoding scheme in GET parameters is based on JSON-RPC over HTTP Specification [2008-1-15(RC1)].
|
||
|
|
The encoding of GET parameters are follows::
|
||
|
|
|
||
|
|
/jsonrpc?method=METHOD_NAME&id=ID¶ms=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¶ms=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¶ms=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
|
||
|
|
|
||
|
|
|
||
|
|
JSON-RPC sobre WebSocket
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
JSON-RPC sobre WebSocket utiliza o mesmo método de assinatura e resposta
|
||
|
|
do formato JSON-RPC sobre HTTP. O WebSocket suportado é da versão 13
|
||
|
|
o qual é detalhado na :rfc:`6455`.
|
||
|
|
|
||
|
|
Para enviar uma requisição RPC para um servidor RPC, enviar strings serializadas
|
||
|
|
JSON num frame Text. A resposta do servidor RPC será entregue também em um frame
|
||
|
|
Text.
|
||
|
|
|
||
|
|
O servidor RPC ira enviar a notificação ao cliente. A notificação é
|
||
|
|
unidirecional, portanto o cliente que receber a notificação não pode
|
||
|
|
responde-la. Esse método de assinatura de notificação é muito usual mas
|
||
|
|
não provê uma identificação de chave. Os valores associados pelos parâmetros
|
||
|
|
chave são os dados que a notificação porta. O formato desses valores
|
||
|
|
variam dependendo do método de notificação. Os seguintes métodos de notificação
|
||
|
|
são definidos:
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.onDownloadStart(event)
|
||
|
|
|
||
|
|
|
||
|
|
Essa notificação será enviada quando e se o download for iniciado.
|
||
|
|
*event* é o tipo de estrutura e pode conter as seguintes chaves:
|
||
|
|
O formato do valor é string.
|
||
|
|
|
||
|
|
``gid``
|
||
|
|
GID do download.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.onDownloadPause(event)
|
||
|
|
|
||
|
|
|
||
|
|
Esta notificação será enviada se o download for pausado. *event*
|
||
|
|
tem a mesma estrutura do argumento *event* do método da função
|
||
|
|
:func:`aria2.onDownloadStart`.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.onDownloadStop(event)
|
||
|
|
|
||
|
|
|
||
|
|
Essa notificação será enviada se o download for interrompido pelo usuário.
|
||
|
|
*event* tem a mesma estrutura do argumento *event* do método da função
|
||
|
|
:func:`aria2.onDownloadStart`.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.onDownloadComplete(event)
|
||
|
|
|
||
|
|
|
||
|
|
Esta notificação será enviada quando o download for completado. Para
|
||
|
|
downloads BitTorrent, esta notificação será enviada quando for completado e
|
||
|
|
o (seed) terminar. O *event* tem a mesma estrutura do *event* do método da
|
||
|
|
função :func:`aria2.onDownloadStart`.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.onDownloadError(event)
|
||
|
|
|
||
|
|
|
||
|
|
Esta notificação será enviada se o download for interrompido por causa de
|
||
|
|
um erro.
|
||
|
|
O *event* tem a mesma estrutura do *event* do método da função
|
||
|
|
:func:`aria2.onDownloadStart`.
|
||
|
|
|
||
|
|
|
||
|
|
.. function:: aria2.onBtDownloadComplete(event)
|
||
|
|
|
||
|
|
|
||
|
|
Esta notificação será enviada se o download for completado para o
|
||
|
|
BitTorrent (mas o seeding pode não ter sido concluído). O *event* tem a
|
||
|
|
mesma estrutura do *event* do método da função :func:`aria2.onDownloadStart`.
|
||
|
|
|
||
|
|
Exemplo Código Cliente XML-RPC
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
O seguinte script Ruby script adiciona ``http://localhost/aria2.tar.bz2`` em
|
||
|
|
aria2c no servidor em localhost com a opção :option:`--dir=/downloads <-d>` e
|
||
|
|
imprime a resposta do processamento:
|
||
|
|
|
||
|
|
.. code-block:: ruby
|
||
|
|
|
||
|
|
#!/usr/bin/env ruby
|
||
|
|
|
||
|
|
require 'xmlrpc/client'
|
||
|
|
require 'pp'
|
||
|
|
|
||
|
|
client=XMLRPC::Client.new2("http://localhost:6800/rpc")
|
||
|
|
|
||
|
|
options={ "dir" => "/downloads" }
|
||
|
|
result=client.call("aria2.addUri", [ "http://localhost/aria2.tar.bz2" ], options)
|
||
|
|
|
||
|
|
pp result
|
||
|
|
|
||
|
|
|
||
|
|
Se você usa Python, pode usar xmlrpclib (em Python3.x, use xmlrpc.client) para
|
||
|
|
interagir com aria2::
|
||
|
|
|
||
|
|
import xmlrpclib
|
||
|
|
from pprint import pprint
|
||
|
|
|
||
|
|
s = xmlrpclib.ServerProxy("http://localhost:6800/rpc")
|
||
|
|
r = s.aria2.addUri(["http://localhost/aria2.tar.bz2"], {"dir":"/downloads"})
|
||
|
|
pprint(r)
|
||
|
|
|
||
|
|
DIVERSOS
|
||
|
|
--------
|
||
|
|
|
||
|
|
Mensagens na Console
|
||
|
|
~~~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
Enquanto executa o download de arquivos, aria2 imprime mensagens na console
|
||
|
|
para mostrar o progresso dos downloads. Um exemplo abaixo::
|
||
|
|
|
||
|
|
[#1 SIZE:400.0KiB/33.2MiB(1%) CN:1 SPD:115.7KiBs ETA:4m51s]
|
||
|
|
|
||
|
|
Entenda o que estes números e strings significam.
|
||
|
|
|
||
|
|
``#N``
|
||
|
|
N significa GID, o qual é um ID único para cada download.
|
||
|
|
|
||
|
|
``SIZE``
|
||
|
|
Tamanho Total e Tamanho em bytes. Se a :option:`--select-file` é usada,
|
||
|
|
será exibida a somatória do tamanho do arquivo.
|
||
|
|
|
||
|
|
``SEEDING``
|
||
|
|
Taxa compartilhamento ratio. O cliente está funcionando. Após término do
|
||
|
|
download do BitTorrent, ``SIZE`` será substituído por ``SEEDING``.
|
||
|
|
|
||
|
|
``CN``
|
||
|
|
Número de conexões que o cliente estabeleceu.
|
||
|
|
|
||
|
|
``SEED``
|
||
|
|
O número de seeders ao qual o cliente está conectado.
|
||
|
|
|
||
|
|
``SPD``
|
||
|
|
Velocidade do download.
|
||
|
|
|
||
|
|
``UP``
|
||
|
|
Velocidade e número de bytes transmitidos upload.
|
||
|
|
|
||
|
|
``ETA``
|
||
|
|
Tempo previsto para conclusão.
|
||
|
|
|
||
|
|
``TOTAL SPD``
|
||
|
|
A soma das velocidades de download para todos downloads paralelos.
|
||
|
|
|
||
|
|
Quando aria2 está alocando o espaço para arquivo ou validando o checksum,
|
||
|
|
adicionalmente exibirá o progresso:
|
||
|
|
|
||
|
|
FileAlloc
|
||
|
|
GID, tamanho alocado e total em bytes.
|
||
|
|
|
||
|
|
Checksum
|
||
|
|
GID, tamanho validado e total em bytes.
|
||
|
|
|
||
|
|
EXEMPLOS DOWNLOAD HTTP / FTP
|
||
|
|
----------------------------
|
||
|
|
|
||
|
|
Download Segmentado HTTP/FTP
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
Download de arquivo
|
||
|
|
^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c "http://servidor/arquivo.zip"
|
||
|
|
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Para parar o download, pressione :kbd:`Ctrl-C`. Posteriormente pode ser
|
||
|
|
retomado o mesmo download no mesmo diretório. Podem ser modificadas as URIs
|
||
|
|
pois elas apontam para o mesmo arquivo.
|
||
|
|
|
||
|
|
Download de arquivo de 2 servidores HTTP diferentes
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c "http://servidor/arquivo.zip" "http://espelhobrasil/arquivo.zip"
|
||
|
|
|
||
|
|
|
||
|
|
Download de arquivo do mesmo servidor HTTP usando 2 conexões
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c -x2 -k1M "http://servidorbrasil/arquivo.zip"
|
||
|
|
|
||
|
|
|
||
|
|
Download de arquivo de servidor HTTP e FTP
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c "http://svrbrasil/arquivo.zip" "ftp://servebr/arquivo.zip"
|
||
|
|
|
||
|
|
|
||
|
|
Download arquivos especificados num arquivo txt concomitantemente
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c -i arquivo.txt -j2
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
-j especifica número de downloads paralelos.
|
||
|
|
|
||
|
|
Usando proxy
|
||
|
|
^^^^^^^^^^^^
|
||
|
|
Para HTTP:
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --http-proxy="http://svrproxy:8080" "http://servidor/arquivo"
|
||
|
|
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --http-proxy="http://svrproxy:8080"
|
||
|
|
--no-proxy="localhost,127.0.0.1,192.168.0.0/16" "http://servidor/arquivo"
|
||
|
|
|
||
|
|
a máscara de rede /16 quer dizer que para toda a rede 192.168 também não
|
||
|
|
será usado o servidor proxy
|
||
|
|
|
||
|
|
Para FTP:
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --ftp-proxy="http://svrproxy:8080" "ftp://servidor/arquivo"
|
||
|
|
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Ver :option:`--http-proxy`, :option:`--https-proxy`, :option:`--ftp-proxy`,
|
||
|
|
:option:`--all-proxy` e :option:`--no-proxy` para detalhes. Proxy pode ser
|
||
|
|
especificado nas variáveis de ambiente. Ver seção `VARIÁVEIS DE AMBIENTE`_ .
|
||
|
|
|
||
|
|
Proxy com autenticação / authorização
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --http-proxy="http://usuário:senha@svrproxy:8080" "http://servidor/arquivo"
|
||
|
|
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --http-proxy="http://svrproxy:8080" --http-proxy-user="usuário" --http-proxy-passwd="senha" "http://servidor/arquivo"
|
||
|
|
|
||
|
|
|
||
|
|
Download Metalink
|
||
|
|
~~~~~~~~~~~~~~~~~
|
||
|
|
Download arquivos com Metalink remoto
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --follow-metalink=mem "http://servidor/arquivo.metalink"
|
||
|
|
|
||
|
|
|
||
|
|
Download arquivos com Metalink local
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c -p --lowest-speed-limit=4000 arquivo.metalink
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Para parar o download, pressione :kbd:`Ctrl-C`.
|
||
|
|
A transferência pode ser retomada executando aria2c com o mesmo argumento
|
||
|
|
no mesmo diretório
|
||
|
|
|
||
|
|
Download diversos arquivos Metalink local
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c -j2 arquivo1.metalink arquivo2.metalink
|
||
|
|
|
||
|
|
|
||
|
|
Download só arquivos selecionados usando index
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --select-file=1-4,8 arquivo.metalink
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
O index é exibido na console usando opção -S.
|
||
|
|
|
||
|
|
Download um arquivo usando Metalink local com preferência do usuário
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --metalink-location=pt,us --metalink-version=1.1 --metalink-language=pt-BR arquivo.metalink
|
||
|
|
|
||
|
|
|
||
|
|
Download BitTorrent
|
||
|
|
~~~~~~~~~~~~~~~~~~~
|
||
|
|
Download arquivos de BitTorrent remotos
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --follow-torrent=mem "http://servidortorrent/arquivo.torrent"
|
||
|
|
|
||
|
|
|
||
|
|
Download usando arquivo torrent local
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --max-upload-limit=40K arquivo.torrent
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
--max-upload-limit especifica taxa máxima de transmissão (upload).
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Para parar o download, pressione :kbd:`Ctrl-C`. A transferência pode ser retomada
|
||
|
|
ao executar aria2c com os mesmos argumentos no mesmo diretório.
|
||
|
|
|
||
|
|
Download usando URI BitTorrent Magnet
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c "magnet:?xt=urn:btih:248D0A1CD08284299DE78D5C1ED359BB46717D8C&dn=aria2"
|
||
|
|
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Lembre-se inserir delimitadores na URI BitTorrent Magnet, pois ela inclui ``&``
|
||
|
|
que tem significado de parâmetro. Utilizar apóstrofo(``'``) ou aspas(``"``).
|
||
|
|
|
||
|
|
Download 2 torrents
|
||
|
|
^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c -j2 arquivo1.torrent arquivo2.torrent
|
||
|
|
|
||
|
|
|
||
|
|
Download um arquivo usando torrent e servidor HTTP/FTP
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c -T arqfile.torrent "http://serv1/arqfile" "ftp://svr2/arqfile"
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Download de arquivos múltiplos torrent com HTTP e FTP não é suportado.
|
||
|
|
|
||
|
|
Download arquivos selecionados usando index(chamado "download seletivo")
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --select-file=1-4,8 arquivo.torrent
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
O index é exibido na console usando-se a opção -S.
|
||
|
|
|
||
|
|
Especificar arquivo saída
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
|
||
|
|
Para especificar arquivo de saída em Downloads de BitTorrent, faz-se necessário
|
||
|
|
conhecer o index do arquivo no torrent usando a opção :option:`--show-files <-S>`.
|
||
|
|
Por exemplo, a saída exibirá algo como::
|
||
|
|
|
||
|
|
idx|path/length
|
||
|
|
===+======================
|
||
|
|
1|dist/base-2.6.18.iso
|
||
|
|
|99.9MiB
|
||
|
|
---+----------------------
|
||
|
|
2|dist/driver-2.6.18.iso
|
||
|
|
|169.0MiB
|
||
|
|
---+----------------------
|
||
|
|
|
||
|
|
|
||
|
|
Para salvar 'dist/base-2.6.18.iso' em '/tmp/meudir/base.iso' e
|
||
|
|
'dist/driver-2.6.18.iso' em '/tmp/dir/driver.iso', use o seguinte comando:
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --dir=/tmp --index-out=1=meudir/base.iso --index-out=2=dir/driver.iso arquivo.torrent
|
||
|
|
|
||
|
|
|
||
|
|
Modificando porta escuta para peer de entrada
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --listen-port=7000-7001,8000 arquivo.torrent
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Já que aria2 não configura o firewall ou porta de roteamento para portas
|
||
|
|
de encaminhamento, isto deve ser explicitado manualmente por você.
|
||
|
|
|
||
|
|
Especificar condição para para o programa torrent após término do download
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --seed-time=120 --seed-ratio=1.0 arquivo.torrent
|
||
|
|
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
No exemplo acima, o programa termina após transcorrer 120 minutos após
|
||
|
|
término do download ou taxa chegar a 1.0.
|
||
|
|
|
||
|
|
Controlar velocidade upload Torrent
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --max-upload-limit=100K arquivo.torrent
|
||
|
|
|
||
|
|
|
||
|
|
Habilitar IPv4 DHT
|
||
|
|
^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --enable-dht --dht-listen-port=6881 arquivo.torrent
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
DHT utiliza a porta udp, como o aria2 não configura firewall nem porta de roteamento
|
||
|
|
ou forwarding, por favor executar estas configurações manualmente.
|
||
|
|
|
||
|
|
Habilitar IPv6 DHT
|
||
|
|
^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --enable-dht6 --dht-listen-port=6881 --dht-listen-addr6=YOUR_GLOBAL_UNICAST_IPV6_ADDR --enable-async-dns6
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Se aria2c não foi compilado com c-ares, a opção :option:`--enable-async-dns6`
|
||
|
|
não é necessária. aria2 compartilha a mesma porta ente IPv4 e IPv6 DHT.
|
||
|
|
|
||
|
|
Adicionar e remover rastreador URI
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
|
||
|
|
Remover todos os rastreadores (tracker) das URIs descritas no arquivo.torrent
|
||
|
|
utilize ``http://tracker1/announce`` e ``http://tracker2/announce``
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --bt-exclude-tracker="*" --bt-tracker="http://tracker1/announce,http://tracker2/announce" file.torrent
|
||
|
|
|
||
|
|
|
||
|
|
Funcionalidades avançadas HTTP
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
Carregar cookies
|
||
|
|
^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --load-cookies=cookies.txt "http://servidor/arquivo.zip"
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Podem ser utilizados sem nenhuma modificação coookies dos navegadores:
|
||
|
|
Firefox / Mozilla / Chromium.
|
||
|
|
|
||
|
|
Continuar download iniciado por navegadores ou outros programas
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
Quando desejar continuar ou retomar um download cujo processamento foi
|
||
|
|
interrompido, seja em navegador ou qualquer outro programa utilize
|
||
|
|
o aria2c para retomar este download do ponto onde parou.
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c -c -s2 "http://servidor/arquivodedownloadparcial.zip"
|
||
|
|
|
||
|
|
|
||
|
|
Autenticação certificado para Cliente SSL/TLS
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --certificate=/path/para/mycert.pem --private-key=/path/para/mykey.pem https://servidor/arquivo
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
O arquivo especificado na opção :option:`--private-key` não pode estar
|
||
|
|
criptografado. O comportamento do processo fica indefinido quando o
|
||
|
|
arquivo estiver criptografado.
|
||
|
|
|
||
|
|
Verificar peer em SSL/TLS usando certificados CA
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --ca-certificate=/path/para/ca-certificates.crt
|
||
|
|
--check-certificate https://servidor/arquivo
|
||
|
|
|
||
|
|
|
||
|
|
Funcionalidades avançadas adicionais
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
Controlar velocidade de download
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
|
||
|
|
Quando for necessário o controle da utilização da banda disponível, pode ser
|
||
|
|
utilizado a opção abaixo. Atenção o sufixo K ou M deve ser em letra maiúscula.
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --max-download-limit=100K arquivo.metalink
|
||
|
|
|
||
|
|
|
||
|
|
Reparar um download danificado
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c -V arquivo.metalink
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
Reparar downloads danificados pode ser mais eficiente usando
|
||
|
|
BitTorrent ou Metalink com a opção verificação (checksums).
|
||
|
|
|
||
|
|
Desconectar conexão se a velocidade download for menor que um valor
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --lowest-speed-limit=10K file.metalink
|
||
|
|
|
||
|
|
|
||
|
|
Suporte a URI parametrizada
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
A URI pode ser especificada como partes de um conjunto:
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c -P "http://{svr1,svr2,svr3}/arquivo.iso"
|
||
|
|
|
||
|
|
|
||
|
|
Também podem ser especificados sequencias de intervalos:
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c -Z -P "http://servidor/imagem[000-100].png"
|
||
|
|
|
||
|
|
|
||
|
|
.. note::
|
||
|
|
|
||
|
|
-Z opção requerida para que todas URIs não apontem para o mesmo arquivo,
|
||
|
|
como declarado no código acima.
|
||
|
|
|
||
|
|
Especificar incrementos para contador:
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c -Z -P "http://servidor/imagem[A-Z:2].png"
|
||
|
|
|
||
|
|
|
||
|
|
Vericar validação checksum
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --checksum=sha-1=0192ba11326fe2298c8cb4de616f4d4140213837
|
||
|
|
http://dobrasil.org/arquivo
|
||
|
|
|
||
|
|
|
||
|
|
Download Paralelo de uma quantidade arbitrária de URI, Metalink ou Torrent
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c -j3 -Z "http://servidor/arquivo1" arquivo2.torrent arq3.metalink
|
||
|
|
|
||
|
|
|
||
|
|
BitTorrent Criptografado
|
||
|
|
^^^^^^^^^^^^^^^^^^^^^^^^
|
||
|
|
Criptografar todo conjunto usando ARC4:
|
||
|
|
|
||
|
|
.. code-block:: console
|
||
|
|
|
||
|
|
$ aria2c --bt-min-crypto-level=arc4 --bt-require-crypto=true arquivo.torrent
|
||
|
|
|
||
|
|
|
||
|
|
Ver Também
|
||
|
|
----------
|
||
|
|
|
||
|
|
Site do Projeto aria2: http://aria2.sourceforge.net/
|
||
|
|
|
||
|
|
Wiki aria2: http://sourceforge.net/apps/trac/aria2/wiki
|
||
|
|
|
||
|
|
Site do Projeto Metalink: http://www.metalinker.org/
|
||
|
|
|
||
|
|
Descrição do Formato Download Metalink: :rfc:`5854`
|
||
|
|
|
||
|
|
COPYRIGHT
|
||
|
|
---------
|
||
|
|
|
||
|
|
Copyright (C) 2006, 2012 Tatsuhiro Tsujikawa
|
||
|
|
Tradução para Português do Brasil 2012, Gilberto dos Santos Alves
|
||
|
|
utilizando editor kate e gedit no Debian squeeze 6.0.6 novembro de 2012
|
||
|
|
|
||
|
|
Esse programa é software livre; pode ser redistribuido e/ou modificado
|
||
|
|
sob os termos da Licença GNU General Public License como publicada por
|
||
|
|
Free Software Foundation www.fsf.org; versão 2 da Licença, ou qualquer
|
||
|
|
versão mais recente, qualquer que seja sua escolha.
|
||
|
|
|
||
|
|
Este programa é distribuído na intenção de ser útil, mas SEM NENHUMA GARANTIA;
|
||
|
|
sem qualquer garantia implícita de ser COMERCIALIZÁVEL ou para PROPÓSITO
|
||
|
|
ESPECÍFICO. Consulte a Linceça GNU Genérica para mais detalhes.
|
||
|
|
|
||
|
|
Você precisa receber uma cópia da Licença Pública GNU Genérica junto com
|
||
|
|
este programa; caso não tenha, escrevá para Free Software Foundation, Inc.,
|
||
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||
|
|
|
||
|
|
Adicionalmente, como uma exceção especial, os detentores do direito autoral
|
||
|
|
autorizam a permissão para compilar programas que possuem ligação com
|
||
|
|
parte do código com a biblioteca OpenSSL sob certas condições como descritas
|
||
|
|
em cada arquivo fonte e autorizam a distribuição das das combinações das
|
||
|
|
ligações incluindo ambas.
|
||
|
|
Devem ser obedecidos todos os detalhes da Licença Pública GNU Genérica
|
||
|
|
em relação a OpenSSL. Caso haja modificação nos arquivos com esta exceção
|
||
|
|
deverá ser extendida esta exceção para as versões modificadas dos arquivos, mas
|
||
|
|
isto não é obrigatório. Se não houver esta intenção exclua esta declaração
|
||
|
|
de exceção da sua versão. Caso sejam excluídas as declarações de todos
|
||
|
|
os arquivos fontes, exclua também esta declaração daqui.
|
||
|
|
|
||
|
|
NOTE
|
||
|
|
----
|
||
|
|
|
||
|
|
This manual page may not necessarily contain the latest information.
|
||
|
|
If there are some contradictions between this manual page and actual
|
||
|
|
software, please refer to English version of man page.
|