Liens de la semaine 51-2014

Liens de la semaine 51-2014: ce que j'ai retenu cette semaine.


Projets:

• famo.us: 'THE ULTIMATE WEB PLATFORM FOR DEVELOPERS AND DESIGNERS'Ce  framework javascript permet de développer des applications web avec un rendu digne des jeux vidéos : 60 FPS (Frame per Second) et quelque soit le support.( PC / mobile)
• tanagra: outils de data mining. Un dispositif concurrent de l'écosystème 'R'.  Le langage R est plutôt orienté statistique.
• io.js : fork de Node.js, un drame ? non une chance de plus pour cette technologie
• Restlet Studio :  outil de conception d'API REST.
• Swagger:  outil de conception d'API REST.
• wakanda: outil de conception d'application web.
• Langage de programmation :ArnoldC - Programming language based on the one-liners of Arnold Schwarzenegger

Intelligence numérique sociale:

• Simplifier vos démarches administratives sur le net :article ici.
• Les timbres fiscaux pour les passeports seront dématérialisés en 2015 - Next INpact lien ici.

• management : EXPERIENCES DES MENAGERES DE LEWIN, 1943 (les abats de boeuf)

Livres: 

• Learning JavaScript Data Structures and Algorithms (Loiane Groner - PACKT publishing) : lien ici.
• Selenium 1.0 Testing Tools - Free Download eBook - pdf lien ici.
• Vous ne connaissez pas javascript : série ebook lien ici.
• Discovering Docker : lien ici
• Les géants du web : pratiques en matière de développement et exploitation ebook:lien ici

Conférences:

• Ruby After Rails by Ernie Miller  - RubyConf 2014: video ici.

Photo bonus: 

devops : développeurs et exploitants dans le même bateau.

Pour continuer dans le sillage de la gestion de projet Agile, voici  un nouveau phénomène adopté par  de plus en plus d'entreprise: le devops.

