• L'envoi de mails, qu'on utilise souvent lorsque le joueur s'inscrit, pour notifier à un joueur qu'il a reçu un message privé, pour annoncer à tous les joueurs une nouveauté majeur, etc.
  
  
• L'envoi de requêtes HTTP, pour envoyer un fichier sur Amazon S3, récupérer les informations Facebook d'un membre, etc.
  
  
• Le traitement d'images, pour générer un avatar, réduire la taille d'une image, etc.
  
  

• Le déclenchement d'événements comme les changements de tour, la distribution de ressources, etc.
  
  
• Les tâches de maintenance, comme le rafraîchissement des caches, l'actualisation des pages de classement, la suppression des comptes inactifs.
  
  
• La planification de tâches, comme la publication de news écrites à l'avance.
  
  

class Game < ActiveRecord::Base

  # ...

 

  # Assign territories and set the limit time.

  def start_deployment!

    update_attributes!(state: Game:EPLOYMENT, deployment_finish_at: 24.hours.from_now)

    dispatch_territories!(Territory.all.shuffle, participations.shuffle)

 

    job = FinishDeploymentJob.new(id)                       # On instancie notre tâche.

    Delayed::Job.enqueue(job, run_at: deployment_finish_at) # On la planifie.

  end

end

class FinishDeploymentJob

  attr_reader :game_id

 

  # Constructeur de l'objet, on s'en sert pour donner des informations.

  # L'objet sera serialisé, qu'on puisse accéder à ces informations lors

  # de l'exécution.

  def initialize(game_id)

    @game_id = game_id

  end

 

 

  # Corps de la tâche. C'est là que ça se passe !

  def perform

    game = Game.find(game_id)

    game.update_attribute(tate, Game::RUNNING)

 

    mail = GameNotifier.notify_game_start(game)

    mail.deliver

  end

 

 

  # On peut même configurer des callbacks qui seront appelés à différents moments

  # du cycle de vie de la tâche. Ce n'est bien sûr pas obligatoire.

 

  # Appelé avant l'exécution de la tâche.

  def before(job)

  end

 

  # Appelé après l'exécution de la tâche, qu'elle réussie ou échoue.

  def after(job)

  end

 

  # Appelé si la tâche est exécutée correctement.

  def success(job)

  end

 

  # Appelé si une exception survient pendant l'exécution de la tâche.

  def error(job, exception)

  end

 

  # Appelé si la tâche échoue.

  def failure

  end

end

$ rake jobs:work

class GamesController < ApplicationController

  before_filter :check_if_turn_must_change

 

  def show

    # ...

  end

 

 

  protected

 

  def check_if_turn_must_change

    @game = Game.find(params[:id])

    @game.next_turn! if @game.turn_finish_at.past?

  end

end

class GamesController < ApplicationController

  before_filter :check_if_active_player_is_still_active

 

  def show

    # ...

  end

 

  def check_turn

    response = { change_turn: @change_turn }

 

    if @change_turn

      response[:active_player] = @game.active_player

    end

 

    render json: response

  end

 

 

  protected

 

  def check_if_active_player_is_still_active

    @game        = Game.find(params[:id])

    @change_turn = @game.turn_finish_at.past?

 

    @game.next_turn! if @change_turn

  end

end

checkTurn = function(){

  var url = '/game/42/check_turn';

  $.get(url, function(data){

    if(data.change_turn) visuallyChangeActivePlayer(data.active_player);

  });

}

setInterval(checkTurn, 10 * 1000);

• Pas de tests inutiles au chargement des pages ;
  
  
• Le serveur ne reçoit aucune requête inutile ;
  
  
• Les opérations lourdes sont effectuées en dehors des requêtes ;
  
  

class GamesController < ApplicationController

  def show

    @game = Game.find(params[:id])

  end

end

 

 

class Game

  def next_turn!

    next_turn_at = 8.hours.from_now

 

    # La méthode next_active_player retourne… Le prochain joueur actif !

    update_attribute(:active_player, next_active_player)

 

    # On envoie les informations aux navigateurs grâce au push.

    data = { next_turn_at:  next_turn_at, active_player: active_player }

    Push.publish("games/#{id}/change_turn", data)

 

    # On planifie une tâche qui sera exécutée à la date du prochain tour (comme par hasard !).

    Delayed::Job.enqueue(ChangeTurnJob.new(id), run_at: next_turn_at)

  end

end

 

 

class ChangeTurnJob

  def initialize(game_id)

    @game_id = game_id

  end

 

  def perform

    Game.find(@game_id).next_turn!

  end

end

Push.subscribe("/games/42/change_turn", function(data){

  visuallyChangeActivePlayer(data.active_player);

});