resque-integration 3.4.1

data/README.md

@@ -0,0 +1,281 @@
+# Resque::Integration
+
+<a href="http://dolly.railsc.ru/projects/47/builds/latest/?ref=master"><img src="http://dolly.railsc.ru/badges/abak-press/resque-integration/master" height=18 /></a>
+
+Интеграция Resque в Rails-приложения с поддержкой следующих плагинов:
+* [resque-progress](https://github.com/idris/resque-progress)
+* [resque-lock](https://github.com/defunkt/resque-lock)
+* [resque-multi-job-forks](https://github.com/stulentsev/resque-multi-job-forks)
+* [resque-failed-job-mailer](https://github.com/anandagrawal84/resque_failed_job_mailer)
+* [resque-scheduler](https://github.com/resque/resque-scheduler)
+* [resque-retry](https://github.com/lantins/resque-retry)
+
+Этот гем существует затем, чтобы избежать повторения чужих ошибок и сократить время, необходимое для включения resque в проект.
+
+## Установка
+
+Добавьте в `Gemfile`:
+```ruby
+gem 'resque-integration'
+```
+
+Добавьте в `config/routes.rb`:
+```ruby
+mount Resque::Integration::Application => "/_job_", :as => "job_status"
+```
+
+Вместо `_job_` можно прописать любой другой адрес. По этому адресу прогресс-бар будет узнавать о состоянии джоба.
+
+Если вы до сих пор не используете sprockets, то сделайте что-то вроде этого:
+```bash
+$ rails generate resque:integration:install
+```
+(результат не гарантирован, т.к. не тестировалось)
+
+## Задачи
+
+Создайте файл `app/jobs/resque_job_test.rb`:
+```ruby
+class ResqueJobTest
+  include Resque::Integration
+
+  # это название очереди, в которой будет выполняться джоб
+  queue :my_queue
+
+  # с помощью unique можно указать, что задача является уникальной, и какие аргументы определяют уникальность задачи.
+  # в данном случае не может быть двух одновременных задач ResqueJobTest с одинаковым первым аргументом
+  # (второй аргумент может быть любым)
+  unique { |id, description| [id] }
+
+  # В отличие от обычных джобов resque, надо определять метод execute.
+  #
+  # Либо же вы можете определить метод perform, но первым аргументом должен быть указан meta_id (уникальный ID джоба):
+  #   def self.perform(meta_id, id, description)
+  #     ...
+  #   end
+  def self.execute(id, description)
+    (1..100).each do |t|
+      at(t, 100, "Processing #{id}: at #{t} of 100")
+      sleep 0.5
+    end
+  end
+end
+```
+
+### Перезапуск задачи
+
+Допустим, у вас есть очень длинная задача и вы не хотите, чтобы возникло переполнение очереди (или памяти). Тогда можно выполнить часть задачи, а потом заново поставить задачу в очередь.
+```ruby
+class ResqueJobTest
+  include Resque::Integration
+
+  unique
+  continuous # теперь вы можете перезапускать задачу
+
+  def self.execute(company_id)
+    products = company.products.where('updated_at < ?', 1.day.ago)
+
+    products.limit(1000).each do |product|
+      product.touch
+    end
+
+    # В очередь поставится задача с теми же аргументами, что и текущая.
+    # Можно передать другие аргументы: `continue(another_argument)`
+    continue if products.count > 0
+  end
+end
+```
+
+Такая задача будет выполняться по частям, не потребляя много памяти. Еще один плюс: другие задачи из очереди тоже смогут выполниться.
+ОПАСНО! Избегайте бесконечных циклов, т.к. это в некотором роде "рекурсия".
+
+## Конфигурация воркеров resque
+
+Создайте файл `config/resque.yml` с несколькими секциями:
+```yaml
+# конфигурация redis
+# секция не обязательная, вы сами можете настроить подключение через Resque.redis = Redis.new
+redis:
+  host: bz-redis
+  port: 6379
+  namespace: blizko
+
+resque:
+  interval: 5 # частота, с которой resque берет задачи из очереди в секундах (по умолчанию 5)
+  verbosity: 1 # "шумность" логера (0 - ничего не пишет, 1 - пишет о начале/конце задачи, 2 - пишет все)
+  root: "/home/pc/current" # (production) абсолютный путь до корня проекта
+  log_file: "/home/pc/static/pulscen/local/log/resque.log" # (production) абсолютный путь до лога
+  config_file: "/home/pc/static/pulscen/local/log/resque.god" # (production) абсолютный путь до кофига god
+  pids: "/home/pc/static/pulscen/local/pids" # (production) абсолютный путь до папки с пид файлами
+
+# переменные окружения, которые надобно передавать в resque
+env:
+  RUBY_HEAP_MIN_SLOTS: 2500000
+  RUBY_HEAP_SLOTS_INCREMENT: 1000000
+  RUBY_HEAP_SLOTS_GROWTH_FACTOR: 1
+  RUBY_GC_MALLOC_LIMIT: 50000000
+
+# конфигурация воркеров (названия воркеров являются названиями очередей)
+workers:
+  kirby: 2 # 2 воркера в очереди kirby
+  images:
+    count: 8 # 8 воркеров в очереди images
+    jobs_per_fork: 250 # каждый воркер обрабатывает 250 задач прежде, чем форкается заново
+    minutes_per_fork: 30 # альтернатива предыдущей настройке - сколько минут должен работать воркер, прежде чем форкнуться заново
+    stop_timeout: 5 # максимальное время, отпущенное воркеру для остановки/рестарта
+    env: # переменные окружение, специфичные для данного воркера
+      RUBY_HEAP_SLOTS_GROWTH_FACTOR: 0.5
+  'companies,images': 2 # совмещённая очередь, приоритет будет у companies
+  'xls,yml':
+    shuffle: true # совмещённая очередь, приоритета не будет
+
+# конфигурация failure-бэкэндов
+failure:
+  # конфигурация отправщика отчетов об ошибках
+  notifier:
+    enabled: true
+    # адреса, на которые надо посылать уведомления об ошибках
+    to: [teamlead@apress.ru, pm@apress.ru, programmer@apress.ru]
+    # необязательные настройки
+    # от какого адреса слать
+    from: no-reply@blizko.ru
+    # включать в письмо payload (аргументы, с которыми вызвана задача)
+    include_payload: true
+    # класс отправщика (должен быть наследником ActionMailer::Base, по умолчанию ResqueFailedJobMailer::Mailer
+    mailer: "Blizko::ResqueMailer"
+    # метод, который вызывается у отправщика (по умолчанию alert)
+    mail: alert
+```
+
+Обратите внимание на параметр `stop_timeout` в секции конфигурирования воркеров.
+Это очень важный параметр. По умолчанию воркеру отводится всего 10 секунд на то,
+чтобы остановиться. Если воркер не укладывается в это время, супервизор (мы используем
+[god](http://godrb.com/)) посылает воркеру сигнал `KILL`, который "прибьет" задачу.
+Если у вас есть длинные задачи (навроде импорта из XML), то для таких воркеров
+лучше ставить `stop_timeout` побольше.
+
+Для разработки можно (и нужно) создать файл `config/resque.local.yml`, в котором можно переопределить любые параметры:
+```yaml
+redis:
+  host: localhost
+  port: 6379
+
+resque:
+  verbosity: 2
+
+workers:
+  '*': 1
+```
+
+## Запуск воркеров
+
+Ручной запуск воркера (см. [официальную документацию resque](https://github.com/resque/resque/blob/1-x-stable/README.markdown))
+```bash
+$ QUEUE=* rake resque:work
+```
+
+Запуск всех воркеров так, как они сконфигурированы в `config/resque.yml`:
+```bash
+$ rake resque:start
+```
+
+Останов всех воркеров:
+```bash
+$ rake resque:stop
+```
+
+Перезапуск воркеров:
+```bash
+$ rake resque:restart
+```
+
+## Постановка задач в очередь
+
+### Для задач, в который включен модуль `Resque::Integration`
+```ruby
+meta = ResqueJobTest.enqueue(id=2)
+@job_id = meta.meta_id
+```
+
+Вот так можно показать прогресс-бар:
+```haml
+%div#progressbar
+
+:javascript
+  $('#progressbar').progressBar({
+    url: #{job_status_path.to_json}, // адрес джоб-бэкенда (определяется в ваших маршрутах)
+    pid: #{@job_id.to_json}, // job id
+    interval: 1100, // частота опроса джоб-бэкэнда в миллисекундах
+    text: "Initializing" // initializing text appears on progress bar when job is already queued but not started yet
+  }).show();
+```
+
+### Для обычных задач Resque
+```ruby
+Resque.enqueue(ImageProcessingJob, id=2)
+```
+
+## Resque Scheduler
+
+Расписание для cron-like заданий должно храниться здесь `config/resque_schedule.yml`
+
+## Resque Retry
+
+В силу несовместимостей почти всех плагинов с resque-meta (unique основан на нём) - объявить задание перезапускаемым
+в случае ошибки нужно ДО `unique`
+
+```ruby
+class ResqueJobTest
+  include Resque::Integration
+
+  retrys delay: 10, limit: 2
+  unique
+end
+```
+
+## Resque Multi Job Forks
+
+```yaml
+workers:
+  'high':
+    count: 1
+    jobs_per_fork: 10
+```
+
+## Resque Ordered
+
+Уникальный по каким-то параметрам джоб может выполняться в одно и тоже время только на одном из воркеров
+
+```ruby
+class ResqueJobTest
+  include Resque::Integration
+
+  unique { |company_id, param1| [company_id] }
+  ordered max_iterations: 20 # max_iterations - сколько раз запустится метод `execute` с аргументами в очереди,
+                             # прежде чем джоб перепоставится
+
+  def self.execute(ordered_meta, company_id, param1)
+    heavy_lifting_work
+  end
+end
+```
+
+При необходимости, можно добиться уникальности упорядоченных джобов, указав параметры в опции `unique`
+
+```ruby
+class UniqueOrderedJob
+  include Resque::Integration
+
+  unique { |company_id, param1| [company_id] }
+  ordered max_iterations: 10, unique: ->(_company_id, param1) { [param1] }
+  ...
+end
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/abak-press/resque-integration/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/app/assets/javascripts/standalone/progress_bar.js

@@ -0,0 +1,47 @@
+//модуль для показа прогресс-бара создания отчетов
+
+app.modules.progressBar = (function(self) {
+
+  function _requestError(data) {
+    var payload = data.payload;
+
+    if (app.config.progressBar.documentLocationError) {
+      alert('Ошибка');
+      location.href = app.config.progressBar.documentLocationError;
+    }
+
+    if (payload && payload.error_messages) {
+      $('.js-pberrors').html(payload.error_messages.join('<br>'));
+    }
+  }
+
+  function _requestSuccess(data) {
+    var
+      progress = data.progress;
+
+    if (progress && progress.message) {
+      $('.js-pbstat').text(progress.num + ' из ' + progress.total + ' (' + Math.round(progress.percent) + '%)');
+    }
+  }
+
+  function _init() {
+    $('.js-progressbar').progressBar({
+      url: app.config.progressBar.url,
+      pid: app.config.progressBar.pid,
+      onSuccess: function() {
+        location.href = app.config.progressBar.documentLocation;
+      },
+      onError: function(data) {
+        _requestError(data);
+      },
+      onRequestSuccess: function(data) {
+        _requestSuccess(data);
+      }
+    });
+  }
+
+  self.load = function() {
+    _init();
+  };
+  return self;
+}(app.modules.progressBar || {}));

data/app/controllers/resque/jobs_controller.rb

@@ -0,0 +1,42 @@
+module Resque
+  class JobsController < ActionController::Metal
+    include ActionController::ConditionalGet
+
+    JOB_ID_PATTERN = /([a-f0-9]{32})/
+
+    def show
+      unless meta
+        self.status = 404
+        self.content_type = "application/json; charset=utf-8"
+        self.response_body = '{"message":"not found"}'
+        return
+      end
+
+      data = {
+        enqueued_at: meta.enqueued_at,
+        started_at: meta.started_at,
+        finished_at: meta.finished_at,
+        succeeded: meta.succeeded?,
+        failed: meta.failed?,
+        progress: meta.progress,
+        payload: meta['payload']
+      }
+
+      self.status = 200
+      self.content_type = "application/json; charset=utf-8"
+      self.response_body = MultiJson.dump(data)
+      expires_now
+    end
+
+    private
+
+    def meta
+      @meta ||= Resque::Plugins::Meta.get_meta(meta_id) if meta_id
+    end
+
+    def meta_id
+      id = params[:id]
+      id if JOB_ID_PATTERN =~ id
+    end
+  end
+end

data/app/controllers/resque/queues/info_controller.rb

@@ -0,0 +1,9 @@
+module Resque
+  module Queues
+    class InfoController < ActionController::Metal
+      def show
+        self.response_body = {data: Resque.queues_info.data}.to_json
+      end
+    end
+  end
+end

data/app/controllers/resque/queues/status_controller.rb

@@ -0,0 +1,38 @@
+module Resque
+  module Queues
+    class StatusController < ActionController::Metal
+      def show
+        request = params.fetch('request')
+        self.response_body =
+          case request
+          when 'age'
+            age(params['queue'])
+          when 'size'
+            size(params['queue'])
+          when 'failures_count'
+            Resque.queues_info.failures_count_for_queue(params['queue'])
+          when 'threshold_size'
+            Resque.queues_info.threshold_size(params.fetch('queue'))
+          when 'threshold_age'
+            Resque.queues_info.threshold_age(params.fetch('queue'))
+          when /^threshold_failures_per_(?<period>\w+)$/
+            Resque.queues_info.threshold_failures_count(params.fetch('queue'), $LAST_MATCH_INFO['period'])
+          when 'channel'
+            Resque.queues_info.channel(params.fetch('queue'))
+          else
+            0
+          end.to_s
+      end
+
+      private
+
+      def age(queue)
+        queue ? Resque.queues_info.age_for_queue(queue) : Resque.queues_info.age_overall
+      end
+
+      def size(queue)
+        queue ? Resque.queues_info.size_for_queue(queue) : Resque.queues_info.size_overall
+      end
+    end
+  end
+end

data/app/views/shared/job_progress_bar.html.haml

@@ -0,0 +1,17 @@
+- content_for :javascripts_bottom do
+  = javascript_include_tag 'standalone/progress_bar', :defer => true
+
+#progress
+  .progressbar.js-progressbar
+  #pbstat.js-pbstat
+    #pberrors.pberrors.js-pberrors
+- if @back_url.present?
+  = link_to 'Закрыть', @back_url
+
+:javascript
+  app.config.progressBar = {
+    url: #{job_status_path(domain: :current).to_json},
+    pid: #{@job_id.to_json},
+    documentLocation: #{@success_url.to_json},
+    documentLocationError: #{@error_url ? @error_url.to_json : nil.to_json}
+  };

data/bin/resque-status

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'redis'
+require 'resque'
+require 'active_support/core_ext/hash/slice'
+require 'active_support/time'
+
+options = {}
+
+opt_parser = OptionParser.new do |opt|
+  opt.banner = 'Usage: resque-status [OPTIONS]'
+  opt.separator ''
+  opt.separator 'Resque Status Tool'
+  opt.separator ''
+
+  opt.separator 'Options:'
+
+  opt.on('-k', '--key [KEY]', 'resque info key, default pending') do |value|
+    options[:key] = value
+  end
+
+  opt.on('-h', '--host HOST', 'redis host') do |value|
+    options[:host] = value
+  end
+
+  opt.on('-p', '--port PORT', 'redis port') do |value|
+    options[:port] = value
+  end
+
+  opt.on('-n', '--namespace NAMESPACE', 'redis namespace') do |value|
+    options[:namespace] = value
+  end
+
+  opt.on('--help', 'help') do
+    puts opt_parser
+    exit
+  end
+end
+
+opt_parser.parse!
+
+Resque.redis = Redis.new(options.slice(:host, :port))
+Resque.redis.namespace = options.fetch(:namespace)
+
+info = Resque.info
+key = options.fetch(:key, :pending).to_sym
+
+if info.key?(key)
+  puts info[key]
+elsif key == :oldest
+  # oldest job work time in seconds
+  workers = Resque.workers
+  jobs = workers.map(&:job)
+  worker_jobs = workers.zip(jobs).reject { |w, j| w.idle? || j['queue'].nil? }
+  puts worker_jobs.map { |_, job| (Time.now.utc - DateTime.strptime(job['run_at'] ,'%Y-%m-%dT%H:%M:%S').utc).to_i }.max || 'null'
+else
+  $stderr.puts "Unknown key. Should be one of the [#{info.keys.join(', ')}]"
+end

data/config/routes.rb

@@ -0,0 +1,13 @@
+Rails.application.routes.draw do
+  namespace :resque do
+    namespace :queues do
+      resource :info, only: :show, controller: :info
+      resource :status, only: :show, controller: :status
+    end
+  end
+
+  get "#{Rails.application.config.resque_job_status.fetch(:route_path)}(/:id)",
+      to: 'resque/jobs#show',
+      as: 'job_status',
+      constraints: ::Rails.application.config.resque_job_status.fetch(:route_constraints)
+end

data/config.ru

@@ -0,0 +1,9 @@
+# coding: utf-8
+require "rubygems"
+require "bundler"
+
+Bundler.setup
+
+require "resque/integration/application"
+
+run Resque::Integration::Application

data/dip.yml

@@ -0,0 +1,44 @@
+version: '1'
+
+environment:
+  DOCKER_RUBY_VERSION: '2.2'
+  RUBY_IMAGE_TAG: 2.2-latest
+  COMPOSE_FILE_EXT: development
+  RAILS_ENV: test
+  APRESS_GEMS_CREDENTIALS: ""
+
+compose:
+  files:
+    - docker-compose.yml
+    - docker-compose.${COMPOSE_FILE_EXT}.yml
+
+interaction:
+  sh:
+    service: app
+
+  irb:
+    service: app
+    command: irb
+
+  bundle:
+    service: app
+    command: bundle
+
+  appraisal:
+    service: app
+    command: bundle exec appraisal
+
+  rspec:
+    service: app
+    command: bundle exec appraisal bundle exec rspec
+
+  clean:
+    service: app
+    command: rm -f Gemfile.lock gemfiles/*.gemfile.*
+
+provision:
+  - docker volume create --name bundler_data
+  - dip bundle config --local https://gems.railsc.ru/ ${APRESS_GEMS_CREDENTIALS}
+  - dip clean
+  - dip bundle install
+  - dip appraisal install

data/docker-compose.development.yml

@@ -0,0 +1,12 @@
+version: '2'
+
+services:
+  app:
+    volumes:
+      - ../:/localgems
+      - bundler-data:/bundle
+
+volumes:
+  bundler-data:
+    external:
+      name: bundler_data

data/docker-compose.drone.yml

@@ -0,0 +1,6 @@
+version: '2'
+
+services:
+  app:
+    volumes:
+      - /bundle:/bundle

data/docker-compose.yml

@@ -0,0 +1,10 @@
+version: '2'
+
+services:
+  app:
+    image: abakpress/ruby-app:$RUBY_IMAGE_TAG
+    environment:
+      - BUNDLE_PATH=/bundle/$DOCKER_RUBY_VERSION
+    command: bash
+    volumes:
+      - .:/app

data/lib/generators/resque/integration/install/install_generator.rb

@@ -0,0 +1,38 @@
+require 'rails'
+
+# Supply generator for Rails 3.0.x or if asset pipeline is not enabled
+if !defined?(Sprockets) || !::Rails.application.config.assets.enabled
+  module Resque::Integration
+    module Generators
+      class InstallGenerator < ::Rails::Generators::Base
+
+        desc "This generator installs resque-integration (#{Resque::Integration::VERSION}) assets"
+        source_root File.expand_path('../../../../../../vendor/assets', __FILE__)
+
+        def copy_resque_progressbar
+          say_status("copying", "resque-integration (#{Resque::Integration::VERSION})", :green)
+          copy_file "images/progressbar/white.gif", "public/images/progressbar/white.gif"
+          copy_file "javascripts/jquery.progressbar.js", "public/javascripts/jquery.js"
+          copy_file "stylesheets/jquery.progressbar.no_pipeline.css", "public/stylesheets/jquery.progressbar.css"
+        end
+      end
+    end
+  end
+else
+  module Resque::Integration
+    module Generators
+      class InstallGenerator < ::Rails::Generators::Base
+        desc "Just show instructions so people will know what to do when mistakenly using generator for Rails 3.1 apps"
+
+        def do_nothing
+          say_status("deprecated", "You are using Rails 3.1 with the asset pipeline enabled, so this generator is not needed.")
+          say_status("", "The necessary files are already in your asset pipeline.")
+          say_status("", "Just add `//= require jquery.progressbar` to your app/assets/javascripts/application.js")
+          say_status("", "If you upgraded your app from Rails 3.0 and still have jquery.progressbar.js in your javascripts, be sure to remove them.")
+          say_status("", "If you do not want the asset pipeline enabled, you may turn it off in application.rb and re-run this generator.")
+          # ok, nothing
+        end
+      end
+    end
+  end
+end

data/lib/resque/integration/backtrace.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+module Resque
+  module Integration
+    # Extend your job with this class to see full backtrace in resque log
+    module Backtrace
+      def around_perform_backtrace(*)
+        yield
+      rescue => ex
+        $stderr.puts(_format_exception(ex))
+
+        raise
+      end
+
+      private
+      def _format_exception(exception)
+        bt = exception.backtrace.dup
+
+        "%s %s: %s (%s)\n%s" % [
+          Time.now.to_s,
+          bt.shift,
+          exception.message,
+          exception.class.to_s,
+          bt.map { |line| ' ' * 4 + line }.join("\n")
+        ]
+      end
+    end # module Backtrace
+  end # module Integration
+end # module Resque