Dans ce dispositif, des développeurs (dev) et des exploitants ( (ops du mot anglais operations = exploitant) sont regroupés dans une véritable  task force. Ce concept existe depuis environ 5 ans. Ce qui est nouveau, c'est engouement  qu'il connait auprès des entreprises comme: google, Amazon, Bouygues, free etc.

ex :

Ce mode de fonctionnement est le quotidien des petites structures (PME ?) avec des équipes informatiques réduites. Son introduction dans des grands groupes est quelque part un constat échec.

Le devop permet de capitaliser sur une démarche Agile en amont.

source 01Net

Lien sur l'article de 01Net:ici.....

Le devop n'est pas un 'facilitateur' ou un interlocuteur privilégier vis à vis de l'exploitation: Il est exploitant à part entière. Cette compétence vient en complément avec sa maîtrise du développement.
Dans cette configuration, la task force aura la responsabilité du projet de la conception à la mise en production. Ce système est en contradiction avec les bonnes pratiques (ex: ITIL)  qui recommandent un cloisonnement entre le développement et la production. En effet les deux entités poursuivent des objectifs contradictoires: le développeur produit du changement (nouvelle version, fonctionnalité) alors que l'exploitant est le gardien de la stabilité: les applications ronronnent sagement.

Séduisant sur le papier mais difficile à mettre en place.

La mise en place d'un tel dispositif n'est pas facile: on touche ici à des sujets d'organisation avec une remise en cause des pratiques.

Lire article  Les 8 erreurs à éviter pour réussir votre démarche DevOps (Frédéric Richer)


ici les slides de la devops  Paris 2013.

nodebots: Piloter un arduino par le web.

Dans un précédent post, j'avais présenté l'utilisation la librairie  johnny-five qui permet de piloter des robots dont l'arduino en javascript.

Au lieu d'utiliser le langage natif d'arduino, on installe un programme 'firmata' qui permet de dialoguer avec un programme en javascript tournant sur un PC.

Johnny-five propose deux modes d'utilisation:
En interractif: REPL :Read - Eval - Print - Loop. C'est l'équivalent d'un interpréteur de commande.
(voir exemple dans mon post cité plus haut).
Soit en mode autonome: Le programme se déroule sur le PC et envoie ses instructions sur l'arduino.

Maintenant comment piloter son arduino depuis Internet, son smartphone , un site WEB .. ?
Le montage était destiné à piloter un laser pour distraire un chat (et moi par la même occasion)

 

Nous devons introduire un dialogue supplémentaire entre  le PC et le robot. Ce dialogue utilisera  le protocole MQTT: Le protocole des 'choses'  reliées à Internet.( MQ Telemetry Transport)
MQTT is a machine-to-machine (M2M)/"Internet of Things" connectivity protocol.

Une série de slide ici sur MQTT.


Ce protocole est très léger et il connu par la plupart des objets connectés. Et son domaine d'utilisation s'est élargie au transport de message pour les Tchats.
  Pour mémoire, Facebook utilise MQTT pour sa messagerie instantanée (ici un lien sur l'histoire de MQTT)


Pour le mettre en place , il faut disposer d'un serveur MQTT et des clients.

Pour le serveur, mon choix s'est porté sur MOSCA. C'est un serveur MQTT en javascript propulsé par le réacteur Node.js

Lien ici.
Mosca vous permet de construire votre propre serveur MQTT.

Mon code pour le serveur est le suivant:

	var mosca = require('mosca')
	var ascoltatore = {
	//using ascoltatore
	type: 'mongo',
	url: 'mongodb://localhost:27017/mqtt',
	pubsubCollection: 'ascoltatori',
	mongo: {}
	};
	var moscaSettings = {
	port: 1883,
	backend: ascoltatore,
	persistence: {
	factory: mosca.persistence.Mongo,
	url: 'mongodb://localhost:27017/mqtt'
	}
	};
	var server = new mosca.Server(moscaSettings);
	server.on('ready', setup);
	server.on('clientConnected', function(client) {
	console.log('client connected', client.id);
	});
	// fired when a message is received
	server.on('published', function(packet, client) {
	console.log('Published', packet.payload);
	});
	// fired when the mqtt server is ready
	function setup() {
	console.log('Mosca server is up and running')
	}

view raw serveur_mosca.js hosted with ❤ by GitHub

Le serveur utilise un bakend pour stocker les messages dans mon exemple j'utilise une base NoSQL MongoDB.


Le serveur se teste facilement avec un outil en ligne de commande: mosquitto
(MQTT est protocole de type : PubSub : publier , souscrire)
mosquitto_sub -t 'hello/you'

mosquitto_pub -m "c est moi" -t 'hello/you'

Le schéma général est le suivant:

réalisé avec http://shaky.github.bushong.net/

La partie web est en mode REST


Trois  motifs  sont utilisés pour décoder es URL , un pour l'axe des X , un pour l'axe des Y, le dernier pour allumer ou éteindre le laser.

	mqtt = require 'mqtt'
	mosca_host = 'localhost'
	mosca_port = '1883'
	client_settings =
	keepalive: 1000
	protocolId: 'MQIsdp'
	protocolVersion: 3
	clientId: 'client-2'
	express = require 'express'
	routes = require './routes'
	http = require 'http'
	app = express()
	client = mqtt.createClient(mosca_port, mosca_host, client_settings);
	myMiddleware = (req, res, next) ->
	if (req.method == 'GET')
	console.log "hi , I am here"
	## keep executing the router middleware
	next()
	app.configure ->
	app.set 'port', process.env.PORT || 3000
	app.set 'views', __dirname + '/views'
	app.set 'view engine', 'ejs'
	app.use express.favicon()
	app.use express.logger 'dev'
	app.use express.bodyParser(uploadDir : "./")
	app.use express.methodOverride()
	app.use app.router
	app.use myMiddleware
	app.use express.static(__dirname + '/public')
	app.get '/', routes.index
	app.get '/y/:nb' , (req,res) ->
	nb = req.params.nb
	console.log nb
	client.publish 'laser/cat',"axey:#{nb}"
	res.send 'ok'
	app.get '/x/:nb' , (req,res) ->
	nb = req.params.nb
	console.log nb
	client.publish 'laser/cat',"axex:#{nb}"
	res.send 'ok'
	app.get '/laser/:nb' , (req,res) ->
	nb = req.params.nb
	console.log nb
	client.publish 'laser/cat',"laser:#{nb}"
	res.send 'ok'
	server = http.createServer(app)
	server.listen app.get('port'),() ->
	console.log "Express server listening on port " + app.get('port')

view raw app.coffee hosted with ❤ by GitHub

La parie contrôle d'arduino est de la forme:

	five = require "johnny-five"
	mqtt = require 'mqtt'
	mosca_host = 'localhost'
	mosca_port = '1883'
	client_settings =
	keepalive: 1000
	protocolId: 'MQIsdp'
	protocolVersion: 3
	clientId: 'client-ard'
	board = new five.Board()
	client = mqtt.createClient mosca_port, mosca_host, client_settings
	reg = /(\w+):(\d+)/
	tab = reg.exec("vertical:123");
	board.on "ready", ()->
	myServoX = new five.Servo 9
	myServoY = new five.Servo(pin: 8 , range: [ 70, 115 ])
	myLed = new five.Led 7
	# board.repl.inject servo: myServoX
	# board.repl.inject servo: myServoY
	# servo =
	# servoX: myServoX
	# servoY: myServoY
	# led : myLed
	client.subscribe 'laser/cat'
	client.on 'message', (topic, message) ->
	console.log 'received', topic, message
	console.log( typeof message)
	tab = reg.exec(message)
	ordre = tab[1]
	too = tab[2]
	console.log ordre
	console.log too
	if ordre == "axex"
	myServoX.to(too)
	if ordre == "axey"
	myServoY.to(too)
	if ordre == "laser"
	if too == '1'
	myLed.on()
	else
	myLed.off()
	console.log( typeof too)
	# myLed.off()
	myServoY.to(too)
	# board.repl.inject servo
	myLed.on()
	myServoY.center()
	myServoX.center()

view raw arduino.coffee hosted with ❤ by GitHub

Le lasercat peut maintenant etre commandé depuis le site web sous Express , par un smartphone, en ligne de commande par curl.

Bonne fête les chats.

Une blague sur le COBOL..éternel COBOL

C'est l'histoire du développeur COBOL qui a fait fortune avec les maintenances liées au passage à l'an 2000. Avec son argent, il décide de se faire cryogéniser (congeler) et de tomber dans un sommeil (presque) éternel.

Un jour quelqu'un le met au micro-onde et le réveille. Le développeur COBOL ouvre les yeux et demande: pourquoi vous me réveillez ? . L'autre lui répond: on est en l'an 9999 , on fait comment pour le COBOL ?

Cette blague est issu d'un article ici qui traite de l'avenir d'un nouveau langage appelé COBOL.

Des robots pour les humains et pour les chats

Samedi 26 Juillet, c'était le NodeBots day (Journée internationale) .

Des microcontrôleurs (Arduino ?)  pilotés en javascript dont Node.js

Le groupe des NodeBots de Paris avait organisé un atelier à la cité des sciences de la Villette (Carrefour Numerique)
Quelques photos

C'est ici un 'catbot' : robots pour amuser les chats

Ce robot utilise 2 servo-moteur et 1 laser.

Ici toutes les ressources nécessaires.

Les projets évoqués: cylon.js 

Et son homologue en Ruby:Artoo 

Ces deux projets proposent une implémentation en couche un peu à la mode MVC à destination des microcontroleurs

Nous avons parlé aussi du protocole MQQT qui permet de construire des dialogues de machine à machine. Ce protocole est basé sur le mode  publish-subscribe  et il est utilisé aussi pour les programmes de 'chat' (exemple facebook messenger) 

Le projet mosca  implemente un serveur MQQT:

Les clients existent en Javascript et en ruby.

La partie codage: 

ici mon code pour piloter le robot:

-----

	five = require "johnny-five"
	board = new five.Board()
	r1 = () ->
	a= Math.floor( 180 * Math.random() )
	return a
	r2 = () ->
	a= Math.floor( 30 * Math.random() ) + 85
	return a
	r3 = () ->
	a = Math.floor( 5000 * Math.random() ) + 1000
	myrandom = () ->
	bond =
	x: r1()
	y: r2()
	t: r3()
	board.on "ready", ()->
	myServoX = new five.Servo 9
	myServoY = new five.Servo(pin: 8 , range: [ 95, 115 ])
	myLed = new five.Led 7
	board.repl.inject servo: myServoX
	board.repl.inject servo: myServoY
	servo =
	servoX: myServoX
	servoY: myServoY
	led : myLed
	board.repl.inject servo
	myLed.on()
	myServoY.center()
	myServoX.center()
	t = myrandom()
	console.log t
	myServoY.to(t.y)
	myServoX.to(t.x)
	@.loop 5000, ()->
	t = myrandom()
	console.log t
	myServoY.to(t.y)
	myServoX.to(t.x)

view raw lasercat.coffee hosted with ❤ by GitHub

----

Mais ce n'est pas la bonne  manière vraiment utiliser la combinaison javascript / arduino. L'idée est de piloter en temps réel l'arduino au travers d'une interface web. La pile est donc: express, mqqt pour la partie web et johnny-five et mqqt pour la partie robot.
A tester !

Retour sur Hackathon impots.gouv.fr

Il y avait du monde pour répondre à l'appel de la DGFiP pour imaginer le futur portail des impôts.

La team en pleine action. Les idées ne manquaient pas:


Notre proposition: une plate-forme de distribution:

Coté architecture , il ne faut pas hésiter à se faire plaisir quand c'est openbar:

Nous nous sommes amusé avec: 

parse.com : un frontal REST à une base NoSQL (pour stocker les informations de la timeline)

Et kafka 

Un petit tour sur bitbucket

Avec bien sur une dose d'angularJS

Un peu de D3 JS  (a essayer dimple.js plus tard )

Je me suis fait des nouveaux amis:

j'ai visité un atelier d'impression 3D:

Et le codage pendant ce temps ? 

Heureusement les gars d'altic ont assurés.

Le graphiste de wcie  etait le top du top:

Peut-être bientôt sur vos tablettes:

image wcie

Ce que reste à faire: passer du prototype mode puzzle à un vrai projet qui fonctionne.

Opérations avancées avec MongoDB

Dans une video, j'avais présenté une introduction à MongoDB.

Pour faire une suite voici quelques manipulations avec le client mongo ou  l'API Ruby.

Pour commencer: 

Avec le client mongo :
voir toutes les bases : shows dbs 
voir toutes les collections d'une base: show collections

Pour les recherches :

Rechercher à l'aide d'une expression régulière :ATTENTION à réserver que pour les champs 'string'
Toutes les stations de velib dont l'adresse contient le mot 'filles' (ex filles du calvaire )
db.stations.find({address :/.+filles.+/i}).count()

ou en version moins compacte :
db.stations.find({address : $regex :{/.+filles.+/i}}).count()

Pour inverser la sélection : $regex :{/(?!.+filles.+)/i}

Avec l'API Ruby:
rech = @stations.find({:address => /#{Regexp.quote(arr)}/}).each { |p| ...


Rechercher les entrées avec qui n'ont pas un champs précis:
db.stations.find({rem: {$exists : false}})

ou 

db.stations.find({rem: null})  # cette forme ne fonctionne pas si un champs contient la valeur null

Avec l'API Ruby:

rech = @stations.find({:arrondissement => nil})....

Afficher que certain champs en sortie:

db.stations.find({arrondissement: 75001},{'state.total_slots' : 1})

Avec Ruby : utiliser le symbole :fields :


@pgm = @db['jcl'].find({'source' => {'$exists' => true}},{:fields => {'jcl' => 1 , 'source' => 1, '_id' => 0}} ).to_a

(le champs id ou _id est special ,c'est l'identifiant des entrées.  il est toujours retourné sauf si , la valeur de sa clé est mise  à zero.)

Une recherche avec une  condition qui porte sur  deux champs de l'entrée (utilisation de $where et this.
(API Ruby)

@alerte = @coll.find('$where'  => "this.reel['total moe'] >= this.valide['total moe']" , 'semaine' => semaine )

Enfin: un tri
db.stations.find({},{address:1}).sort({'state.total_slots' :-1 }).limit(1)
Ici , le tri combiné à   limit(1) permet de récupérer la valeur la plus grande.

Regroupement d'entrée: 

• Le plus simple est l'opérateur distinct:

db.stations.distinct('arrondissement')

distinct retourne un array (tableau) , aussi pour connaitre le nombre d élément:
db.stations.distinct('arrondissement').length  

• L'operateur group:

Un autre manière de déterminer le maxima d'une série

@arr = @coll.group( :initial => {cmax:0} ,:reduce =>  "function(obj,prev) { if(prev.cmax < obj.semaine) prev.cmax = obj.semaine; }" )

un autre exemple avec le client mongo
db.stations.group({initial : {cmax : 0 } ,reduce : function(obj,prev) { if (obj.state.total_slots > prev.cmax) prev.cmax = obj.state.total_slots }})

[ { "cmax" : 72 } ]

Enfin un exemple de regroupement avec cumul intermédiaire et condition :

esi  =@coll.group(:key => :esi ,
                       :reduce => "function(obj,res) {res.pr.push({projet :obj['projet'],v: obj['valide']          ['moed'], r:obj['reel']['moed']  });
                                    res.valideESI += obj['valide']['moed'] ;  
                                    res.reelESI += obj['reel']['moed'] ; }",
                        :initial => {  :pr =>  [],
                                       :valideESI => 0,
                                       :reelESI   => 0 
                         },
                       :cond => {:semaine => max})

Les vues avec angularjs

Dans cette video et dans les slides , une présentation de la gestion des vues dans angularjs.
C'est la technique de base pour réaliser des SPA (application d'une seule page)

Angularjs102 from eric german

Pour cela , il faut récupérer l'extension  angular-route sur le site d'angularJS.

Le code est simple:

	var myApplModule = angular.module('myAppli',['ngRoute']);
	myApplModule.config(['$routeProvider',
	function($routeProvider) {
	$routeProvider.
	when('/page1', {
	templateUrl: 'partials/page1.tpl.html'
	}).
	when('/page2', {
	templateUrl: 'partials/page2.tpl.html'
	}).
	otherwise({
	templateUrl: 'partials/pageD.tpl.html',
	redirectTo: '/'
	});
	}]);
	myApplModule.controller('HelloController',['$scope',
	function($scope) {
	$scope.greeting = { text: 'Hello' };
	}]);

view raw code2.js hosted with ❤ by GitHub

Une video est associée à la présentation (disponible ici)


Le serveur web est porté par Sinatra:

Quelques lectures:

Suite et fin de la vidéo de présentation d'angularJS

Je termine ma présentation d'AngularJS par une application minimaliste.

Au passage je fais une petite démonstration de l'IDE  Brackets.

Pour bien commencer : 2 livres gratuits consacrés à AngularJS


Les slides de support de la video sont :

Angularjs101 p2 from eric german

La video est sur youtube: lien ici

Une introduction à angularJS et aux Single Page Application

J'étais parti pour faire une video sur AngularJS mais j'ai éprouvé la nécessité de remettre cette technologie dans un cadre plus général de développement des applications.

J'expose le système courant du templating coté serveur et coté client.

Templates coté client 

Avec ici la synthèse:

Mais le plus important est de replacer le phénomene des SPA: Single Page Application dans le contexte. REST , MVVM (angularJS ) , SPA et NoSQL sont autant des pièces d'un même puzzle.

Pourquoi des applications de ce type:

• Pour des raisons Economiques: les coûts sont partagés , elles sont scalables, elles sont simples.
• Pour la simplicité des solutions misent en oeuvre.

 Au premier abord toutes ces notions semblent très compliquées, mais en commençant doucement par des exemples simples, tout devient possible.

En conclusion: ce n'est pas un simple mouvement de mode. Ces évolutions touchent la manière de faire des applications, de conduire des projets.

Le support des slides de la video est ici:lien

Sur youtube : la video est diffusée a cette adresse.

Pour bien commencer avec les Architectures REST ou RESTFUL

La vague  REST va déferler sur nous. Hélas, la encore des marchands de rêve vont chercher à vous vendre du REST au kilo.

Ce qu'il faut bien  comprendre: Les architectures REST devront être une CONSÉQUENCE de l'évolution de vos applications  et non pas une CAUSE d'évolution de celles-ci.
En clair: commencer par mette du REST sans avoir ce qui va avec, mettra en difficulté votre système informatique, vos équipes etc.

Pour commencer le REST (ou RESTFUl ) c'est quoi ?

• C'est une une  thèse de Roy T. Fielding. En 2000.

«Fielding, Roy Thomas. Architectural Styles and the Design of Network-based Software Architectures. Doctoral dissertation, University of California, Irvine, 2000.»

Un chapitre ici traduit en français. (Le 5eme : un des plus important)

• C'est un livre de chevet (publié en 2007) :lien ici 

Couverture ( observez qui à donné son avis sur le livre)

(selfie truqué : pourquoi ? : à vous de trouver l'erreur)

• C'est une série de principe : 

1) Utilisation des verbes (Méthodes) du HTTP.
GET : lire une ressource
DELETE : supprimer une ressource
POST et PUT: pour creer ou modifier une ressource
(ou inversement : l'idée est d avoir un verbe pour créer différent de celui utiliser pour modifier)

source stackoverflow: http://stackoverflow.com/questions/630453/put-vs-post-in-rest

2) Chaque ressource a son URL. On interagit avec les ressources en combinant les  url avec les methodes HTTP.

• GET http://www.example.com/customers/12345
• GET http://www.example.com/customers/12345/orders
• GET http://www.example.com/buckets/sample
• PUT http://www.example.com/customers/12345
• PUT http://www.example.com/customers/12345/orders/98765

3) Pas de session gérée  coté serveur : Toute l'information de session est stockée sur le client ET donc chaque requête est autonome et complète.

4) Le serveur applicatif ne sert qu'a délivrer de la donnée (le plus souvent au format JSON et non plus XML)

