divERsions Parce qu'il faut un blog (Erlang mode)…

Utilisation de structures pour JSON

Jusqu’à présent, les données renvoyées étaient fournies sous forme d’un flux final de caractères :

handle_http(Req, {'GET', json}, _) ->
  ercm_ctx:return_json_data(Req, "{title:'Test',content:'Data loaded from server'}").

On doit pouvoir construire la structure JSON de façon dynamique et efficace. Pour cela, il faudra créer les structures attendues par le module mochijson2.

Ce module permet de renvoyer un flux JSON via la méthode encode/1. La méthode attend en paramètre (voir la documentation de Mochiweb) un json_object(). Cet objet est défini ainsi :

{struct, [{json_string(), json_term()}]}

json_term() permet une définition récursive. Ce qui nous intéresse est le json_string() qui est représenté soit par un atome, soit par un binaire.

Ce qui fait que le flux JSON précédent peut s’écrire de cette façon :

{struct, [{<<"title">>,<<"Test">>},{<<"content">>,<<"Data">>}]}

Cette notation étrange est celle des binaires. On pourrait utiliser des atomes pour les clés comme ci dessous, mais le fait qu’il y ait un nombre limité d’éléments fait que ce n’est pas une bonne idée :

{struct, [{title,<<"Test">>},{content,<<"Data">>}]}

Pour que ce flux puisse être renvoyé, il doit être encodé :

handle_http(Req, {'GET', json}, _) ->
  Json = {struct, [{<<"title">>,<<"Test">>},{<<"content">>,<<"Data">>}]},
  Result = mochijson2:encode(Json),
  ercm_ctx:return_json_data(Req, Result).

On peut alors simplifier les traitements en modifiant légèrement la fonction return_json_data/2 comme suit (chaque fonction est dans un fichier différent) :

return_json_data(Req, Data) ->
  Json = {struct, Data},
  Result = mochijson2:encode(Json),
  Req:ok({"application/json", [], Result}).
 
handle_http(Req, {'GET', json}, _) ->
  Json = [{<<"title">>, <<"Test">>},
	   {<<"content">>, <<"Data">>}],
  ercm_ctx:return_json_data(Req, Json).

C’est tout (mais comme j’ai du temps en ce moment, j’en profite…).

Sources : http://github.com/rv/ercm/tree/blog04.

Modules et contrôleurs

Erlang est un langage qui permet de créer et maintenir des applications complexes et volumineuses (en lignes de code). Pour ce faire, il est donc important de pouvoir découper de façon logique les programmes.

Ici, on utilisera la notion de modules. Rien d’extraordinaire en l’occurrence.

Sécurisation des accès aux URL et REST

Le premier développement Erlang sera de pouvoir sécuriser un petit peu l’accès à l’application, et préparer le futur système de routage.

La sécurisation d’une application passe par la possibilité de restreindre les vecteurs d’attaque potentiels et de ne permettre l’utilisation de l’API que de la façon dont on l’a imaginée.

Ainsi, notre requête /test ne devrait être accessible que par méthode GET, et uniquement dans le cadre d’un appel Ajax.

De plus, on essaiera d’avoir un fonctionnement proche d’une architecture RESTful.

Traces

Avant de pouvoir commencer les développements Erlang, il est intéressant de savoir comment « débuguer » (!!! pfff) et générer des traces.

Comme pour les autres fonctions Erlang, il peut être consommateur de temps de trouver les informations nécessaires.

Pour les traces, un système « simple » et immédiat sera de tracer les informations dans la console, via le shell.