Lors d’une précédente expérience professionnelle en 2007 (AF83) j’avais mis en oeuvre des techniques de répartition de charge via des traitements asynchrones pour le développement d’un microblog/chat web. Je cherchais depuis à réutiliser ces technologies, ce qui m’a poussé au développement de Nodecast.

Or si à l’époque le domaine des serveurs de message queues était encore balbutiant, il a nettement évolué depuis. En effet à l’époque après en avoir testé quelques uns, j’avais fini par me résoudre à utiliser le protocole XMPP via un serveur Jabber. Il faut bien avouer que la mise en œuvre a été plutôt ardu. XMPP est un bon protocole mais il est au final peu adapté pour un simple système de file d’attente, trop verbeux et la librairie Ruby XMPP4R faiblarde, à l’époque en tout cas.

Depuis les serveurs de file d’attente ont poussé comme des champignons, et certains sont même dérivés de serveur type clé/valeur.  J’ai pour ma part choisi Gearman qui me parait une bonne technologie depuis sa réécriture en C, et c’est un bon compromis fonctionnalités / simplicité / performances. Avant d’aller plus loin je préfère présenter le schéma de l’architecture du site, ce qui rendra plus aisé les explications.

Architecture

La partie droite en orange représente le site web. Nginx transmet les requêtes HTTP vers un pool de services Thin qui est un serveur web applicatif, il est en charge d’exécuter l’application en Ruby on Rails. Pour des raisons de performances et efficacité, j’ai choisi d’utiliser une base de données NoSQL, mongoDB.

La partie intéressante est celle à gauche représentée par le nuage gris. En effet il représente les services en charge de l’API.

API asynchrone

L’API est ici une API REST. Le client en Qt effectue donc simplement des requêtes HTTP afin de communiquer avec le service web. Il fait des POST pour l’ajout de données, des PUT pour la modification et des GET pour la consultation.

Plus le client envoi des données sur un court délai, plus les statistiques seront détaillées. Le problème est que cela génère une multitude de connexions et donc de traitement. Et plus il y en a, plus la réponse au client sera longue, ce qui va dégrader la qualité de service. Bien entendu la solution est de rendre asynchrone les traitements afin que la réponse au client soit la plus rapide possible.

Cela est représenté par l’échange 1 et 2 entre le serveur Nginx et le serveur thin.

Client <-> serveur

Lors d’un POST, le client va demander la création d’une donnée au service. Ici il s’agit de la création d’une nouvelle machine (host) à monitorer. Le workflow est le suivant :

1. client Qt POST les datas
2. serveur sinatra authentifie le client
3. serveur sinatra génère un identifiant unique (UUID)
4. serveur sinatra sérialize les datas, et transmet la charge à Gearman dans la file d’attente du dispatcher
5. serveur sinatra renvoi au client un XML contenant l’identifiant unique
6. le client stocke cet identifiant et l’utilisera pour tous les prochains échanges

Le principe ici est que le serveur sinatra ne fasse que le strict minimum, afin de répondre le plus rapidement et d’être disponible pour une prochaine requête. Ainsi même sous une charge importante, les requêtes transmises par les clients Qt, seront empilé et mise en attente au chaud dans le serveur de file Gearman.

Pour une requête PUT le workflow est plus simple puisque l’étape 3 est supprimée. Le serveur sinatra renvoi dans tous les cas un XML contenant le status « proceed » afin de signaler au client que sa requête a été prise en compte.

L’intérêt de Sinatra est qu’il est très simple à mettre en oeuvre ce qui en fait à mon avis un candidat idéal pour servir une API. Le code du serveur tiens d’ailleurs dans un seul fichier :

#!/usr/bin/env ruby
require 'rubygems'

require 'gearman'

require "bundler"
Bundler.setup
Bundler.require(:default)

RAILS_ENV="production"

#Gearman::Util.debug = true
SERVERS = ['localhost:4730']

@@logger = Logger.new('log/server.log', 'daily')
@@logger.debug("Created logger")

File.open(File.join('../config/database.mongo.yml'), 'r') do |f|
 @settings = YAML.load(f)[RAILS_ENV]
end

Mongoid.configure do |config|
 name = @settings["database"]
 host = @settings["host"]
 config.use_object_ids = @settings["use_object_ids"]
 @@logger.info "database : #{name}"
 @@logger.info "host : #{host}"
 config.master = Mongo::Connection.new.db(name)
 # config.slaves = [
 #                Mongo::Connection.new(host, @settings["slave_one"]["port"], :slave_ok => true).db(name)
 #               ]
end

require 'models_mongoid/user.rb'
require 'models_mongoid/profil.rb'
require 'models_mongoid/host.rb' 

set :logging, true

helpers do
 def protected!
 unless authorized?
 response['WWW-Authenticate'] = %(Basic realm="Nodecast HTTP Auth")
 throw(:halt, [401, "Not authorized\n"])
 end
 end

 def authorized?
 @auth ||=  Rack::Auth::Basic::Request.new(request.env)
 @current_user = User.where(:email => @auth.credentials.first, :authentication_token => @auth.credentials.last).first
 @auth.provided? && @auth.basic? && @current_user
 end
end

post '/hosts.xml' do
 protected!
 xml = Crack::XML.parse(request.body.read)
 @@logger.info("#{Time.now} : RECEIVE CREATE")

 uuid = UUIDTools::UUID.timestamp_create.to_s

 host = {
 :user => @current_user.email,
 :uuid => uuid,
 :timestamp => Time.now.utc,
 :datas => xml
 }

 payload('dispatcher_add', host)

 builder do |xml|
 xml.instruct!
 xml.host do
 xml.uuid host[:uuid]
 end
 end
end

put '/host/update/:id' do
 protected!
 xml = Crack::XML.parse(request.body.read)
 @@logger.info("#{Time.now} : RECEIVE UPDATE")

 host = {
 :user => @current_user.email,
 :uuid => params[:id],
 :timestamp => Time.now.utc,
 :datas => xml
 }

 payload('dispatcher_update', host)

 builder do |xml|
 xml.instruct!
 xml.host do
 xml.status "proceed"
 end
 end
end

private

def payload(worker, data)

 client = Gearman::Client.new(SERVERS)
 taskset = Gearman::TaskSet.new(client)

 #task = Gearman::Task.new('update', Marshal.dump(host), :background => true, :poll_status_interval => 1)
 task = Gearman::Task.new(worker, Marshal.dump(data))
 task.on_complete {|d| @@logger.info "complete : #{d}" }  

 task.on_warning {|w| @@logger.info "[client] warn: #{w}" }
 task.on_fail {|f| @@logger.info "[client] calculation failed : #{f}" }
 taskset.add_task(task)  
end

On voit bien ici que « post ‘/hosts.xml’ do » et ‘put ‘/host/update/:id’ do » permettent de répondre très simplement aux requêtes POST et PUT des clients. Pour le reste on voit bien que le serveur ne fait que préparer un Hash avec l’XML transmis par le client, un timestamp, l’uuid du host et l’id de l’utilisateur. Ce Hast est ensuite sérialisé puis la charge est envoyée dans la file d’attente du dispatcher.

Dispatcher <-> workers

Comme on le voit dans le code les traitements sont envoyés dans la file d’attente sur 2 canaux : « dispatcher_update » et « dispatcher_add ». Il y a donc un processus Ruby qui attend des traitements sur ces canaux afin de les préparer puis les transmettre à chaque worker. J’avais tout d’abord un seul worker, mais il est beaucoup plus intéressant de le découper en plusieurs workers spécifiques à une tâche. En effet des utilisateurs peuvent décider de ne pas envoyer les informations relatives au CPU ou bien au réseau. De fait les worker auront la charge qui correspond au contenu des requêtes transmises.

