White Magician

Revista Programar - 14ª Edição - Maio De 2008

Publicado por wmagician em 19 Maio, 2008

Revista PROGRAMAR
Edição 14 - Maio de 2008

Apesar de um atraso de sensivelmente 2 semanas, pelo qual pedimos desculpa aos nossos assíduos leitores, dois meses depois do nosso segundo aniversário, trazemos até vós mais uma edição da Revista PROGRAMAR.

Numa edição que inclui variados temas, encontrará, entre outros assuntos, um artigo sobre interacção com MySQL a partir da linguagem Python, um artigo sobre engenharia de software, uma análise de um livro sobre Python e um excelente artigo sobre network scanning. Poderá ainda ler sobre dois importantes eventos: o Festival Nacional de Robótica o Techdays 2008.

Mais info.

Publicado em Revista P@P | Tagged: , , | 2 Comentários »

Manipulação de Ficheiros com Ruby

Publicado por wmagician em 14 Março, 2008

Neste artigo vamos explorar a linguagem Ruby e os seus recursos para manipulação de ficheiros e directórios bem como as capacidades de Input/Ouput disponíveis. Para isso vão ser utilizadas as bibliotecas mais comuns como Dir, File e IO. Embora existam outras mais recentes e com mais recursos estão são as mais comuns, de simples utilização e que servem para base de bibliotecas mais recentes.

Directórios

Para trabalhar com directórios vamos utilizar a Classe Dir. Esta classe disponibiliza diversos métodos que permitem aceder e manipular directórios de forma rápida .Vamos começar por ver um exemplo simples, um pequeno script que verifica se o directório actual é o definido pelo programa. Depois de passar para o referido directório todo o conteúdo é impresso um a um.

1 WORK_DIR = "/home/magician/"
2
3 if Dir.pwd != WORK_DIR
4   Dir.chdir( WORK_DIR )
5 end
6
7 Dir.foreach( WORK_DIR ) { |nome| puts nome }

É possível ainda criar e eliminar directórios de forma muito simples, bastando usar os métodos mkdir e rmdir que a classe Dir dispõe.

1 Dir.mkdir( "/home/magician/Ruby", 755 )
2
3 Dir.rmdir( "/home/magician/Ruby" )

O exemplo acima não faz mais do que criar um directório no caminho dado e com as permissões dadas. Estas permissões são opcionais, podemos apenas dar o caminho. Em seguida eliminamos o directório criado com o método rmdir. Podíamos utilizar o método delete em detrimento ao método rmdir, pois ambos fazem exactamente o mesmo.

A classe dir também permite criar Streams a directórios, permitindo desta forma percorrer o conteúdo de directórios de forma mais flexível do que usando o método foreach mostrado anteriormente.

1  dir = Dir.open( "/home/magician/" )
2
3  dir.path #=> "/home/magician"
4
5  dir.tell #=> 0
6
7  dir.read #=> "Ficheiro 1"
8
9  dir.tell #=> 599320
10
11 dir.read #=> "Ficheiro 2"
12
13 dir.rewind
14
15 dir.close

Como podemos ver na linha 1 é aberta uma ligação ao directório. A partir dai podemos, entre outras coisas, percorrer todos os ficheiros e directórios contidos no directório aberto. O método tell (linha 5 e 9) retorna a localização do apontador sob forma de inteiro, o método read (linha 7 e 11) retorna sob forma de String a próxima entrada no directório, retornando nil quando não existirem mais entradas. Por fim o método rewind (linha 13) permite colocar o apontador da stream de novo no inicio e método close (linha 15) fecha a ligação ao directório.

Ficheiros

Criar um ficheiro não podia ser mais simples, basta utilizar a classe File

1 file = File.new( "exemplo.txt", "w" )

O exemplo acima cria o ficheiro exemplo.txt e abre o ficheiro em modo de escrita. Vamos agora ver que outros modos de abertura e criação de ficheiros existem.

  • “r” - Read-Only. Começa no inicio do ficheiro.
  • “r+” - Read-Write. Começa no inicio do ficheiro.
  • “w” - Write-Only. Passa o tamanho do ficheiro a zero ou cria um novo ficheiro para escrita.
  • “w+” - Read-Write. Passa o tamanho do ficheiro a zero ou cria um novo ficheiro para escrita e leitura.
  • “a” - Write-Only. Começa no fim do ficheiro caso este exista, caso contrário cria o ficheiro para escrita.
  • “a+” - Read-Write. Começa no fim do ficheiro caso este exista, caso contrário cria o ficheiro para escrita e leitura.
  • “b” - (DOS/WIN only) Binary.

