pg_cron 2.0.0

data/lib/pg_cron/statements.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module PgCron
+  # Migration methods for pg_cron schedules, following F(x)'s conventions
+  # exactly: a name, an optional `version` naming a file in db/cron, an optional
+  # `sql_definition` that takes its place, and `revert_to_version` so a rollback
+  # restores the previous definition instead of dropping the job outright.
+  #
+  # Replaces schedule_pg_cron_job / unschedule_pg_cron_job / update_pg_cron_job,
+  # which took only a name and read a YAML file. Those had no versioning, so a
+  # changed schedule left no record of what it had been and a rollback could
+  # only delete the job.
+  module Statements
+    # Create a new cron job.
+    #
+    # @param name [String, Symbol] The job's name. pg_cron keys on jobname, so
+    #   this is its identity — scheduling over an existing name replaces it.
+    # @param version [Integer] The version number, used to find the definition
+    #   file in `db/cron`. Defaults to `1`.
+    # @param sql_definition [String] The SQL for the job. An error is raised if
+    #   `sql_definition` and `version` are both set, as they are mutually
+    #   exclusive.
+    # @return [void]
+    #
+    # @example Create from `db/cron/drain_juicefs_events_v01.sql`
+    #   create_cron_job(:drain_juicefs_events, version: 1)
+    #
+    # @example Create from provided SQL string
+    #   create_cron_job(:drain_juicefs_events, sql_definition: <<~SQL)
+    #     SELECT cron.schedule(
+    #       'drain_juicefs_events',
+    #       '* * * * *',
+    #       $$SELECT juicefs_index_events(500)$$
+    #     );
+    #   SQL
+    #
+    def create_cron_job(name, version: nil, sql_definition: nil, revert_to_version: nil)
+      validate_cron_version_and_sql_definition_exclusive!(version, sql_definition)
+      version ||= 1
+
+      return unless PgCron.database.pg_cron_enabled?
+
+      PgCron.database.create_job(resolve_cron_sql_definition(sql_definition, name, version))
+    end
+
+    # Drop a cron job by name.
+    #
+    # @param name [String, Symbol] The job's name.
+    # @param revert_to_version [Integer] Used to reverse this on
+    #   `rake db:rollback`; passed as `version` to {#create_cron_job}.
+    # @return [void]
+    #
+    def drop_cron_job(name, revert_to_version: nil)
+      return unless PgCron.database.pg_cron_enabled?
+
+      PgCron.database.drop_job(name)
+    end
+
+    # Update a cron job.
+    #
+    # One statement, not unschedule-then-schedule: cron.schedule() against an
+    # existing jobname REPLACES that job. Dropping first would leave a window in
+    # which the schedule does not exist, and on a frequently-firing job that
+    # window is a missed run.
+    #
+    # @param name [String, Symbol] The job's name.
+    # @param version [Integer] The version number, used to find the definition
+    #   file in `db/cron`.
+    # @param sql_definition [String] The SQL for the job.
+    # @param revert_to_version [Integer] The version to roll back to.
+    # @return [void]
+    #
+    def update_cron_job(name, version: nil, sql_definition: nil, revert_to_version: nil)
+      validate_cron_version_or_sql_definition_present!(version, sql_definition)
+      validate_cron_version_and_sql_definition_exclusive!(version, sql_definition)
+
+      return unless PgCron.database.pg_cron_enabled?
+
+      PgCron.database.update_job(name, resolve_cron_sql_definition(sql_definition, name, version))
+    end
+
+    private
+
+    # THE `cron_` ON THESE THREE NAMES IS LOAD-BEARING. Do not tidy it away.
+    #
+    # This module and F(x)'s Statements are both included into the SAME object,
+    # ActiveRecord::ConnectionAdapters::AbstractAdapter, and we are included
+    # second — so anything here with a name F(x) also uses SHADOWS F(x)'s copy
+    # for every migration in the application, not just for ours.
+    #
+    # All three helpers below were lifted from F(x) under F(x)'s own names, and
+    # `resolve_sql_definition` differs from it by one argument: F(x) passes the
+    # object kind (:function, :trigger, :view) as a fourth. So with this gem
+    # loaded, every create_function / create_trigger / update_function in the
+    # host application died on
+    #
+    #   ArgumentError: wrong number of arguments (given 4, expected 3)
+    #
+    # before it reached the database, and the two validators were a matching
+    # arity away from doing the same. Nothing was wrong with the caller's SQL;
+    # the two DSLs simply could not both be in the room.
+    #
+    # Prefixed rather than made arity-tolerant, because "works as long as F(x)
+    # keeps that signature" is the same bug with a longer fuse. A name that is
+    # ours cannot collide at all.
+    VERSION_OR_SQL_DEFINITION_REQUIRED = "version or sql_definition must be specified"
+    private_constant :VERSION_OR_SQL_DEFINITION_REQUIRED
+
+    VERSION_AND_SQL_DEFINITION_EXCLUSIVE = "sql_definition and version cannot both be set"
+    private_constant :VERSION_AND_SQL_DEFINITION_EXCLUSIVE
+
+    def validate_cron_version_or_sql_definition_present!(version, sql_definition)
+      raise ArgumentError, VERSION_OR_SQL_DEFINITION_REQUIRED, caller if version.nil? && sql_definition.nil?
+    end
+
+    def validate_cron_version_and_sql_definition_exclusive!(version, sql_definition)
+      raise ArgumentError, VERSION_AND_SQL_DEFINITION_EXCLUSIVE, caller if version.present? && sql_definition.present?
+    end
+
+    def resolve_cron_sql_definition(sql_definition, name, version)
+      return sql_definition.strip_heredoc if sql_definition
+
+      PgCron::Definition.job(name: name, version: version).to_sql
+    end
+  end
+end

