CORBA (Common Object Request Broker Architecture) é um padrão definido pelo grupo OMG (Object Management Group), este permite a interação entre Objetos Distribuídos, em diferentes linguagens e sistemas. Ele também proporciona total transparência na comunicação entre os objetos distribuídos. A localização de objetos é feito via suas referências, que são resolvidas pelo ORB. A linguagem IDL (Interface Definition Language) é a tecnologia utilizada para descrever as interfaces dos objetos. Esta é uma linguagem puramente declarativa. Ela possui seus próprios tipos de dados, que são mapeados para tipos de dados nas linguagens suportadas. Existe o Compilador IDL que gera os códigos responsáveis pela comunicação entre objetos, mapeia os tipos de dados, se encarrega de fazer a serialização dos dados.

Mas na prática como funciona? Bom, possuimos as definições em um arquivo .idl, neste caso o arquivo Bank-idl (lembre-se de renomea-lo para bank.idl).

Acessando esse arquivo vocês verão diversas definições como:

Definição do modulo

module banco {

Definição do tipo valor

typedef double valor;

Definição da estrutura de dados Transação

struct transacao {
unsigned long data; // Formato: ddmmyyyy
string<12> descricao;
valor quantia;
};

Definição da interface, seus métodos, variaveis, excessões

interface auto_atendimento {
readonly attribute string boas_vindas;
valor saldo ( in conta c )
raises ( conta_inval );
void extrato ( in conta c,
out transacoes t, out valor saldo )
raises ( conta_inval );
void transferencia ( in conta origem,
in conta destino, in valor v )
raises ( conta_inval, saldo_insuf );
void investimento ( in conta c,
in aplicacao apl, in valor v )
raises ( conta_inval, saldo_insuf );
};

Com este arquivo, você pode criar as diversas interfaces com diferentes compiladores para diferentes linguagens. Para gerar as interfaces utilize

idlj -fall bank.idl

O mesmo irá gerar diversos arquivos dentro da pasta banco, com arquivos .java, com interfaces, métodos e exceções. Os mesmos devem ser ainda implementados para funcionar como você desejar.

Um exemplo de implementação de um Servidor de Banco e um Cliente em Java, utilizando CORBA com IDL

Matheus

PS: Isto foi apenas uma breve introdução. O CORBA utiliza diversas outras definições como o OMA e outras.

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.

Nas aulas de programação concorrente o professor passou uma introdução de Programação Distribuida e pediu que nós criassemos algo que utilizasse ela. Então eu sugeri ao meu colega Olav para implementarmos um “quebrador” de senha por força bruta. O mesmo funciona da seguinte maneira, existe um master onde os slaves se conectam, o master informa a string a ser quebrada e qual faixa de caracteres o slave deve tentar. Após terminar aquela faixa caso ele não obtenha sucesso o slave recebe uma nova faixa, caso ele encontre, ele informa o master qual a string utilizada para gerar tal MD5.

Implementação do “MD5 Decrypter”

Existem muitas coisas que ainda podem ser aperfeiçoadas nesse programa como:
- Não precisar um número fixo de Slaves. Aceitar todos que forem se conectando em tempo real.
- Melhor distribuição de faixas.

Ele pode ser praticamente o inicio de um programa de Força Bruta Distribuida, que já devem existir vários por ai.

Espero que goste,
Matheus

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 mexer 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

Estava tentando acessar minha conta do banco e não conseguia por problemas do java. Conversando com um amigo ele me ensinou o que devia ser instalado para conseguir utilizar o mesmo. Para conseguir utilizar o java no ubuntu 64bits você deve utilizar o sun-java-plugin. Para instalar o mesmo você pode utilizar o seguinte comando:

sudo apt-get install sun-java6-plugin

Abraços,
Matheus

English Version