Por que criar um servidor com um cliente torrent com acess web? Como eu moro com outras pessoas, que também utilizam torrent e tinha um computador rodando direto com outros serviços, decidi adicionar um cliente torrent (transmission) com acesso via web, assim não precisando deixar os computadores ligados baixando. Cada um possui acesso e pode deixar o seu.

Mas qual cliente utilizar? Verifiquei a existência desse tipo de clientes e verifiquei que existem dois bastante famosos, o w3btorrent e o torrentflux, li que ambos exercem muito bem sua função, porém o que eu não gostei é que eles precisam de servidor WEB como o Apache, o segundo se não estou enganado também precisa de PHP e por ai vai. Mas, será que não tem um que não precise disso? Claro que existe o próprio transmission, cliente nativo do Ubuntu.

Bom, chega de dar outras opções pra você e vamos a instalação do Transmission. Inicialmente acesse seu servidor via ssh e instale o transmission-daemon com o seguinte comando:

$ sudo apt-get install transmission-daemon

Agora você deve configurar o mesmo, para configurar o mesmo, acessei /home/usuario/.config/transmission-daemon/settings.json

O arquivo é extenso e possui diversas configurações mas todas praticamente intuitivas.

“download-dir”: – É o diretório onde os downloads terminados irão ficar
“incomplete-dir”: – É o diretório onde os downloads incompletos irão ficar
“incomplete-dir-enabled”: – Se irá usar o diretório incompleto ou não
“rpc-enabled”: – Se o acesso via web estará ligado ou não
“rpc-port”: – Porta do serviço
“rpc-whitelist-enabled”: – Se permitirá o acesso somente a certos IPs
“rpc-whitelist”: – Lista dos ips permitidos

Existem diversas outras configurações que podem ser feitas, mas essas são as básicas que utilizei para fazer ele funcionar, tive alguns problemas com a White-list então desabilitei a mesma, habilitei o rpc e pronto.

Este é o meu
Arquivo de configuração do transmission-daemon no mesmo a senha é “teste” e o usuário é “admin”

Para iniciar o transmission-daemon com um arquivo de configuração diferente, utilize –config-dir DIR/PARA/O/ARQUIVO

(Lembrando que não é necessário colocar o caminho até o settings.json e sim somente o caminho onde está o mesmo)

Adicionei no /etc/rc.local

transmission-daemon –config-dir /home/usuario/.config/transmission-daemon/

Removi o transmission-daemon do /etc/init.d/ reinicie e pronto.

Qualquer dúvida ou problema entre em contato, ficarei feliz em ajudar,
Matheus

Hoje o Jorge me perguntou se eu sabia como enviar arquivos via XML-RPC. Pensando no assunto não me recordava como devia ser feito, resolvi dar uma rápida pesquisada para ensina-lo. Acabei me entretendo e resolvi modificar o Cliente e Servidor Java XML-RPC para fazer o mesmo.

Implementei o mesmo e não foi complexo só olhei a documentação do Apache XML-RPC para ver como eram enviados bytes. Os mesmos eram enviados codificando o array de bytes (byte[]) em Base64. Pesquisei um pouco como fazer isso e achei uma Biblioteca Java de Base64 em dominio publico. Também procurei por como pegar o array de bytes de um arquivo e como criar um novo arquivo apartir de um array de bytes (byte[]).

Esses sites onde peguei ambos os métodos estão como comentarios no arquivo.

XML-RPC-Transferencia-De-Arquivo

Espero que seja útil,
Matheus

PS: Da maneira como eu implementei qualquer arquivo do sistema que o Cliente XML-RPC pedir o Servidor irá enviar, isso criaria uma possivel brecha de segurança.

PS2: Caso deseja que o Cliente envie arquivos para o Servidor, o Cliente deve pegar o array de bytes do Arquivo, codifica-lo em base64 e passa-lo como parametro. O Servidor irá receber este parametro, decodificar após isso manipu-le o array de bytes como você desejar.

Como havia comentado a algum tempo atrás, estava trabalhando com um cliente XML-RPC em Java, durante a fase de desenvolvimento do mesmo tive que criar um servidor XML-RPC hipotetico para testar as funcionalidades do cliente, enquanto o servidor certo ainda não estava disponivel para minha pessoa.