Le dispatcher ne dépend pas des traitements à effectuer, son rôle est de découper le traitement en de multiples sous-traitement qu’il transmet dans le canal de chaque worker. Si les traitements sont lourds il peut malgré tout continuer à les répartir dans chacun des canaux, quelque soit la charge en cours.

Les traitements se font réellement dans chaque worker. Ils désérialisent les données reçues de leur file d’attente, puis les stocke dans mongodb. Voici un des workers dédié au traitement des load :

#!/usr/bin/env ruby
require 'rubygems'

gem 'mongoid', '1.9.0'

require 'mongoid'
gem 'gearman-ruby', '3.0.1'
require 'gearman'
require 'uuidtools'

require 'logger'
require 'yaml'
require 'optparse'
require "pp"

options = {}

optparse = OptionParser.new do |opts|
 opts.on('-w', '--work WORK', 'path to the work directory') do |work|                                        
 options[:work] = work
 end
 opts.on('-m', '--mongo MONGO', 'path to the mongo file') do |mongo|                                        
 options[:mongo] = mongo
 end
 opts.on('-e', '--env ENV', 'rails environment') do |env|                                        
 options[:env] = env
 end
end

begin
 optparse.parse!
 mandatory = [:work, :mongo, :env]
 missing = mandatory.select{ |param| options[param].nil? }
 if not missing.empty?
 puts "Missing options: #{missing.join(', ')}"
 puts optparse
 exit
 end
rescue OptionParser::InvalidOption, OptionParser::MissingArgument
 puts $!.to_s
 puts optparse
 exit
end

puts "Performing task with options: #{options.inspect}"            

#Gearman::Util.debug = true if options[:env] == "development"

servers = ['localhost:4730']
@@worker = Gearman::Worker.new(servers)

logger = Logger.new("#{options[:work]}/log/worker_stats_load.log", 'daily')
logger.debug("Created logger")

File.open(File.join("#{options[:mongo]}/database.mongo.yml"), 'r') do |f|
 @settings = YAML.load(f)[options[:env]]
end

Mongoid.configure do |config|
 name = @settings["database"]
 host = @settings["host"]
 config.use_object_ids = @settings["use_object_ids"]
 logger.info "database : #{name}"
 logger.info "host : #{host}"
 config.master = Mongo::Connection.new.db(name)
 # config.slaves = [
 #                Mongo::Connection.new(host, @settings["slave_one"]["port"], :slave_ok => true).db(name)
 #               ]
end

require "#{options[:work]}/models_mongoid/user.rb"
require "#{options[:work]}/models_mongoid/profil.rb"
require "#{options[:work]}/models_mongoid/host.rb"
require "#{options[:work]}/models_mongoid/osystem.rb" 

require "#{options[:work]}/models_mongoid/host_ram.rb"
require "#{options[:work]}/models_mongoid/host_cpu.rb"
require "#{options[:work]}/models_mongoid/host_network.rb"
require "#{options[:work]}/models_mongoid/host_last_comment.rb"
require "#{options[:work]}/models_mongoid/host_stats_uptime.rb"
require "#{options[:work]}/models_mongoid/host_stats_load.rb"
require "#{options[:work]}/models_mongoid/host_stats_network.rb"
require "#{options[:work]}/models_mongoid/host_stats_cpu.rb"
require "#{options[:work]}/models_mongoid/host_stats_memory.rb" 

require "#{options[:work]}/models_mongoid/load_statistic.rb" 

########## JOB UPDATE STAT ############
@@worker.add_ability('update_load') do |data,job|

 dump = Marshal.load(data)

 xml = dump[:push]
 host = Host.where(:uuid => dump[:uuid]).first

 host_load = {
 :created_at => dump[:timestamp],
 :updated_at => dump[:timestamp],
 :loadavg0 => xml[:loadavg0],
 :loadavg1 => xml[:loadavg1],
 :loadavg2 => xml[:loadavg2]
 }    

 begin

 ls = host.load_statistics.create(host_load)
 logger.info "LOAD stats created"

 loadavg0 = 0.0
 loadavg1 = 0.0
 loadavg2 = 0.0

 host.load_statistics.each do |stat|
 loadavg0 += stat.loadavg0
 loadavg1 += stat.loadavg1
 loadavg2 += stat.loadavg2
 end

 if !host.stats_load
 host.create_stats_load(
 :created_at => dump[:timestamp],
 :updated_at => dump[:timestamp],
 :number => 1,
 :loadavg0 => ls.loadavg0,
 :loadavg1 => ls.loadavg1,
 :loadavg2 => ls.loadavg2,
 :max0 => ls.loadavg0,
 :max1 => ls.loadavg1,
 :max2 => ls.loadavg2
 )
 else      
 host.stats_load.updated_at = dump[:timestamp]
 host.stats_load.number += 1

 host.stats_load.max0 = ls.loadavg0 if ls.loadavg0 > host.stats_load.max0
 host.stats_load.max1 = ls.loadavg1 if ls.loadavg1 > host.stats_load.max1
 host.stats_load.max2 = ls.loadavg2 if ls.loadavg2 > host.stats_load.max2

 host.stats_load.average0 = loadavg0 / host.stats_load.number
 host.stats_load.average1 = loadavg1 / host.stats_load.number
 host.stats_load.average2 = loadavg2 / host.stats_load.number

 host.stats_load.loadavg0 = ls.loadavg0
 host.stats_load.loadavg1 = ls.loadavg1
 host.stats_load.loadavg2 = ls.loadavg2

 host.save
 end

 logger.info "Embedded host load stats updated"

 rescue => e
 logger.info "failed on update : #{e}"
 raise Exception.new("failed on update : #{e}")
 end

end

loop do
 @@worker.work
end

Avantages

En cas de soucis sur les workers, ceux-ci pourront être stoppé sans problème même en production. Grâce au découplage mis en place, les traitements sont tous simplement en attente dans leur file d’attente. Il y a intérêt à avoir un serveur d’API très basique (ici le code dans Sinatra) afin d’éviter au maximum les éventuels plantages ou corruption des données, et de plus cela le rend, comme je l’ai déjà dis, plus rapide.

Evolution

Cette architecture est encore basique car ne tourne que sur une seule machine. Cependant les technologies employées permettront de la répartir sur plusieurs machines très simplement. Tout d’abord au niveau de mongoDB via des slaves. Puis en démarrant plusieurs démons Gearman. Les workers pourront ainsi dépiler leurs jobs sur l’un des serveurs Gearman du cluster.

Ensuite il pourra être intéressant que chaque worker log dans mongoDB ses tâches et ses temps de traitement afin de détecter les éventuels bottleneck. Gearman possède également une multitude d’options comme pouvoir rendre prioritaire un job.

Enfin il est bien entendu approprié que le front web puisse utiliser l’API afin d’effectuer des traitements lourds demandés par l’utilisateur.

Qu’est-ce que le desktop 2.0 ?

Historiquement le desktop est composé de logiciels installés sur une machine et qui au mieux dans certains cas communiquent entre eux. On télécharge le logiciel, on l’installe, on le paramètre si nécessaire et on l’utilise. Cette description n’a pas changé depuis environ 25 ans. Pour une mise en perspective, le web qui est venu bien après, qui est complexe à faire évoluer techniquement et administrativement, a régulièrement évolué et fait un bond en avant avec HTML5 : http://slides.html5rocks.com/#slide3

