sidejob 4.0.2 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c508ddf20a2498ce9d4b37f1bb5a9ff46a0cf80
-  data.tar.gz: 8e5b8fbdb89070d8e01857734669883b8cbc6be5
+  metadata.gz: e731ae1460c300e29d0698535fd1b7108efd3568
+  data.tar.gz: be777ac02165ead0b44de9100cefb8dfbb3c16ac
 SHA512:
-  metadata.gz: 22a8451a4c19f630a9a26d72b771b8cf40879e7ce55daaed0f702137ccfe5d233e5eebe3edbfe80d15a514e63917c8ba5378d002e456ae578bef49e7bbd712dd
-  data.tar.gz: a61a49db836b89ddb5298b20b376f70fda787b2cb81a4e3ef052c309c996287f7461118ecdd1e9953ceb8593671c856c56559baee8bdfc77ac7d2760e75dabd6
+  metadata.gz: 82265dc59bf18956bff558a9e9c996d74ae4a7a2f70f396d6a6188a73c884743756c57fac40bbba958de9bc9fe95e5aca435a3ae4489d23b56700c8f3b330448
+  data.tar.gz: baac41c609404f39cc9083f13dd489856faaa34f76db2fc5774e1190cf0c9ddbbdab036d893a77a22749a92f5670a62cc04e033e9367eb3ab3f6b1ecf3368cac

data/README.md

@@ -18,6 +18,7 @@ Jobs
     * This ID is used as Sidekiq's jid
     * Note: a job can be queued multiple times on Sidekiq's queues
     * Therefore, Sidekiq's jids are not unique
+* Jobs can also have any number of globally unique string names as aliases
 * Jobs have a queue and class name
 * Jobs have any number of input and output ports
 * A job can have any number of named child jobs
@@ -48,6 +49,29 @@ Ports
   a port named `*` exists in which case new ports are dynamically created and inherit its options.
 * Currently, the only port option is a default value which is returned when a read is done on the port when its empty.
 
+Channels
+--------
+
+Channels provide a global reliable pubsub system. Every port can be associated with some number of channels.
+Writes to output ports will publish the data to the associated channels. Any published messages to a channel
+are written to all input ports that have subscribed to that channel.
+
+The pubsub system is reliable in that the subscribed jobs do not need to be running to receive messages.
+Other clients can also subscribe to channels via standard non-reliable Redis pubsub.
+
+Channel names use slashes to indicate hierarchy. Published messages to a channel are also published to channels
+up the hierarchy. For example, a message sent to the channel `/namespace/event` will be sent to the channels
+`/namespace/event`, `/namespace` and `/`.
+
+SideJob uses channels starting with /sidejob. The channels used by sidejob:
+
+* `/sidejob/log` : Log message. In the context of a running job, the job id will be included in the log entry.
+    * { timestamp: (date), read: [{ job: (id), (in|out)port: (port), data: [...] }, ...], write: [{ job: (id), (in|out)port: (port), data: [...] }, ...] }
+    * { timestamp: (date), error: (message), backtrace: (exception backtrace) }
+    * { timestamp: (date), message: (message) }
+* `/sidejob/workers/[queue]` : Worker registry updated for the queue
+* `/sidejob/job/[id]` : Job messages
+
 Workers
 -------
 
@@ -55,6 +79,7 @@ Workers
 * Workers are required to register themselves
 * A Sidekiq process should only handle a single queue so all registered workers in the process are for the same queue
 * It should have a perform method that is called on each run
+* It may have a startup method that is called once before the first run of the job
 * It may have a shutdown method that is called before the job is terminated
 * Workers should be idempotent as they may be run more than once for the same state
 * SideJob ensures only one worker thread runs for a given job at a time
@@ -94,28 +119,26 @@ Additional keys used by SideJob:
 
 * workers:(queue) - Hash mapping class name to worker configuration. A worker should define
   the inports and outports hashes that map port names to port options.