data/lib/pg_cron/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PgCron
+  VERSION = "2.0.0"
+end

data/lib/pg_cron/version.rb.erb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PgCron
+  VERSION = "<%= version %>"
+end

data/lib/pg_cron.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Definition first: Configuration reads Definition::DIRECTORY in its class body,
+# so requiring it later raises NameError at boot.
+require "pg_cron/definition"
+require "pg_cron/job"
+require "pg_cron/adapters/postgres"
+require "pg_cron/configuration"
+require "pg_cron/schema_dumper"
+require "pg_cron/statements"
+require "pg_cron/command_recorder"
+require "pg_cron/railtie" if defined?(::Rails::Railtie)
+
+module PgCron
+  def self.load
+    # Make PgCron::Statements available during migrations
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.include PgCron::Statements
+
+    # Make PgCron::Statements reversible for migration rollbacks
+    ActiveRecord::Migration::CommandRecorder.include PgCron::CommandRecorder
+
+    # Teach the schema dumper about cron jobs. Without this db/schema.rb carries
+    # every table and none of the schedules, so a db:schema:load database comes
+    # up silently missing them.
+    ActiveRecord::SchemaDumper.prepend PgCron::SchemaDumper
+  end
+
+  # The adapter cron statements run through.
+  #
+  # Was a SECOND connection, opened via ActiveRecord::Base.postgresql_connection
+  # against a database named `postgres`, and reconnected by hand. Two problems:
+  # postgresql_connection was removed in Rails 8, and the separate database was
+  # wrong for this setup anyway — cron.job lives in whatever cron.database_name
+  # points at, which is the application's own database, so the application's own
+  # connection is the one that can see it.
+  #
+  # It also has to be that connection for a second reason: pg_cron puts
+  # row-level security on cron.job filtering by username, so jobs created on a
+  # different connection as a different role are invisible to the app and to the
+  # schema dumper.
+  def self.connection
+    configuration.adapter
+  end
+end

data/lib/tasks/pg_cron/down.rake

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "utils"
+
+namespace :pg_cron do
+  desc "Tear down pg_cron PSQL extension for your development environment"
+  task :down, [:pg_cron_version] => :environment do |_t, args|
+    puts "Tearing down pg_cron"
+    validate_rails_environment
+    validate_homebrew_is_installed
+    validate_psql_is_running_with_brew
+    if pg_cron_is_installed(args[:pg_cron_version] || DEFAULT_PG_CRON_VERSION)
+      drop_extension
+      remove_pg_cron_from_shared_preload_libraries
+      restart_psql_service
+    end
+  rescue StandardError => e
+    puts "Something went wrong while tearing down pg_cron"
+    puts e
+  end
+end