Le desktop 2.0 pourrait être un desktop qui utilise Internet afin de proposer des fonctionnalités supplémentaires. A priori ca existe déjà, par exemple iTunes qui permet de consulter le store d’Apple et d’y faire des achats depuis une interface native. Sauf que iTunes n’est qu’un logiciel qui intègre le moteur d’un navigateur web afin de présenter de manière un peu mieux intégré au desktop le store et surtout de gérer les DRM sur les fichiers achetés…

L’intérêt d’Internet est essentiellement de pouvoir partager et communiquer, consommer n’étant qu’une forme particulière de partage sous contrainte.

Mais pour moi il ne représente en aucun cas un but final. Dans les années 2000 on disait « il FAUT être sur Internet ». C’est une perception complètement erronée de l’outil ce qui a à mon avis complètement pervertie notre conscience. En effet, à l’époque le contexte était qu’il fallait y être en ayant un site web. Maintenant en 2010 il FAUT y être en ayant des suites bureautiques en web, des systèmes d’exploitation en web, et toute une suite de logiciels, en web …

Joost le fameux logiciel de vidéo en P2P par les créateurs de Kazaa est mort soit disant car il fallait installer un logiciel… Bullshit !!! La version full web est tout aussi morte. Joost est mort car il n’y avait pas de contenu. Et il y en avait pas car le seul contenu autorisé venait que des partenaires … Ca s’appelle la télévision ça, ce n’est pas Internet.

De fait la vision que nous avons d’Internet n’a pas changé depuis ses premiers pas ! Une vision très restrictive de l’outil.

Si le desktop 2.0 ne ressemble pas aux iTunes like, si ce n’est pas des applications web, qu’est-ce qu’il est ?

Le desktop 2.0 existe déjà

Plutôt que de décrire la chose avec des métaphores et des descriptions techniques autant prendre l’exemple parlant du seul gars qui a compris ce que c’était, qui l’a même pratiquement inventé et industrialisé à grande échelle : Steve Jobs.

Quoi encore lui ! bin oui … l’iPhone c’est quoi ? C’est un ordinateur (de poche) capable d’aller sur Internet (comme un ordinateur avec un abonnement Internet), et un kit de développement, le tout suffisamment bien conçu pour rendre n’importe quelle application web2 ridicule.

Attention tous les mots de cette phrase ont leur importance, notez d’ailleurs l’absence du mot téléphonie, car ne m’intéresse pas dans le contexte de ce billet. Et d’ailleurs le succès de l’iPad en rajoute une couche puisqu’il ne fait pas téléphone …

l’iPhone et maintenant l’iPad implémententent le desktop 2.0, car :

• Les applications sont natives. Ce qui rend « l’expérience utilisateur » (comme on dit), beaucoup plus fun, car cela apporte :
  • La réactivité
  • L’intégration au bureau
  • L’accès aux extensions matériel actuelles et à venir (3D, GPS, gyroscope, accéléromètre, …)

Et qui dit fun, dit j’utilise plus facilement qu’une application web qui ne peut pas avoir ces avantages. Qui dit j’utilise dit je suis potentiellement prêt à payer.

• Les applications utilisent Internet. Et je parle bien des applications pas uniquement du navigateur web !
• Les applications sont faciles à trouver, à installer et à mettre à jour grâce à l’AppStore.

NATIF, INTERNET, STORE

Ces 3 termes définissent bien la chose. On peut faire un paquet de reproches justifiés à Jobs, par contre on ne peut pas lui enlever la vision qu’il a eu. Car il ne suffit pas de dire je vais faire un téléphone qui peut aller sur Internet, ca existait déjà avant l’iPhone. Il faut imaginer ces 3 concepts, faire fabriquer le matériel qui tient la route, développer les logiciels et les services, et intégrer le tout de manière cohérente.

Google a d’ailleurs bien compris la leçon, et le confirme avec le succès d’Android.

Et le PC ?

NATIF ?

De manière historique les applications sont natives, mais pour diverses fausses bonnes raisons (déploiement et mise à jour) beaucoup d’applications « professionnelles » sont uniquement en web (IE6).

INTERNET ?

Depuis le début d’Internet les PC y accèdent. Sauf qu’ici dans la description du desktop 2.0 je parle des applications. Or il faut bien avouer qu’à part le navigateur web il n’y a pas beaucoup d’applications qui exploitent Internet, même en 2010 !!!

STORE ?

Gros point d’avance pour Linux qui possédait un « store » depuis la naissance de Debian au moins, dans les années 90 (et voui). Nous parlons de dépôts. De nos jours toutes les distributions en possèdent un et il permet de plus de mettre à jour tout le système et pas uniquement les applications utilisateurs !

Hormis Linux point de salut du côté de Windows et MacOS, même si des rumeurs d’appstore pour MacOS X ont circulé.

Arguments

NATIF !

Parmi les arguments en faveur d’une application native qui aboutissent à une « expérience utilisateur » agréable, il y en a une autre loin d’être négligeable pour le développeur, la facilité de développement. Il faut certes maitriser la technologie nécessaire à développer une application native, mais d’une part le choix est vaste sur un PC, et d’autres part une application web « équivalente » va nécessiter la maitrise d’un paquet de technologies côté client (Javascript, HTML, XML, CSS) pour un résultat bien inférieur et la maîtrise de plusieurs boites à outils nécessaires à débuger tout ça.

Pourquoi est-ce si pénible ? Tout simplement parce que le web n’a jamais été prévu pour développer des applications mais simplement pour afficher des pages … Bien sûr l’HTML5 vise à remédier à ces lacunes, mais cela restera malgré tout en deçà de n’importe qu’elle application native correctement développé et intégré. Et ne parlons même pas de l’exploitation de périphériques matériel ou même de la 3D, webgl commence à peine à être intégré à certains navigateurs web, en 2010 …

Enfin une botte secrète du web est la compatibilité de l’application quel que soit l’OS. Je balaie cela d’un revers de la main, car du coup on a renvoyé vers le développeur la complexité de la chose ainsi que vers le navigateur, on se rappelle tous des années de lutte à faire respecter les standards afin d’afficher et pouvoir utiliser correctement une application web… De plus une bibliothèque comme Qt est multi-plateforme, il n’y a qu’à voir Skype ou Opera. Et bien entendu Java (Eclipse, …)

Pour en revenir au faux exemple de Joost, devoir installer une application n’est pas une contrainte. Les succès de Skype, Dropbox, Spotify, iTunes, … le prouvent. Le frein est simplement la nullité d’une mauvaise application.

INTERNET !

Un des avantages d’une application web et ce qui a entre autre expliqué leur explosion est le fait de pouvoir tout stocker côté serveur. L’utilisateur a ainsi qu’à se rappeler de son login et mot de passe pour retrouver toutes ses données. Or rien empêche une application native de faire de même ! Elle peut même faire en sorte de stocker en local si une coupure au réseau survient.  C’est précisément ce que vient combler l’HTML5 pour les applications web …..

Les développeurs d’applications natives pour iPhone ont eux bien compris l’intérêt et ne s’en prive pas. Internet devient de fait ce pour quoi il est bon : stocker, présenter et partager des données. L’application native se contente elle de faire ce pour quoi elle est bonne : faire l’acquisition des données via l’utilisateur et/ou des extensions matériels (GPS, accéléromètre, gyroscope, …) et rendre cela agréable en exploitant au maximum les capacités du matériel.

Alors peut être qu’il y aura un jour une version d’HTML qui va permettre d’accéder au GPS … laule…

