CAPÍTULO 6 Programação visual com Software Livre EDIT LIN EDITORIAL S.L, dos autores Daniel Campos Fernández e José Luis Redrejo. Prólogo de Benoit Minisini |
|
<< Anterior | Próximo >> |
6.7 Protocolo HTTP
Em um nível acima de todo o explicado encontra-se o protocolo HTTP, no qual não trata-se apenas de conectar a um servidor, e sim estabelecer um formato para a comunicação entre clientes e servidores. O protocolo HTTP é um dos mais utilizados ao longo da internet, dado que, entre outras coisas, é empregado para transmitir paginas web. No protocolo HTTP, o cliente solicita ao servidor um documento em uma localização e este o devolve seguindo uma série de convenções acerca da codificação de caracteres, controle de erros, nível de compressão de dados, formato dos dados binários, etc. O protocolo HTTP estabelece dois métodos principais para solicitar dados ao servidor. O primeiro, e mais comum por ser utilizado para receber paginas web no navegador quando escrevemos um endereço, por exemplo, é chamado método GET, no qual o cliente apenas solicita um endereço URL, devolvendo o servidor o resultado. O segundo método, chamado POST, o cliente não apenas solicita a URL, e sim envia uma série de informações adicionais que o servidor processará antes de enviar o resultado. É o caso habitual quando preenchemos um formulário com dados em uma pagina web e pressionamos o botão enviar. Gambas possui no componente gb.net.curl, um cliente chamado HttpClient, que provê acesso a servidores HTTP. O trabalho de negociação entre cliente e servidor, assim com a gestão de formatos, é tarefa interna do cliente HTTP, a aplicação que desenvolvemos só terá de preocupar-se em pedir um documento e recebe-lo. O cliente HTTP pode funcionar de dois modos: o mais simples é o modo síncrono, nele que recebemos diretamente o documento após a chamada e os métodos GET ou POST; no segundo, assíncrono, o modo de trabalho se parece mais ao descrito para os sockets: com a aplicação em funcionamento iremos recebendo fragmentos do documentos em cada evento READ que uniremos em uma cadeia. Criaremos um projeto de console para receber a pagina web http://gambas.gnulinex.org/gtk/. Terá uma referência a gb.net e um módulo ModMain,com este código: |
|
' Gambas module file
PUBLIC SUB Main() DIM Http AS HttpClient DIM sCad AS String Http = NEW HttpClient Http.Async = FALSE Http.TimeOut = 10 Http.URL = "http://gambas.gnulinex.org/gtk/" Http.Get() IF Http.Status < 0 THEN PRINT "Erro ao receber a pagina" ELSE PRINT sCad END IF CLOSE #Http END |
|
Em primeiro lugar definimos e criamos um objeto da classe HttpClient chamado Http. Colocamos sua propriedade Async a FALSE para que o processo seja síncrono, ou seja, que o cliente fique bloqueado enquanto recebe a pagina. Já que o bloqueio poderá durar um tempo excessivo, definimos também a propriedade TimeOut um tempo máximo em segundos antes de dar por fracassada a conexão e recepção de dados. Indicamos a URL que contem o nome do servidor e o documento dentro deste. Chamamos o método Get com o propósito de receber a pagina, com que o programa é interrompido até sua recepção até um erro ou até que se passem 10 segundos no máximo. Lemos o valor da propriedade Status que, como no caso dos sockets ou do DNS,
terá valor maior que zero quando está ativo, zero em caso
de exito, menor que zero em caso de erro. Se houver um erro, se houver
um erro, o indicamos pelo console. Se bem, lemos, como no caso do
socket ou qualquer outro fluxo, empregando a instrução READ e mostramos o conteúdo da pagina recebida no console.
Finalmente, encerramos o cliente Http. Isto é necessário já que o cliente mantem viva a conexão com o servidor enquanto for possível, para fazer desta maneira a recepção de múltiplos documentos de um mesmo servidor. |
|
O protocolo HTTP estabelece um tempo no qual o servidor mantem o socket conectado com o cliente. Se necessitamos receber várias páginas de um servidor ou realizar várias petições POST consecutivas, deveríamos empregar a instrução CLOSE só após todo o processo, com o qual se ganhará em velocidade e se utilizarão menos sos do sistema. | |
Enquanto o método
assíncrono, o modo de proceder e exatamente o mesmo que com os
sockets: esperar o evento Read para ir lendo fragmentos do documento em
processo de recepção, ou o evento Error para entender
possíveis problema de comunicação com o servidor.
A margem dos problemas físicos de comunicação, que detecta-se com o Error, o proprio protocolo HTTP pode especificar códigos de erro nos quais a comunicação/recepção de dados foi perfeita a nível físico, mas ocorreram erros lógicos. O caso mais comum é solicitar um documento que não existe e em cujo caso gera-se o erro 404. outros erros comuns pode ser elementos proibidos) ou o 500 (erro interno do servidor). Para detectar e tratar problemas, o cliente HTTP proporciona duas propriedades que podemos controlar já que é numéricas e devolve o código de erro (o valor 200 significa que tudo foi bem), e Reason, que é uma cadeia de texto explicativa do erro, proporcionada pelo servidor. |
|
O valor devolvido em Reason depende do programa utilizado como servidor web e não é obrigatório. Por isso, a efeito de controle de erros, devemos empregar só o valor do código e usar Reason só a efeito de informação do usuário. | |
Os fragmentos HTTP
recebem-se empacotados, de forma que existe um encabeçamento
contendo meta informação do servidor e um corpo onde
encontra alojado o documento em si, a leitura mediante READ
ou outros métodos para fluxos só acessam os dados do
corpo. Para obter as cabeceiras, que podem ser utilizado para comprovar
dados tais como a data e hora do servidor, o tipo de servidor
informações específicas, podemos recorrer a
propriedade Headers. Cada meta informação é uma linha, pelo que Headers
devolvem uma matriz de cada uma das quais é uma
informação procedente do servidor. Neste caso derivado do
anterior mostra-se ao final do encabeçado do servidor.
|
|
' Gambas module file
PUBLIC SUB Main() DIM Http AS HttpClient DIM sCad AS String Http = NEW HttpClient Http.Async = FALSE Http.TimeOut = 10 Http.URL = "http://gambas.gnulinex.org/gtk/" Http.Get() IF Http.Status < 0 THEN PRINT "Erro ao receber a pagina" ELSE READ #Http, sCad, Lof(Http) PRINT sCad PRINT "\n-------------Metadados------------------\n" FOR EACH sCad IN Http.Headers PRINT sCad NEXT END IF CLOSE #Http END |
|
O protocolo HTTP permite ao cliente autenticar-se para receber determinadas páginas não acessíveis ao publico em geral. O usuário tem de dispor de um nome de usuário e uma senha. Para introduzir estes valores, há de especificar o nome de usuário e a propriedade User e a senha na propriedade Password, antes de chamar os métodos Get ou Post. Por outro lado existe diversos métodos de autenticação, desde os menos seguros (envio de usuário/senha sem codificar) até alguns algorítimos mais seguros. Alem do usuário e senha, há de especificar o método de autenticação preenchendo o valor da propriedade Auth com algumas das constantes que representam os métodos suportados: Neth.AuthBasic Neth.AuthDigest Neth.AuthGSSNegotiate Neth.AuthNTLM Ao desenvolver uma aplicação há de conhecer de antemão o método que necessitamos para acessar o servidor. O protocolo HTTP também contemplam o uso de cookies, que é a informação que o servidor guarda no cliente e que é consultada de novo pelo servidor em ocasiões posteriores, antes de enviar um documento ao cliente. Pode servir por exemplo, para saber se a página já foi visitada anteriormente por esse cliente. Por padrão, o cliente HTTP não aceita os cookeis proveniente do servidor. Se especificarmos um caminho a um arquivo com a propriedade CookeisFile, estas ativarão-se e o cliente HTTP se nutrirá dos cookeis existentes neste arquivo para devolver informações ao servidor. Se a propriedade UpdateCookies for levada a TRUE, permitirá o acesso a escrita no arquivo de cookies, no qual os novos cookies serão guardados entre execução e execução do programa. Este componente encontra-se em fase de desenvolvimento e futuras versões suportarão o uso de SSL e certificados. |
|
<< Anterior | Próximo >> |
Cópia literal Extraído
do livro “GAMBAS, programação visual
com software
Livre”, da editora EDIT LIN EDITORIAL S.L, dos
autores Daniel Campos Fernández e José
Luis
Redrejo. Prólogo de Benoit Minisini
LICENSA DESTE DOCUMENTO É permitido a cópia e
distribuição da
totalidade ou parte desta obra sem fins lucrativo. Toda
cópia
total ou parcial devera expressar o nome do autor e da editora e
incluir esta mesma licença, adicionando se é uma
cópia literal “Cópia
literal”. Se é
autorizada a modificação e
tradução da
obra sem fins lucrativo sempre se deve constar na obra
resultante a modificação o nome da obra
original o
autor da obra original e o nome da editora e a obra resultante
também deverá ser livremente reproduzida,
distribuída, ao publico e transformada em termos similares
ao
exposto nesta licença.
Tradução Cientista (Antonio Sousa) |
|