postjob 0.5.5 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4f4e54ce9a3522400d5f29d0ebfbb8552b98e72b
-  data.tar.gz: 66154224d10c0fb2b5d72e350476ccb817c5634e
+SHA256:
+  metadata.gz: 574e3a114fa762835314b2e72a2d12b73840569661d9ff8ab06f1ba08d95fb92
+  data.tar.gz: e922e1f1116423b4895a4725107f0456260fa6382edcb308e220fdf62622b528
 SHA512:
-  metadata.gz: 6e48d531c2da7d304e351630faa9f535b380009efa5aac4fef2f60a3f6cf339d0a8bcf34e59467f435a993daff02210f3eec4509bf218daee31f10a5c3ad08db
-  data.tar.gz: 2d588a518f7602595809a06c9b44d93e69b268f55bc1eec5a60419ec2218369bf18f5c5d69c379dbcf37a2423c0ca4c9064ed5474dd2f4ee3634f1384538f017
+  metadata.gz: 9d7a61a2298c1fc15efc9ce424111d1baf102326b4f73a8314b3e42085a3929443390df44f8e721ef9bac0d4d2273d57a21c8252a4e30a140c6c523ee3766939
+  data.tar.gz: 782b95ae3ab74ad021772b7eb4f3886b8c92835ef3484fa34f1c4ba84792db80e5448273a8318661004d4a36229f554674b87ee00e453882388a27a72d7403be

data/lib/postjob/cli/cron.rb

@@ -0,0 +1,16 @@
+module Postjob::CLI
+  # Enqueues a cron workflow
+  def cron_enqueue(workflow, *args, interval:, queue: "ruby", tags: nil)
+    interval = Integer(interval)
+
+    connect_to_database!
+
+    Postjob.enqueue! workflow, *args, queue: queue, tags: parse_tags(tags), cron_interval: interval
+  end
+
+  # Disable an existing cron job
+  def cron_disable(workflow, *args)
+    connect_to_database!
+    Postjob::Queue.disable_cron_jobs(workflow, args)
+  end
+end

data/lib/postjob/cli/enqueue.rb

@@ -0,0 +1,14 @@
+module Postjob::CLI
+  # Enqueues a workflow
+  #
+  # Adds a workflow to the job table, with name <workflow> and the given
+  # arguments.
+  #
+  # Note that the workflow will receive the arguments as strings and must be
+  # prepared to handle these.
+  def enqueue(workflow, *args, queue: "ruby", tags: nil)
+    connect_to_database!
+
+    Postjob.enqueue! workflow, *args, queue: queue, tags: parse_tags(tags)
+  end
+end

data/lib/postjob/cli/job.rb

@@ -5,23 +5,9 @@ module Postjob::CLI
     Postjob.resolve(token: token, result: result)
   end
 
-  # # Fail a job by token
-  # def job_resolve(token, result)
-  #   connect_to_database!
-  #   Postjob.resolve(token: token, result: result)
-  # end
-
-  # Enqueues a workflow
-  #
-  # Adds a workflow to the job table, with name <workflow> and the given
-  # arguments.
-  #
-  # Note that the workflow will receive the arguments as strings and must be
-  # prepared to handle these.
   def job_enqueue(workflow, *args, queue: "ruby", tags: nil)
-    connect_to_database!
-
-    Postjob.enqueue! workflow, *args, queue: queue, tags: parse_tags(tags)
+    logger "The job:enqueue command is deprecated, pls use enqueue instead."
+    enqueue(workflow, *args, queue: queue, tags: tags)
   end
 
   # Reset failed jobs
@@ -101,8 +87,18 @@ module Postjob::CLI
   public
 
   def registry
-    workflows = Postjob::Registry.workflows
-    names = workflows.map(&:workflow_name)
-    puts names.sort.join("\n")
+    workflows_with_versions = Postjob::Registry.workflows.keys.reject { |k| k[1] == "" }
+    workflows_with_versions = workflows_with_versions.sort_by { |name, _version| name }
+
+    data = workflows_with_versions.map do |name, version|
+      spec = Postjob::Registry.lookup! name: name, version: version
+      {
+        name: name,
+        version: version.inspect,
+        options: spec.options.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+      }
+    end
+
+    tp data
   end
 end