-* jobs:last_id - Stores the last job ID (we use incrementing integers from 1)
-* jobs:logs - List with JSON encoded logs.
-    * { timestamp: (date), job: (id), read: [{ job: (id), (in|out)port: (port), data: [...] }, ...], write: [{ job: (id), (in|out)port: (port), data: [...] }, ...] }
-    * { timestamp: (date), job: (id), error: (message), backtrace: (exception backtrace) }
-* jobs - Set with all job ids
-* job:(id) - Hash containing job state. Each value is JSON encoded.
-    * status - job status
-    * queue - queue name
-    * class - name of class
-    * args - array of arguments passed to worker's perform method
-    * parent - parent job ID
-    * created_at - timestamp that the job was first queued
-    * created_by - string indicating the entity that created the job. SideJob uses job:(id) for jobs created by another job.
-    * ran_at - timestamp of the start of the last run
-    * Any additional keys used by the worker to track internal job state
+* jobs - Set with all job ids.
+* jobs:last_id - Stores the last job ID (we use incrementing integers from 1).
+* jobs:aliases - Hash mapping a name to job id.
+* job:(id):worker - JSON encoded hash with queue, class, and args for calling the worker.
+* job:(id):status - Job status
+* job:(id):created_at - Timestamp that the job was first queued
+* job:(id):created_by - The entity that created the job. SideJob uses job:(id) for jobs created by another job.
+* job:(id):ran_at - Timestamp of the start of the last run
+* job:(id):aliases - Set with job aliases
 * job:(id):in:(inport) and job:(id):out:(outport) - List with unread port data. New data is pushed on the right.
 * job:(id):inports and job:(id):outports - Set containing all existing port names.
 * job:(id):inports:default and job:(id):outports:default - Hash mapping port name to JSON encoded default value for port.
+* job:(id):inports:channels and job:(id):outports:channels - Hash mapping port name to JSON encoded connected channels.
+* job:(id):parent - Parent job ID
 * job:(id):children - Hash mapping child job name to child job ID
+* job:(id):state - Hash containing job specific internal state. Each value is JSON encoded.
 * job:(id):rate:(timestamp) - Rate limiter used to prevent run away executing of a job.
     Keys are automatically expired.
 * job:(id):lock - Used to control concurrent writes to a job.
     Auto expired to prevent stale locks.
 * job:(id):lock:worker - Used to indicate a worker is attempting to acquire the job lock.
     Auto expired to prevent stale locks.
+* channel:(channel) - Set with job ids that may have ports subscribed to the channel.

data/lib/sidejob.rb

@@ -7,6 +7,7 @@ require 'sidejob/worker'
 require 'sidejob/server_middleware'
 require 'time' # for iso8601 method
 require 'securerandom'
+require 'pathname'
 
 module SideJob
   # Configuration parameters
@@ -49,11 +50,17 @@ module SideJob
 
     # To prevent race conditions, we generate the id and set all data in redis before queuing the job to sidekiq
     # Otherwise, sidekiq may start the job too quickly
-    id = SideJob.redis.incr('jobs:last_id').to_s
+    id = SideJob.redis.incr('jobs:last_id')
     SideJob.redis.sadd 'jobs', id
     job = SideJob::Job.new(id)
 
-    job.set({queue: queue, class: klass, args: args, status: 'completed', created_by: by, created_at: SideJob.timestamp})
+    redis_key = job.redis_key
+    SideJob.redis.multi do |multi|
+      multi.set "#{redis_key}:worker", {queue: queue, class: klass, args: args}.to_json
+      multi.set "#{redis_key}:status", 'completed'
+      multi.set "#{redis_key}:created_at", SideJob.timestamp
+      multi.set "#{redis_key}:created_by", by
+    end
 
     if parent
       raise 'Missing name option for job with a parent' unless name
@@ -67,12 +74,11 @@ module SideJob
     job.run(at: at)
   end
 
-  # Finds a job by id
-  # @param job_id [Integer, nil] Job Id
+  # Finds a job by name or id.
+  # @param name_or_id [String, Integer] Job name or id
   # @return [SideJob::Job, nil] Job object or nil if it doesn't exist
-  def self.find(job_id)
-    return nil unless job_id
-    job = SideJob::Job.new(job_id) rescue nil
+  def self.find(name_or_id)
+    SideJob::Job.new(name_or_id) rescue nil
   end
 
   # Returns the current timestamp as a iso8601 string
@@ -81,31 +87,81 @@ module SideJob
     Time.now.utc.iso8601(9)
   end
 
-  # Adds a log entry to redis with current timestamp.
-  # @param entry [Hash] Log entry
+  # Publishes a log message using the current SideJob context.
+  # @param entry [Hash|Exception|String] Log entry
   def self.log(entry)
