easy_job 1.0.0.alpha → 1.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4aebfe194102056b9da3a53a88cbb9cc29edf14
-  data.tar.gz: 6fd93ce6449daab58c9f011281d756bfac6ebd12
+  metadata.gz: 06d362b4970f9a75202dfaac478eed36b453edad
+  data.tar.gz: 40a4a9a711c617f7b76476098e3611aab9b82ec9
 SHA512:
-  metadata.gz: 4f7e11f580c8cf8ead56db8a0b25327aa4847ea3cb6234c1a9463685753f5867f761ea1f7bca450dfba2bb52b604ef4b395e209dc334990caa6c8c5fe92503ea
-  data.tar.gz: a246b7327c7daf91e6a868b82df10c1da2ce185b4b20dfbd599b98b8f5cef1c626c90ddb615614fbfd5459d5f13491b4708dae3dac42b1c68edde17b8053ea24
+  metadata.gz: 0a1a9111d2ebae0034052e5b2a3dbf7ec79b12df9017296c04ddaaca502b4a6ef1afc48ac5d5c98e78edb1d7b2d630c31bb04d46a84920b765256b06f887174d
+  data.tar.gz: 790f2b27b1053aa0a1458363973d43675241c5c08fb5bde1b92c41f6d9c51097b93526adabfe3c2cd8e5cc6300e47c0001a9f0e6ca3d3ed4b566c1690017e29a

data/.gitignore

@@ -7,3 +7,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+/.redmine/
+/redmine.tar.gz

data/Gemfile

@@ -2,3 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in easy_job.gemspec
 gemspec
+
+gem 'pry'
+gem 'rspec-rails'

data/README.md

@@ -1,8 +1,6 @@
 # EasyJob
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/easy_job`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Asynchronous job for Redmine, EasyRedmine and EasyProject.
 
 ## Installation
 
@@ -22,15 +20,62 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Delay jobs
+
+Every methods called after `.easy_delay` will be delayed and executed on other thread. This method could be used for any ruby Object.
+
+```ruby
+# Reschedule first issue to today
+Issue.first.easy_delay.reschedule_on(Date.today)
 