Voila le rapidement présenté le  REST.

Pourquoi le REST a-t-il le vent en poupe ?

• Il permet de répartir les coûts d'infrastructure entre le fournisseur de ressource (service) et l'utilisateur (poste client). Il est donc pleinement compatible avec le modèle économique des clouds. Les traitements coûteux en CPU  (assemblages des pages WEB, manipulation des donnée)  sont réalisés sur la machine du client. 

• Les infrastructures et les applications sont plus simples: pas besoin d'avoir des serveurs de session, des bus d'entreprise etc. 

• La scalabilité est linéaire: sans partage de session à prévoir, avec des serveurs à gestion d 'événement (Node.js , nginx) , l'ajout d'un serveur augmente surement le nombre de connexion possible.

• Il met fin au débat entre les langages et les framework : PHP ,Java, Spring, Express, Rails  :La partie serveur ne sert qu'a délivrer de la donnée JSON. Le seul langage à maîtriser vraiment est le Javascript (le seul langage universel pour le navigateurs). Aussi, si vous n'avez pas les ressources de développement aguerries au Javascript l'adoption du  REST sera difficile.

Aussi mettre en place du REST sans avoir un idée de la stratégie à mettre en place coté client (Angular, Backbone , Ember ?...) c'est prendre le sujet à l'envers.