data/lib/postjob/cli/ps.rb

@@ -24,9 +24,15 @@ module Postjob::CLI
           END AS status,
         error,
         COALESCE((results->0)::varchar, error_message) AS result,
+        max_attempts,
+        cron_interval AS cron,
+        CASE
+          WHEN is_sticky THEN COALESCE(sticky_host_id::varchar, 'yes')
+          ELSE 'no'
+          END AS sticky,
         next_run_at,
-        next_run_at - (now() at time zone 'utc') AS next_run_in,
-        to_char(EXTRACT(EPOCH FROM (now() at time zone 'utc') - postjobs.created_at), '999999999.99') AS age,
+        to_char(EXTRACT(EPOCH FROM (next_run_at - now() at time zone 'utc')), '999999999.99') AS next_run_in,
+        to_char(EXTRACT(EPOCH FROM (now() at time zone 'utc' - postjobs.created_at)), '999999999.99') AS age,
 
         tags
       FROM postjob.postjobs AS postjobs

data/lib/postjob/host.rb

@@ -0,0 +1,41 @@
+require_relative "./record"
+
+class Postjob::Host < Postjob::Record
+  class << self
+    def clear_storage
+      File.unlink(storage_path) if File.exist?(storage_path)
+    end
+
+    def host_id
+      @host_id ||= atomic_set_and_get(storage_path) { register_host }
+    end
+
+    private
+
+    def storage_path
+      env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+      ".postjob.#{env}.host_id"
+    end
+
+    def atomic_set_and_get(path)
+      value = nil
+      File.open(path, File::RDWR | File::CREAT, 0644) do |f|
+        f.flock(File::LOCK_EX)
+
+        value = f.read
+        value = yield if value == "" || value.nil?
+        f.rewind
+        f.write(value)
+        f.flush
+        f.truncate(f.pos)
+      end
+      value
+    end
+
+    def register_host
+      attributes = {}
+      Postjob.logger.debug "registering host w/#{attributes.inspect}"
+      ::Postjob::Queue.host_register(attributes)
+    end
+  end
+end

data/lib/postjob/job.rb

@@ -9,29 +9,29 @@ class Postjob::Job < Postjob::Record
     Simple::SQL.ask(scope, into: Postjob::Job)
   end
 
-  attribute :id
-  attribute :parent_id
-  attribute :full_id
-  attribute :root_id
-  attribute :created_at
-  attribute :queue
-  attribute :workflow
-  attribute :workflow_method
-  attribute :workflow_version
-  attribute :args
-  attribute :next_run_at
-  attribute :timing_out_at
-  attribute :failed_attempts
-  attribute :max_attempts
-  attribute :status
-  attribute :results
-  attribute :error
-  attribute :error_message
-  attribute :error_backtrace
-  attribute :recipients
-  attribute :timed_out
-  attribute :tags
-  attribute :last_worker_session_id
+  attr_reader :id
+  attr_reader :parent_id
+  attr_reader :full_id
+  attr_reader :root_id
+  attr_reader :created_at
+  attr_reader :queue
+  attr_reader :workflow
+  attr_reader :workflow_method
+  attr_reader :workflow_version
+  attr_reader :args
+  attr_reader :next_run_at
+  attr_reader :timing_out_at
+  attr_reader :failed_attempts
+  attr_reader :max_attempts
+  attr_reader :status
+  attr_reader :results
+  attr_reader :error
+  attr_reader :error_message
+  attr_reader :error_backtrace
+  attr_reader :recipients
+  attr_reader :timed_out
+  attr_reader :tags
+  attr_reader :last_worker_session_id
 
   STATUSES = %w(ok ready processing sleep err failed timeout)
 

data/lib/postjob/migrations/006_enqueue.sql