Depois de criarmos um ficheiro, podemos precisar de apagar o ficheiro ou até mesmo mudar o nome desse ficheiro. Este processo é também muito simples, para isso a classe File disponibiliza os métodos rename e delete que permitem estas operações.

1 File.new( "exemplo.txt", "w" )
2 File.rename( "exemplo.txt", "novoExemplo.txt" )
3 File.delete( "novoExemplo.txt" )

O exemplo acima cria o ficheiro “exemplo.txt” (linha 1), em seguida o nome do ficheiro é modificado de “exemplo.txt” para “novoExemplo.txt” (linha 2), por fim o ficheiro é eliminado (linha 3).

A classe File permite ainda realizar mais algumas operações úteis, como por exemplo verificar se um ficheiro existe, se é um directório, se é possível ler ou escrever no ficheiro, entre outras. Vamos ver alguns exemplos:

1  File.exist?( "ficheiro.txt" )
2
3  File.file?( "ficheiro.txt" )
4
5  File.directory?( "ficheiro.txt" )
6
7  File.readable?( "ficheiro.txt" )
8
9  File.writable?( "ficheiro.txt" )
10
11 File.executable?( "ficheiro.txt" )
12
13 File.zero?( "ficheiro.txt" )
14
15 File.size( "ficheiro.txt" )
16
17 File.size?( "ficheiro.txt" )

O exemplo mostra algumas das mais importantes operações sobre ficheiros. Na linha 1, o método exist? verifica se o ficheiro existe retornando true ou false, em seguida nas linhas 3 e 5 verificam se o ficheiro dado no path é realmente um ficheiro ou se é um directório. Nas linhas 7 e 9 os métodos readable? e writable? verificam se é possível ler ou escrever no ficheiro e na linha 11 o método executable verifica se o ficheiro é ou não executável. No final do exemplo podemos ver os métodos zero?, size e size?. O método zero? verifica se o ficheiro tem ou não tamanho igual a zero, os métodos size e size? fazem exactamente o mesmo que retornar o tamanho do ficheiro em bytes, com a diferença que caso este seja nulo, o primeiro retorna 0 e o segundo nil. Para além destes métodos é ainda possível obter mais algumas informações sobre os ficheiros como por exemplo data de criação, de edição e do ultimo acesso. Vamos por isso ver um exemplo desta funcionalidades.

1 File.ctime( "ficheiro.txt" )  #=> Thu Jan 21 19:55:16 +0000 2008
2
3 File.mtime( "ficheiro.txt" )  #=> Thu Jan 21 19:55:16 +0000 2008
4
5 File.atime( "ficheiro.txt" )  #=> Thu Jan 25 19:55:16 +0000 2008

Como podemos ver, na linha 1 o método ctime retorna uma String como a apresentada acima com a data e hora a que o ficheiro foi criado, o mesmo se passando com os métodos mtime (linha 3) e atime (linha 5), mas neste caso estes métodos retornam a informação referente à ultima modificação e ao ultimo acesso do ficheiro respectivamente.

A classe File tem ainda mais um recurso bastante útil que é o chmod. Este método permite alterar as permissões de acesso ao ficheiro. As masks para as permissões são as seguintes.

r - read

w - write

x - execute

  • 0700 - rwx para o dono.
  • 0400 - r para o dono.
  • 0200 - w para o dono.
  • 0100 - x para o dono.
  • 0070 - rwx para o grupo.
  • 0040 - r para o grupo.
  • 0020 - w para o grupo.
  • 0010 - x para o grupo.
  • 0007 - rwx para os outros.
  • 0004 - r para os outros.
  • 0002 - w para os outros.
  • 0001 - x para os outros.
  • 4000 - Altera o user ID na execução.
  • 2000 - Altera o group ID na execução.
  • 1000 - Salva texto em swap mesmo depois de usar.

A utilização do método chmod é muito simples, basta abrir o ficheiro como foi mostrado anteriormente e executar o método chmod.

1 file = File.new( "ficheiro.txt", "r" )
2 file.chmod( 0644 )

O exemplo acima dá permissão de de leitura de escrita (4 + 2) ao dono e de leitura ao grupo e todos os outros utilizadores.

Input/Ouput de Ficheiros

Ruby tem ainda mais uma classe muito útil, a classe IO. Esta pode ser usada isoladamente ou em conjunto com a classe File, e permite trabalhar com fluxos de input e output. Em seguida vamos ver alguns exemplos da utilização dos recursos desta classe através da classe File.

1 src = File.open("exemplo.txt","r")
2
3 puts src.readline  #=> Linha 1
4 puts src.readline  #=> Linha 2
5 puts src.readline  #=> Linha 3
6
7 src.flush
8 src.close