Comment reconnaître le vrai du faux REST.

Le critère de la session gérée coté client est important, sinon le simple test suivant est suffisant :

Est ce que votre application fonctionne avec le simple client HTTP en ligne de  commande CURL ?

Ex :  curl -X DELETE http://localhost:4567/pgm/5352d84751514034cc000048

(la partie serveur qui répond à la requete)

## Restful uri

##
delete '/pgm/:id'  do
@id_pgm =  params[:id]
@pgm =  @db['pgm'].remove('_id'  => BSON::ObjectId(@id_pgm) )
response.write ("{ok}")
end

Les bases NoSQL pour stocker du XML

Pendant de nombreuses années le XML tenait le haut du pavé dans le domaine de format de fichier: pour les données , les configurations etc. Le XML était partout:

Source : https://delta-xi.net/gfx/xml-landscape.gif

Depuis, on revient à un usage plus raisonnable du XML. Et des formats comme le JSON, le YAML ont  maintenant trouvés leur place.

Comment stocker efficacement des fichiers XML ?.

La solution habituelle.

La solution basique consiste à extraire les informations pertinentes du XML pour les sérialiser dans une base de données. Le format XML se prête mal a des opérations de recherche.
Cette solution à ses limites surtout pour des enregistrements XML de taille variable. L'exemple qui vient à l'esprit est celui de la récente réforme des échanges bancaires: le SEPA.
D'un format fixe de 240 caractères , les nouvelles normes ont évoluées sur des articles XML de taille variable. Le volume est plus important en raison de l'utilisation du XML, du détails des opérations mais d'une taille non prédictible.

 Des solutions à base de NoSQL.

