Pièces détachées

Pour construire notre robot nous avons besoin des ces divers éléments :

• Ruby
• La bibliothèque Mechanize
• Un éditeur de texte, si vous êtes sous windows je vous conseille d’aller voir du côté de chez e-texteditor

Assemblage

Nous allons étudier un exemple fourni dans la documentation de Mechanize : celui qui permet d’envoyer automatiquement une image sur le site Flickr.

require 'rubygems'
require 'mechanize'
agent = WWW::Mechanize.new
 
# Page de connexion à Flickr
page  = agent.get('http://flickr.com/signin/flickr/')
 
# Remplissage du formulaire de connexion
form  = page.forms.name('flickrloginform').first
form.email = ARGV[0]
form.password = ARGV[1]
page  = agent.submit(form)
 
# Page de transfert
page  = agent.click page.links.text('Upload')
 
# Remplissage du formulaire de transfert
form  = page.forms.action('/photos_upload_process.gne').first
form.file_uploads.name('file1').first.file_name = ARGV[2]
agent.submit(form)

Rien qu’en lisant le code on arrive déjà à comprendre le fonctionnement général de cet exemple. On retrouve les classiques inclusions de bibliothèque et initialisations d’objets au début du script.

Mechanize permet d’effectuer toutes les actions que ferrait un visiteur humain sur une page web. Notre robot commence donc par ouvrir la page de connexion de Flicker en utilisant le fonction get. Puis il trouve le formulaire avec forms.name(‘nom_du_formulaire’).first et remplis chaque champs : la fonction précédente nous à retourné un objet initialisé avec tous les champs du formulaire, on peut y accéder directement. Il ne nous reste plus qu’a soumettre ce formulaire, c’est ce que fait la méthode submit, ça reviendrait à cliquer sur le bouton Get in there si on était un vrai visiteur en chair et en os.

Voila, on est connecté, pour transférer une image il faut simuler un clic sur le lien texte Upload, c’est ce que fait le morceau de script qui suit (Le agent.clic …) et remplir le nouveau formulaire, celui du transfert. On notera la fonction file_uploads qui facilite bien les choses …

Le transfert commence dès qu’on valide ce dernier formulaire.

Vous avez vu, c’est vraiment très simple. Il ne vous reste plus qu’a créer votre propre script pour automatiser vos tâches de navigation qui seraient un peut trop rébarbatives. Vous pouvez vous en servir pour exemple mettre à jour un site de façon régulière en plaçant votre script dans une tâche cron.

Lecture du flux

Commençons par ajouter les bibliothèques utilisées :

require 'rss'
require 'open-uri'

Voici un exemple de code qui va récupérer les informations dans le fichier RSS et préparer une chaine pour l’affichage :

feed_url = "http://www.url_du_flux"
output = "<h1>Lecture d'un flux RSS</h1>"
open(feed_url) do |http|
  response = http.read
  result = RSS::Parser.parse(response, false)
  output += "Titre du flux : #{result.channel.title}<br />"
  result.items.each_with_index do |item, i|
    output += "#{i+1}. #{item.title}<br />" if i < 10
  end
end

Explications :

• feed_url est bien sûr l’adresse du flux
• output est une chaine qui contiendra le code à afficher dans notre page web

On commence par lire le flux avec http.read puis on le parse avec RSS::Parser.parse, cette étape permet de transformer le flux en un objet simple d’utilisation, par exemple, pour obtenir le titre du flux, un result.channel.title suffit.

Ce n’est pas plus compliqué que ça et de plus il existe un tutoriel en anglais pour RSS Parser si vous voulez approfondir.

Mise en cache

Pourquoi pas utiliser le petit système de cache que j’ai présenté dernièrement ? Voici comment faire :

if CachedItem.check_for("RSS")
  # Disponible depuis le cache
  flux_rss = CachedItem.get_cached("RSS")
else
  feed_url = "http://www.url_du_flux..."
  open(feed_url) do |http|
    flux_rss = http.read
    flux_rss = RSS::Parser.parse(flux_rss, false)
    CachedItem.store_data("RSS", flux_rss)
  end
end

On commence par vérifier si le flux à déjà été parsé récemment et si ce n’est pas le cas, on le récupère et on le stocke dans le cache.

Je me suis inspiré d’un article de Robby pour le sujet de ce billet.

Il faut commencer par créer la table qui va stocker les données, voici les commandes sql pour mySQL :

CREATE TABLE `cached_items` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `cachekey` varchar(255) DEFAULT NULL,
  `created` datetime DEFAULT NULL,
  `expires` datetime DEFAULT NULL,
  `content` longblob,
  `cachehit` int(11) NOT NULL,
  PRIMARY KEY  (`id`),
  KEY `cacheditems_cachekey_index` (`cachekey`),
  KEY `cacheditems_created_index` (`created`),
  KEY `cacheditems_expires_index` (`expires`)
);

Ensuite, il faut créer un modèle appelé CachedItem dans app/models/cached_item.rb c’est grâce à lui qu’on pourra accéder aux données cachées :

require 'digest/sha1'
 
class CachedItem < ActiveRecord::Base
  def self.check_for(item)
    key = Digest::MD5.hexdigest(Marshal.dump(item))
    logger.info "Cache checking for key #{key}"
    self.find(:first, :conditions => ["cachekey = ? AND expires > NOW()", key])
  end
 
  def self.get_cached(item)
    key = Digest::MD5.hexdigest(Marshal.dump(item))
    logger.info "Cache getting by key #{key}"
    getc = self.find( :first, :conditions => ["cachekey = ?", key] )
    hitcount = getc.cachehit + 1
    self.update(getc.id, {:cachehit => hitcount})
    self.delete_all "expires < NOW()"  # Efface les données trop vieilles
    return Marshal.load(getc.content)
 end
 
  def self.store_data(item, data)
    key = Digest::MD5.hexdigest(Marshal.dump(item))
    logger.info "%%% storing by key #{key}"
    content = Marshal.dump(data)
    logger.level = (4) # Empêche d'afficher les données de Marshal dans le log
    ci = new()
    ci.cachekey = key
    ci.created = Time.now()
    ci.expires = 30.minutes.from_now() # durée de vie de la donnée cachée
    ci.content = content
    ci.cachehit = 0
    ci.save
    return data
  end
end

Voila, le plus dur est fait. Faites attention au type de données que vous stockez, Marshal ne supporte pas tous les types. Vous pouvez sans problème stocker une chaîne, par exemple pour du XML vous pouvez faire :

donnees = REXML::Document.new(mes_donnees_xml).root
CachedItem.store_data(donnees_id, donnees.to_s)

Pour stoker des donnes xml. Pour les relire :

donnees = REXML::Document.new(CachedItem.get_cached(mes_donnees_xml_id)).root

Les données trop vieilles sont automatiquement effacée lors d’une lecture quelconque (voir get_cached) et la durée de vie d’une donnée est définie lors de l’écriture dans store_data.

Merci à joeldg pour son code qui a servi de base à ce billet.