O exemplo acima abre o ficheiro em modo de leitura e lê as três primeiras linhas do ficheiro. Podíamos ainda utilizar o método gets que tem exactamente o mesmo funcionamento, com excepção de que o readline lança uma excepção quando o ficheiro chega ao fim. Para além de ler é também possível escrever para o ficheiro.

1 dst = File.open("exemplo.txt","w")
2
3 dst.puts("Linha 1")
4 dst.puts("Linha 2")
5 dst.puts("Linha 3")
6
7 dst.flush
8 dst.close

Este exemplo utiliza o método puts para escrever no ficheiro de destino, a cada execução do puts é automaticamente inserido um “\n”, para escrever sem a inserção de nova linha podemos utilizar o método putc este método coloca um carácter e cada vez. Assim encerramos o artigo com toda a informação básica necessária para trabalhar com ficheiros.

API

Este artigo foi originalmente escrito por Fábio Correira (magician) para a 13ª Edição da Revista PROGRAMAR

Publicado em Revista P@P, Ruby | Tagged: , , | Sem Comentários »

Revista Programar - 13ª Edição Março 2008

Publicado por wmagician em 10 Março, 2008

Revista PROGRAMAR
Edição 13 - Março de 2008
A Revista Programar faz 2 Anos e para comemorar nada melhor do que, uma vez mais, lançar a tempo e horas uma nova edição cheia de informação e conhecimento para todos.Nesta edição poderá encontrar:
- Assinaturas Digitais em XML
- Introdução ao SOAP
- Programação em Lógica com PROLOG
- Algoritmia Clássica em C++
- Manipulação de Ficheiros com Ruby
- Bioinformática - O lado do programador
- Tecnologias Wireless

Mais info.

Publicado em Revista P@P | Tagged: , , | Sem Comentários »

Java Sockets

Publicado por wmagician em 5 Março, 2008

Neste artigo vamos ficar a conhecer o suporte que Java oferece para a utilização do mecanismo de comunicação Socket, o mecanismo mais utilizado para a comunicação entre aplicações.Java permite o uso de socktes pelos seguintes modos utilização.

  • Modo Orientado à Conexão - Funciona com o protocolo TCP.
  • Modo Orientado ao Datagrama - Funciona com o protocolo UDP.
Ambos os modos funcionam sobre o protocolo IP(Internet Protocol).
Cada um destes modos tem a sua utilidade, vantagens e desvantagens na sua utilização.Modo Orientado á Conexão (TPC/IP).

  • Vantagens :

- Serviços confiáveis , sem perda de dados na rede e ordem dos pacotes.

- Possibilidade de usar DataStreams.

  • Desvantagens :

- É mais lento que o modo orientado ao datagrama.

- O comportamento do servidor é diferente do comportamento do cliente.Modo Orientado ao

Datagrama (UDP/IP).
  • Vantagens :

- É bastante mais rápido que o modo orientado a conexão.

  • Desvantagens :

- Serviços não confiáveis, mensagens perdidas na rede e perda da ordem das mensagens.

- Cada mensagem é um datagrama : [Remetente, Destinatário, Conteúdo].

Devido a uma maior utilização e estabilidade iremos apenas analisar e implementar o Modo Orientado à Conexão - TCP/IP.

Sockets TCP/IP

O processo de comunicação entre sockets TCP/IP, de uma forma simples, o servidor escolhe uma porta e aguarda conexões a essa porta, o cliente deve conter as seguintes informações :

- Endereço do Servidor (HOST).

- A porta usada pelo servidor(PORT).

Com essa informação o cliente solicita uma conexão ao servidor (Figura 1).

Figura1

Se após o pedido de conexão não ocorrer nenhum problema, o servidor aceita a conexão gerando um socket numa porta do servidor, o que vai criar um canal de comunicação entre o ciente e o servidor (Figura 2).

Figura2

Por norma o servidor funciona em ciclo (loop) esperando por novas conexões e criando sockets para solicitações de clientes.

Em seguida iremos ver as acções necessárias para implementar comunicações sobre TCP através de um socket cliente e um socket servidor.

Socket Client

1 – Abrir Conexão.

import java.io.*;
import java.net.*;
//Conectar ao servidor localhost na porta 8080.
Socket client = new Socket("127.0.0.1",8080);

2 – Obter Streams de entrada e saída para comunicação com o servidor.

//Cria um canal para receber dados.
DataInputStream in = new DataInputStream(client.getInputStream());
//Cria um canal para enviar dados.
DataOutputStream out = new DataOutputStream(client.getOutputStream());

3 – Realizar a comunicação com o servidor.