Le principe de ces solutions est de stocker les fichiers XML échangés dans  une base de donnée Nosql. Le choix de cette base se portera sur un dispositif orienté document comme MongoDB.

source:
http://blogs.the451group.com/information_management/2011/04/15/nosql-newsql-and-beyond/

Les informations seront stockées sous deux formes:
Sous la forme d'origine en XML et sous un format JSON avec une succession de  clé / valeur. Les opérations de recherche se feront sur la partie JSON.

Ci-dessous un exemple de programme en Ruby utilisant la librairie nokogiri pour parser le XML:

	## cas primaire
	require 'json'
	def cas_general (filename, owner, node)
	ch ={}
	ch[:node] =[]
	ch[:owner] = owner
	owner =nil
	ch_ent = {}
	owner ||= node.attr('name')
	owner ||= node.attr('cobolrecordname')
	node.keys.each do |t|
	ch_ent[t.to_sym] = ch[t.to_sym] = node.attr(t) if !node.attr(t).empty?
	end
	ch_ent[:name] = ch[:name] = node.attr('cobolrecordname') if !ch[:name]
	if node.children.size > 0 then
	ch_ent[:nature] = ch[:nature] = 'groupe'
	node.children.each do |n|
	ch[:node] << cas_general(filename,owner,n)
	end
	else
	ch_ent[:nature] =ch[:nature] = 'simple'
	ch.delete(:node)
	end
	ch_ent[:filename] = filename
	puts filename
	ch_ent[:size] =ch_ent[:size].to_i if ch_ent.has_key?(:size)
	ch_ent[:decimal] =ch_ent[:decimal].to_i if ch_ent.has_key?(:decimal)
	ch_ent[:occurs] =ch_ent[:occurs].to_i if ch_ent.has_key?(:occurs)
	ch_ent.keys.each do |t|
	ch_ent[t] = false if ch_ent[t] == 'false'
	ch_ent[t] = true if ch_ent[t] == 'true'
	end
	ts =ch_ent.to_json
	puts ts
	return ch
	end
	###
	require 'nokogiri'
	Dir.glob("copybooks/*.xml").each do |filename|
	f= File.open(filename)
	doc = Nokogiri::Slop (f)
	f.close
	copy = doc.document.html.body.children.children[0]
	### le premier niveau est traite particuliairement
	ch = {}
	ch[:node]=[]
	ch[:node] << cas_general(filename, 'root',copy)
	end