-## Development
+# Save ORM object with lot of callbacks
+[Issue.new, Issue.new].map { |i| i.easy_delay.save }
+```
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+### Mailer jobs
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Deliver email later.
 
-## Contributing
+```ruby
+# Generating and sending will be done later
+Mailer.issue_add(issue, ['test@example.net'], []).easy_deliver
+
+# Email is generated now but send later
+Mailer.issue_add(issue, ['test@example.net'], []).easy_safe_deliver
+```
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/easy_job.
+### Custom jobs
+
+You can also create custom task with own exceptions capturing.
+
+```ruby
+class PDFJob < EasyJob::RedmineTask
+
+  include IssuesHelper
+
+  def perform(issue_ids, project_id)
+    issues = Issue.where(id: issue_ids)
+    project = Project.find(project_id)
+    query = IssueQuery.new
+
+    result = issues_to_pdf(issues, project, query)
+
+    path = Rails.root.join('public', 'issues.pdf')
+    File.open(path, 'wb') {|f| f.write(result) }
+  end
+
+end
+
+PDFJob.perform_async(Issue.ids, Project.first.id)
+```
+
+## Ideas for next version
+
+- Behaviour model.
+- Repeat after failing.
+- Dashboard.
+- Queue defining.
+
+## Contributing
 
+Bug reports and pull requests are welcome on GitHub at https://github.com/ondra-m/easy_job.

data/Rakefile

@@ -1,6 +1,12 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec
+
+namespace :test do
+  task :prepare do
+    Kernel.system('./test_prepare.sh')
+  end
+end

data/easy_job.gemspec

@@ -11,14 +11,12 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Ondřej Moravčík']
   spec.email         = ['moravcik.ondrej@gmail.com']
 
-  spec.summary       = %q{Asynchronous job for easyproject}
+  spec.summary       = %q{Asynchronous job for Redmine, EasyRedmine and EasyProject}
   spec.description   = %q{}
   spec.homepage      = 'https://github.com/ondra-m/easy_job'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  # spec.bindir        = 'exe'
-  # spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
   spec.required_ruby_version = '>= 2.1'

data/lib/easy_job.rb

@@ -1,5 +1,77 @@
-require "easy_job/version"
+require 'monitor'
+require 'concurrent'
+require 'securerandom'
+
+require 'pry'
 
 module EasyJob
-  # Your code goes here...
+  extend MonitorMixin
+
+  autoload :Task,           'easy_job/task'
+  autoload :RedmineTask,    'easy_job/redmine_task'
+  autoload :DelayTask,      'easy_job/delay_task'
+  autoload :DelayTaskProxy, 'easy_job/delay_task'
+  autoload :MailerTask,     'easy_job/mailer_task'
+  autoload :TaskWrapper,    'easy_job/task_wrapper'
+  autoload :Logger,         'easy_job/logger'
+  autoload :Queue,          'easy_job/queue'
+  autoload :Attribute,      'easy_job/attribute'
+  autoload :Logging,        'easy_job/logging'
+
+  def self.get_queue(name)
+    synchronize do
+      @@queues ||= Concurrent::Map.new
+      @@queues.fetch_or_store(name) { EasyJob::Queue.new(name) }
+    end
+  end
+
+  # Block `all_done?` method for `interval` seconds.
+  # Method `all_done?` is checking `scheduled_task_count`
+  # but `ScheduledTask` is added to executor queue after delay time.
+  def self.block_all_done_for(interval)
+    synchronize do
+      @@block_all_done_until ||= Time.now
+
+      new_time = Time.now + interval.to_f
+      if @@block_all_done_until < new_time
+        @@block_all_done_until = new_time
+      end
+    end
+  end
+
+  # One time, non-blocking.
+  def self.all_done?
+    synchronize do
+      return true if @@queues.nil?
+
+      @@block_all_done_until ||= Time.now
+      if @@block_all_done_until > Time.now
+        false
+      else
+        @@queues.values.map(&:all_done?).all?
+      end
+    end
+  end
+
+  # Blocking passive waiting.
+  def self.wait_for_all(wait_delay: 5)
+    loop {
+      if all_done?
+        return
+      else
+        sleep wait_delay
+      end
+    }
+  end
+
+  def self.logger
+    synchronize do
+      @@loger ||= Logger.new(Rails.root.join('log', 'easy_jobs.log'))
+    end
+  end
+
 end
+
+require 'easy_job/version'
+require 'easy_job/ext/object'
+require 'easy_job/rails/message_delivery_patch'

data/lib/easy_job/attribute.rb

@@ -0,0 +1,45 @@
+module EasyJob
+  module Attribute
+
+    def self.included(base)
+      base.extend(Methods)
+    end
+
+    module Methods
+
+      def attribute(name, defaults=nil)
+        class_eval <<-METHODS
+          def self.#{name}=(value)
+            singleton_class.class_eval do
+              define_method(:#{name}) do |new_value=nil|
+                if new_value.nil?
+                  value
+                else
+                  self.#{name} = new_value
+                end
+              end
+            end
+
+            value
+          end
+
+          def self.#{name}?
+            !!#{name}
+          end
+
+          def #{name}
+            self.class.#{name}
+          end
+
+          def #{name}?
+            self.class.#{name}?
+          end
+        METHODS
+
+        self.send("#{name}=", defaults)
+      end
+
+    end
+
+  end
+end

data/lib/easy_job/behavior.rb

@@ -0,0 +1,109 @@
+# Behavior model
+#
+# NOT used in current version
+# Just and idea
+
+##
+# EasyJob::Behavior
+#
+# Container for behavior definition
+#
+module EasyJob
+  class Behavior
+
+    @@behaviors = {}
+
+    def self.define(name, &block)
+      @@behaviors[name] = new(name, &block)
+    end
+
+    def self.get(name)
+      @@behaviors[name]
+    end
+
+    def initialize(name, &block)
+      @name = name
+      instance_eval(&block)
+    end
+
+    def on_create
+      if block_given?
+        @on_create = Proc.new
+      else
+        @on_create || proc{}
+      end
+    end
+
+  end
+end
+
+##
+# EasyJob::TaskWrapper
+#
+# Modified wrapper
+#
+module EasyJob
+  class TaskWrapper
+
+    def initialize(task_class, args)
+      @behaviors = Array(task_class.behaviors)
+      @behaviors.map!{|b| Behavior.get(b) }
+      @behaviors.compact!
+
+      @behaviors.each{|b| instance_eval(&b.on_initialize) }
+    end
+
+    def perform
+    end
+
+  end
+end
+
+
+##
+# Definition of behavior
+#
+EasyJob::Behavior.define 'Database' do
+
+  on_create do
+    @connection_attempt = 0
+  end
+
+  on_perform do |task|
+    begin
+      ActiveRecord::Base.connection_pool.with_connection { task.run }
+    rescue ActiveRecord::ConnectionTimeoutError
+      @connection_attempt += 1
+      if @connection_attempt > max_db_connection_attempts
+        log_error 'Max ConnectionTimeoutError'
+        return
+      else
+        log_warn "ConnectionTimeoutError attempt=#{@connection_attempt}"
+        retry
+      end
+    end
+  end
+
+end
+
+EasyJob::Behavior.define 'RedmineEnv' do
+
+  on_create do
+    @current_user = User.current
+    @current_locale = I18n.locale
+  end
+
+  on_create do |task|
+    begin
+      orig_user = User.current
+      orig_locale = I18n.locale
+      User.current = @current_user
+      I18n.locale = @current_locale
+      super
+    ensure
+      User.current = orig_user
+      I18n.locale = orig_locale
+    end
+  end
+
+end

data/lib/easy_job/delay_task.rb

@@ -0,0 +1,48 @@
+class EasyJob::DelayTaskProxy < BasicObject
+
+  def initialize(object)
+    @object = object
+    @chains = []
+  end
+
+  def __object
+    @object
+  end
+
+  def __chains
+    @chains
+  end
+
+  def easy_delay
+    self
+  end
+
+  def method_missing(name, *args, &block)
+    @chains << [name, args, block]
+    if @chains.size == 1
+      ::EasyJob::DelayTask.perform_in(1, self)
+    end
+    self
+  end
+
+end
+
+##
+# EasyJob::DelayTask
+#
+# Run chains of commands deleyed
+#
+#   Issue.first.easy_delay.reschedule_on(Date.today)
+#
+class EasyJob::DelayTask < EasyJob::RedmineTask
+
+  def perform(proxy)
+    object = proxy.__object
+    chains = proxy.__chains
+
+    chains.each do |name, args, block|
+      object = object.send(name, *args, &block)
+    end
+  end
+
+end

data/lib/easy_job/ext/object.rb

@@ -0,0 +1,23 @@
+class Object
+
+  # Be carefull with nested calling. Parameters could be generated some times.
+  #
+  #   # It's OK
+  #   Issue.first.easy_delay.reschedule_on(Date.today)
+  #
+  #   # This could be a problem
+  #   def calc_date
+  #     sleep 100
+  #     Date.today
+  #   end
+  #
+  #   Issue.easy_delay.first.reschedule_on(calc_date)
+  #
+  # On second example only `first` method will be executed because Job does not know
+  # how many calling be triggered. Small workaround: method is delayed for 1s.
+  #
+  def easy_delay
+    EasyJob::DelayTaskProxy.new(self)
+  end
+
+end

data/lib/easy_job/logger.rb

@@ -0,0 +1,13 @@
+module EasyJob
+  class Logger < ::Logger
+
+    def initialize(*args)
+      super $stdout
+      self.formatter = proc do |severity, datetime, progname, msg|
+        time = datetime.strftime('%H:%M:%S')
+        "#{severity.first}, [#{time}] #{msg}\n"
+      end
+    end
+
+  end
+end

data/lib/easy_job/logging.rb

@@ -0,0 +1,48 @@
+module EasyJob
+  module Logging
+
+    def self.included(base)
+      base.include(InstanceMethods)
+      base.extend(ClassMethods)
+    end
+
+    module InstanceMethods
+
+      def log_info(message)
+        message = "#{self.class.name}:#{job_id} - #{message}"
+        EasyJob.logger.info(message)
+      end
+
+      def log_warn(message)
+        message = "#{self.class.name}:#{job_id} - #{message}"
+        EasyJob.logger.warn(message)
+      end
+
+      def log_error(message)
+        message = "#{self.class.name}:#{job_id} - #{message}"
+        EasyJob.logger.error(message)
+      end
+
+    end
+
+    module ClassMethods
+
+      def log_info(message)
+        message = "#{self.name} - #{message}"
+        EasyJob.logger.info(message)
+      end
+
+      def log_warn(message)
+        message = "#{self.name} - #{message}"
+        EasyJob.logger.warn(message)
+      end
+
+      def log_error(message)
+        message = "#{self.name} - #{message}"
+        EasyJob.logger.error(message)
+      end
+
+    end
+
+  end
+end

data/lib/easy_job/mailer_task.rb

@@ -0,0 +1,14 @@
+class EasyJob::MailerTask < EasyJob::RedmineTask
+
+  def perform(message)
+    case message
+    when ActionMailer::MessageDelivery
+      # Generate mail and send it
+      message.deliver_now
+    when Mail::Message
+      # Already generated, just send it
+      message.deliver
+    end
+  end
+
+end

data/lib/easy_job/queue.rb

@@ -0,0 +1,43 @@
+module EasyJob
+  class Queue < Concurrent::Synchronization::LockableObject
+
+    attr_reader :pool
+
+    # == ThreadPoolExecutor options:
+    # idletime::
+    #   The number of seconds that a thread may be idle before being reclaimed
+    #
+    # auto_terminate::
+    #   When true (default) an at_exit handler will be registered which
+    #   will stop the thread pool when the application exits
+    #
+    # max_queue::
+    #   0 is unlimited
+    #
+    DEFAULT_EXECUTOR_OPTIONS = {
+        min_threads:    3,
+        max_threads:    3,
+        idletime:       60,
+        max_queue:      0,
+        auto_terminate: false
+    }
+
+    def initialize(name)
+      super()
+      @name = name
+      @pool = Concurrent::ThreadPoolExecutor.new(DEFAULT_EXECUTOR_OPTIONS)
+    end
+
+    def post(*args, &block)
+      synchronize {
+        @pool.post(*args, &block)
+      }
+    end
+
+    # It will work only if perform method was wrapped by begin rescue end
+    def all_done?
+      pool.scheduled_task_count == pool.completed_task_count
+    end
+
+  end
+end

data/lib/easy_job/rails/message_delivery_patch.rb

@@ -0,0 +1,54 @@
+module EasyJob
+  ##
+  # ActionMailer::MessageDelivery
+  #
+  # It's a delegator which is created on method_missing.
+  #
+  module MessageDeliveryPatch
+
+    def self.included(base)
+      if Rails.env.test?
+        base.send(:include, TestInstanceMethods)
+      else
+        base.send(:include, InstanceMethods)
+      end
+    end
+
+    module InstanceMethods
+
+      # Mail will be generated and sent later
+      #
+      #   Mailer.issue_add(issue, [], []).easy_deliver
+      #
+      def easy_deliver
+        EasyJob::MailerTask.perform_async(self)
+      end
+
+      # Mail is generated now and sent later
+      #
+      #   Mailer.issue_add(issue, [], []).easy_deliver
+      #
+      def easy_safe_deliver
+        EasyJob::MailerTask.perform_async(message)
+      end
+
+    end
+
+    module TestInstanceMethods
+
+      def easy_deliver
+        deliver
+      end
+
+      def easy_safe_deliver
+        deliver
+      end
+
+    end
+
+  end
+end
+
+if defined?(ActionMailer)
+  ActionMailer::MessageDelivery.include(EasyJob::MessageDeliveryPatch)
+end

data/lib/easy_job/redmine_task.rb

@@ -0,0 +1,7 @@
+module EasyJob
+  class RedmineTask < Task
+
+
+  end
+end
+

data/lib/easy_job/task.rb

@@ -0,0 +1,38 @@
+module EasyJob
+  class Task
+    include Attribute
+    include Logging
+
+    attribute :queue_name, 'default'
+
+    attr_accessor :job_id
+
+    def self.perform_async(*args)
+      wrapper = TaskWrapper.new(self, args)
+      queue = EasyJob.get_queue(queue_name)
+      queue.post(wrapper, &:perform)
+      wrapper
+    end
+
+    def self.perform_in(interval, *args)
+      wrapper = TaskWrapper.new(self, args)
+      queue = EasyJob.get_queue(queue_name)
+      concurrent_job = Concurrent::ScheduledTask.execute(interval.to_f, args: wrapper, executor: queue.pool, &:perform)
+      EasyJob.block_all_done_for(interval)
+      wrapper
+    end
+
+    def perform(*)
+      raise NotImplementedError
+    end
+
+    def handle_error(ex)
+      log_error ex.message
+      ex.backtrace.each do |line|
+        log_error line
+      end
+    end
+
+  end
+end
+

data/lib/easy_job/task_wrapper.rb

@@ -0,0 +1,86 @@
+module EasyJob
+  class TaskWrapper
+    include Logging
+
+    STATE_PENDING = 0
+    STATE_RUNNING = 1
+    STATE_FINISHED = 2
+
+    def initialize(task_class, args)
+      @task_class = task_class
+      @args = args
+      @state = STATE_PENDING
+
+      @connection_attempt = 0
+      @current_user = User.current
+      @current_locale = I18n.locale
+    end
+
+    def job_id
+      @job && @job.job_id
+    end
+
+    def pending?
+      @state == STATE_PENDING
+    end
+
+    def running?
+      @state == STATE_RUNNING
+    end
+
+    def finished?
+      @state == STATE_FINISHED
+    end
+
+    def perform
+      @job = @task_class.new
+      @job.job_id = SecureRandom.uuid
+
+      ensure_connection {
+        ensure_redmine_env {
+          begin
+            @state = STATE_RUNNING
+            @job.perform(*@args)
+          rescue => ex
+            @job.handle_error(ex)
+          ensure
+            @state = STATE_FINISHED
+            log_info 'Job ended'
+          end
+        }
+      }
+    rescue => e
+      # Perform method must end successfully.
+      # Otherwise `all_done?` end on deadlock.
+    end
+
+    def ensure_connection
+      ActiveRecord::Base.connection_pool.with_connection { yield }
+    rescue ActiveRecord::ConnectionTimeoutError
+      @connection_attempt += 1
+      if @connection_attempt > max_db_connection_attempts
+        log_error 'Max ConnectionTimeoutError'
+        return
+      else
+        log_warn "ConnectionTimeoutError attempt=#{@connection_attempt}"
+        retry
+      end
+    end
+
+    def ensure_redmine_env
+      orig_user = User.current
+      orig_locale = I18n.locale
+      User.current = @current_user
+      I18n.locale = @current_locale
+      yield
+    ensure
+      User.current = orig_user
+      I18n.locale = orig_locale
+    end
+
+    def inspect
+      %{#<EasyJob::TaskWrapper(#{@task_class}) id="#{job_id}">}
+    end
+
+  end
+end

data/lib/easy_job/version.rb

@@ -1,3 +1,3 @@
-class EasyJob
-  VERSION = '1.0.0.alpha'
+module EasyJob
+  VERSION = '1.0.0.beta'
 end

data/test_prepare.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+
+# -v print lines as they are read
+# -x print lines as they are executed
+# -e abort script at first error
+set -e
+
+if [[ ! -d ".redmine" ]]; then
+  mkdir .redmine
+  pushd .redmine
+    # Download and extract redmine
+    wget "http://www.redmine.org/releases/redmine-3.3.0.tar.gz" -O redmine.tar.gz
+    tar xzf redmine.tar.gz --strip 1
+
+    # Init gems
+    echo "
+      gem 'pry'
+      gem 'pry-rails'
+      gem 'puma'
+      gem 'easy_job', path: '../'
+    " > Gemfile.local
+
+    # Init database
+    ruby -ryaml -e "
+      config = {
+        'adapter' => 'postgresql',
+        'database' => 'easy_job_redmine',
+        'host' => '127.0.0.1',
+        'encoding' => 'utf8'
+      }
+      config = { 'development' => config, 'production' => config }.to_yaml
+      File.write('config/database.yml', config)
+    "
+
+    # Install
+    bundle --local
+    bundle exec rake db:create RAILS_ENV=production
+    bundle exec rake db:migrate RAILS_ENV=production
+    bundle exec rake generate_secret_token RAILS_ENV=production
+    bundle exec rake redmine:load_default_data REDMINE_LANG=en RAILS_ENV=production
+  popd
+fi

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_job
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha
+  version: 1.0.0.beta
 platform: ruby
 authors:
 - Ondřej Moravčík
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-18 00:00:00.000000000 Z
+date: 2016-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -81,8 +81,20 @@ files:
 - Rakefile
 - easy_job.gemspec
 - lib/easy_job.rb
-- lib/easy_job/easy_job.rb
+- lib/easy_job/attribute.rb
+- lib/easy_job/behavior.rb
+- lib/easy_job/delay_task.rb
+- lib/easy_job/ext/object.rb
+- lib/easy_job/logger.rb
+- lib/easy_job/logging.rb
+- lib/easy_job/mailer_task.rb
+- lib/easy_job/queue.rb
+- lib/easy_job/rails/message_delivery_patch.rb
+- lib/easy_job/redmine_task.rb
+- lib/easy_job/task.rb
+- lib/easy_job/task_wrapper.rb
 - lib/easy_job/version.rb
+- test_prepare.sh
 homepage: https://github.com/ondra-m/easy_job
 licenses:
 - MIT
@@ -106,5 +118,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Asynchronous job for easyproject
+summary: Asynchronous job for Redmine, EasyRedmine and EasyProject
 test_files: []

data/lib/easy_job/easy_job.rb

@@ -1,3 +0,0 @@
-class EasyJob
-
-end