Un exemple concret de l’intérêt d’Internet ? Prenons un logiciel natif comme un client mail qui propose des fonctionnalités complémentaires comme la lecture de flux RSS. La personnalisation de ces flux comme l’ajout et leur catégorisation nécessite un certain temps. Or si vous avez un laptop comme ordinateur secondaire, ou bien celui du boulot, vous devrez refaire ce travail redondant de paramétrage, et je ne parle même pas qu’un article lu depuis son travail sera marqué non lu chez soi… Si ce logiciel pouvait sauvegarder sa configuration et ses données sur Internet, il suffirait d’une simple synchronisation pour se faciliter là vie.

A remarquer que la Mozilla Fondation a très bien compris cela puisque qu’elle propose l’extension Firefox sync, ainsi que Google chrome qui gère ça nativement. A leur avantage ces 2 entités ont de très forte compétences en développement client et serveur, ce que n’a pas forcément le développeur d’une application desktop lambda. Remarque importante pour la suite de cet article.

STORE !

L’autre avantage d’une application web était sur les déploiements et les mises à jour. Cependant grâce aux stores cet argument s’efface, et pour les OS préhistorique qui ne gère pas encore cette fonctionnalité, il parait trivial d’ajouter cela au sein même de l’application …

De plus un store permet de faciliter la vente de son application, ce qui est loin d’être négligeable. Côté Linux seul Canonical semble le comprendre et faire un pas dans ce sens. Il semble que le « petit » milliard de dollars reversé par Apple aux développeurs iPhone, ait fini par convaincre, il était temps !

QUEL AVENIR

du Desktop

D’un côté il va y avoir le fameux Chrome OS qui est là pour renforcer la présence des applications Google. Le truc drôle c’est qu’eux ont bien compris les limitations du web, aussi compétent soient-ils, et aussi bien HTML5 soit-il. Donc afin de rendre les applications web plus agréable et pour pouvoir développer tout type d’application, ce qui est important lorsqu’on a la prétention de faire un OS grand public, ils proposent le plugin Chrome nativeclient qui va permettre de développer des applications … natives … à l’intérieur de Chrome ! On marche sur la tête ?!

Ou quand le web réinvente le natif afin de combler ses propres lacune tout adaptant à son monde ce qui fait le succès d’Apple… Et bien entendu Google étant loin d’être bête va proposer son « store » market pour son OS.

De l’autre, il est heureux de constater certains réveil, encore une fois via Canonical avec son Ubuntu One. Ce service permet de stocker et synchroniser ses données sur Internet via les programmes qui supporte desktopcouch. Et ceci est la réponse aux programmeurs qui n’ont pas les compétences ou l’envie de développer eux mêmes ces fonctionnalités. Il était temps qu’un éditeur d’OS propose ce type d’API à ses développeurs !

Pour pousser le concept un peu plus loin, je rêverais d’un OS qui me permette, suite à son installation, de télécharger automatiquement tous les logiciels que j’utilise sur mon PC principal ainsi que toutes les préférences associées à ces logiciels.

Ces informations personnelles mais pas vraiment critique, pourrait même être partagée via un réseau social si l’utilisateur le souhaite.

du Réseau Social

Ce secteur à la mode a ceci de particulier qu’il est le révélateur flagrant de cette dualité web / desktop. Par exemple, au départ ces applications web de type Facebook étaient complètement fermées et uniquement accessible depuis un navigateur web. Avec la mode web2, ils se sont ouvert via des API ce qui a permis de faire émerger une multitudes d’applications natives pour mobile, puis pour PC.

Quand le web redécouvre l’intérêt du bon vieux client natif… Cependant on en est toujours sur du vertical, une application dédié à un service.

C’est ici que débarque le très intéressant social desktop et son OCS API, une API qui doit permettre l’accès des applications natives à des réseaux sociaux. En effet il est complètement aberrant qu’il faille utiliser une application en particulier pour faire du social ! Cette pratique est complètement transverse est de fait n’importe quelle application est capable de présenter un intérêt social ! Que cela soit d’intégrer le service Gitorious dans un IDE, comme QtCreator qui le fait, ou bien intégrer l’API d’un site de recettes de cuisine à des logiciels de gestion des courses….

Le social est transverse, il est ridicule de devoir utiliser un client dédié ou bien même un serveur en particulier… Côté serveur le très intéressant microblog décentralisé statusnet montre le voie, ainsi que la plateforme sociale décentralisée movim.

A moins que l’on souhaite que le futur du desktop ne tourne que dans l’onglet d’un navigateur web, ce qui est déjà le cas avec Chrome OS, Jolicloud, etc, il reste aux éditeurs d’OS et de bureaux de proposer des services web décentralisés et des API, afin que n’importe application desktop puisse enfin sortir des années 1990…

Pour finir je tiens à poser une question qui peut résumer ce débat.

Les acteurs et organisations du web travaillent à faire évoluer leurs technologies afin de proposer des fonctionnalités les plus proches d’une application native. Les éditeurs de logiciels natifs et développeurs d’environnement de bureau travaillent à proposer des fonctionnalités permettant le développement d’applications qui exploitent les capacités offertes par Internet (web services, cloud, …).

Entre ces 2 visions quelle est celle qui a le plus court chemin à faire et laquelle est la plus à même de répondre aux besoins envies des utilisateurs ?

Sinatra est un framework web léger non MVC qui permet via son DSL de répondre à toutes les méthodes HTTP (DELETE, PUT,POST,GET) simplement et en utilisant un seul fichier Ruby. L’introduction démontre la plupart de ses capacités. C’est à mon avis idéal pour servir une API plutôt que de sortir l’artillerie lourde Rails.

MongoID est un driver Ruby pour la base NoSQL mongoDB. Il est en concurrence avec MongoMapper.

Gearman est un serveur qui fait parti des innombrables serveur de job. En effet depuis ces dernières années un nouveau serveur sort tous les 6 mois ou presque avec plus ou moins de succès. Parmi ceux-ci on peut citer Beanstalkd ou RabbitMQ, il existe un « vieux » (1 an) comparatif non exhaustif de quelques serveurs de job Choosing a message queue for Python on Ubuntu on a VPS. Pour ajouter au trouble on peut trouver parmi eux des serveurs NoSQL type clé/valeur comme redis avec le plugin Resque.

Je travaille depuis quelques mois sur mon projet Nodecast et je souhaitais rendre l’API asynchrone. Le principe du projet est qu’un client desktop extrait régulièrement des informations systèmes et les transmet au site web. Un serveur Sinatra expose l’API et enregistre les données dans MongoDB. Le problème est que si de plus en plus clients viennent pusher leurs données sur le serveur Sinatra, celui-ci aura forcément de plus en plus de mal à encaisser la charge. Avec une architecture de ce type entre la requête HTTP POST du client et la réponse du serveur, tout fonctionne de manière synchrone, de fait si le serveur Sinatra atteins son pallier il ne sera plus en mesure de répondre à de nouvelles requêtes. Il est nécessaire que l’échange entre le client et le serveur Sinatra soit le plus rapide possible.

Pour cela il est essentiel de découpler l’interaction entre le serveur et le travail effectué. Pour comprendre cela imaginons que le client ne transmette pas d’informations systèmes mais carrément une vidéo que le serveur devra par exemple ré-encoder. Il n’est pas concevable que lorsque le client (desktop ou browser) a fini de poster la vidéo, l’utilisateur doive encore attendre la fin du réencodage du film avant d’avoir la main. Ce travail de ré-encodage doit s’effectuer dans un 2ème temps.