view raw XML2json hosted with ❤ by GitHub

Le fichier XML est exploré récursivement  puis injecté dans une base NoSQL mongoDB par ce script:

	require 'mongo'
	require 'json'
	include Mongo
	mongo_client = MongoClient.new("localhost",27017)
	filecontent = ARGV.pop
	content = File.readlines(filecontent)
	db = mongo_client.db("pocpaye")
	entites = db.collection("entites")
	content.each do |mt|
	puts mt.inspect
	#item = JSON.pretty_generate(mt)
	# puts item
	ts =JSON.parse(mt)
	entites.insert(ts)
	puts ts
	end

view raw injecteur hosted with ❤ by GitHub

Le fichier XML sera injecté par ailleurs.

Ainsi l'information sera disponible sous deux formes avec une des formes autorisant des recherches multicriteres. Le stockage dans un système sans schéma est particulièrement adapté à des informations hétérogènes.

La scalabilité dans un fauteuil avec phusion passenger

Lors de la  mise en place d'architecture à base de Node.js, les mêmes questions reviennent:
Comment superviser des applications sous node.js ?
La réponse habituelle est FOREVER : forever permet de lancer un programme sous node.js et de le relancer si besoin.
Sur une machine multi-processeur, il est fréquent lancer plusieurs instances de l'applications sous node.js.
Node.js étant monoprocesseur (monothreading) il restera cantonné sur un CPU.