@@ -1,3 +1,28 @@
+DROP FUNCTION IF EXISTS {SCHEMA_NAME}.enqueue(
+    p_worker_session_id UUID,
+    queue VARCHAR,
+    workflow VARCHAR,
+    workflow_method VARCHAR,
+    workflow_version VARCHAR,
+    args JSONB,
+    parent_id BIGINT,
+    tags JSONB,
+    max_attempts INTEGER,
+    timeout DOUBLE PRECISION);
+
+DROP FUNCTION IF EXISTS {SCHEMA_NAME}.enqueue(
+    p_worker_session_id UUID,
+    queue VARCHAR,
+    workflow VARCHAR,
+    workflow_method VARCHAR,
+    workflow_version VARCHAR,
+    args JSONB,
+    parent_id BIGINT,
+    tags JSONB,
+    max_attempts INTEGER,
+    timeout DOUBLE PRECISION,
+    p_cron_interval integer);
+
 CREATE OR REPLACE FUNCTION {SCHEMA_NAME}.enqueue(
     p_worker_session_id UUID,
     queue VARCHAR,
@@ -8,34 +33,53 @@ CREATE OR REPLACE FUNCTION {SCHEMA_NAME}.enqueue(
     parent_id BIGINT,
     tags JSONB,
     max_attempts INTEGER,
-    timeout DOUBLE PRECISION)
+    timeout DOUBLE PRECISION,
+    p_cron_interval INTEGER,
+    p_is_sticky BOOLEAN)
   RETURNS SETOF {SCHEMA_NAME}.postjobs
 AS $$
   DECLARE
     job_id BIGINT;
   BEGIN
-    -- set defaults ---------------------------------------------------
+    -- check arguments --------------------------------------------------------
+
     IF workflow = '__manual__' AND COALESCE(max_attempts, 1) != 1 THEN
       RAISE NOTICE 'Adjusting max_attempts of __manual__ job to 1';
       max_attempts := 1;
     END IF;
 
+    IF p_cron_interval IS NOT NULL THEN
+      IF parent_id IS NOT NULL THEN
+        RAISE 'A cron job must be a root job';
+      END IF;
+      IF p_cron_interval < 1 THEN
+        RAISE 'The cron_interval must be positive';
+      END IF;
+    END IF;
+
+    -- check arguments --------------------------------------------------------
+
     workflow_version  := COALESCE(workflow_version, '');
     queue             := COALESCE(queue, 'q');
     max_attempts      := COALESCE(max_attempts, 5);
+    p_is_sticky       := COALESCE(p_is_sticky, FALSE);
 
     -- create postjobs entry ------------------------------------------
     INSERT INTO {SCHEMA_NAME}.postjobs (
       last_worker_session_id,
       queue, workflow, workflow_method, workflow_version, args,
       parent_id, tags, max_attempts,
-      timing_out_at
+      timing_out_at,
+      cron_interval,
+      is_sticky
     )
     VALUES(
       p_worker_session_id,
       queue, workflow, workflow_method, workflow_version, args,
       parent_id, tags, max_attempts,
-      (now() at time zone 'utc') + timeout * interval '1 second'
+      (now() at time zone 'utc') + timeout * interval '1 second',
+      p_cron_interval,
+      p_is_sticky
     ) RETURNING {SCHEMA_NAME}.postjobs.id INTO job_id;
 
     -- fill in root_id and full_id ------------------------------------

data/lib/postjob/migrations/006a_processing.sql

@@ -2,8 +2,10 @@ DROP FUNCTION IF EXISTS {SCHEMA_NAME}._set_job_processing(job_id BIGINT);  -- re
 CREATE OR REPLACE FUNCTION {SCHEMA_NAME}._set_job_processing(worker_session_id UUID, job_id BIGINT) RETURNS VOID AS $$
 DECLARE
   v_pid int;
+  v_host_id uuid;
 BEGIN
   v_pid := pg_backend_pid();
+  SELECT host_id INTO v_host_id FROM {SCHEMA_NAME}.worker_sessions WHERE id=worker_session_id;
 
   UPDATE {SCHEMA_NAME}.postjobs
   SET
@@ -12,8 +14,9 @@ BEGIN
     error=NULL,
     error_message=NULL,
     error_backtrace=NULL,
