Atualmente, na internet, a técnica de comunicação entre sistemas distribuídos que mais ganha força é a REST(Representational State Transfer). REST é a descrição de uma interface web que utiliza o HTTP e um formato de encapsulamento de dados como JSON ou XML para troca de mensagens sem a necessidade da especificação de um outro protocolo.

Abaixo estão os princípios de um sistema RESTful retirado do wikipedia:

Um protocolo cliente/servidor sem estado: cada mensagem HTTP contém toda a informação necessária para compreender o pedido. Como resultado, nem o cliente e nem o servidor necessitam gravar nenhum estado das comunicações entre mensagens. Na prática, muitas aplicações baseadas em HTTP utilizam cookies e outros mecanismos para manter o estado da sessão (algumas destas práticas, como a reescrita de URLs, não são permitidas pela regra do REST).
Um conjunto de operações bem definidas que se aplicam a todos os recursos de informação: HTTP em si define um pequeno conjunto de operações, as mais importantes são POST, GET, PUT e DELETE. Com frequência estas operações são combinadas com operações CRUD para a persistência de dados, onde POST não se encaixa exatamente neste esquema.
Uma sintaxe universal para identificar os recursos. No sistema REST, cada recurso é unicamente direcionado através da sua URI.

Para encapsular os dados, o formato mais utilizado com REST para comunicação com dispositivos móveis é o JSON, pois possui um menor nível de complexidade para interpretação dos dados.

O OpenEpos não possui suporte por padrão para uma arquitetura RESTful de aplicação web e, dessa forma, proporciona uma oportunidade de trabalho nessa área. Com o desenvolvimento de alguns componentes e aproveitando a já implementação do TCP, pode-se adicionar o suporte a um servidor web com características RESTful ao Epos.

2) Objetivo[edit]

O objetivo do trabalho é desenvolver um webservice RESTful no Epos. Para comprovação do resultado do trabalho, é planejado o desenvolvimento de um sistema que irá informar a temperatura que o mesmo tem armazenado e permitir que o mesmo receba uma temperatura de um dispositivo qualquer externo. Essas características do sistema irão permitir que testes simples possam ser efetivos.

Abaixo estão as características do sistema:

- Servidor HTTP 1.1.

- Verificar os pedidos e determinar as respostas de acordo com a especificação do webservice RESTful.

- JSON Parser para ler dados de pedidos http e JSON Writter para escrever dados no formato JSON para respostas http.

3) Especificação Webservice[edit]

1- Pedido por temperatura

- Pedido:

HTTP GET /temperatura

- Resposta:

HTTP.OK
contentType=application/json
content={“temperatura”:”##.##”}

2- Recebimento de temperatura

- Pedido:

HTTP POST /temperatura
contentType=application/json
content= {“temperatura”:”##.##”}

- Resposta:

HTTP.NO_CONTENT

4) Projeto do Desenvolvimento[edit]

O projeto será desenvolvido para o OpenEPOS e será feito em cima da implementação do TCP existente. O seguintes componentes foram identificados como necessários:

- HttpServer

Responsável por receber as conexões e responder aos pedidos através do TCP::ServerSocket já implementado no OpenEPOS.
Possuirá todos os handlers que são responsáveis por responder pedidos suportados, ou seja, o HttpServer irá procurar qual handler deve atender o pedido recebido.

- HttpServerHandler

Interface que irá permitir implementação de um handler de um tipo de pedido, ou seja, responsável por receber um pedido e devolver uma resposta para que o HttpServer responda ao cliente.

- PathParser

Responsável por determinar se um caminho requisitado corresponde a um padrão de caminho pré-determinado. Também irá juntar os argumentos do caminho: um caminho podendo ser "/temperatura/84", o padrão do mesmo seria "/temperatura/*", ou seja, todo asterisco em um padrão de caminho representa um argumento que poderá ser utilizado por um Recurso para responder o pedido.

- HttpRequest

Objeto que irá encapsular um pedido.

- HttpResponse

Objeto que irá encapsular uma resposta.

- HttpRequestParser

Responsável por transformar uma String do pedido em um objeto HttpRequest.

- HttpResponseWriter

Responsável por transformar uma estrutura do tipo HttpResponse em uma String.

- JSONParser

Responsável por ler uma String e obter todos os JSONNodes e, caso a String não seja válida, retorna uma exceção de erro.

- JSONWriter

Responsável por escrever dados no formato JSON. Retorna uma String formatada.

- JSONNode

Encapsula o conceito de variável e valor e é utilizado pelo JSONParser para armazenar todos os valores identificados no processo de reconhecimento.

4.1) Diagrama de Classes[edit]