data/lib/tasks/pg_cron/schedule_all_jobs.rake

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+namespace :pg_cron do
+  desc "Schedule every job in db/cron at its highest version"
+  task schedule_all_jobs: :environment do |_t, _args|
+    latest_job_versions.each do |name, version|
+      ActiveRecord::Base.connection.create_cron_job(name, version: version)
+    end
+    puts "All the pg_cron jobs were successfully scheduled"
+  rescue StandardError => e
+    puts "Something went wrong while scheduling the pg_cron jobs"
+    puts e
+  end
+
+  private
+
+  # Definitions are db/cron/<name>_v<NN>.sql, so a job with several versions has
+  # several files and only the HIGHEST is current. Globbing filenames the way
+  # this task did for YAML would schedule every historical version in turn and
+  # leave whichever sorted last in place.
+  def latest_job_versions
+    directory = Rails.root.join("db", PgCron::Definition::DIRECTORY)
+
+    Dir.glob("*_v*.sql", base: directory).each_with_object({}) do |file, latest|
+      match = file.match(/\A(?<name>.+)_v(?<version>\d+)\.sql\z/)
+      next unless match
+
+      name = match[:name]
+      version = match[:version].to_i
+      latest[name] = version if version > latest.fetch(name, 0)
+    end
+  end
+end

data/lib/tasks/pg_cron/schedule_job.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :pg_cron do
+  desc "Schedule a job"
+  task :schedule_job, [:job_name] => :environment do |_t, args|
+    ActiveRecord::Base.connection.schedule_pg_cron_job(args[:job_name])
+    puts "The pg_cron job #{args[:job_name]} was successfully scheduled"
+  rescue StandardError => e
+    puts "Something went wrong while scheduling the pg_cron job with name #{args[:job_name]}"
+    puts e
+  end
+end

data/lib/tasks/pg_cron/unschedule_job.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :pg_cron do
+  desc "Unschedule a job"
+  task :unschedule_job, [:job_name] => :environment do |_t, args|
+    ActiveRecord::Base.connection.unschedule_pg_cron_job(args[:job_name])
+    puts "The pg_cron job #{args[:job_name]} was successfully unscheduled"
+  rescue StandardError => e
+    puts "Something went wrong while unscheduling the pg_cron job with name #{args[:job_name]}"
+    puts e
+  end
+end

data/lib/tasks/pg_cron/up.rake

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "utils"
+
+namespace :pg_cron do
+  desc "Install and enable pg_cron PSQL extension for your development environment"
+  task :up, [:pg_cron_version] => :environment do |_t, args|
+    puts "Setting up pg_cron"
+    validate_rails_environment
+    validate_homebrew_is_installed
+    validate_latest_psql_is_installed
+    validate_psql_is_running_with_brew
+    if !pg_cron_is_installed(args[:pg_cron_version] || DEFAULT_PG_CRON_VERSION)
+      install_pg_cron
+      add_pg_cron_to_shared_preload_libraries
+      restart_psql_service
+      create_extension
+    else
+      restart_psql_service
+    end
+  rescue StandardError => e
+    puts "Something went wrong while setting up pg_cron"
+    puts e
+  end
+end

data/lib/tasks/pg_cron/utils.rb