La première règle à définir est que l’échange entre le client et le serveur doit s’effectuer le plus vite possible, c’est un échange du type « fire and forget ». Pour cela lorsque le client desktop poste les informations, le serveur ne doit renvoyer qu’un acknowledge et aucune autre information permettant au client de savoir si le travail s’est bien effectué. Car si c’était le cas on reviendrait à un fonctionnement synchrone … Cependant rien empêche le serveur de renvoyer au client un identifiant unique afin de lui permettre par la suite de connaitre via une autre requête l’état de du travail envoyé.

Pour rendre cela possible il est nécessaire de séparer le code qui réceptionne la requête du code qui va traiter la demande. Il manque un tampon entre les deux, car le code qui va traiter la demande, le worker, peut être justement occupé à en traiter une. L’intérêt d’un serveur de job (appelé aussi serveur de file de message) est de stocker le job et le transmettre au worker lorsque celui-ci en fait la demande. Dans l’industrie il existe le protocole AMQP que RabbitMQ implémente. Je n’ai malheureusement pas réussi à faire lancer ce dernier sur mon serveur Ubuntu 10.04. J’ai découvert Gearman qui est presque aussi simple d’usage sur Beanstalkd tout en proposant des capacités de montée en charge, un worker pouvant s’abonner à plusieurs serveurs Gearman. De plus cet outil est développé par Danga pour LiveJournal, voir leur présentation sur le backend de LiveJournal : Behind the Scenes at LiveJournal: Scaling Storytime.

Sinatra expose l’API, réceptionne les demandes des clients, les transmet aussitôt à Gearman dans une file nommée en fonction du job (update,insert,…) puis renvoie aussitôt un ack au client desktop pour lui confirmer que sa requête est prise en compte. Sinatra est donc rapidement disponible à réceptionner une nouvelle requête. Le worker est abonné aux files d’attente dont il a la charge, il supprime le job du serveur afin de le traiter. Enfin Gearman offre la possibilité au worker de retourner au client l’état du travail effectué. Le client, ici Sinatra, dispose de ces 3 méthodes :

Il peut ainsi stocker dans un fichier de log le statut du worker.

Voici le code du client Sinatra lancé par Thin :

#!/usr/bin/env ruby
require 'rubygems'

require 'gearman'

require "bundler"

Bundler.setup

Bundler.require(:default)

RAILS_ENV="development"

Gearman::Util.debug = true

SERVERS = ['localhost:4730']

logger = Logger.new('log/server.log', 'daily')

logger.debug("Created logger")

File.open(File.join('../config/database.mongo.yml'), 'r') do |f|

@settings = YAML.load(f)[RAILS_ENV]

end

Mongoid.configure do |config|

name = @settings["database"]

host = @settings["host"]

config.use_object_ids = @settings["use_object_ids"]

logger.info "database : #{name}"

logger.info "host : #{host}"

config.master = Mongo::Connection.new.db(name)

end

require 'models_mongoid/user.rb'

require 'models_mongoid/profil.rb'

require 'models_mongoid/host.rb'

set :logging, true

helpers do

def protected!

unless authorized?

response['WWW-Authenticate'] = %(Basic realm="Nodecast HTTP Auth")

throw(:halt, [401, "Not authorized\n"])

end

end

def authorized?

@auth ||=  Rack::Auth::Basic::Request.new(request.env)

# logger.info "AUTH = #{@auth.inspect}"

@current_user = User.where(:email => @auth.credentials.first, :authentication_token => @auth.credentials.last).first

@auth.provided? && @auth.basic? && @current_user

end

end

post '/hosts.xml' do

protected!

xml = Crack::XML.parse(request.body.read)

logger.info("POST")

uuid = UUIDTools::UUID.timestamp_create.to_s

host = {

:user => @current_user.email,

:uuid => uuid,

:datas => xml

}

client = Gearman::Client.new(SERVERS)

taskset = Gearman::Taskset.new

# task = Gearman::Task.new('add', Marshal.dump(xml), :background => true, :poll_status_interval => 1)

task = Gearman::Task.new('add', Marshal.dump(host))

task.on_complete {|d| logger.info "complete : #{d}" }

task.on_warning {|w| logger.info "[client] warn: #{w}" }

task.on_fail {|f| logger.info "[client] calculation failed : #{f}" }

taskset << task

client.run(taskset)

builder do |xml|

xml.instruct!

xml.host do

xml.uuid host[:uuid]

end

end

end

put '/host/update/:id' do

protected!

xml = Crack::XML.parse(request.body.read)

host = {

:user => @current_user.email,

:uuid => params[:id],

:datas => xml

}

logger.info("UPDATE")

client = Gearman::Client.new(SERVERS)

taskset = Gearman::Taskset.new

#task = Gearman::Task.new('update', Marshal.dump(host), :background => true, :poll_status_interval => 1)

task = Gearman::Task.new('update', Marshal.dump(host))

task.on_complete {|d| logger.info "complete : #{d}" }

task.on_warning {|w| logger.info "[client] warn: #{w}" }

task.on_fail {|f| logger.info "[client] calculation failed : #{f}" }

taskset << task

client.run(taskset)

builder do |xml|

xml.instruct!

xml.host do

xml.status "proceed"

end

end

end

et le code du worker lancé par un script daemons

#!/usr/bin/env ruby
require 'rubygems'

gem 'mongoid', '1.9.0'
require 'mongoid'
gem 'gearman-ruby', '2.0.0'
require 'gearman'
require 'uuidtools'
require 'logger'
require 'yaml'
require 'optparse'
require "pp"

options = {}

optparse = OptionParser.new do |opts|
  opts.on('-w', '--work WORK', 'path to the work directory') do |work|
    options[:work] = work
  end
  opts.on('-m', '--mongo MONGO', 'path to the mongo file') do |mongo|
    options[:mongo] = mongo
  end
  opts.on('-e', '--env ENV', 'rails environment') do |env|
    options[:env] = env
  end
end

begin
  optparse.parse!
  mandatory = [:work, :mongo, :env]
  missing = mandatory.select{ |param| options[param].nil? }
  if not missing.empty?
    puts "Missing options: #{missing.join(', ')}"
    puts optparse
    exit
  end
rescue OptionParser::InvalidOption, OptionParser::MissingArgument
  puts $!.to_s
  puts optparse
  exit
end

puts "Performing task with options: #{options.inspect}"            

Gearman::Util.debug = true if options[:env] == "development"

servers = ['localhost:4730']
@@worker = Gearman::Worker.new(servers)

logger = Logger.new("#{options[:work]}/log/worker.log", 'daily')
logger.debug("Created logger")

File.open(File.join("#{options[:mongo]}/database.mongo.yml"), 'r') do |f|
  @settings = YAML.load(f)[options[:env]]
end

Mongoid.configure do |config|
  name = @settings["database"]
  host = @settings["host"]
  config.use_object_ids = @settings["use_object_ids"]
  logger.info "database : #{name}"
  logger.info "host : #{host}"
  config.master = Mongo::Connection.new.db(name)
end

require "#{options[:work]}/models_mongoid/user.rb"
require "#{options[:work]}/models_mongoid/profil.rb"
require "#{options[:work]}/models_mongoid/host.rb"
require "#{options[:work]}/models_mongoid/osystem.rb"
require "#{options[:work]}/models_mongoid/load_statistic.rb"
require "#{options[:work]}/models_mongoid/memory_statistic.rb"
require "#{options[:work]}/models_mongoid/uptime_statistic.rb"
require "#{options[:work]}/models_mongoid/network_statistic.rb"
require "#{options[:work]}/models_mongoid/cpu_statistic.rb" 