Resumidamente para você que não conhece XML-RPC ele é um “formato” , um “jeito”, não sei ao certo a palavra certa para definir agora, onde você cria um servidor e o mesmo quando requisitado faz as operações necessarias e retorna um resultado. Um exemplo seria, você tem um código de criptografia que funciona MUITO bem em C, mas seu sistema é todo em Java, você poderia criar um Cliente JAVA e um Servidor C onde o Java faria requisição para Criptografar as coisas. Talvez utilizar XML-RPC de Java para Java possa ser meio estranho, mas quando os serviços estão distantes, pode ser algo util.

Para começar a mecher com o XML-RPC no Java eu utilizei o apache xml-rpc. Após isso apenas desenvolvi.

Baixe os exemplos cliente e servidor xml-rpc em java.

Servidor:

package xmlrpc;

import org.apache.xmlrpc.server.PropertyHandlerMapping;
import org.apache.xmlrpc.server.XmlRpcServer;
import org.apache.xmlrpc.webserver.WebServer;

public class ServidorXMLRPCParaTestes {

private static ServidorXMLRPCParaTestes euMesmo = null;

private ServidorXMLRPCParaTestes() {
try {
WebServer server = new WebServer(8185); // Cria um servidor na porta 8185
XmlRpcServer servidor = server.getXmlRpcServer(); // Pega o servidor XmlRpc
PropertyHandlerMapping phm = new PropertyHandlerMapping();
phm.addHandler(“Calc”, Calculadora.class); // Adiciona um novo “handler” ao PHM
servidor.setHandlerMapping(phm); // Define o handler no servidor
server.start(); // inicia o servidor.
} catch (Exception exception) {
System.err.println(“JavaServer: ” + exception);
}
}

public static ServidorXMLRPCParaTestes obterInstância() {
if (euMesmo == null)
euMesmo = new ServidorXMLRPCParaTestes();
return euMesmo;
}
}

- Eu utilizeo o obterInstancia para não poder existir mais de um ServidorXMLRPC
- O handler faz o seguinte, quando for chamado Calc.METODO no servidor ele irá buscar dentro do Calculadora.class

Handler Calculadora:

package xmlrpc;

public class Calculadora {

public int soma(int x, int y) {
return x + y;
}
public int subtracao(int x, int y) {
return x – y;
}

}

Cliente XML-RPC generico:

package xmlrpc;

import java.net.URL;
import org.apache.xmlrpc.*;
import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;

public class ClienteXmlRpc {

private static final String urlServidor = “http://localhost:8185″; //DEFINE A URL DO SERVIDOR
private XmlRpcClient xmlrpc;

public ClienteXmlRpc() {
try {
XmlRpcClientConfigImpl configuraçãoCliente = new XmlRpcClientConfigImpl();
configuraçãoCliente.setServerURL(new URL(urlServidor));

xmlrpc = new XmlRpcClient();
xmlrpc.setConfig(configuraçãoCliente);

} catch (Exception exception) {
exception.printStackTrace();
}
}

public Object executar(String comando, Object[] parametros) {
try {
Object resposta = xmlrpc.execute(comando, parametros);
return resposta;
} catch (XmlRpcException e) {
e.printStackTrace();
return null;
}
}

}

- Acredito que o Cliente XML-RPC e o Cliente são auto-explicativos. Qualquer duvida entre em contato.

CalculadoraCliente:

package cliente;

import xmlrpc.ClienteXmlRpc;

public class CalculadoraCliente {
private ClienteXmlRpc cliente;

public CalculadoraCliente() {
cliente = new ClienteXmlRpc();
}

public int soma(int x, int y) {
Object[] parametros = new Object[]{new Integer(x), new Integer(y)};
Integer resultado = (Integer) cliente.executar(“Calc.soma”, parametros);
return resultado;
}

public int subtracao(int x, int y) {
Object[] parametros = new Object[]{new Integer(x), new Integer(y)};
Integer resultado = (Integer) cliente.executar(“Calc.subtracao”, parametros);
return resultado;
}
}

Para rodar os mesmos e testar gerei 2 classes com main e executei as mesmas (executando primeiro o servidor é claro)

RodarServidor:

import xmlrpc.ServidorXMLRPCParaTestes;

public class RodarServidor {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ServidorXMLRPCParaTestes Servidor = ServidorXMLRPCParaTestes.obterInstância();
}

}

RequisicaoCliente:

import cliente.CalculadoraCliente;

public class RequisicaoCliente {

/**
* @param args
*/
public static void main(String[] args) {
CalculadoraCliente x = new CalculadoraCliente();
System.out.println(x.soma(1, 1));
}

}

Abraços,
Matheus