@@ -0,0 +1,124 @@
+# rubocop:disable Style/SpecialGlobalVars
+
+DEFAULT_PG_CRON_VERSION = "1.3.0".freeze
+
+def validate_homebrew_is_installed
+  `brew --version`
+  raise "This rake task only support Darwin based OS" unless $?.success?
+end
+
+def validate_psql_is_running_with_brew
+  fetch_psql_brew_service_version.present?
+end
+
+def fetch_psql_brew_service_version
+  psql_services = `brew services list | grep "started" | grep "postgresql"`
+  psql_services.split(" ").first.strip
+end
+
+def validate_rails_environment
+  raise "This rake task should only be used in development" unless Rails.env.development?
+end
+
+# rubocop:disable Style/GuardClause
+# rubocop:disable Layout/LineLength
+def validate_latest_psql_is_installed
+  `brew list postgresql`
+  unless $?.success?
+    raise "Due to pg_cron compilation issues the postgresql brew package is needed, please install the latest psql brew package: brew install postgresql"
+  end
+end
+# rubocop:enable Style/GuardClause
+# rubocop:enable Layout/LineLength
+
+def pg_cron_is_installed(requested_version)
+  result = PgCron.connection.execute <<-SQL
+    SELECT
+      extversion
+    FROM
+      pg_extension
+    WHERE
+    extname='pg_cron'
+  SQL
+
+  extension_version = result.first&.dig("extversion")
+  parsed_extension_version = extension_version ? parse_pg_cron_version(extension_version) : nil
+  parsed_requested_version = parse_pg_cron_version(requested_version)
+  parsed_extension_version == parsed_requested_version
+end
+
+def parse_pg_cron_version(version)
+  major_minor_tuple = version.split(".").first(2)
+  { major: major_minor_tuple[0], minor: major_minor_tuple[1] }
+end
+
+# rubocop:disable Layout/LineLength
+def install_pg_cron
+  latest_pg_cron_path = `brew --prefix postgresql`.strip
+  compilation_path = "#{latest_pg_cron_path}/bin:$PATH"
+  pg_cron_version = DEFAULT_PG_CRON_VERSION
+  `cd /tmp && \
+    curl -s -L https://github.com/citusdata/pg_cron/archive/refs/tags/v#{pg_cron_version}.zip --output pg_cron.zip && \
+    unzip -u pg_cron.zip && \
+    cd pg_cron-#{pg_cron_version} && \
+    PATH=#{compilation_path} make && PATH=#{compilation_path} sudo make install && \
+    cp $(brew --prefix postgresql)/share/postgresql/extension/pg_cron* $(brew --prefix #{fetch_psql_brew_service_version})/share/#{fetch_psql_brew_service_version}/extension/ && \
+    rm -rf pg_cron*
+  `
+end
+# rubocop:enable Layout/LineLength
+
+def add_pg_cron_to_shared_preload_libraries
+  psql_config_file_path = PgCron.connection.execute("SHOW config_file").first&.dig("config_file")
+  config_file_content = ""
+  File.open(psql_config_file_path, "r") do |file|
+    file.each_line do |line|
+      if line.match(/(#\s*)?shared_preload_libraries =.*/)
+        libraries = line.split("=").last.match(/'.*'/).to_a.first.gsub("'", "").split(",").map(&:strip).filter do |s|
+          s != "pg_cron"
+        end
+        libraries << "pg_cron"
+        line = "shared_preload_libraries = '#{libraries.join(",")}' \n"
+      end
+
+      config_file_content << line
+    end
+  end
+
+  File.atomic_write(psql_config_file_path, "/tmp") { |file| file.write config_file_content }
+end
+
+def remove_pg_cron_from_shared_preload_libraries
+  psql_config_file_path = PgCron.connection.execute("SHOW config_file").first&.dig("config_file")
+  config_file_content = ""
+  File.open(psql_config_file_path, "r") do |file|
+    file.each_line do |line|
+      if line.match(/(#\s*)?shared_preload_libraries =.*/)
+        libraries = line.split("=").last.match(/'.*'/).to_a.first.gsub("'", "").split(",").map(&:strip).filter do |s|
+          s != "pg_cron"
+        end
+        line = "shared_preload_libraries = '#{libraries.join(",")}' \n"
+        line.prepend("#") if libraries.empty?
+      end
+
+      config_file_content << line
+    end
+  end
+
+  File.atomic_write(psql_config_file_path, "/tmp") { |file| file.write config_file_content }
+end
+
+def create_extension
+  PgCron.connection.enable_extension("pg_cron")
+end
+
+def restart_psql_service
+  `brew services restart #{fetch_psql_brew_service_version}`
+  sleep 1 # Prevent timing issues
+end
+
+def drop_extension
+  PgCron.connection.disable_extension("pg_cron")
+end
+
+# rubocop:enable Style/SpecialGlobalVars

data/spec/dummy/.gitignore

@@ -0,0 +1,71 @@
+# Rails 
+
+*.rbc
+capybara-*.html
+.rspec
+/db/*.sqlite3
+/db/*.sqlite3-journal
+/db/*.sqlite3-[0-9]*
+/public/system
+/coverage/
+/spec/tmp
+*.orig
+rerun.txt
+pickle-email-*.html
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# TODO Comment out this rule if you are OK with secrets being uploaded to the repo
+config/initializers/secret_token.rb
+config/master.key
+
+# Only include if you have production secrets in this file, which is no longer a Rails default
+# config/secrets.yml
+
+# dotenv, dotenv-rails
+# TODO Comment out these rules if environment variables can be committed
+.env
+.env.*
+
+## Environment normalization:
+/.bundle
+/vendor/bundle
+
+# these should all be checked in to normalize the environment:
+# Gemfile.lock, .ruby-version, .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# if using bower-rails ignore default bower_components path bower.json files
+/vendor/assets/bower_components
+*.bowerrc
+bower.json
+
+# Ignore pow environment settings
+.powenv
+
+# Ignore Byebug command history file.
+.byebug_history
+
+# Ignore node_modules
+node_modules/
+
+# Ignore precompiled javascript packs
+/public/packs
+/public/packs-test
+/public/assets
+
+# Ignore yarn files
+/yarn-error.log
+yarn-debug.log*
+.yarn-integrity
+
+# Ignore uploaded files in development
+/storage/*
+!/storage/.keep
+/public/uploads

data/spec/dummy/.ruby-version

@@ -0,0 +1 @@
+2.7.4

data/spec/dummy/README.md

@@ -0,0 +1,24 @@
+# README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::API
+end

data/spec/dummy/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/spec/dummy/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path('../config/application', __dir__)
+require_relative "../config/boot"
+require "rails/commands"

data/spec/dummy/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../config/boot"
+require "rake"
+Rake.application.run

data/spec/dummy/bin/setup

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require "fileutils"
+
+# path to your application root.
+APP_ROOT = File.expand_path('..', __dir__)
+
+def system!(*args)
+  system(*args) || abort("\n== Command #{args} failed ==")
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
+  # Add necessary setup steps to this file.
+
+  puts '== Installing dependencies =='
+  system! 'gem install bundler --conservative'
+  system('bundle check') || system!('bundle install')
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?('config/database.yml')
+  #   FileUtils.cp 'config/database.yml.sample', 'config/database.yml'
+  # end
+
+  puts "\n== Preparing database =="
+  system! 'bin/rails db:prepare'
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! 'bin/rails log:clear tmp:clear'
+
+  puts "\n== Restarting application server =="
+  system! 'bin/rails restart'
+end

data/spec/dummy/config/application.rb

@@ -0,0 +1,40 @@
+require_relative "boot"
+
+require "rails"
+# Pick the frameworks you want:
+require "active_model/railtie"
+# require "active_job/railtie"
+require "active_record/railtie"
+# require "active_storage/engine"
+require "action_controller/railtie"
+# require "action_mailer/railtie"
+# require "action_mailbox/engine"
+# require "action_text/engine"
+require "action_view/railtie"
+# require "action_cable/engine"
+# require "sprockets/railtie"
+# require "rails/test_unit/railtie"
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+
+module Dummy
+  class Application < Rails::Application
+    # Initialize configuration defaults for originally generated Rails version.
+    config.load_defaults 6.1
+
+    # Configuration for the application, engines, and railties goes here.
+    #
+    # These settings can be overridden in specific environments using the files
+    # in config/environments, which are processed later.
+    #
+    # config.time_zone = "Central Time (US & Canada)"
+    # config.eager_load_paths << Rails.root.join("extras")
+
+    # Only loads a smaller set of middleware suitable for API only apps.
+    # Middleware like session, flash, cookies can be added back manually.
+    # Skip views, helpers and assets when generating a new resource.
+    config.api_only = true
+  end
+end

data/spec/dummy/config/boot.rb

@@ -0,0 +1,3 @@
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+
+require "bundler/setup" # Set up gems listed in the Gemfile.

data/spec/dummy/config/credentials.yml.enc

@@ -0,0 +1 @@
+3Y2y6yJJt66Phu+Yrv75qlm7edlJxbzIJuKJckgv0Zof/JfCUNXYJqfi1qx2IKMiKrptpTq8j/MrdhqYIw3Tnol4/Rd7+QYlVBZ2fLDh5CUxcqonj0rE3Xzxm9iXm5H8UQtee2GAfQibhLUalF7FbYx9/92UZ36hKfnAdIO75y9gXR5KkiwXSjvOUExA/4RMIsC+QngYpiC1J3JP3aIbymW+KSv0XGbMN5XQDs7/gENUsfTi936UCVz7TmCyz84zdGjwIpKBX1IPDyCIDxs3sb/ndV/TvlSBON9aE/f4juGl4nDAT9GPSPLEjJ0kfrIFs65JWhLceJVPfjIiWqSIUWFCxuFvtdGp4dCmriJhuedjef0PhXIZm2HsWmrRY5w44B28RhGubc/f9/pTZKDqd2UTY839I0SP+i9H--PGXsXE4chMSqSuEV--joWbNc15jbK1ds0sFOcjJw==