Je lance donc plusieurs instances de node.js (1 par CPU) par la commande forever.
Dans le cas où on dispose de plusieurs serveur (physique ou VM ) , il est d'usage de placer un serveur web NGINX en frontal qui fera office de reverse proxy.

On obtient les architectures suivantes:

(voir article sur ce lien)

Se pose alors le problème de supervision générale du système.
Pour ma part, je lance un 'agent' sur chaque serveur qui renseigne en temps reel sur les instances Node.js qui tournent sur un serveur.

	http = require 'http'
	exec = require('child_process').exec
	tab=[]
	teste_ligne_utile = (result) ->
	cperr = 0
	cpok = 0
	cp = 0
	res ={}
	while cp < result.length - 2
	tmp = result[cp + 2]
	tmatch = tmp.match(/\d+:\d+:\d+/)
	tab_match = tmatch[0].split(':')
	if tab_match[0] == '0' and tab_match[1] == '0' and tab_match[2] == '0'
	cperr+=1
	else
	cpok += 1
	cp += 1
	res = {ok : cpok , ko : cperr}
	command = (res)-> exec('forever list',
	(error,stdout, stderr) ->
	tab = stdout.split('data')
	rep = JSON.stringify( teste_ligne_utile(tab))
	res.end(rep)
	)
	monserveur = http.createServer (req, res) ->
	if (req.url == '/check_safe' && req.method.toLowerCase() == 'get')
	res.writeHead(200, {'content-type': 'application/json'})
	command(res)
	monserveur.listen 8888