-    context = (Thread.current[:sidejob_log_context] || {}).merge(timestamp: SideJob.timestamp)
-    SideJob.redis.rpush 'jobs:logs', context.merge(entry).to_json
-  end
+    context = (Thread.current[:sidejob_context] || {}).merge(timestamp: SideJob.timestamp)
+
+    if entry.is_a?(Exception)
+      exception = entry
+      entry = { error: exception.message }
+      if exception.backtrace
+        # only store the backtrace until the first sidekiq line
+        entry[:backtrace] = exception.backtrace.take_while {|l| l !~ /sidekiq/}.join("\n")
+      end
+    elsif entry.is_a?(String)
+      entry = { message: entry }
+    end
 
-  # Return all job logs and optionally clears them.
-  # @param clear [Boolean] If true, delete logs after returning them (default true)
-  # @return [Array<Hash>] All logs with the oldest first
-  def self.logs(clear: true)
-    SideJob.redis.multi do |multi|
-      multi.lrange 'jobs:logs', 0, -1
-      multi.del 'jobs:logs' if clear
-    end[0].map {|log| JSON.parse(log)}
+    # Disable logging to prevent infinite publish loop for input ports subscribed to /sidejob/log which could generate log entries
+    SideJob::Port.group(log: false) do
+      SideJob.publish '/sidejob/log', context.merge(entry)
+    end
   end
 
-  # Adds the given metadata to all {SideJob.log} calls within the block.
-  # @param metadata [Hash] Metadata to be merged with each log entry
-  def self.log_context(metadata, &block)
-    previous = Thread.current[:sidejob_log_context]
-    Thread.current[:sidejob_log_context] = (previous || {}).merge(metadata.symbolize_keys)
+  # Adds to the current SideJob context within the block.
+  # @param data [Hash] Data to be merged into the current context
+  def self.context(data, &block)
+    previous = Thread.current[:sidejob_context]
+    Thread.current[:sidejob_context] = (previous || {}).merge(data.symbolize_keys)
     yield
   ensure
-    Thread.current[:sidejob_log_context] = previous
+    Thread.current[:sidejob_context] = previous
+  end
+
+  # Publishes a message up the channel hierarchy to jobs by writing to ports subscribed to the channel.
+  # Also publishes to the destination channel only via normal redis pubsub.
+  # @param channel [String] Channel is path-like, separated by / to indicate hierarchy
+  # @param message [Object] JSON encodable message
+  def self.publish(channel, message)
+    # We don't publish at every level up hierarchy via redis pubsub since a client can use redis psubscribe
+    SideJob.redis.publish channel, message.to_json
+
+    job_subs = {}
+
+    # Set the context to the original channel so that a job that subscribes to a higher channel can determine
+    # the original channel that the message was sent to.
+    SideJob.context({channel: channel}) do
+      # walk up the channel hierarchy
+      Pathname.new(channel).ascend do |channel|
+        channel = channel.to_s
+        jobs = SideJob.redis.smembers "channel:#{channel}"
+        jobs.each do |id|
+          job = SideJob.find(id)
+          if ! job_subs.has_key?(id)
+            job_subs[id] = {}
+            if job
+              SideJob.redis.hgetall("#{job.redis_key}:inports:channels").each_pair do |port, channels|
+                channels = JSON.parse(channels)
+                channels.each do |ch|
+                  job_subs[id][ch] ||= []
+                  job_subs[id][ch] << port
+                end
+              end
+            end
+          end
+
+          if job && job_subs[id] && job_subs[id][channel]
+            job_subs[id][channel].each do |port|
+              job.input(port).write message
+            end
+          else
+            # Job is gone or no longer subscribed to this channel
+            SideJob.redis.srem "channel:#{channel}", id
+          end
+        end
+      end
+    end
   end
 end
 

data/lib/sidejob/job.rb

@@ -33,13 +33,55 @@ module SideJob
     # Retrieve the job's status.
     # @return [String] Job status
     def status
-      get(:status)
+      check_exists
+      SideJob.redis.get "#{redis_key}:status"
     end
 
     # Set the job status.
     # @param status [String] The new job status
     def status=(status)
