JAVASCRIPT OBJECT NOTATION - JSON-RPC

JAVASCRIPT OBJECT NOTATION - JSON

                                     

RPC 

Uma Chamada de Procedimento Remoto (RPC) é uma comunicação entre processos que permite a um programa de computador executar uma sub-rotina ou procedimento em outro endereço (geralmente em outro computador em uma rede compartilhada) sem que o programador tenha codificado explicitamente os detalhes sobre a interação remota.

Isto é, o programador escreve essencialmente o mesmo código quer a sub-rotina seja para execução local do programa, ou para execução remota.

 Quando o software em questão utiliza princípios de orientação a objetos, RPC é chamado de invocação remota ou invocação de método remoto.

Envio de Mensagens

Uma RPC é iniciada pelo cliente, que envia uma mensagem de requisição para um servidor remoto conhecido para executar um procedimento especificado com parâmetros fornecidos.

 O servidor remoto envia uma resposta para o cliente, e o aplicativo continua o seu processo.

 Enquanto o servidor está processando a chamada, o cliente é bloqueado (ele espera até que o servidor tenha terminado o processamento antes de retomar a execução), a não ser que o cliente envie uma solicitação assíncrona para o servidor, como uma chamada XHTTP.

 Há muitas variações e subtilezas em várias implementações, resultando numa variedade de diferentes (incompatíveis) protocolos RPC.

Uma diferença importante entre chamadas de procedimento remoto e chamadas locais é que as chamadas remotas podem falhar por causa de problemas imprevisíveis de rede.

 Além disso, os chamadores geralmente tem que lidar com essas falhas sem saber se o procedimento remoto foi aceito, ou se teve a requisição compilada.

 Procedimentos idempotentes (aqueles que não têm efeitos adicionais se for chamado mais de uma vez) são facilmente manipulados, mas muitas dificuldades permanecem onde o código para chamar procedimentos remotos é muitas vezes confinado um a escrita cuidadosa em subsistemas de baixo nível.

                          

Seqüência de eventos durante uma RPC

1. O cliente chama o stub (um trecho do código usado para conversão de parâmetros passados durante uma RPC) do cliente. A chamada é um de procedimento de chamada local, com parâmetros colocados em pilha de uma forma normal.
2. O stub do cliente empacota os parâmetros em uma mensagem e faz uma chamada para o sistema enviar a mensagem. Empacotar dos parâmetros é chamado de  marshalling ( serialização - processo de conversão de dados ou objetos em um fluxo de bytes ).
3. Sistema operacional local do cliente envia a mensagem a partir da máquina do cliente para a máquina do servidor.
4. O sistema operacional na máquina do servidor repassa os pacotes da entrada para o stub do servidor.
5. O stub do servidor desempacota os parâmetros da mensagem. Desempacotando os parâmetros é chamado unmarshalling (deserialização - processo inverso de conversão de um fluxo de bytes de volta a seus dados ou objetos originais).
6. Finalmente, o stub do servidor chama o procedimento servidor do sistema operacional. A resposta segue os mesmos passos na direção inversa.

Padronização dos Mecanismos de Contato

Para permitir que diferentes clientes acessem os servidores, foram criadas uma série de sistemas RPC padronizados. 

A maioria deles usa uma Linguagem de Descrição da interface (IDL) para permitir que várias plataformas possam chamar o RPC.

 Os arquivos IDL pode então ser utilizado para gerar o código de interface entre o cliente e o servidor.

JSON_RPC

É um protocolo RPC (Remote Procedural Call) construído em JSON, como um substituto para o XML-RPC e SOAP, sendo um simples protocolo que define somente alguns tipos de dados e comandos. 

Em contraste ao XML-RPC ou ao SOAP, ele permite comunicação bidirecional entre o serviço e o cliente, como uma espécie de peer-to-peer, onde cada uma das pontas pode chamar a outra ou enviar notificações(informações enviadas ao servidor que não requerem uma resposta). Ele também permite o envio de múltiplas chamadas de uma ponta a outra que podem ser respondidas fora de ordem.

