heimdall-worker 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0b7a93b686ebbac0443797bd3202095c6f081a00020c04db22b665ce486f84b5
+  data.tar.gz: 61cd38475818a4ab93b9f3d85b83373c67671f08701f7e92148ed1ba15815016
+SHA512:
+  metadata.gz: 8a8f4a06751167445de726e0f2b4c6f7843b4878e6131499965b1718a09a143433d9eb9ac46b006a58101a9f84d1fedc160796ecc4a49a0d37c7317488df470f
+  data.tar.gz: 521be25ae29004026ecdbdce3effe77530110f9d4fce058be43037c7455e4a0f9a9b857606ac433f2d43aaa293ce390b8d3fb3ec2d8b0387fe2a6ed33a101933

data/.version

@@ -0,0 +1 @@
+0.1.0

data/lib/heimdall/heimdall_base.rb

@@ -0,0 +1,152 @@
+module Heimdall
+  EVENT_HOOKS ||= {}
+
+  extend self
+
+  def run
+    start
+    run_runner
+  end
+
+  def run_runner
+    return if CONFIG['running']
+
+    CONFIG.running = true
+
+    CONFIG.active_jobs = ObjectSpace
+      .each_object(Class)
+      .select { |klass| klass < ::Heimdall::Worker }
+
+    log 'HEIMDALL started with %s jobs (%s)' % [CONFIG.active_jobs.length, CONFIG.active_jobs.join(', ')], true
+
+    # will run forever in background and get new jobs every CONFIG.sleep
+    Thread.new do
+      while CONFIG.running
+        while que.has_free? && get_next
+          # add all new jobs to a que with minimal sleep
+          sleep 0.01
+        end
+
+        sleep CONFIG.sleep_lookup
+      end
+    end
+
+    Schedule.run
+  end
+
+  def call env
+    ::Heimdall::Web.call env
+  end
+
+  def que
+    CONFIG.que
+  end
+
+  def config
+    CONFIG
+  end
+
+  def stop
+    log 'HEIMDALL is stopping'
+
+    CONFIG.running = false
+
+    while !poll.done?
+      sleep 0.3
+    end
+
+    log 'HEIMDALL STOPED'
+  end
+
+  def log text, screen = false
+    return if CONFIG.silent
+    puts text if screen
+    CONFIG.logger.info text
+  end
+
+  def logger
+    CONFIG.logger
+  end
+
+  def tasks filter = {}, limit = 100
+    Task
+      .order(Sequel.lit('id desc'))
+      .limit(limit)
+      .all
+  end
+
+  def server
+    CONFIG[:server] || raise('Heimdall not started')
+  end
+
+  def db
+    CONFIG[:db]
+  end
+
+  # add job to job server
+  def add job_klass = nil, opts = {}
+    if block_given?
+      Thread.current[:_heimdall_batch] = [Time.now.to_f, Digest::SHA1.hexdigest(rand.to_s)[0, 10]].join('').sub('.', '')
+
+      begin
+        yield self
+      ensure
+        Thread.current[:_heimdall_batch] = nil
+      end
+    else
+      if Thread.current[:_heimdall_batch]
+        opts = opts.merge _batch: Thread.current[:_heimdall_batch]
+      end
+
+      if job_klass.class == Symbol
+        job_klass = "#{job_klass}_job".classify.constantize
+      end
+
+      server.add(job_klass, opts)
+
+      true
+    end
+  end
+
+  def restart job_id
+    Task[job_id.to_i].update status_sid: 'a', remaining_runs: 1, scheduled_at: Time.at(1)
+  end
+
+  # run next job from job server
+  def get_next
+    if (task = server.pop)
+      que.add do
+        begin
+          job_class = task.job_class.new
+
+          task.logger 'STARTED'
+
+          Timeout::timeout job_class.cattr.timeout.to_i do
+            job_class.call task.opts.to_hwia
+            task.set_done job_class.log
+          end
+        rescue => error
+          log_data = ["#{error.class}: #{error.message}"]
+
+          if job_class.cattr.backtrace
+            log_data.push error.backtrace.map{|el| "  #{el}"}.join($/)
+            log_data.push ''
+          end
+
+          task.set_fail log_data.join("\n")
+        end
+      end
+    end
+  end
+
+  # Heimdall.job_on :fail do |task, status| ...
+  def job_on name, &block
+    allowed = [:all, :done, :start, :error, :fail]
+
+    unless allowed.include?(name)
+      raise ArgumentError, 'Event kind %s does not exist' % name
+    end
+
+    EVENT_HOOKS[name] = block
+  end
+end