-      set({status: status})
+      check_exists
+      oldstatus = SideJob.redis.getset("#{redis_key}:status", status)
+      if oldstatus != status && worker_config['status_publish'] != false
+        SideJob::Port.group(log: false) do
+          publish({status: status})
+        end
+      end
+    end
+
+    # Returns all aliases for the job.
+    # @return [Array<String>] Job aliases
+    def aliases
+      SideJob.redis.smembers "#{redis_key}:aliases"
+    end
+
+    # Add an alias for the job.
+    # @param name [String] Alias for the job. Must begin with an alphabetic character.
+    # @raise [RuntimeError] Error if name is invalid or the name already refers to another job
+    def add_alias(name)
+      check_exists
+      raise "#{name} is not a valid alias" unless name =~ /^[[:alpha:]]/
+      current = SideJob.redis.hget('jobs:aliases', name)
+      if current
+        raise "#{name} is already used by job #{current}"  if current.to_i != id
+      else
+        SideJob.redis.multi do |multi|
+          multi.hset 'jobs:aliases', name, id
+          multi.sadd "#{redis_key}:aliases", name
+        end
+      end
+    end
+
+    # Remove an alias for the job.
+    # @param name [String] Alias to remove for the job
+    # @raise [RuntimeError] Error if name is not an alias for this job
+    def remove_alias(name)
+      check_exists
+      raise "#{name} is not an alias for job #{id}" unless SideJob.redis.sismember("#{redis_key}:aliases", name)
+      SideJob.redis.multi do |multi|
+        multi.hdel 'jobs:aliases', name
+        multi.srem "#{redis_key}:aliases", name
+      end
     end
 
     # Run the job.
@@ -53,8 +95,6 @@ module SideJob
     # @param wait [Float] Run in the specified number of seconds
     # @return [SideJob::Job, nil] The job that was run or nil if no job was run
     def run(parent: false, force: false, at: nil, wait: nil)
-      check_exists
-
       if parent
         pj = self.parent
         return pj ? pj.run(force: force, at: at, wait: wait) : nil
@@ -110,6 +150,7 @@ module SideJob
     # Queues a child job, setting parent and by to self.
     # @see SideJob.queue
     def queue(queue, klass, **options)
+      check_exists
       SideJob.queue(queue, klass, options.merge({parent: self, by: "job:#{id}"}))
     end
 
@@ -129,9 +170,7 @@ module SideJob
     # Returns the parent job.
     # @return [SideJob::Job, nil] Parent job or nil if none
     def parent
-      parent = get(:parent)
-      parent = SideJob.find(parent) if parent
-      parent
+      SideJob.find(SideJob.redis.get("#{redis_key}:parent"))
     end
 
     # Disown a child job so that it no longer has a parent.
@@ -148,7 +187,7 @@ module SideJob
       end
 
       SideJob.redis.multi do |multi|
-        multi.hdel job.redis_key, 'parent'
+        multi.del "#{job.redis_key}:parent"
         multi.hdel "#{redis_key}:children", name
       end
     end
@@ -157,12 +196,13 @@ module SideJob
     # @param orphan [SideJob::Job] Job that has no parent
     # @param name [String] Name of child job (must be unique among children)
     def adopt(orphan, name)
+      check_exists
       raise "Job #{id} cannot adopt itself as a child" if orphan == self
       raise "Job #{id} cannot adopt job #{orphan.id} as it already has a parent" unless orphan.parent.nil?
       raise "Job #{id} cannot adopt job #{orphan.id} as child name #{name} is not unique" if name.nil? || ! child(name).nil?
 
       SideJob.redis.multi do |multi|
-        multi.hset orphan.redis_key, 'parent', id.to_json
+        multi.set "#{orphan.redis_key}:parent", id.to_json
         multi.hset "#{redis_key}:children", name, orphan.id
       end
     end
@@ -176,14 +216,16 @@ module SideJob
       parent.disown(self) if parent
 
       children = self.children
+      aliases = self.aliases
 
       # delete all SideJob keys and disown all children
       ports = inports.map(&:redis_key) + outports.map(&:redis_key)
       SideJob.redis.multi do |multi|
         multi.srem 'jobs', id
         multi.del redis_key