Uma comunicação JSON pode ser feita em uma requisição HTTP onde o conteúdo é do tipo application/json.1 Além de usar o HTTP para transporte, podem ser usados sockets TCP/IP. Usando sockets, podem ser criadas aplicações web mais responsivas com o JSON-RPC, em comparação com um simples tráfego de um serviço JSON-RPC sobre HTTP.

Abaixo há um exemplo de um JSON-RPC 2.0 com pedido e resposta usando parâmetros posicionais.

--> {"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1}
<-- {"jsonrpc": "2.0", "result": 19, "id": 1}

Utilização do JSON-RPC

JSON-RPC funciona através do envio de uma solicitação para um servidor de aplicação que implemente este protocolo. O cliente neste caso é tipicamente o software com a intenção de chamar um único método de um sistema remoto.

Múltiplos parâmetros de entrada podem ser passados ​​para o método remoto como um array ou objeto, ao passo que o próprio método pode também retornar múltiplos dados de saída (Isso depende da versão implementada)


Um método remoto é invocado pelo envio de uma requisição a um serviço remoto usando HTTP ou um soquete TCP/IP. Ao usar o HTTP, o tipo de conteúdo pode ser definido como application/json.

Todos os tipos de transferência são objetos individuais, serializados (convertidos em um fluxo de bytes) usando JSON.

Requisição é uma chamada enviada um método específico disponível em um sistema remoto. Deve conter três certas propriedades :

1. Método - Uma String com o nome do método a ser invocado.
2. parâmetros - Um Array de objetos a serem passados ​​como parâmetros para um determinado método.
3. id - Um valor de algum tipo, que é usado para comparar a resposta com a requisição que foi executada.

O receptor do pedido deve responder com uma resposta válida a todos os pedidos recebidos. A resposta deve conter as propriedades mencionadas abaixo:

1. resultado - Os dados retornados pelo método invocado. Se ocorreu um erro ao chamar o método, esse valor deve ser nulo.
2. erro - Um código de erro especificado se houver um erro de chamar do método , caso contrário, nulo.
3. id - O ID da requisição que está sendo respondida.

Uma vez que há situações em a resposta não é necessária ou mesmo indesejadas, notificações foram introduzidas.

Uma notificação é semelhante a uma requisição exceto pelo id, que não é necessário porque nenhuma resposta será retornada. Neste caso a propriedade id deve ser omitida ou ser nula.

Exemplos para JSON-RPC Versão 2.0

Nestes exemplos, --> indica os dados enviados a um serviço (requisição), enquanto <-- indica os dados de resposta provenientes de um serviço. (Embora <-- muitas vezes é chamado de resposta em computação cliente-servidor, dependendo da versão JSON-RPC não implica, necessariamente, resposta a um pedido).

Chamada de procedimento com parâmetros de posição: 

--> {"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1}
<-- {"jsonrpc": "2.0", "result": 19, "id": 1}

--> {"jsonrpc": "2.0", "method": "subtract", "params": [23, 42], "id": 2}
<-- {"jsonrpc": "2.0", "result": -19, "id": 2}

Chamada de procedimento com parâmetros nomeados: 

--> {"jsonrpc": "2.0", "method": "subtract", "params": {"subtrahend": 23, "minuend": 42}, "id": 3}
<-- {"jsonrpc": "2.0", "result": 19, "id": 3}

--> {"jsonrpc": "2.0", "method": "subtract", "params": {"minuend": 42, "subtrahend": 23}, "id": 4}
<-- {"jsonrpc": "2.0", "result": 19, "id": 4}

Exemplo de Notificação: 

--> {"jsonrpc": "2.0", "method": "update", "params": [1,2,3,4,5]}

--> {"jsonrpc": "2.0", "method": "foobar"}

Exemplo de Chamada de Procedimento de um Procedimento Não-Existente:

--> {"jsonrpc": "2.0", "method": "foobar", "id": 10}
<-- {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Procedure not found."}, "id": 10}

Chamada de Procedimento com JSON inválido: 

--> {"jsonrpc": "2.0", "method": "foobar", "params": "bar", "baz"]
<-- {"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error"}, "id": null}

Chamada de Procedimento com JSON-RPC inválido: 

--> [1,2,3]
<-- [
  {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null},
  {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null},
  {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}
]

--> {"jsonrpc": "2.0", "method": 1, "params": "bar"}
<-- {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request"}, "id": null}