-    next_run_at=NULL
-   WHERE id=job_id;
+    next_run_at=NULL,
+    sticky_host_id=(CASE WHEN is_sticky THEN v_host_id ELSE NULL END)
+  WHERE id=job_id;
 END;
 $$ LANGUAGE plpgsql;
 

data/lib/postjob/migrations/007_job_results.sql

@@ -45,10 +45,12 @@ BEGIN
 END;
 $$ LANGUAGE plpgsql;
 
+DROP FUNCTION IF EXISTS {SCHEMA_NAME}._prepare_next_run(BIGINT, {SCHEMA_NAME}.statuses, BOOLEAN);
+
 -- If this is a recoverable error and if we have another run possible
 -- we'll set next_run_at, and the status to "err", otherwise
 -- next_run_at will be NULL and the status would be "failed" or "timeout"
-CREATE OR REPLACE FUNCTION {SCHEMA_NAME}._prepare_next_run(
+CREATE OR REPLACE FUNCTION {SCHEMA_NAME}._prepare_rerun(
   job_id BIGINT,
   p_status {SCHEMA_NAME}.statuses,
   p_fast_mode BOOLEAN) RETURNS VOID AS $$
@@ -119,8 +121,7 @@ BEGIN
     next_run_at=NULL
   WHERE id=job_id;
 
-  -- prepare next run, if any
-  PERFORM {SCHEMA_NAME}._prepare_next_run(job_id, p_status, p_fast_mode);
+  PERFORM {SCHEMA_NAME}._prepare_rerun(job_id, p_status, p_fast_mode);
   PERFORM {SCHEMA_NAME}._wakeup_parent_job(p_worker_session_id, job_id);
 END;
 $$ LANGUAGE plpgsql;
@@ -144,7 +145,7 @@ BEGIN
   WHERE id=job_id;
 
   -- prepare next run, if any
-  PERFORM {SCHEMA_NAME}._prepare_next_run(job_id, 'timeout', p_fast_mode);
+  PERFORM {SCHEMA_NAME}._prepare_rerun(job_id, 'timeout', p_fast_mode);
   PERFORM {SCHEMA_NAME}._wakeup_parent_job(p_worker_session_id, job_id);
 END;
 $$ LANGUAGE plpgsql;
@@ -170,7 +171,7 @@ BEGIN
   WHERE id=job_id;
 
   -- prepare next run, if any
-  PERFORM {SCHEMA_NAME}._prepare_next_run(job_id, 'err', p_fast_mode);
+  PERFORM {SCHEMA_NAME}._prepare_rerun(job_id, 'err', p_fast_mode);
   PERFORM {SCHEMA_NAME}._wakeup_parent_job(p_worker_session_id, job_id);
 END;
 $$ LANGUAGE plpgsql;

data/lib/postjob/migrations/008a_childjobs.sql

@@ -49,47 +49,42 @@ BEGIN
     RAISE 'Invalid parent job id NULL';
   END IF;
 
-  IF v_parent_id IS NOT NULL THEN
-    SELECT INTO parent * FROM {SCHEMA_NAME}.postjobs WHERE id=v_parent_id;
-    IF parent.id IS NULL THEN
-      RAISE 'No such job: %', v_parent_id;
-    END IF;
-  END IF;
+  -- create a child job if it doesn't exist yet.
 
-  -- check for existing child record
+  SELECT id INTO child_id FROM {SCHEMA_NAME}.postjobs
+  WHERE parent_id=v_parent_id
+    AND workflow=v_workflow
+    AND workflow_method=v_workflow_method
+    AND args=v_args
+    ;
 
-  -- IF v_parent_id IS NOT NULL THEN
-    SELECT id INTO child_id FROM {SCHEMA_NAME}.postjobs
-    WHERE parent_id=v_parent_id
-      AND workflow=v_workflow
-      AND workflow_method=v_workflow_method
-      AND args=v_args
-      ;
+  IF child_id IS NULL THEN
+    SELECT * INTO parent
+      FROM {SCHEMA_NAME}.postjobs
+      WHERE postjobs.id=v_parent_id;
 
-    IF child_id IS NOT NULL THEN
-      -- note that RETURN QUERY does not return the function here. It 'only'
-      -- adds the specified query to the result set.
-      RETURN QUERY
-        SELECT * FROM {SCHEMA_NAME}.postjobs WHERE id=child_id
-      ;
-    ELSE
-      IF v_tags IS NOT NULL THEN
-        RAISE WARNING 'Ignoring tags %', v_tags;
-      END IF;
+    SELECT id INTO child_id FROM {SCHEMA_NAME}.enqueue(
+      p_worker_session_id,
+      COALESCE(v_queue, parent.queue),  -- queue VARCHAR,
+      v_workflow,                       -- workflow VARCHAR,
+      v_workflow_method,                -- workflow_method VARCHAR,
+      NULL,                             -- workflow_version VARCHAR,
+      v_args,                           -- args JSONB,
+      v_parent_id,                      -- parent_id BIGINT,
+      parent.tags,                      -- tags JSONB,
+      v_max_attempts,                   -- max_attempts INTEGER,
+      v_timeout,                        -- timeout
+      NULL,                             -- cron_interval,
+      parent.is_sticky                  -- is_sticky?
+    );
 
-      RETURN QUERY
-        SELECT * FROM {SCHEMA_NAME}.enqueue(
-          p_worker_session_id,
-          COALESCE(v_queue, parent.queue),  -- queue VARCHAR,
-          v_workflow,                       -- workflow VARCHAR,
-          v_workflow_method,                -- workflow_method VARCHAR,
-          NULL,                             -- workflow_version VARCHAR,
-          v_args,                           -- args JSONB,
-          v_parent_id,                      -- parent_id BIGINT,
-          parent.tags,                      -- tags JSONB,
-          v_max_attempts,                   -- max_attempts INTEGER,
-          v_timeout);
-    END IF;
-  -- END IF;
+    UPDATE {SCHEMA_NAME}.postjobs
+      SET sticky_host_id=parent.sticky_host_id
+      WHERE id=child_id;
+  END IF;
+
+  RETURN QUERY
+    SELECT * FROM {SCHEMA_NAME}.postjobs WHERE id=child_id
+  ;
 END;
 $$ LANGUAGE plpgsql;

data/lib/postjob/migrations/010_settings.sql

@@ -27,5 +27,5 @@ $$ LANGUAGE plpgsql;
 
 -- define version settings ----------------------------------------------------
 
-SELECT {SCHEMA_NAME}.settings_set('version', '0.5.0');
+SELECT {SCHEMA_NAME}.settings_set('version', '0.5.6');
 SELECT {SCHEMA_NAME}.settings_set('client_version', '{CLIENT_VERSION}');

data/lib/postjob/migrations/{008_checkout_runnable.sql → 013a_checkout_runnable.sql}

@@ -4,9 +4,10 @@ CREATE OR REPLACE FUNCTION {SCHEMA_NAME}.time_to_next_job(p_worker_session_id UU
 AS $$
 DECLARE
   p_processable_at timestamp;
-  p_workflows_with_version varchar[];
+  session {SCHEMA_NAME}.worker_sessions;
 BEGIN
-  SELECT workflows INTO p_workflows_with_version FROM {SCHEMA_NAME}.worker_sessions WHERE id=p_worker_session_id;
+  SELECT * INTO session
+  FROM {SCHEMA_NAME}.worker_sessions WHERE id=p_worker_session_id;
 
   SELECT MIN(processable_at) INTO p_processable_at FROM (
       SELECT MIN(timing_out_at) AS processable_at
@@ -16,10 +17,11 @@ BEGIN
       SELECT MIN(next_run_at) AS processable_at
       FROM {SCHEMA_NAME}.postjobs
       WHERE status IN ('ready', 'err')
-        AND workflow || workflow_version = ANY (p_workflows_with_version)
+        AND (workflow || workflow_version) = ANY (session.workflows)
+        AND COALESCE(sticky_host_id, {SCHEMA_NAME}._null_uuid()) IN (session.host_id, {SCHEMA_NAME}._null_uuid())
   ) sq;
 
-  RETURN EXTRACT(EPOCH FROM  p_processable_at - (now() at time zone 'utc'));
+  RETURN EXTRACT(EPOCH FROM p_processable_at - (now() at time zone 'utc'));
 END;
 $$ LANGUAGE plpgsql;
 
@@ -29,9 +31,10 @@ CREATE OR REPLACE FUNCTION {SCHEMA_NAME}.checkout(p_worker_session_id UUID, p_fa
 AS $$
 DECLARE
   job {SCHEMA_NAME}.postjobs;
-  p_workflows_with_version varchar[];
+  session {SCHEMA_NAME}.worker_sessions;
 BEGIN
-  SELECT workflows INTO p_workflows_with_version FROM {SCHEMA_NAME}.worker_sessions WHERE id=p_worker_session_id;
+  SELECT * INTO session
+  FROM {SCHEMA_NAME}.worker_sessions WHERE id=p_worker_session_id;
 
   LOOP
     -- try to checkout a job. Each of the conditions here is matching
@@ -47,7 +50,8 @@ BEGIN
       (
         s.status IN ('ready', 'err')
         AND s.next_run_at <= (now() at time zone 'utc')
-        AND (s.workflow || s.workflow_version) = ANY (p_workflows_with_version)
+        AND (s.workflow || s.workflow_version) = ANY (session.workflows)
+        AND COALESCE(s.sticky_host_id, {SCHEMA_NAME}._null_uuid()) IN (session.host_id, {SCHEMA_NAME}._null_uuid())
       )
     ORDER BY (LEAST(s.next_run_at, s.timing_out_at))
     FOR UPDATE SKIP LOCKED

data/lib/postjob/migrations/017_zombie_check.sql

@@ -15,6 +15,12 @@ DECLARE
 BEGIN
   zombie_count := 0;
   FOR zombie_id, _one IN
+    -- select jobs that have a last_worker_session_id, which points to a
+    -- host whose latest heartbeat is older than +zombie_threshold+.
+    --
+    -- note that we ignore hosts (and, for that matter, jobs) that don't
+    -- have any heartbeats, since this scenario should only appear during
+    -- tests.
     SELECT jobs.id, 1
     FROM {SCHEMA_NAME}.postjobs jobs
     LEFT JOIN {SCHEMA_NAME}.worker_sessions sessions ON jobs.last_worker_session_id=sessions.id
@@ -27,10 +33,7 @@ BEGIN
     ) heartbeat ON sessions.host_id = heartbeat.host_id
     WHERE
       jobs.status IN ('processing')
-      AND (
-        heartbeat.created_at IS NULL OR
-        heartbeat.created_at < ((now() at time zone 'utc') - zombie_threshold)
-      )
+      AND heartbeat.created_at < ((now() at time zone 'utc') - zombie_threshold)
   LOOP
     PERFORM {SCHEMA_NAME}._set_job_zombie(zombie_id, p_fast_mode);
     zombie_count := zombie_count + 1;
@@ -51,8 +54,10 @@ BEGIN
   -- event, which has a zombie count value in its attributes.
   IF NOT EXISTS (SELECT 1 FROM {SCHEMA_NAME}.events WHERE name='zombie' AND created_at > (now() at time zone 'utc') - zombie_check_interval) THEN
     p_zombie_count := {SCHEMA_NAME}._zombie_check(p_fast_mode);
-    INSERT INTO {SCHEMA_NAME}.events(name, host_id, attributes)
-      VALUES('zombie', {SCHEMA_NAME}._null_uuid(), jsonb_build_object('zombie_count', p_zombie_count));
+    IF p_zombie_count > 0 THEN
+      INSERT INTO {SCHEMA_NAME}.events(name, host_id, attributes)
+        VALUES('zombie', {SCHEMA_NAME}._null_uuid(), jsonb_build_object('zombie_count', p_zombie_count));
+    END IF;
   END IF;
 END;
 $$ LANGUAGE plpgsql;

data/lib/postjob/migrations/021_cron_jobs.sql

@@ -0,0 +1,65 @@
+DO $$
+  BEGIN
+    ALTER TABLE {SCHEMA_NAME}.postjobs ADD COLUMN cron_interval integer;
+  EXCEPTION
+    WHEN duplicate_column THEN RAISE DEBUG 'column {SCHEMA_NAME}.postjobs.cron_interval already exists';
+  END;
+$$;
+
+--- define triggers to automatically restart cron jobs ------------------------
+
+-- This method is called whenever a job's status changes. It enqueues a fresh 
+
+--
+-- An event is created whenever a job's status changes.
+--
+
+CREATE OR REPLACE FUNCTION {SCHEMA_NAME}._restart_cron_job()
+  RETURNS TRIGGER
+AS $$
+DECLARE
+  p_new_jonb_id BIGINT;
+BEGIN
+  IF NEW.status = OLD.status THEN
+    RETURN NEW;
+  END IF;
+
+  IF TG_OP != 'UPDATE' OR NEW.status NOT IN ('failed', 'ok') THEN
+    RETURN NEW;
+  END IF;
+
+  IF NEW.cron_interval IS NULL THEN
+    RETURN NEW;
+  END IF;
+
+  SELECT id INTO p_new_jonb_id FROM {SCHEMA_NAME}.enqueue(
+    NEW.last_worker_session_id,                                                     -- p_worker_session_id 
+    NEW.queue,                                                                      -- queue 
+    NEW.workflow,                                                                   -- workflow 
+    NEW.workflow_method,                                                            -- workflow_method 
+    NULL,                                                                           -- workflow_version 
+    NEW.args,                                                                       -- args 
+    NULL,                                                                           -- parent_id 
+    NEW.tags,                                                                       -- tags 
+    NEW.max_attempts,                                                               -- max_attempts
+    (EXTRACT(EPOCH FROM NEW.timing_out_at) - EXTRACT(EPOCH FROM NEW.created_at)),   -- timeout
+    NEW.cron_interval,
+    NEW.is_sticky
+  );
+
+  UPDATE {SCHEMA_NAME}.postjobs
+  SET next_run_at = now() at time zone 'utc' + NEW.cron_interval * interval '1 second'
+  WHERE id=p_new_jonb_id;
+  
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+BEGIN;
+  DROP TRIGGER IF EXISTS _restart_cron_job ON {SCHEMA_NAME}.postjobs;
+
+  CREATE TRIGGER _restart_cron_job AFTER UPDATE
+    ON {SCHEMA_NAME}.postjobs
+    FOR EACH ROW
+    EXECUTE PROCEDURE {SCHEMA_NAME}._restart_cron_job();
+COMMIT;

data/lib/postjob/migrations/023_sticky_jobs.sql

@@ -0,0 +1,16 @@
+DO $$
+  BEGIN
+    ALTER TABLE {SCHEMA_NAME}.postjobs ADD COLUMN is_sticky BOOLEAN NOT NULL DEFAULT FALSE;
+  EXCEPTION
+    WHEN duplicate_column THEN RAISE DEBUG 'column {SCHEMA_NAME}.postjobs.is_sticky already exists';
+  END;
+$$;
+
+DO $$
+  BEGIN
+    ALTER TABLE {SCHEMA_NAME}.postjobs ADD COLUMN sticky_host_id UUID 
+      REFERENCES {SCHEMA_NAME}.hosts;
+  EXCEPTION
+    WHEN duplicate_column THEN RAISE DEBUG 'column {SCHEMA_NAME}.postjobs.sticky_host_id already exists';
+  END;
+$$;

data/lib/postjob/migrations.rb

@@ -16,6 +16,8 @@ module Postjob
     expect! SCHEMA_NAME != "public"
 
     def unmigrate!
+      ::Postjob::Host.clear_storage
+
       SQL.exec "SET client_min_messages TO WARNING"
       SQL.exec "DROP SCHEMA IF EXISTS #{SCHEMA_NAME} CASCADE"
     end
@@ -45,7 +47,7 @@ module Postjob
 
     def run_migration_sql(file)
       sql = File.read(file)
-      sql.gsub!(/\{([^\}]+)\}/) { |_| const_get($1) }
+      sql.gsub!(/\{([^\}]+)\}/) { |_| const_get(Regexp.last_match(1)) }
       SQL.exec sql
     end
   end