########## JOB ADD HOST ############
@@worker.add_ability('add') do |data,job|

  dump = Marshal.load(data)
  xml = dump[:datas]

  @current_user = User.where(:email => dump[:user]).first

  p "user = #{@current_user.inspect}"

  push_host = {
    :uuid => dump[:uuid],
    :public => xml['host']['public'],
     s_version => xml['host']['version'],
    :patch_level => xml['host']['patch_level'].nil? ? "" : xml['host']['patch_level'].downcase,
    :cpu_vendor => xml['host']['cpu_vendor'],
    :architecture => xml['host']['architecture'],
    :cpu_model => xml['host']['cpu_model'],
    :cpu_mhz => xml['host']['cpu_mhz'],
    :cpu_cache_size => xml['host']['cpu_cache_size'],
    :cpu_number => xml['host']['cpu_number'],
    :cpu_total_cores => xml['host']['cpu_total_cores'],
    :cpu_total_sockets => xml['host']['cpu_total_sockets'],
    :cpu_cores_per_socket => xml['host']['cpu_cores_per_socket'],
    :mem_ram => xml['host']['mem_ram'],
    :mem_total => xml['host']['mem_total'],
    :hostname => xml['host']['hostname'],
    :domain_name => xml['host']['domain_name'],
    :default_gateway => xml['host']['default_gateway'],
    :primary_dns => xml['host']['primary_dns'],
    :secondary_dns => xml['host']['secondary_dns'],
    :primary_interface => xml['host']['primary_interface'],
    :primary_addr => xml['host']['primary_addr'],
    :user_id => @current_user.id
  }

  host_uptime = {
    :time => xml['host']['uptime_time'],
    :days => xml['host']['uptime_days']
  }

  host_load = {
    :loadavg0 => xml['host']['loadavg0'],
    :loadavg1 => xml['host']['loadavg1'],
    :loadavg2 => xml['host']['loadavg2']
  }

  host_mem = {
    :mem_used => xml['host']['mem_used'],
    :mem_free => xml['host']['mem_free'],
    :mem_actual_free => xml['host']['mem_actual_free'],
    :mem_actual_used => xml['host']['mem_actual_used'],
    :mem_actual_free_percent => xml['host']['mem_actual_free_percent'],
    :mem_actual_used_percent => xml['host']['mem_actual_used_percent'],
    :swap_total => xml['host']['swap_total'],
    :swap_used => xml['host']['swap_used'],
    :swap_free => xml['host']['swap_free'],
    :swap_page_in => xml['host']['swap_page_in'],
    :swap_page_out => xml['host']['swap_page_out']
    }

  host_network = {
    :rx_rate => xml['host']['rx_rate'],
    :tx_rate => xml['host']['tx_rate']
  }

  host_cpu = {
    :user => xml['host']['cpu_user'],
    :sys => xml['host']['cpu_sys'],
    :nice => xml['host']['cpu_nice'],
    :idle => xml['host']['cpu_idle'],
    :wait => xml['host']['cpu_wait'],
    :irq => xml['host']['cpu_irq'],
    :soft_irq => xml['host']['cpu_soft_irq'],
    :stolen => xml['host']['cpu_stolen'],
    :combined => xml['host']['cpu_combined'],
    :total => xml['host']['cpu_total']
  }

  begin
    profil = @current_user.profils.where(:context => xml['host']['profil']).first

    if !profil
      profil = @current_user.profils.create(:context  => xml['host']['profil'])
    end

    @host = profil.hosts.create(push_host)

    osystem = Osystem.where(:vendor => xml['host']['vendor'].downcase, :vendor_version => xml['host']['vendor_version'].downcase).first

    if !osystem
      osystem = Osystem.create(
                               :name => xml['host']['name'].downcase,
                               :vendor => xml['host']['vendor'].downcase,
                               :vendor_version => xml['host']['vendor_version'].downcase,
                               :vendor_code_name => xml['host']['vendor_code_name'].nil? ? "" : xml['host']['vendor_code_name'].downcase,
                               :description => xml['host']['description'],
                                s_base => xml['host']['os_base'],
                                s_type => xml['host']['os_type']
                               )
    end

    @host.osystem_id = osystem.id
    osystem.hosts_number += 1
    osystem.save
    @host.save

    if xml['host']['activated_memory'] == "true"
      @host.memory_statistics.create(host_mem)
    end

    if xml['host']['activated_load'] == "true"
      @host.load_statistics.create(host_load)
    end

    if xml['host']['activated_uptime'] == "true"
      @host.uptime_statistics.create(host_uptime)
    end

    if xml['host']['activated_network'] == "true"
      @host.network_statistics.create(host_network)
    end

    if xml['host']['activated_cpu'] == "true"
      @host.cpu_statistics.create(host_cpu)
    end

  rescue => e
    logger.info "error on create host : #{e}"
  end

  @current_user.hosts_number += 1
  @current_user.save

logger.info "created"
end

########## JOB UPDATE HOST ############
@@worker.add_ability('update') do |data,job|

  dump = Marshal.load(data)
  xml = dump[:datas]

  @current_user = User.where(:email => dump[:user]).first
  @host = Host.where(:uuid => dump[:uuid], :blocked => false).first

  if !@host
logger.info "host unknown"

  elsif @current_user.hosts.include?(@host)
    # os = Osystem.find(:all, :conditions => "lower(name) = '#{xml['host'][:os_name].downcase}' AND lower(codename) LIKE '%#{xml['host'][:os_codename].downcase}%' AND version = '#{xml['host'][:os_release]}' AND computer_architecture = '#{xml['host'][:architecture]}'")

    host_uptime = {
      :time => xml['host']['uptime_time'],
      :days => xml['host']['uptime_days']
    }

    host_load = {
      :loadavg0 => xml['host']['loadavg0'],
      :loadavg1 => xml['host']['loadavg1'],
      :loadavg2 => xml['host']['loadavg2']
    }

    host_mem = {
      :mem_used => xml['host']['mem_used'],
      :mem_free => xml['host']['mem_free'],
      :mem_actual_free => xml['host']['mem_actual_free'],
      :mem_actual_used => xml['host']['mem_actual_used'],
      :mem_actual_free_percent => xml['host']['mem_actual_free_percent'],
      :mem_actual_used_percent => xml['host']['mem_actual_used_percent'],
      :swap_total => xml['host']['swap_total'],
      :swap_used => xml['host']['swap_used'],
      :swap_free => xml['host']['swap_free'],
      :swap_page_in => xml['host']['swap_page_in'],
      :swap_page_out => xml['host']['swap_page_out']
    }

    host_network = {
      :rx_rate => xml['host']['rx_rate'],
      :tx_rate => xml['host']['tx_rate']
    }

    host_cpu = {
      :user => xml['host']['cpu_user'],
      :sys => xml['host']['cpu_sys'],
      :nice => xml['host']['cpu_nice'],
      :idle => xml['host']['cpu_idle'],
      :wait => xml['host']['cpu_wait'],
      :irq => xml['host']['cpu_irq'],
      :soft_irq => xml['host']['cpu_soft_irq'],
      :stolen => xml['host']['cpu_stolen'],
      :combined => xml['host']['cpu_combined'],
      :total => xml['host']['cpu_total']
    }

    begin

      if xml['host']['profil'] != @host.profil.context
        profil = @current_user.profils.where(:context => xml['host']['profil']).first
        if !profil
          profil = @current_user.profils.create(:context  => xml['host']['profil'])
        end
        @host.profil = profil
        @host.save
      end

         if xml['host']['activated_memory'] == "true"
           mem = @host.memory_statistics.create(host_mem)
         end

         if xml['host']['activated_load'] == "true"
           @host.load_statistics.create(host_load)
         end

         if xml['host']['activated_uptime'] == "true"
           @host.uptime_statistics.create(host_uptime)
         end

         if xml['host']['activated_network'] == "true"
           @host.network_statistics.create(host_network)
         end

         if xml['host']['activated_cpu'] == "true"
           @host.cpu_statistics.create(host_cpu)
         end

         logger.info "updated"

    rescue => e
      logger.info "failed on update : #{e}"
      raise Exception.new("failed on update : #{e}")
    end

  else
    logger.info "unauthorized update"
    raise Exception.new("unauthorized update")
  end