5) Diagramas de Sequencia[edit]

Os dois diagramas são responsáveis pelo fluxo principal da aplicação e representam os dois casos de uso.

6) Automatos[edit]

6.1) JSON Parser[edit]

6.2) Http Request Parser[edit]

7) Implementacao (andamento)[edit]

7.1) http.h[edit]

Responsável pelas estruturas que encapsulam resposta e pedido HTTP, escritor e parser de HTTP, e o HTTPServer, bem como o HTTPServerHandler.

#ifndef HTTP_H_

#define HTTP_H_

#include<utility/list.h>

#include<utility/path_parser.h>

#include<tcp.h>

#include<utility/string.h>

#include<utility/vector.h>

__BEGIN_SYS

structstring {

char *_string;

};

structrequestLine {

char *_method;

char *_requestUri;

char *_httpVersion;

};

structheader {

char *_name;

char *_value;

};

structstatusLine {

char *_status;

char *_httpVersion;

};

typedefList_Elements::Doubly_Linked<header> HeaderElement;

typedefList_Elements::Doubly_Linked<string> CharElement;

structhttpRequest {

requestLine_requestLine;

List<header, HeaderElement> _headers;

char* _body;

};

structhttpResponse {

statusLine_statusLine;

List<header, HeaderElement> _headers;

char* _body;

};

classHTTPRequestParser {

public:

httpRequest_request;

bool_parsed;

HTTPRequestParser(constchar * input) {

_input = strcpy(_input, input);

_parsed = false;

parse();

}

httpRequestgetRequest() {return_request;}

booldidParse() {return_parsed;}

private :

char * _input;

boolparseRequestLine(char* requestLine);

boolparseHeaders(char * oneHeader);

voidparse();

};

classHTTPResponseWriter {

public:

HTTPResponseWriter(httpResponse * httpResponse) {

_response = newchar[80];

_httpResponse = httpResponse;

write();

}

char* getResponse();

private:

httpResponse * _httpResponse;

char* _response;

voidwrite();

};