data/lib/heimdall/heimdall_database.rb

@@ -0,0 +1,95 @@
+# Talks to the database
+
+module Heimdall
+  class Database
+    STATUS ||= {
+      a: 'Added',
+      r: 'Running',
+      d: 'Done',
+      f: 'Failed',
+    }.to_hwia
+
+    def db
+      CONFIG[:db]
+    end
+
+    def add job_class, opts = {}
+      opts = opts.dup
+      uid  = nil
+
+      job_cattr = job_class.cattr
+
+      # job unique ID, unique accross all jobs. Genareate complicated SHA1 on many keys?
+      # used to define UID on jobs that last long
+      # example: PDF generation that last a long time. user hits page refresh multiple times, only one job is added
+      # [@uique_id_string, @time_to_be_valid_in_seconds or 0 for inf]
+      if (ttl_seconds = (opts.delete(:_unique_for) || job_cattr.unique_for))
+        unless ttl_seconds.is_numeric?
+          raise ArgumentError, '_ttl argument is not numneric'
+        end
+
+        uid = Digest::SHA1.hexdigest((job_class.to_s + opts.to_s).chars.sort.join)
+
+        if db[:tasks].where(uid: uid).where(Sequel.lit('created_at > ?', Time.now - ttl_seconds.to_i.seconds)).first
+          Heimdall.logger.info '%s skipped add by TTL check' % job_class
+        end
+      end
+
+      batch   = opts.delete :_batch
+      retries = job_class.cattr.retries.to_i
+      retries = 1 if retries < 1
+
+      scheduled_at = opts.delete(:_scheduled_at).to_i
+
+      task = Task.create({
+        created_at: Time.now,
+        scheduled_at: Time.at(scheduled_at),
+        job: job_class.to_s,
+        opts: opts.to_json,
+        uid: uid,
+        batch: batch,
+        remaining_runs: retries,
+        total_runs: 0,
+        status_sid: 'a'
+      })
+
+      task.logger 'ADDED - %s' % opts.to_json
+
+      task
+    end
+
+    def pop
+      if (task = available_base.first)
+        task.total_runs     += 1
+        task.update({
+          status_sid: 'r',
+          started_at: Time.now,
+          restart_at: Time.now + task.job_class.cattr.timeout.to_i.seconds,
+          finished_at: nil,
+          total_runs: task.total_runs
+        })
+
+        task
+      end
+    end
+
+    def available_ids
+      available_base.select(:id).to_a.map{|el| el[:id] }
+    end
+
+    private
+
+    def available_base
+      Task
+        .order(Sequel.lit('RANDOM()'))
+        .xwhere(%{
+          remaining_runs>0
+          and (
+            (scheduled_at<:time and status_sid in :list)
+            or
+            (status_sid = 'r' and restart_at<:time)
+          )
+        }, time: Time.now, list: %w[a e])
+    end
+  end
+end

data/lib/heimdall/heimdall_model.rb

@@ -0,0 +1,33 @@
+module Heimdall
+  PER_PAGE = 50
+
+  Model = Class.new(Sequel::Model(Heimdall::CONFIG[:db]))
+
+  def Model.first_or_new filter
+    object = where(filter).first || new(filter)
+    yield object if block_given? && !object.id
+    object
+  end
+
+  Model.dataset_module do
+    def page num, size = nil
+      num = num.to_i
+      num = 1 if !num || num < 1
+
+      size ||= PER_PAGE
+      self.limit(size).offset((num - 1) * size).all
+    end
+
+    def xwhere *args
+      self.where Sequel.lit *args
+    end
+  end
+
+  Model.class_eval do
+    def update opts
+      # do not call callbacks
+      this.update opts
+    end
+  end
+end
+

data/lib/heimdall/heimdall_model_schedule.rb