-        multi.del ports + %w{children inports outports inports:default outports:default}.map {|x| "#{redis_key}:#{x}" }
+        multi.del ports + %w{worker status state aliases parent children inports outports inports:default outports:default inports:channels outports:channels created_at created_by ran_at}.map {|x| "#{redis_key}:#{x}" }
         children.each_value { |child| multi.hdel child.redis_key, 'parent' }
+        aliases.each { |name| multi.hdel('jobs:aliases', name) }
       end
 
       # recursively delete all children
@@ -191,6 +233,7 @@ module SideJob
         child.delete
       end
 
+      publish({deleted: true})
       return true
     end
 
@@ -236,20 +279,39 @@ module SideJob
       set_ports :out, ports
     end
 
-    # Returns the entirety of the job's state with both standard and custom keys.
-    # @return [Hash{String => Object}] Job state
+    # Returns
+    # @return [Hash]
+    def info
+      check_exists
+      data = SideJob.redis.multi do |multi|
+        multi.get "#{redis_key}:worker"
+        multi.get "#{redis_key}:created_by"
+        multi.get "#{redis_key}:created_at"
+        multi.get "#{redis_key}:ran_at"
+      end
+
+      worker = JSON.parse(data[0])
+      {
+          queue: worker['queue'], class: worker['class'], args: worker['args'],
+          created_by: data[1], created_at: data[2], ran_at: data[3],
+      }
+    end
+
+    # Returns the entirety of the job's internal state.
+    # @return [Hash{String => Object}] Job internal state
     def state
-      state = SideJob.redis.hgetall(redis_key)
-      raise "Job #{id} does not exist!" if ! state
+      check_exists
+      state = SideJob.redis.hgetall("#{redis_key}:state")
       state.update(state) {|k,v| JSON.parse("[#{v}]")[0]}
       state
     end
 
-    # Returns some data from the job's state.
+    # Returns some data from the job's internal state.
     # @param key [Symbol,String] Retrieve value for the given key
     # @return [Object,nil] Value from the job state or nil if key does not exist
     def get(key)
-      val = SideJob.redis.hget(redis_key, key)
+      check_exists
+      val = SideJob.redis.hget("#{redis_key}:state", key)
       val ? JSON.parse("[#{val}]")[0] : nil
     end
 
@@ -259,7 +321,7 @@ module SideJob
     def set(data)
       check_exists
       return unless data.size > 0
-      SideJob.redis.hmset redis_key, *(data.map {|k,v| [k, v.to_json]}.flatten)
+      SideJob.redis.hmset "#{redis_key}:state", *(data.map {|k,v| [k, v.to_json]}.flatten)
     end
 
     # Unsets some fields in the job's internal state.
@@ -267,7 +329,7 @@ module SideJob
     # @raise [RuntimeError] Error raised if job no longer exists
     def unset(*fields)
       return unless fields.length > 0
-      SideJob.redis.hdel redis_key, fields
+      SideJob.redis.hdel "#{redis_key}:state", fields
     end
 
     # Acquire a lock on the job with a given expiration time.
@@ -276,6 +338,7 @@ module SideJob
     # @param retry_delay [Float] Maximum seconds to wait (actual will be randomized) before retry getting lock
     # @return [String, nil] Lock token that should be passed to {#unlock} or nil if lock was not acquired
     def lock(ttl, retries: 3, retry_delay: 0.2)
+      check_exists
       retries.times do
         token = SecureRandom.uuid
         if SideJob.redis.set("#{redis_key}:lock", token, {nx: true, ex: ttl})
@@ -291,6 +354,7 @@ module SideJob
     # @param ttl [Fixnum] Refresh lock expiration for the given time in seconds
     # @return [Boolean] Whether the timeout was set
     def refresh_lock(ttl)
+      check_exists
       SideJob.redis.expire "#{redis_key}:lock", ttl
     end
 
@@ -298,6 +362,7 @@ module SideJob
     # @param token [String] Token returned by {#lock}
     # @return [Boolean] Whether the job was unlocked
     def unlock(token)
