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

Le premier RubyCamp s’est bien déroulé ce samedi. Je remercie Damien Mathieu pour l’organisation et O2Sources pour avoir sponsorisé l’évènement avec des pizzas .

Quelques Suisses avaient fait le trajet, Jean-Michel Garnier un expatrié en Espagne que j’avais déjà vu à Paris on Rails présentait cucumber. Guillaume Cottenceau (ancien développeur de frozen bubble) a présenté Ruby/GTK+. Damien a présenté Ruby et Gaspard Bucher un impressionnant compilateur de template (zafu).

Pour un premier Barcamp à Lyon j’ai trouvé ça très réussi et on est tous d’accord pour remettre ça cette année. Toutes les infos sur le wiki RubyCampLyon.

Photos et photos

Je n’avais pas posté depuis 2 mois, donc puisqu’on est encore en janvier jusqu’à ce soir, je vous souhaite une bonne année

Comme l’indique le titre il va y avoir un Barcamp à Lyon le 21 février consacré à Ruby. Je viens de m’y inscrire, et même si je n’ai aucune idée de ce que je pourrais présenter cela sera l’occasion de revoir ce bon vieux Guillaume Desrat ainsi que Lucas Bonnet

Avec de la chance j’aurais peut être avancé un peu sur mon projet perso en Rails, et aurais 2-3 trucs à dire… En tout cas ça serait bien que ce genre de réunion soit récurrente, car c’est très frustrant de voir régulièrement des actions à Paris et rien à Lyon.

Si vous suivez l’actualité RubyonRails, vous savez sans doute que l’édition 2008 de Paris on Rails a lieu le 1er décembre à la Cité des sciences. Par contre vous ne savez peut être pas qu’une Rails party est organisé la vieille ce dimanche 30 novembre. Toutes les infos ici : rails party 2008 et inscription ici. Ils ont bien de la chance ces parisiens ! Quand est-ce que Lyon sera à la hauteur de sa dimension … ?

Pour enchainer sur le thème Ruby, j’ai réalisé une nouvelle et sans doute dernière version de Geekast 0.1.3 afin de fixer ce bug. Peercast n’étant plus maintenu par son développeur la motivation n’y est plus et je suis de plus en apprentissage du C++ sur iMotion un autre projet perso. Quoi qu’il en soit je ne compte pas abandonner Ruby qui est un vrai plaisir à utiliser et complémentaire à un langage compilé.

Je viens de publier un article en 2 parties sur le blog d’AF83 :

De la répartition de charge en Ruby on Rails 1/2

De la répartition de charge en Ruby on Rails 2/2

C’est plutôt technique, et présente une solution parmi tant d’autres dans ce domaine très particulier.

Et voilà le petit vient de naître. J’ai le grand plaisir d’annoncer la naissance officielle du site web RubyFrance.

Ce site utilise RadiantCMS, Mongrel, Apache2 et PostgreSQL Que du bon

Bien sûr pour l’instant le site est vide mais il se remplira à mesure. J’espère que nous aurons quelque chose de présentable lors de Paris on Rails.

Comments

1. jean-mi a dit 24 minutes later:
   

   Oui enfin, que ce instiki disparaisse à jamais dans les flammes de l’enfer.

   DHH devait avoir trop bu après avoir fêté la release de rails.

2. fredix a dit 29 minutes later:
   

   C’est clair, entre Instiki et Hiki on en a bavé.

Geekast est sur le site de Gstreamer dans la liste des applications l’utilisant : http://gstreamer.freedesktop.org/apps/

Je suis tout intimidé du coup

En ces périodes festives j’ai décidé de m’offrir un nouveau blog.

Cette démarche entre pleinement dans mon investissement sur le langage Ruby. En effet je souhaite utiliser au maximum les outils utilisant Ruby.

Typo répond à ce critère et est de plus un excellent blog (AJAXisé pour ceux qui aiment). De plus un concours a permit à un grand nombre de thèmes de voir le jour. N’hésitez pas à les consulter sur typogarden, voir également le blog du développeur

Enfin ceux ayant déjà un blog sur dotclear peuvent essayer le script de migration vers typo que j’ai déposé sur Rubyfr. Il est plutôt gruik, mais pour un one shot cela me va très bien, cependant n’hésitez pas à l’améliorer.

RAD : Rapid Application Development

En général lorsque l’on parle de RAD, on pense souvent à Windev ou Visual Basic qui ont des modules RAD. Et bien entendu on pense à application générée, obligatoirement mal faite et aux possibilités d’évolution nulle. Bref RAD veut dire souvent soft poubelle.

Sous Linux il est possible d’arriver à quelque chose proche du RAD avec les outils existant. Ici cela veut dire le tryptique Glade, libglade et Ruby. Pas de Windowserie à la Kylix donc, rien que du standard respectant les us et coutumes Linuxiennes.

Un petit script magique apporte à ce trio la génération du code nécessaire permettant de faire du RAD : ruby-glade-create-template (qui fait parti du paquet libglade2-ruby). Il suffit de fournir au script le fichier xml de votre projet Glade pour qu’il génère un fichier Ruby utilisant la libglade. Il ne vous reste plus qu’à coder les fonctions de callback.
Grâce à la libglade le code reste très court et simple à comprendre. Bien sûr à chaque modification de votre interface avec Glade il faudra régénérer le code, donc sauver avant vos fonctions de callback. Mais c’est un excellent début pour apprendre le développement en Ruby/GTK+ ou simplement créer une petite application.

Mais laissons place à une excellente démonstration en flash qui, cerise sur le gateau, montre comment intégrer le moteur gecko en quelques lignes de Ruby : RubyZilla