@@ -0,0 +1,81 @@
+# Class to handle scheduled and repeted jobs
+
+# https://crontab.guru/every-1-minute
+
+module Heimdall
+  class Schedule < Model
+    class << self
+      # sets schedules and fills in memory objects
+      def set_schedules
+        @active_schedules = []
+
+        jobs = CONFIG.active_jobs.select{|el| el.cattr.every || el.cattr.cron }
+
+        for job in Schedule.all
+          job.delete unless jobs.map(&:to_s).include?(job)
+        end
+
+        for job_class in jobs
+          if job_class.cattr.cron
+            CronParser.new(job_class.cattr.cron)
+          end
+
+          row = self.first_or_new name: job_class.to_s
+          row.every = job_class.cattr.every
+          row.cron  = job_class.cattr.cron
+          row.next_run_at ||= Time.now - 1.day
+          row.save
+          @active_schedules.push row
+        end
+
+        run
+      end
+
+      # run schedules in a loop
+      def run
+        return if @running
+        @running = true
+
+        require 'parse-cron'
+
+        set_schedules
+
+        if CONFIG[:disable_cron]
+          puts 'Heimdall - CRON disabled in config'
+        else
+          Thread.new do
+            loop do
+              for schedule in @active_schedules
+                if schedule.next_run_at < Time.now
+                  schedule.set_next_run
+                  schedule.job.call
+                end
+              end
+
+              sleep 1
+            end
+          end
+        end
+      end
+    end
+
+    ###
+
+    def job
+      name.constantize
+    end
+
+    def set_next_run
+      if self[:cron].present?
+        self[:next_run_at] = CronParser.new(cron).next(Time.now)
+      elsif self[:every].present?
+        self[:next_run_at] = Time.now + every.to_i.seconds
+      end
+
+      self[:last_run_at] = Time.now
+
+      save
+    end
+  end
+end
+

data/lib/heimdall/heimdall_model_task.rb

