Comment démarrer la tâche de rake delta rake de Sphinx à partir du script de déploiement?

Question

J'ai une configuration de Thinking Sphinx et je travaille, mais j'ai un problème pour démarrer les tâches de Rake Delayed Job pendant le déploiement.

je la tâche suivante dans deploy.rb qui semble exécuter, mais les emplois en retard ne sont pas traités - ils empilent jusqu'à ce que je lance rake ts: dd de la ligne de commande du serveur:

namespace :thinkingsphinx do 
    desc 'Start Delayed Job Sphinx delta indexing' 
    task :dd do 
    run "cd #{current_path} && rake ts:dd RAILS_ENV=#{rails_env} &" 
    end 
end 

Comment puis-je obtenir les travaux retardés pour démarrer à partir du script de déploiement?

Merci

Simon

Answer 1

Le link Florian fourni a le code par Amit Solanki ça marche!

Voici ce que je fait pour que cela fonctionne avec Capistrano:

gemmes Installer

• ts-delayed-delta
• daemon_generator
• whenever

Créer un fichier appelé script/delayed_delta avec le contenu:

#!/usr/bin/env ruby 
require 'rubygems' 
require 'daemons' 
dir = File.expand_path(File.join(File.dirname(__FILE__), '..')) 

daemon_options = { 
    :multiple => false, 
    :dir_mode => :normal, 
    :dir => File.join(dir, 'tmp', 'pids'), 
    :backtrace => true 
} 
puts 'delayed_delta' 

Daemons.run_proc('job_runner', daemon_options) do 
    if ARGV.include?('--') 
    ARGV.slice! 0..ARGV.index('--') 
    else 
    ARGV.clear 
    end 

    Dir.chdir dir 
    RAILS_ENV = ARGV.first || ENV['RAILS_ENV'] || 'development' 
    require File.join('config', 'environment') 

    Delayed::Worker.new(
    :min_priority => ENV['MIN_PRIORITY'], 
    :max_priority => ENV['MAX_PRIORITY'] 
).start 
end 

Configurer Capistrano

Capistrano doit commencer Sphinx et job_runner (avec notre script/delayed_delta).

Ajouter quelque chose comme ceci à la deploy.rb:

deploy.task :restart, :roles => :app do 
    run "export RAILS_ENV=production && cd #{deploy_to}/current && /usr/bin/rake ts:rebuild" 
    run "export RAILS_ENV=production && cd #{current_path} && /usr/bin/ruby script/delayed_delta start" 
end 

Configurer whenever petit bijou

Dans vos config/schedule.rb ajouter des lignes pour mettre à jour l'index Sphinx et commencer à job_runner si elle est pas déjà en cours d'exécution

every 30.minutes do 
    command "export RAILS_ENV=production && cd /path/to/rails/production && /usr/bin/rake ts:index && /usr/bin/ruby script/delayed_delta start" 
end 

Cela est converti en un crontab qui est exécuté toutes les 30 minutes pour mettre à jour Sphinx

Notes finales et leçons apprises

• Le script/delayed_delta utilise le daemon_generator joyau pour démarrer le job_runner script de travailleur de fond. Cela équivaut à exécuter rake thinking_sphinx:delayed_deltas sur la console, mais persistant.

• Assurez-vous que seul job_runner ou processus rake thinking_sphinx:delayed_deltas est en cours à un moment

• Laissez Capistrano commencer les deux Sphinx (râteau ts: reconstruction) et script/delayed_delta. J'ai eu un problème lorsque j'ai commencé sphinx et delayed_deltas de différents utilisateurs ou différents environnements

Answer 2

je mettrais votre tâche delayed_job dans un script séparé et l'exécuter à partir Cron ou l'ont commencé/surveillé par votre outil de surveillance de choix (par exemple, monit). Votre script de déploiement peut simplement le tuer pour s'assurer qu'il redémarre à chaque fois (killall job_runner). Voici le script que j'utilise:

 
#!/usr/bin/env ruby 
## this script is for making sure and delayed_jobs get run 
## it is used by thinking sphinx 
require File.dirname(__FILE__) + '/../config/environment' 

# you can also put the definition of this in config/environments/*.rb so it's different for test, production and development 
JobRunnerPidFile = "#{RAILS_ROOT}/tmp/pids/job_runner.pid" 

if File.exists?(JobRunnerPidFile) 
    old_pid = File.read(JobRunnerPidFile).to_i 
    begin 
    if Process.getpgid(old_pid) > 0 
     # still running, let's exit silently... 
     exit(0) 
    end 
    rescue 
    # looks like nothing is running, so let's carry on 
    end 
end 

File.open(JobRunnerPidFile, "w") {|f| f.write "#{$$}\n" } 

Delayed::Worker.new.start 

Answer 3

Ce lien sera utile pour tous ceux qui ont besoin de redémarrer la tâche de râteau delayed_delta à partir du script deploy:

http://amitsolanki.com/2010/04/running-delayed-delta-daemon-in-background-for-thinking-sphinx/#comment-5802