end

@@worker.work

C’est alors que la lumière fut lorsque je découvris l’offre de « cloud » de StatusNet http://status.net/signup En effet nul besoin de s’auto-héberger (mon temps est précieux), cette offre me permet d’avoir mon propre sous-domaine chez status.net et de l’administrer selon mon bon vouloir, notamment de faire sauter cette stupide limitation de caractères : http://fredix.status.net/

Elle permet aussi d’héberger sa propre communauté http://status.net/whos-using-statusnet, ouverte ou pas, Mozilla ne s’en est d’ailleurs pas privé : http://mozilla.status.net/ On dépasse largement avec tout ça le peu que propose Twitter. Cependant si je souhaite des services complémentaires comme les SMS ou XMPP, Status.net va proposer ce mois-ci une offre premium ajoutant un certain nombre d’options : http://status.net/cloud (SMS, XMPP, fichiers, …) J’espère que le prix sera abordable !

Je trouve cela très intelligent de leur part, et c’est une copie du modèle de http://wordpress.com/. Un logiciel que l’on peut s’installer et héberger soit même, ou bien simplement utiliser la version gratuite, ou la version avec des options payantes. Tout cela avec la garantie de pouvoir récupérer et exploiter ses données à tout instant grâce au code libre téléchargeable.

Cette 3ème voie me semble parfaite pour les logiciels libres qui souhaitent trouver un modèle économique. Il est dommage que pas mal de libristes feignent de l’ignorer, et préfèrent sacrifier le soutient financier du libre sur l’autel de l’auto-hébergement « pure et pas minitel 2.0″ …..

J’estime d’ailleurs que certaines organisations à but non lucratif devraient s’en inspirer afin de financer leurs actions et pourquoi pas même leurs développeurs … Et bien même soyons fou pour financer le développement de services concurrentiels à Google, l’éthique et la confiance accordées à des organisations type FSF , EFF ou GNOME Foundation sont d’une valeur inestimable face à n’importe quelle entreprise suspecte par définition. Mais ceci est un autre débat

Pour terminer, en plus de status.net et wordpress.com il existe aussi l’excellent http://shapado.com/ logiciel libre de question/réponse qui propose un hébergement avec des options payantes (plutôt chères  )  : http://shapado.com/plans Voici un exemple avec un shapado consacré à android : http://android.shapado.com/

Il y a quelques mois j’ai fais l’acquisition d’un Samsung Spica, l’un des smartphone sous Android le moins cher à ce jour. J’ai profité d’une offre de reprise de mon HTC touch en windows mobile daubé, chez Rueducommerce, avec qui j’ai d’ailleurs du échanger quelques mails pour pouvoir utiliser le code promo. Petite surprise ensuite à la réception en voyant que le tel démarrait en néerlandais, problème confirmé par la doc papier. Heureusement dès la connexion réseau Android a basculé seul en français.

Bref, depuis j’attendais patiemment la mise à jour de Samsung du Spica en Android 2.1 Eclair prévue fin mars. Et là je dois dire que ca a été l’enfer. L’outil officiel de samsung, New PC Studio, est une vraie merde des années 90, mais en plus une merde en plusieurs exemplaires selon la source. 1.2 sur le CD, 1.3 sur le site FR, 1.4 sur le sous domaine ma.samsungmobile.com et enfin 1.5 béta fournie par une source sur twitter (twitter.com/SamsungFirmware). J’ai passé des heures à installer, ré-installer chaque version, et les quelques fois ou le soft NPS ne plantait pas, et où les serveurs samsung répondaient, aucune mise à jour de dispo pour mon tel ou plutôt si, une qui m’a ré-installé Android 1.5 !

Mon Spica était censé être acheté nu (sans abonnement) mais j’ai fini par en douter, car j’ai appris entre temps que cette mise à jour ne concernait que les Spica nus … Finalement j’ai fini par utiliser l’outil non officiel des mises à jour, Odin, après avoir récupéré la ROM qui va bien, quitte à perdre la garantie. A savoir afin de ne pas perdre à nouveau quelques heures (sic) qu’il est nécessaire de désactiver l’antivirus, sous peine qu’Odin ne voit pas le Spica sur l’USB ! Bonjour la Windowserie … Ah oui j’ai du faire la mise à jour sur un Windows natif car l’accès USB depuis VirtualBox a fait planter le kernel 2.6.32 de Fedora, aie. Et bien entendu l’outil ou plutôt la bouse de mise à jour NPS ne fonctionne que sur Windows, t’es sur Linux ou MacOS -> DTC. Idem pour Odin d’ailleurs, mais c’est pardonnable puisque ce n’est pas l’outil de Samsung.

Au final la 2.1 donne l’accès à certaines applications du market qui n’étaient pas disponible pour Android 1.5. Par contre pas de wallpaper animé même après en avoir installé. Sinon il est clair qu’Android est un vrai danger pour l’iPphone. Enfin un smartphone réactif (contrairement à windows mobile) avec un OS étudié pour, un market digne de ce nom, efficace et qui propose des mises à jour des logiciels installés. Bien entendu une synchronisation avec son compte Google (contacts, mails, calendrier), et la possibilité avec la 2.1 d’utiliser plusieurs comptes Google , très pratique quand son compte principal est sur Google apps car il ne donne accès qu’à un nombre restreint d’applications web Google. Et le tout en code libre.

Dans une industrie des télécoms figée, habituée à gratter les consommateurs,  Samsung essaye bien de fournir une mise à jour en trainant les pieds, mais a malgré tout sorti un nouveau modèle quasi identique en Android 2.1… J’ai d’ailleurs lu (perdu la source) que Google souhaiterait proposer lui même les mises à jour du système, évidement afin de passer outre les freins et l’incompétence des constructeurs et des opérateurs. On aurait ainsi ce que l’on vie avec bonheur depuis des années sur n’importe quel PC / Linux. On peut remercier Google pour cela, arriver à désenclaver cette industrie avec du libre, où Internet n’est pas Internet (et en plus s’en vanter).

Certes Google c’est Big Brother, boooooou, mais à défaut d’alternative équivalente (sérieuse et libre) je leur accorde ma confiance. Et d’ailleurs une telle alternative est possible puisque l’Archos utilise Android et son propre market AppsLib.

Les sources :

Le forum Frandroid dédié au Spica avec pas mal de bruits malheureusement.

Un tuto de mise à jour via Odin , j’ai par contre paramétré l’archive .tar sur « PDA » comme indiqué sur certains forums et non « One Package »

Les firmwares Android pour Spica avec l’outil Odin et un PDF de mise à jour (attention erroné puisqu’il faut appuyer sur le bouton caméra et non la touche OK pour basculer en mode mise à jour du firmware). J’ai installé le I570EXXJCF dernier à ce jour.

@SamsungFirmware le twitter du site.

J’avais bien sûr visionné des vidéos de ses conférences et lu quelques comptes rendus, aussi ai-je eu un sentiment de déjà vu tout le long de son discours qui s’est bien entendu terminé par une transformation en Saint IGNUcius.