view raw agent.coffee hosted with ❤ by GitHub

Ce programme en coffeescript lance la commande forever avec l'option list  (lignes 22 à 28) et 'compte' le nombre de ligne retournée (lignes 9 à 19) .
Ce dispositif accessible par une API REST (lignes 30 à 35 )permet de construire des interfaces graphiques de supervision:

Avec le résultat suivant :

Tout ceci est à faire manuellement.

Est ce que je suis le seul à avoir ces problèmes ?: NON répond Hongli LAI à la conférence Dot.js de Paris: (video sur ce lien )

Il reprend les différentes étapes de construction d'un projet Node.js

forever forever...

Puis faire démarrer le tout

Mettre en serveur Nginx en reverse proxy

Mettre plusieurs instances en cluster

Et monitorer l'ensemble

Ces dispositifs sont utilisés chez quelques PME : Apple, Pixar, New York Times, AirBnB, Juniper etc.. et  over 350.000 websites.

Ce montage en couche peut être remplacé par 1 seul composant : phusion passenger

phusion passenger fournit les informations suivantes: 

Lancement des Node.js : phusion passenger se charge de lancer le nombre d'instance qu'il faut et d'équilibrer leur charge. 

Reverse proxy

Supervision: à la place d'une supervision à programmer , la ligne de commande phusion passenger retourne les informations suivantes.

$ passenger-status
Version : 4.0.37
Date    : 2013-11-14 21:55:30 +0100
Instance: 25002
----------- General information -----------
Max pool size : 6
Processes     : 1
Requests in top-level queue : 0

----------- Application groups -----------
/Users/phusion/nodetestapp#default:
  App root: /Users/phusion/nodetestapp
  Requests in queue: 0
  * PID: 25012   Sessions: 0       Processed: 2       Uptime: 9s
    CPU: 0%      Memory  : 14M     Last used: 3s ago

Phusion passenger fonctionne soit tout seul ,  integré avec nginx ou encore avec apache.

Avec Node.js les architectures sont encore plus simples , plus performantes  plus robustes et moins chères.