classHTTPServer : publicTCP::ServerSocket {

public:

classHTTPServerHandler {

public :

char * path;

HTTPServerHandler(constchar * path) {

strcpy(this->path, path);

}

~HTTPServerHandler () {};

virtualhttpResponse * onRequest(httpRequestreq, List<char, PathParser::ArgsElement> * args);

};

classJsonRestResource {

public:

char * path;

JsonRestResource(constchar * path) {

strcpy(this->path , path);

}

~JsonRestResource() {}

virtualchar * onRequest(List<char, PathParser::ArgsElement> * args);

};

classHTTPRestHandler : publicHTTPServerHandler {

public:

structrestHandler {

JsonRestResource * _handler;

char* _path;

};

typedefList_Elements::Doubly_Linked<restHandler> JsonResourceElement;

List<restHandler, JsonResourceElement> restResources;

HTTPRestHandler(constchar * path) : HTTPServerHandler(path) {}

httpResponse * onRequest(httpRequestreq, List<char, PathParser::ArgsElement> * args) {

JsonRestResource * selected_handler;

PathParser * parsed_path;

JsonResourceElement *h = restResources.head();

db<TCP>(TRC) << "HTTPRestHandler attempting to get resource for request on path=" << req._requestLine._requestUri <<"\n";

while(h != 0) {

//get path parser to verify if path is compatible

PathParser * parser = newPathParser(req._requestLine._requestUri, h->object()->_path);

if(parser->didMatch()) {

selected_handler = h->object()->_handler;

parsed_path = parser;

db<TCP>(TRC) << "HTTPRestHandler found resource for request on path=" << req._requestLine._requestUri <<"\n";

break;

}

h = h->next();

}

httpResponse * response;

if(h) {

db<TCP>(TRC) << "HTTPRestHandler found resource for request on path=" << req._requestLine._requestUri <<"\n";

char * jsonResponse = h->object()->_handler->onRequest(&parsed_path->args);

db<TCP>(TRC) << "HTTPRestHandler BUILDING RESPONSE\n";

//build response for Rest Json web service

response = newhttpResponse();

response->_statusLine._httpVersion = newchar[strlen("HTTP/1.1")];

strcpy(response->_statusLine._httpVersion, "HTTP/1.1");

db<TCP>(TRC) << "HTTPRestHandler setting httpVersion\n";

response->_statusLine._status = newchar[strlen("200 OK")];

strcpy(response->_statusLine._status, "200 OK");

db<TCP>(TRC) << "HTTPRestHandler setting statusCode\n";

response->_body = newchar[strlen(jsonResponse)];

strcpy(response->_body, jsonResponse);

db<TCP>(TRC) << "HTTPRestHandler setting body\n";

//headers

//content len

header * contentLenghHeader = new header();

contentLenghHeader->_name = newchar[strlen("Content-Length")];

strcpy(contentLenghHeader->_name,"Content-Length" );

intlenInt = strlen(jsonResponse);

char * c = new (&lenInt) char[sizeof(lenInt)];

contentLenghHeader->_value = newchar[strlen( c)];

strcpy(contentLenghHeader->_value, c);

response->_headers.insert(newHeaderElement(contentLenghHeader));

db<TCP>(TRC) << "HTTPRestHandler setting contentLen\n";

//content type

header * contentTypeHeader = new header();

contentTypeHeader->_name = newchar[strlen("Content-Type")];

strcpy(contentTypeHeader->_name,"Content-Type" );

contentTypeHeader->_value = newchar[strlen("application/json")];

strcpy(contentTypeHeader->_value, "application/json");

response->_headers.insert(newHeaderElement(contentTypeHeader));

db<TCP>(TRC) << "HTTPRestHandler did build response on path=" << req._requestLine._requestUri <<"\n";

return response;

} else {

db<TCP>(TRC) << "HTTPRestHandler resource not found for path=" << req._requestLine._requestUri <<"\n";

response = newhttpResponse();

response->_statusLine._httpVersion = newchar[strlen("HTTP/1.1")];

response->_statusLine._status = newchar[strlen("404 not found")];

strcpy(response->_statusLine._httpVersion,"HTTP/1.1");

strcpy(response->_statusLine._status,"404 not found");

return response;

}

booladdHandler(JsonRestResource * h) {

//verify if path is already mapped

bool possible = true;

if(restResources.size() > 0) {

JsonResourceElement * element = restResources.head();

while(element) {

if(strcmp(element->object()->_path, h->path) == 0) {

possible = true;

}

element = element->next();

}

if(possible) {

restHandler * ha = newrestHandler();

ha->_handler = h;

ha->_path = newchar[strlen(h->path)];

strcpy(ha->_path, h->path);

restResources.insert_tail(newJsonResourceElement(ha));

db<TCP>(TRC) << "\nHTTP REST adding handler path=" << ha->_path << " \n";

}

return possible;

}

~HTTPRestHandler() {

//do nothing

}

};

HTTPServer(int port) : TCP::ServerSocket(TCP::Address(tcp()->ip()->address(),port)) {}

structhandler {

HTTPServerHandler * _handler;

char* _path;

};

typedefList_Elements::Doubly_Linked<handler> HandlerElement;

List<handler, HandlerElement> handlers;

booladdHandler(HTTPServerHandler * h) {

//verify if path is already mapped

bool possible = true;

if(handlers.size() > 0) {

HandlerElement * element = handlers.head();

while(element) {

if(strcmp(element->object()->_path, h->path) == 0) {

possible = true;

}

element = element->next();

}

if(possible) {

handler * ha = new handler();

ha->_handler = h;

ha->_path = newchar[strlen(h->path)];

strcpy(ha->_path, h->path);

db<TCP>(TRC) << "\nHTTP adding handler path=" << ha->_path << " \n";

handlers.insert_tail(newHandlerElement(ha));

}

return possible;

}

char * receivedLocal(constchar *data,u16 size) {

received(data, size);

returnresponse;

}

private:

char* response;

httpResponse * resourceNotFoundRe;

TCP::Socket* incoming(constTCP::Address& from) {

//TODO: strategy to accept multiple connections

returnthis;

}

voidconnected() {}

voidclosed() {

listen();

}

voiderror(short err) {}

voidsent(u16 size) {}

voidreceived(constchar *data,u16 size) {

//get req from parser

HTTPRequestParser * parser = newHTTPRequestParser(data);

if(!parser->_parsed) {

return;

}

httpRequestreq = parser->_request;

HTTPServerHandler * selected_handler;

PathParser * parsed_path;

HandlerElement *h = handlers.head();

while(h != 0) {

//get path parser to verify if path is compatible

db<TCP>(TRC) << "\nHTTP testing handler path=" << h->object()->_path << " for path="<< req._requestLine._requestUri << " \n";

PathParser * parser = newPathParser(req._requestLine._requestUri, h->object()->_path);

if(parser->didMatch()) {

selected_handler = h->object()->_handler;

parsed_path = parser;

db<TCP>(TRC) << "HTTPServer handler found for request on path =" <<req._requestLine._requestUri <<"\n";

break;

}

h = h->next();

}

httpResponse * res;

if(selected_handler != 0) {

res = selected_handler->onRequest(req, &parsed_path->args);

db<TCP>(TRC) << "HTTPServer handler informed response for request on path =" <<req._requestLine._requestUri <<"\n";

} else {

db<TCP>(TRC) << "\nHTTP could not find handler\n";

res = resourceNotFoundResponse();

}

//get writter to convert response to

HTTPResponseWriter * wrt = newHTTPResponseWriter(res);

response = wrt->getResponse();

db<TCP>(TRC) << "HTTPServer handler responsed=" << response << " for request on path =" <<req._requestLine._requestUri <<"\n";

send(response, strlen(response));

close();

}

httpResponse * resourceNotFoundResponse() {

if(resourceNotFoundRe == 0) {

resourceNotFoundRe = newhttpResponse();

resourceNotFoundRe->_statusLine._httpVersion = newchar[strlen("HTTP/1.1")];

resourceNotFoundRe->_statusLine._status = newchar[strlen("404 not found")];

strcpy(resourceNotFoundRe->_statusLine._httpVersion,"HTTP/1.1");

strcpy(resourceNotFoundRe->_statusLine._status,"404 not found");

}

returnresourceNotFoundRe;

}

};

__END_SYS

#endif/* HTTP_H_ */

7.2) http.cc[edit]

#include<http.h>

__BEGIN_SYS

boolisspace(char * c);

boolisspace(char c);

char *trimwhitespace(char *str);

CharElement * createElement(char * p);

char* HTTPResponseWriter::getResponse() {

return_response;

}

voidHTTPResponseWriter::write() {

//status line

strcat(_response, _httpResponse->_statusLine._httpVersion);

db<TCP>(TRC) << "\nHTTP Response Writer response=" << _response << " \n";

strcat(_response, " ");

db<TCP>(TRC) << "\nHTTP Response Writer response=" << _response << " \n";

strcat(_response, _httpResponse->_statusLine._status);

db<TCP>(TRC) << "\nHTTP Response Writer response=" << _response << " \n";

strcat(_response,"\r\n");

db<TCP>(TRC) << "\nHTTP Response Writer response=" << _response << " \n";

//headers, if any

if(!_httpResponse->_headers.empty()) {

HeaderElement * h = _httpResponse->_headers.head();

while(h) {

strcat(_response,h->object()->_name);

strcat(_response,":");

strcat(_response,h->object()->_value);

strcat(_response,"\r\n");

h = h->next();

db<TCP>(TRC) << "\nHTTP Response Writer response=" << _response << " \n";

}

//CRLF

strcat(_response,"\r\n");

if(_httpResponse->_body) {

strcat(_response, _httpResponse->_body);

}

db<TCP>(TRC) << "\nHTTP Response Writer response=" << _response << " \n";

}

List<string, CharElement> * split(char * input, constchar * pttr) {

// char str[] ="This\r\n a \r\nsample\r\n string\r\n";

// char * pch;

// pch = strtok(str," ,.-");

// while (pch != 0)

// {

// db<TCP>(TRC) << "\nSPLIT TEST worked =" <<pch<< " \n ";

// pch = strtok(0, "\r\n");

// }

List<string, CharElement> * v = newList<string, CharElement>;

// char pattern[strlen(pttr)];

// strcpy(pattern, pttr);

char *p;

char inp[strlen(input)];

strcpy(inp, input);

p = strtok(inp, pttr);

if(p != 0) {

while (p != 0) {

if(!isspace(p)) {

db<TCP>(TRC) << "\nHTTP did split=" << p << " \n";

v->insert_tail(createElement(p));

}

p = strtok(0, pttr);

}

} else {

db<TCP>(TRC) << "\nHTTPcouldnot SPLIT!!\n";

}

return v;

}

CharElement * createElement(char * p){

string * s = newstring();

s->_string = newchar[strlen(p)];

strcpy(s->_string, p);

CharElement * element = newCharElement(s);

returnelement;

}

boolisspace(char * content) {

int len1 = strlen(content);

if(len1 == 0) {

returntrue;

}

char c[len1];

strcpy(c, content);

intlen = strlen(c);

intcount = 0;

for(int i= 0; i < len; i++) {

if(isspace(c[i])) {

count++;

}

if(count == len) {

returntrue;

} else {

returnfalse;

}

boolisspace(char c){

if(c == 0 || c == 0x20 || c == 0x09 || c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d) {

returntrue;

}

returnfalse;

}

char *trimwhitespace(char *str)

{

size_tlen = 0;

char *frontp = str - 1;

char *endp = 0;

if( str == 0 )

return 0;

if( str[0] == '\0' )

returnstr;

len = strlen(str);

endp = str + len;

/* Move the front andback pointers toaddress

* thefirst non-whitespacecharactersfrom

* each end.

while( isspace(*(++frontp)) );

while( isspace(*(--endp)) && endp != frontp );

if( str + len - 1 != endp )

*(endp + 1) = '\0';

elseif( frontp != str && endp == frontp )

*str = '\0';

/* Shift thestringsothat it starts atstrso

* thatifit'sdynamicallyallocated, wecan

* still free it onthereturned pointer. Note

* the reuse ofendptomeanthe front ofthe

* string buffer now.

endp = str;

if( frontp != str )

{

while( *frontp ) *endp++ = *frontp++;

*endp = '\0';

}

returnstr;

}

//char * trimwhitespace(char *str)

//{

// char *end;

// // Trimleadingspace

// while(isspace(str)) str++;

// if(*str == 0)// Allspaces?

// returnstr;

// // Trimtrailingspace

// end = str + strlen(str) - 1;

// while(end > str && isspace(end)) end--;

// // Write new nullterminator

// *(end+1) = 0;

// returnstr;

//}

voidHTTPRequestParser::parse() {

List<string, CharElement> * allContents = split(_input, "\n");

if(allContents->size() > 0) {

string * requestLine = allContents->head()->object();

//ifcant parse requestline, abort

if(!parseRequestLine(requestLine->_string)) {

db<TCP>(TRC) << "\nHTTP:Nao conseguiu fazer o parser do requestline: "<< _input << " \n";

return;

}

//Verifica qntosheaders tem fazendo a comparacao com a linha em branco que antecede o body ou o final.

CharElement * possibleHeader = allContents->head()->next();

while(possibleHeader != 0) {

db<TCP>(TRC) << "\nHTTP: Processingpossible header <<" << possibleHeader->object()->_string << " \n";

string * header = possibleHeader->object();

boolparsed = parseHeaders(header->_string);

if(!parsed && !possibleHeader->next()) {

db<TCP>(TRC) << "\nHTTP: Processingbody <<" << possibleHeader->object()->_string << " \n";

strcpy(_request._body,possibleHeader->object()->_string);

} elseif(!parsed) {

db<TCP>(TRC) << "\nHTTP: Processing header failed= <<" << possibleHeader->object()->_string << " \n";

return;

}

possibleHeader = possibleHeader->next();

}

_parsed = true;

}

boolHTTPRequestParser::parseRequestLine(char* requestLine) {

db<TCP>(TRC) << "\nHTTP: ParsingRequestLine: "<< requestLine << " \n";

List<string, CharElement> * requestLineContents = split(requestLine, " ");

db<TCP>(TRC) << "\nHTTP:Numero de elementos da requestLineContents: "<< requestLineContents->size() << " \n";

if(requestLineContents->size() == 3) {

CharElement * method = requestLineContents->head();

char * methodValue = trimwhitespace(method->object()->_string);

_request._requestLine._method = newchar[strlen(methodValue)];

strcpy(_request._requestLine._method, methodValue);

db<TCP>(TRC) << "\nHTTP: Parsed httpMethod: "<< _request._requestLine._method << " \n";

char * requestUriValue = trimwhitespace(method->next()->object()->_string);

_request._requestLine._requestUri = newchar[strlen(requestUriValue)];

strcpy(_request._requestLine._requestUri, requestUriValue);

db<TCP>(TRC) << "\nHTTP: Parsed requestUri: "<< _request._requestLine._requestUri << " \n";

char * httpVersionValue = trimwhitespace(method->next()->next()->object()->_string);

_request._requestLine._httpVersion = newchar[strlen(httpVersionValue)];

strcpy(_request._requestLine._httpVersion, httpVersionValue);

db<TCP>(TRC) << "\nHTTP: Parsed httpVersion: "<< _request._requestLine._httpVersion << " \n";

returntrue;

} else {

db<TCP>(TRC) << "\nHTTP:FAILED - > Expected 3 But it found requestLineContents: "<< requestLineContents->size() << " \n";

returnfalse;

}

boolHTTPRequestParser::parseHeaders(char * oneHeader) {

List<string, CharElement> * headerContent = split(oneHeader, ":");

if(headerContent->size() == 2) {

header * _header = new header();

char * headerName = trimwhitespace(headerContent->head()->object()->_string);

_header->_name = newchar[strlen(headerName)];

strcpy(_header->_name, headerName);

db<TCP>(TRC) << "\nHTTP: Parsed headername=: "<<_header->_name << " \n";

char* headerValue = trimwhitespace(headerContent->head()->next()->object()->_string);

_header->_value = newchar[strlen(headerValue)];

strcpy(_header->_value,headerValue );

db<TCP>(TRC) << "\nHTTP: Parsed headervalue=: "<<headerValue<< " \n";

_request._headers.insert(newHeaderElement(_header));

db<TCP>(TRC) << "\nHTTP: Processed header <<" << oneHeader<< " \n";

returntrue;

} else {

db<TCP>(TRC) << "\nHTTP: Processed header failed <<" << oneHeader<< " \n";

returnfalse;

}

__END_SYS

7.3) json.h[edit]

#ifndef JSONPARSER_H_

#define JSONPARSER_H_

#include<utility/list.h>

#include<utility/string.h>

#include<tcp.h>

__BEGIN_SYS

structjsonNode {

char * key;

char * value;

};

classJsonParser {

private:

char * string;

voidparse();

intreadSeparators(int * index, char string[]);

public:

boolparsed;

typedefList_Elements::Doubly_Linked<jsonNode> JsonElement;

List<jsonNode, JsonElement> nodes;

JsonParser(constchar * input) {

string = newchar[strlen(input)];

strcpy(string,input);

parsed = false;

parse();

}

booldidParse();

List<jsonNode, JsonElement> getNodes();

};

classJsonWriter {

public:

char * json;

boolhasValues;

JsonWriter() {

strcpy(json, "{");

hasValues = false;}

voidwrite(constchar * key, constchar * value);

char* getJson() {

char temp2[2];

strcpy(temp2, json);

returnstrcat(temp2, "}");

}

};

__END_SYS

#endif/* PATHPARSER_H_ */

7.4) json.cc[edit]

#include<utility/json.h>

__BEGIN_SYS

voidincreaseArrayIfNeeded(int index, int size, char * keyTemp){

if(index >= size){

char * temp;

temp = newchar[size+1];

for(int i =0; i < size; i++){

temp[i] = keyTemp[i];

}

delete[] keyTemp;

keyTemp = temp;

}

voidincreaseArraySize(int extraSize, int size, char * keyTemp){

char * temp;

temp = newchar[size + extraSize];

for(int i =0; i < size; i++){

temp[i] = keyTemp[i];

}

delete[] keyTemp;

keyTemp = temp;

}

voidJsonWriter::write(constchar *key,constchar * value) {

constchar * DB_QUOTES = "\"";

constchar * TWO_POINTS = " : ";

constchar * SEPARATOR = ",";