@@ -0,0 +1,131 @@
+module Heimdall
+  class Task < Model
+    def name
+      if job == 'HeimdallProxyWorker'
+        begin
+          parts = Marshal.load Base64.decode64 opts['b64']
+          '%s#%s (ProxyWorker)' % parts
+        rescue
+          'HeimdallProxyWorker (?)'
+        end
+      else
+        job
+      end
+    end
+
+    def status
+      Heimdall::Database::STATUS[self[:status_sid]] || 'Unknown'
+    end
+
+    def job_class
+      self[:job].constantize
+    end
+
+    def has_error?
+      self[:status_sid] == 'e'
+    end
+
+    def opts
+      if self[:opts].class == Hash
+        self[:opts]
+      else
+        @opts ||= JSON.load self[:opts]
+      end
+    end
+
+    def full_status
+      @colorize = false
+      full_text_status
+    end
+
+    def full_color_status
+      @colorize = true
+      full_text_status
+    end
+
+    def full_text_status
+      if status_sid == 'd'
+        colorize 'Finished', :green
+      elsif status_sid == 'e'
+          colorize "Failed after #{self[:total_runs]} tries", :red
+      elsif status_sid == 'a'
+          colorize 'In que', :gray
+      elsif status_sid == 'r'
+        diff = (Time.now - self[:started_at]).to_i
+        'Running for %s sec' % diff
+      else
+        'Unknow: %s' % status_sid
+      end
+    end
+
+    def run_time
+      if self[:started_at] && self[:finished_at]
+        '%s sec' % (self[:finished_at] - self[:started_at]).to_i
+      else
+        '-'
+      end
+    end
+
+    def next_run
+      if ['d', 'r'].include?(status_sid) || (status_sid == 'a' && remaining_runs == 0)
+        '-'
+      else
+        if scheduled_at > Time.now
+          Time.ago scheduled_at
+        else
+          'now'
+        end
+      end
+    end
+
+    def set_done log_data
+      self.update status_sid: 'd', log: log_data, remaining_runs: 0, finished_at: Time.now
+      logger 'DONE'
+    end
+
+    def set_fail log_data
+      self.update status_sid: 'e',
+        log: log_data,
+        finished_at: Time.now,
+        scheduled_at: Time.now + Heimdall::CONFIG.repeat_after,
+        remaining_runs: remaining_runs - 1
+
+      logger :error
+    end
+
+    def logger msg
+      return if Heimdall::CONFIG.silent
+
+      status = msg.to_s.downcase.include?('error') ? :error : :info
+      message = "#{self.class}[#{self.id}] (#{self.job}) - #{msg}"
+      Heimdall.logger.send status, message
+    end
+
+    def export
+      data = to_h
+      data['log']  = data['log'].to_s.split($/)
+      data['info'] = {
+        name: name,
+        status: full_text_status,
+        run_time: run_time,
+        has_error: has_error?
+      }
+      data
+    end
+
+    def to_json
+      JSON.pretty_generate export
+    end
+
+    private
+
+    def colorize text, color
+      if @colorize
+        %[<span style="color: #{color};">#{text}</span>]
+      else
+        text
+      end
+    end
+  end
+end
+

data/lib/heimdall/heimdall_proxy.rb

@@ -0,0 +1,43 @@
+# Provides proxy access to heimdall, for easy job offloading
+
+# TODO: at and in -> @object.heimdall(at: Time.now + 5.hours).do_something
+
+# makes    @foo.bar(:baz)
+# work via @foo.heimdall.bar(:baz)
+# delayed
+
+class Object
+  def heimdall
+    Heimdall::ObjectProxy.new self
+  end
+end
+
+module Heimdall
+  class ObjectProxy
+    def initialize object
+      @object = object
+    end
+
+    def method_missing name, *args
+      dump = Marshal.dump [@object, name, args]
+      dump = Base64.encode64 dump
+      dump = dump.sub %r{=*\s*$}, ''
+      Heimdall.add HeimdallProxyWorker, b64: dump
+      true
+    end
+  end
+end
+
+class HeimdallProxyWorker < Heimdall::Worker
+  retries Heimdall::CONFIG[:retries]
+  timeout 3.minutes
+
+  def call opts
+    object, name, args = Marshal.load Base64.decode64 opts[:b64]
+    response = object.send name, *args
+
+    if [Integer, Symbol, String].include?(response.class)
+      log(response.to_s).to_s[0, 1_000]
+    end
+  end
+end

data/lib/heimdall/heimdall_que.rb

@@ -0,0 +1,100 @@
+# runs x parralel ques
+
+module Heimdall
+  class Que
+    attr_reader :active, :size
+
+    def initialize size = 5
+      @size   = size
+      @active = []
+    end
+
+    # add to block, it is possible to add
+    def add &block
+      in_ques do |i|
+        if is_free?(i)
+          @active[i] = Thread.new(&block)
+          return true
+        end
+      end
+
+      false
+    end
+
+    # does it have a free slot?
+    def has_free?
+      in_ques do |i|
+        return true if is_free?(i)
+      end
+
+      false
+    end
+
+    # are the all jobs done?
+    def done?
+      in_ques do |i|
+        return false unless is_free?(i)
+      end
+
+      true
+    end
+
+    def status_text i
+      if @active[i]
+        status = @active[i].status
+        if status.class == String
+          'Active (%s)' % status
+        else
+          'Free'
+        end
+      else
+        'Free'
+      end
+    end
+
+    private
+
+    # loop trough active ques
+    def in_ques
+      0.upto @size - 1 do |i|
+        yield i
+      end
+    end
+
+    # Thread statuses - "sleep", "run", "aborting", false, nil
+    def is_free? num
+      current = @active[num]
+      !current || ["aborting", false, nil].include?(current.status)
+    end
+  end
+end
+
+# func = proc do
+#   num = rand*10
+#   sleep num
+#   puts 'num %s' % num
+# end
+
+# jobs = []
+# 1.upto(10) do
+#   jobs.push func
+# end
+
+# que = Heimdall::Que.new
+
+# while jobs.first
+#   if que.has_free?
+#     que.add &jobs.shift
+#     puts 'added'
+#   else
+#     puts 'waiting'
+#     sleep 1
+#   end
+# end
+
+# while !que.done?
+#   puts 'no still done'
+#   sleep 1
+# end
+
+# puts 'done'

data/lib/heimdall/heimdall_start.rb

@@ -0,0 +1,91 @@
+module Heimdall
+  CONFIG ||= {}.to_hwia
+
+  extend self
+
+  def start
+    return if CONFIG['db']
+
+    CONFIG.db = Sequel.connect ENV.fetch('HEIMDALL_DB')
+
+    # init tables unless exist
+    unless CONFIG.db.tables.include?(:tasks)
+      CONFIG.db.create_table :tasks do
+        primary_key :id
+        Time     :created_at
+        Time     :scheduled_at
+        Time     :started_at
+        Time     :finished_at
+        Time     :restart_at
+        Integer  :total_runs
+        Integer  :remaining_runs
+        String   :batch
+        String   :uid
+        String   :job
+        String   :opts
+        String   :log
+        String   :status_sid, limit: 1
+      end
+
+      CONFIG.db.add_index :tasks, :scheduled_at
+      CONFIG.db.add_index :tasks, :restart_at
+      CONFIG.db.add_index :tasks, :remaining_runs
+      CONFIG.db.add_index :tasks, :uid
+      CONFIG.db.add_index :tasks, :batch
+      CONFIG.db.add_index :tasks, :status_sid
+    end
+
+    unless CONFIG.db.tables.include?(:schedules)
+      CONFIG.db.create_table :schedules do
+        primary_key :id
+        String   :name
+        String   :every
+        String   :cron
+        Time     :next_run_at
+        Time     :last_run_at
+      end
+    end
+
+    # allow custom locations
+    log_location = ENV['HEIMDALL_LOG'] || './log/heimdall.log'
+    log_location = STDOUT if log_location.upcase == 'STDOUT'
+
+    # log errors to screen and file
+    error_log_locations = [STDOUT]
+
+    if log_location != STDOUT
+      error_log_locations.push log_location.sub('.log', '_sql_errors.log')
+    end
+
+    for el in error_log_locations
+      logger = Logger.new el, 1, 1_240_000
+      logger.level = :error
+      CONFIG.db.loggers << logger
+    end
+
+    # models can be loaded only when we have DB connection (Sequel gem req)
+    require_relative 'heimdall_model'
+    require_relative 'heimdall_model_schedule'
+    require_relative 'heimdall_model_task'
+
+    unless CONFIG[:server]
+      # how many seconds to wait before getting new jobs
+      CONFIG[:sleep_lookup] ||= 1
+
+      # default number of retries
+      CONFIG[:retries]      ||= 2
+
+      # repeat failed job after
+      CONFIG[:repeat_after] ||= 1.minute
+
+      CONFIG[:logger_file]  ||= ENV['HEIMDALL_LOG'] || './log/heimdall.log'
+      CONFIG[:logger_file]    = STDOUT if CONFIG[:logger_file].upcase == 'STDOUT'
+      CONFIG[:logger]       ||= Logger.new(CONFIG.logger_file, 3, 10_240_000)
+      CONFIG[:silent]       ||= false
+      CONFIG[:que_size]     ||= 5
+
+      CONFIG.que     = Heimdall::Que.new CONFIG.que_size
+      CONFIG.server  = Heimdall::Database.new
+    end
+  end
+end

data/lib/heimdall/heimdall_web.rb

@@ -0,0 +1,126 @@
+require "bundler/setup"
+
+
+module Heimdall
+  class Web < Sinatra::Base
+    if ENV['RACK_ENV'] == 'development'
+      require "sinatra/reloader"
+      register Sinatra::Reloader
+    end
+
+    helpers do
+      def info_buton name, count, param_name = nil, param_value = nil
+        klass = count > 0 ? 'bg-primary' : 'bg-success'
+        if param_value
+          %[<a class="badge #{klass}" href="?#{param_name}=#{param_value}">#{name} &sdot; #{count}</a>]
+        else
+          %[<span class="badge #{klass}">#{name} &sdot; #{count}</span>]
+        end
+      end
+
+      def action name
+        path = request.path.split '/'
+        path[2] = name
+        path.join('/')
+      end
+
+      def paginate
+        page = (params[:page] || 1).to_i
+        has_prev = page > 1
+        has_next = @tasks.length > 49
+
+        HtmlTag.div class: 'btn-group' do |n|
+          n.a has_prev ? '<' : '&sdot;', class: 'btn btn-secondary', href: has_prev ? "/heimdall?page=#{page - 1}" : nil
+          n.button [page, @total].join(' / '), class: 'btn btn-secondary', onclick: "if (page = prompt('Jump to page:', #{page})){ Page.load('/heimdall?page='+page) }"
+          n.a has_next ? '>' : '-', class: 'btn btn-secondary', href: has_next ? "/heimdall?page=#{page + 1}" : nil
+        end
+      end
+    end
+
+    ###
+
+    get '/' do
+      'Heimdall root. You probably want to go to <a href="/heimdall">/heimdall</a>'
+    end
+
+    get '/heimdall' do
+      @tasks = Heimdall::Task.order(Sequel.lit('id desc'))
+      @tasks = @tasks.where(status_sid: params[:s]) if params[:s]
+      @tasks = @tasks.xwhere('lower(job) like ?', "%#{params[:q].downcase}%") if params[:q]
+      # rr @tasks.sql
+      @tasks = @tasks.page(params[:page])
+      @total = (Heimdall::Task.count / Heimdall::PER_PAGE) + 1
+
+      base = Heimdall::Task.where(Sequel.lit('created_at>?', Time.now - 1.day))
+      @count_in_que  = base.xwhere('remaining_runs>0').count
+      @count_running = base.where(status_sid: 'r').count
+      @count_done    = base.where(status_sid: 'd').count
+      @count_failed  = base.where(status_sid: 'e').count
+
+      @title = 'Tasks'
+
+      haml :tasks, layout: true
+    end
+
+    get '/heimdall/public/*' do
+      file = Pathname.new File.dirname(__FILE__) + '/public/%s' % params[:splat].first
+
+      if file.exist?
+        case params[:splat].first.split('.').last.to_sym
+        when :js
+          content_type :js
+        when :png
+          content_type :png
+        end
+
+        file.read
+      else
+        status 404
+        'File not found'
+      end
+    end
+
+    get '/heimdall/info/:id' do
+      task = Heimdall::Task[params[:id].to_i]
+
+      if task
+        JSON.pretty_generate task.export
+      else
+        status 404
+        { error: 'not found' }.to_json
+      end
+    end
+
+    get '/heimdall/task/:id' do
+      @task  = Heimdall::Task[params[:id].to_i]
+
+      if @task
+        @title = 'Task %s' % @task.id
+        haml :task, layout: true
+      else
+        status 404
+        haml 'Task not found', layout: true
+      end
+    end
+
+    post '/heimdall/restart/:id' do
+      Heimdall.restart params[:id].to_i
+
+      'restarted'
+    end
+
+    get '/heimdall/schedules' do
+      @schedules = Heimdall::Schedule.order(Sequel.lit('id desc'))
+      @title = 'Schedules'
+
+      haml :schedules, layout: true
+    end
+
+    get '/heimdall/ques' do
+      @que = Heimdall.que
+      @title = 'Ques'
+
+      haml :ques, layout: true
+    end
+  end
+end

data/lib/heimdall/heimdall_worker.rb

@@ -0,0 +1,49 @@
+# class TestWorker < Heimdall::Worker
+#   timeout 10
+#
+#   def call opts
+#     ...
+#   end
+# end
+#
+# to add to que
+#
+# Heimdall.add :test, num: 1233
+# or
+# TestWorker.call num: 1233
+
+module Heimdall
+  class Worker
+    cattr :retries, 3
+    cattr :retry_after, 60
+    cattr :timeout, nil
+    cattr :every, nil
+    cattr :cron, nil
+    cattr :backtrace, true
+    cattr :unique_for, nil
+
+    ###
+
+    class << self
+      def call opts = {}
+        Heimdall.add self, opts.to_hwia
+      end
+      alias :perform :call
+    end
+
+    ###
+
+    def initialize
+      @_log = []
+    end
+
+    def log text = nil
+      if text
+        @_log.push text
+        text
+      else
+        @_log.join $/
+      end
+    end
+  end
+end

data/lib/heimdall-worker.rb

@@ -0,0 +1,28 @@
+# With start Heimdall you can add jobs
+# Heimdall.start
+
+# With run you can add and have running server that will process jobs
+# Heimdall.run
+
+# to stop, you should not need that
+# Heimdall.stop
+
+# Heimdall.add :test, num: 123
+
+###
+
+unless ENV['HEIMDALL_DB']
+  puts 'You are using Heimdall (https://....) but you have not defined HEIMDALL_DB'
+  puts 'Examples:'
+  puts 'HEIMDALL_DB=sqlite://./db/heimdall.sqlite'
+  puts 'HEIMDALL_DB=postgres://localhost:5432/heimdall'
+  exit
+end
+
+require_relative 'heimdall/heimdall_start'
+require_relative 'heimdall/heimdall_base'
+require_relative 'heimdall/heimdall_que'
+require_relative 'heimdall/heimdall_database'
+require_relative 'heimdall/heimdall_worker'
+require_relative 'heimdall/heimdall_proxy'
+require_relative 'heimdall/heimdall_web'

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: heimdall-worker
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dino Reic
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-01-31 00:00:00.000000000 Z
+dependencies: []
+description: Sidekicq alternative
+email: reic.dino@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./.version"
+- "./lib/heimdall-worker.rb"
+- "./lib/heimdall/heimdall_base.rb"
+- "./lib/heimdall/heimdall_database.rb"
+- "./lib/heimdall/heimdall_model.rb"
+- "./lib/heimdall/heimdall_model_schedule.rb"
+- "./lib/heimdall/heimdall_model_task.rb"
+- "./lib/heimdall/heimdall_proxy.rb"
+- "./lib/heimdall/heimdall_que.rb"
+- "./lib/heimdall/heimdall_start.rb"
+- "./lib/heimdall/heimdall_web.rb"
+- "./lib/heimdall/heimdall_worker.rb"
+homepage: https://github.com/dux/heimdall-worker
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: Simple, efficient background processing for Ruby.
+test_files: []