//Envia o inteiro 3000.
out.writeInt(3000);
//Envia a String “Olá - Socket Cliente.”.
out.writeUTF("Olá - Socket Cliente.");
//Espera pelo recebimento de um inteiro.
int valor = in.readInt();
//Espera pelo recebimento de uma String.
String texto = in.readUTF();

4 – Fechar as Streams e a conexão.

//Fecha o canal de entrada.
in.close();
//Fecha o canal de saída.
out.close();
//Fecha o Socket.
client.close();

Socket Servidor

1 – Criar Socket Server.

import java.io.*;
import java.net.*;
//Cria um socket servidor na porta 8080.
ServerSocket serveer = new ServerSocket(8080);

2 – Aguardar Conexões.

//O método accept retorna um socket para comunicação com o proximo cliente.
Socket sock = server.accept();

3 – Obter Streams de entrada e saída para comunicação com o cliente.

//Cria um canal para receber dados.
DataInputStream in = new DataInputStream(sock.getInputStream());
//Cria um canal para enviar dados.
DataOutputStream out = new DataOutputStream(sock.getOutputStream());

4 – Realizar a comunicação com o cliente.

//Espera pelo recebimento de um inteiro.
int valor = in.readInt();
//Espera pelo recebimento de uma String.
String texto = in.readUTF();
//Envia o inteiro 6000.
out.writeInt(6000);
//Envia a String “Olá - Socket Servidor.”.
out.writeUTF("Olá - Socket Servidor.");

5 – Fechar Streams e socket cliente.

//Fecha o canal de entrada.
in.close();
//Fecha o canal de saída.
out.close();
//Fecha o Socket que está a atender o cliente.
sock.close();

6 – Fechar o socket Servidor.

//Fecha o servidor.
server.close();

Em seguida podemos ver as classes Cliente e Servidor completamente implementadas.

Classe Cliente

1 import java.io.*;
2 import java.net.*;
3
4 public class Cliente{
5	public Socket client;
6	public DataInputStream in;
7	public DataOutputStream out;
8
9	public Cliente(){
10		try{
11			this.client = new Socket("127.0.0.1",8080);
12			this.in = new DataInputStream(client.getInputStream());
13			this.out = new DataOutputStream(client.getOutputStream());
14		}
15		catch(IOException e){
16			System.out.println(e.getMessage());
17		}
18	}
19
20	public static void main(String args[]){
21		try{
22			Cliente cli = new Cliente();
23			cli.out.writeInt(3000);
24			cli.out.writeUTF("Olá - Socket Cliente.");
25			int valor = cli.in.readInt();
26			String texto = cli.in.readUTF();
27			System.out.println(valor);
28			System.out.println(texto);
29			cli.in.close();
30			cli.out.close();
31			cli.client.close();
32		}
33		catch(IOException e){
34			System.out.println(e.getMessage());
35		}
36	}
37 }
Classe Servidor
1 import java.io.*;
2 import java.net.*;
3
4 public class Servidor{
5	public ServerSocket server;
6 	public Socket sock;
7	public DataInputStream in;
8	public DataOutputStream out;
9
10	public Servidor(){
11		try{
12			this.server = new ServerSocket(8080);
13			this.sock = this.server.accept();
14			this.in = new DataInputStream(sock.getInputStream());
15			this.out = new DataOutputStream(sock.getOutputStream());
16		}
17		catch(IOException e){
18			System.out.println(e.getMessage());
19		}
20	}
21
22	public static void main(String args[]){
23		try{
24			Servidor serv = new Servidor();
25			int valor = serv.in.readInt();
26			String texto = serv.in.readUTF();
27			System.out.println(valor);
28			System.out.println(texto);
29			serv.out.writeInt(6000);
30			serv.out.writeUTF("Olá - Socket Servidor.");
31			serv.in.close();
32			serv.out.close();
33			serv.sock.close();
34			serv.server.close();
35		}
36		catch(IOException e){
37			System.out.println(e.getMessage());
38		}
39	}
40 }

Este artigo foi originalmente escrito por Fábio Correira (magician) para a 6ª Edição da Revista PROGRAMAR

Publicado em Java, Revista P@P | Tagged: , , , | Sem Comentários »

IzPack com novo site e nova versão.

Publicado por wmagician em 23 Fevereiro, 2008

O installer IzPack tem agora um novo site e nova versão, foi com grande alegria que deparei com todas estas novidades.

A mais recente versão 3.11.0 lançada a 12-02-2008 teve muitas melhorias e foram corrigidos muitos bugs podem ver no CHANGELOG as alterações.

O IzPack tem agora ainda um boa DOCUMENTAÇÃO e actulizada tornando ainda mais facil a criação de instaladores multi plataforma.

Publicado em Java | Tagged: , , | 2 Comentários »