+      check_exists
       return SideJob.redis.eval('
         if redis.call("get",KEYS[1]) == ARGV[1] then
           return redis.call("del",KEYS[1])
@@ -306,6 +371,12 @@ module SideJob
         end', { keys: ["#{redis_key}:lock"], argv: [token] }) == 1
     end
 
+    # Publishes a message to the job's channel.
+    # @param message [Object] JSON encodable message
+    def publish(message)
+      SideJob.publish "/sidejob/job/#{id}", message
+    end
+
     private
 
     # Queue or schedule this job using sidekiq.
@@ -314,21 +385,17 @@ module SideJob
       # Don't need to queue if a worker is already in process of running
       return if SideJob.redis.exists "#{redis_key}:lock:worker"
 
-      queue = get(:queue)
-
+      worker = JSON.parse(SideJob.redis.get("#{redis_key}:worker"))
       # Don't need to queue if the job is already in the queue (this does not include scheduled jobs)
       # When Sidekiq pulls job out from scheduled set, we can still get the same job queued multiple times
       # but the server middleware handles it
-      return if Sidekiq::Queue.new(queue).find_job(@id)
-
-      klass = get(:class)
-      args = get(:args)
+      return if Sidekiq::Queue.new(worker['queue']).find_job(@id)
 
-      if ! SideJob.redis.hexists("workers:#{queue}", klass)
+      if ! SideJob::Worker.config(worker['queue'], worker['class'])
         self.status = 'terminated'
-        raise "Worker no longer registered for #{klass} in queue #{queue}"
+        raise "Worker no longer registered for #{klass} in queue #{worker['queue']}"
       end
-      item = {'jid' => id, 'queue' => queue, 'class' => klass, 'args' => args || [], 'retry' => false}
+      item = {'jid' => id, 'queue' => worker['queue'], 'class' => worker['class'], 'args' => worker['args'] || [], 'retry' => false}
       item['at'] = time if time && time > Time.now.to_f
       Sidekiq::Client.push(item)
     end
@@ -338,17 +405,24 @@ module SideJob
       SideJob.redis.smembers("#{redis_key}:#{type}ports").reject {|name| name == '*'}.map {|name| SideJob::Port.new(self, type, name)}
     end
 
+    # Return the worker configuration
+    # @return [Hash] Worker config for the job
+    def worker_config
+      worker = JSON.parse(SideJob.redis.get("#{redis_key}:worker"))
+      SideJob::Worker.config(worker['queue'], worker['class']) || {}
+    end
+
     # Sets the input/outputs ports for the job and overwrites all current options.
     # The ports are merged with the worker configuration.
     # Any current ports that are not in the new port set are deleted (including any data on those ports).
     # @param type [:in, :out] Input or output ports
     # @param ports [Hash{Symbol,String => Hash}] Port configuration. Port name to options.
     def set_ports(type, ports)
+      check_exists
       current = SideJob.redis.smembers("#{redis_key}:#{type}ports") || []
-      config = SideJob::Worker.config(get(:queue), get(:class))
 
       ports ||= {}
-      ports = (config["#{type}ports"] || {}).merge(ports.dup.stringify_keys)
+      ports = (worker_config["#{type}ports"] || {}).merge(ports.dup.stringify_keys)
       ports.each_key do |port|
         ports[port] = ports[port].stringify_keys
       end
@@ -365,13 +439,27 @@ module SideJob
         # replace port defaults
         defaults = ports.map do |port, options|
           if options.has_key?('default')
-            [port, options['default'].to_json]
+            [port, SideJob::Port.encode_data(options['default'])]
           else
             nil
           end
         end.compact.flatten(1)
         multi.del "#{redis_key}:#{type}ports:default"
         multi.hmset "#{redis_key}:#{type}ports:default", *defaults if defaults.length > 0
+
+        # replace port channels
+        channels = ports.map do |port, options|
+          if options.has_key?('channels')
+            options['channels'].each do |channel|
+              multi.sadd "channel:#{channel}", id
+            end
+            [port, options['channels'].to_json]
+          else
+            nil
+          end
+        end.compact.flatten(1)
+        multi.del "#{redis_key}:#{type}ports:channels"
+        multi.hmset "#{redis_key}:#{type}ports:channels", *channels if channels.length > 0
       end
     end
 
@@ -386,9 +474,9 @@ module SideJob
   class Job
     include JobMethods
 
-    # @param id [Integer] Job id
-    def initialize(id)
-      @id = id.to_i
+    # @param alias_or_id [String, Integer] Job alias or id
+    def initialize(alias_or_id)
+      @id = (SideJob.redis.hget('jobs:aliases', alias_or_id.to_s) || alias_or_id).to_i
       check_exists
     end
   end