Le discours et sa structure ne semble ne pas avoir changé depuis de nombreuses années, et son show a laissé malheureusement très peu de temps aux questions. Dommage car j’aurais voulu creuser sa position négative sur les « logiciels comme service » (Software As A Service) notamment par des entités comme la Mozilla Fondation , WordPress.com ou pourquoi pas la FSF. En effet l’avenir se dirige nettement vers ce type de services où même les systèmes d’exploitations y seront fortement liés (Google Chrome OS, JoliCloud, Android, iPhone, …) ou complètement déployé (eyeOS). Il y aura donc de moins en moins la nécessité d’installer du logiciel, libre ou pas, mais certainement d’avoir des alternatives libres et éthiques aux SaaS.

Une question a été posé sur le modèle économique du libre. Il est intéressant de constater que RMS bote en touche en répondant que c’est comme de vouloir parler du modèle économique de la Liberté. Cependant il est curieux de constater que d’un côté il refuse à imaginer un modèle économique et de l’autre il exige via la GPL que n’importe qui puisse commercialiser les logiciels libres. J’en conclu que ce qui lui importe surtout, c’est laisser la liberté aux autres, quelle qu’elle soit, même si pour lui cela revient pour lui à vendre un bol d’air.

C’est à mon avis, exactement cette contradiction qui est à l’origine du mouvement qu’il réprouve, l’OpenSource. Or même si l’OpenSource présente le logiciel libre de manière pragmatique sans tong ni barbe, ce mouvement respecte bien entendu les licences libres et a permis sans aucun doute l’implication dans le mouvement, des entreprises. A contrario il est d’autant plus curieux de constater sa tolérance envers les licences libres BSD qui pourtant autorisent l’intégration de leurs codes dans du logiciel propriétaire, l’inverse ou presque de la GPL …

Quant aux attaques envers Linus, on a grâce à lui la possibilité d’utiliser des systèmes libres depuis les années 1990, car on attend toujours le GNU Hurd …

En tous les cas, très content d’avoir pu rencontrer cet emblème vivant des logiciels libres. Très content aussi d’avoir rencontré un fan d’Amiga visiblement touché par le personnage. En tant qu’ancien fan on peut dire que cette communauté est resté active, et a fini par comprendre l’intérêt des licences libres (voir AROS et Haiku) car Libre is NOT UNIX

Pour finir  j’ai eu la chance d’acheter en avant première sa biographie autorisée et la faire dédicacer ! (voir aussi Richard Stallman à Paris – petite revue de presse)

RMS à Lyon le 13.01.2010

emacs*Background: DarkSlateGray
emacs*Foreground: Wheat
emacs*pointerColor: Orchid
emacs*cursorColor: Orchid
emacs*bitmapIcon: on
#emacs*font: -adobe-helvetica-*-r-*-*-14-*-*-*-*-*-*-*
emacs*font: -*-fixed-bold-r-*-*-15-*-*-*-*-*-*-*
emacs.geometry: 125x40

Pour compléter l’article de Nÿco je trouve qu’il manque juste une passerelle vers les salons Jabber. Cela serait tout simplement énorme qu’un salon jabber puisse être associé à un groupe Juick. On aurait ainsi tout l’historique du salon sur le groupe. Par contre il manque pour gérer cela, le support des groupes dans Juick et le fait de pouvoir poster via l’interface web. J’avais pensé à ce type de fonctionnalité pour Noumba, mais le profil des utilisateurs ne permettait pas de l’envisager. Le site est très jeune mais comme il est complètement pensé autour de Jabber cela serait stupide de ne pas implémenter les salons.

Autre surprise, le business model. Enfin un site qui ne se base pas sur la pub ! Il est nécessaire de payer 9.95$ afin de pouvoir poster plus d’une image par 24 heures. On espère le support de la vidéo bien sûr. Comme l’indique Nÿco il suffit d’envoyer l’image au bot Juick depuis son client Jabber. Par contre les proxy de transfert par défaut dans Gajim ne fonctionnent pas et j’ai du ajouter celui de jabberfr (proxy.jabberfr.org). Une fonctionnalité qui permet de remplacer imageshack !

A propos de Jabber on peut constater que cela va limiter le service aux connaisseurs. Pour y remédier il faudrait a mon avis pouvoir poster via l’interface web et ouvrir une API (UPDATE : l’API existe bien ici décrite en Russe :p , et on me signale l’existence d’un client Juick , il n’utilise pas une API mais parse simplement un XML des derniers messages, ). Quant aux tags appelés hash tags sur Twitter, ils servent à compenser l’absence flagrante des groupes. J’y vois personnellement l’intérêt que sur des termes génériques. Exemple un groupe juick au lieu d’un simple tag, par contre un tag pour définir une humeur ou décrire un média. De plus sur un groupe ou un salon à la jabber on peut y définir des droits d’accès et de multiples propriétés qu’on ne peut envisager avec un simple tag. De la même manière dans un blog les tags et les catégories sont complémentaires.

D’après Nÿco, Juick est écrit en Perl/C++ et cela se ressent à la réactivité immédiate du bot et du site. Certes le nombre d’inscrit est encore très faible, cela sera à confirmer. Je regrette juste l’aspect propriétaire du site.

Pour résumer, voilà donc un site très prometteur où l’on sent que l’auteur a un peu plus de 2 de QI, car il faut vraiment être stupide pour avoir laissé des services tiers compléter les manques flagrants de Twitter… Pour l’avenir de ce type de service, je me demande juste si Google Wave ne mettra pas tout le monde d’accord, car outre des fonctionnalités étonnantes, il sera OpenSource et permettra à chacun d’utiliser son propre serveur à la manière de Jabber.

1. WordPress fait parti des blogs les plus avancés techniquement, et il dépasse de loin le service Blogger qui ne gère toujours pas les pages et le menu par onglet sans bricoler la CSS…
2. Il est Opensource : WordPress.org
3. L’hébergement chez WordPress.com me permet de m’affranchir de l’administration et des mises à jour.
4. L’import (articles, commentaires et catégories) d’un blog Blogger en 2 clics.
5. L’export XML.
6. 3 Go d’espace disque gratuit.
7. widgets.
8. Statistiques de blog sans passer par un service tiers à la Google Analytics.
9. Leurs services payant propose le Domain mapping pour un coût extrêmement modique (9.97$ /an ce qui revient à 7.27€ /an) ce qui me permet d’utiliser mon propre domaine.
10. Le paiement via ce type de service est un excellent moyen de financer le libre. Ce dernier point est pour moi prioritaire car il est à mes yeux indispensable d’encourager les business modèles Opensource d’autant plus lorsqu’ils atteignent ce niveau de qualité technique.

Dans de précédent billets j’ai critiqué le fait que le Libre se focalisait sur le logiciel sans penser à fournir de services. J’avoue avoir sauté chez Google sans penser à regarder mon vieux compte WordPress. La faute est réparée.

Blogger a 2 avantages qui compensent le fait d’être hébergé chez le « Mal absolu » :

1. il permet d’exporter ses données au format XML
2. il permet d’utiliser son propre nom de domaine

Je blogue depuis 2004 ce qui constitue 264 articles de valeur très inégale. Ayant eu la flemme de faire un script d’export vers Blogger j’ai réinjecté manuellement quelques articles, les autres suivront peut être.

Typo reste néanmoins un excellent blog opensource. Cependant les nouvelles plateformes de micro-blogging comme Twitter ou Identi.ca poussent à limiter l’usage des blogs et les rendent moins incontournable.