postjob 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5166951ca6511e2d599b44493288dc1ac43f712a
-  data.tar.gz: f32f0a3255c782e5998d8c77b68b8e5656f356ae
+SHA256:
+  metadata.gz: 4fcc6c18ad2be617abafbdfb1dc6258a435223a0fbd0110d86806b6da47fc5d6
+  data.tar.gz: 98a5384f074100eb291d6357993969fea6da7b058177ba513f79329bc558d9c9
 SHA512:
-  metadata.gz: 40f67bc7082fc9df09bda3c4425297ffa7ce6ddaed0feef2bb849a3b9e5773a06a6b5349972c8f5c8f0d5c7cefb4cc7b1e0f64ce8da336d52fa0239a5e45fde1
-  data.tar.gz: d5928e359abfc51dbeab4a1054d435dbba799ba5107296ccd2b65494e2c9853fca350ab88eba9f291ead1736026b74e04371d6830afad77a8b08bb60020a1ed8
+  metadata.gz: 212977ecccd8f11df6d0e4950155cc47f18c1d6c979b045109b5f981d5eb1e7a68c90aefae78708385458d102870f3d3c9357d8861fa9a54fd5f58c8db9f4f2b
+  data.tar.gz: c31025b4869355c9dd13ed5e119c43133b9ae794eecaa2c12f92eb07c1e476f48c32cefa182757358b7236b64febe34283183d5f492a71116e86569adb36e724

data/lib/postjob/cli/version.rb

@@ -1,10 +1,14 @@
 module Postjob::CLI
   # Prints version info
   def version
-    connect_to_database!
-
     gem_version = Gem.loaded_specs["postjob"].version
-    puts "postjob/ruby: #{gem_version}"
-    puts "postjob/queue: #{::Postjob::Queue.version}"
+    puts "This is postjob (ruby) #{gem_version}"
+
+    begin
+      connect_to_database!
+      puts "postjob/queue: #{::Postjob::Queue.version}"
+    rescue StandardError
+      Postjob.logger.warn "Cannot read postjob schema version. Database might not be configured or migrated."
+    end
   end
 end

data/lib/postjob/job.rb

@@ -5,7 +5,7 @@ require_relative "./record"
 #
 class Postjob::Job < Postjob::Record
   def self.find(job_id)
-    scope = Postjob::Queue.search(id: job_id)
+    scope = Postjob::Queue.search("postjobs", id: job_id)
     Simple::SQL.ask(scope, into: Postjob::Job)
   end
 

data/lib/postjob/queue/database_info.rb

@@ -0,0 +1,23 @@
+# This module holds cached database info, to be used by the search functions.
+module Postjob::Queue::DatabaseInfo
+  extend self
+
+  # returns a Hash of column_name => column_type. Names are available both as
+  # Symbol and as String.
+  def column_types(table_name)
+    @column_types ||= {}
+    @column_types[table_name] ||= begin
+      column_info = ::Simple::SQL::Reflection.column_info(table_name)
+      hsh = {}
+      column_info.each do |column, rec|
+        hsh[column.to_sym] = hsh[column.to_s] = rec.data_type
+      end
+      hsh
+    end
+  end
+
+  def table_columns(table_name)
+    @table_columns ||= {}
+    @table_columns[table_name] ||= Simple::SQL::Reflection.columns(table_name)
+  end
+end

data/lib/postjob/queue/search.rb

@@ -1,82 +1,120 @@
+require_relative "./database_info"
+
 module Postjob::Queue
-  DEFAULT_ATTRIBUTES = [
-    "workflow || COALESCE('@' || workflow_version, '') || args AS job",
-    "COALESCE((results->0)::varchar, error_message) AS result",
-    "(now() at time zone 'utc') - created_at AS age",
-    "updated_at - created_at AS runtime"
-  ]
-
-  def default_attributes
-    @default_attributes ||= begin
-      column_names = Simple::SQL::Reflection.columns("#{SCHEMA_NAME}.postjobs")
-      column_names + DEFAULT_ATTRIBUTES
-    end
-  end
+  class ScopeBuilder
+    SCHEMA_NAME = ::Postjob::Queue::SCHEMA_NAME
 
-  # Builds a search scope (see Simple::SQL::Scope) for the passed in filter criteria.
-  #
-  # Note that the search scope is unsorted.
-  def search(filter = {})
-    expect! filter => Hash
-
-    # extract options
-    filter     = filter.dup
-    root_only  = filter.delete(:root_only) || false
-    attributes = filter.delete(:attributes) || default_attributes
-    expect! attributes => Array
-
-    # build Scope
-    scope = Simple::SQL::Scope.new("SELECT #{attributes.join(", ")} FROM #{SCHEMA_NAME}.postjobs")
-    scope = scope.where("root_id=id") if root_only
-    scope = apply_filters(scope, filter) if filter && !filter.empty?
-    scope
-  end
+    class << self
+      def build(model:, filter:, attributes:)
+        builder(model).send(:scope, filter: filter, attributes: attributes)
+      end
 
-  private
+      private
 
-  def apply_filters(scope, filter)
-    filter.each_key do |key|
-      expect! key => [Symbol, String]
+      # Returns the name of the column used for dynamic filtering.
+      def dynamic_filter(model)
+        case model
+        when "postjobs" then "tags"
+        else "attributes"
+        end
+      end
+
+      def builder(model)
+        @builders ||= {}
+        @builders[model] ||= new(model: model, dynamic_filter: dynamic_filter(model))
+      end
     end
 
-    converted_filters = filter.inject({}) do |hsh, (key, value)|
-      matches = convert_filter_value(value, key: key)
-      matches = matches.first if matches.length == 1
-      hsh.update key => matches
+    private
+
+    def initialize(model:, dynamic_filter:)
+      @model      = model
+      @table_name = "#{SCHEMA_NAME}.#{model}"
+      @column_types = ::Postjob::Queue::DatabaseInfo.column_types(@table_name)
+      @dynamic_filter = dynamic_filter
     end
 
-    column_filters, tags_filters = converted_filters.partition { |key, _| !column_types[key].nil? }
+    def scope(filter:, attributes:)
+      expect! filter => [Hash, nil]
+      expect! attributes => Array
 
-    scope = scope.where(Hash[column_filters])
-    scope = scope.where(tags: Hash[tags_filters])
-    scope
-  end
+      # build Scope
+      scope = Simple::SQL::Scope.new("SELECT #{attributes.join(", ")} FROM #{@table_name}")
+      scope = apply_filters(scope, filter) if filter && !filter.empty?
+      scope
+    end
+
+    # apply the filter hash onto the passed in scope. This matches all filters
+    # with a name which is matching a column name against the column values.
+    # It matches every other filter value against an entry in the
+    # dynamic_filter column.
+    def apply_filters(scope, filter)
+      filter.each_key do |key|
+        expect! key => [Symbol, String]
+      end
 
-  class << self
-    def column_types
-      @column_types ||= _column_types
+      converted_filters = filter.inject({}) do |hsh, (key, value)|
+        matches = convert_filter_value(value, key: key)
+        matches = matches.first if matches.length == 1
+        hsh.update key => matches
+      end
+
+      column_filters, tags_filters = converted_filters.partition { |key, _| !@column_types[key].nil? }
+
+      scope = scope.where(Hash[column_filters]) unless column_filters.empty?
+      scope = scope.where(@dynamic_filter => Hash[tags_filters]) unless tags_filters.empty?
+
+      scope
     end
 
-    private
+    def convert_filter_value(value, key:)
+      value = Array(value)
 
-    def _column_types
-      column_info = ::Simple::SQL::Reflection.column_info("#{SCHEMA_NAME}.postjobs")
-      hsh = {}
-      column_info.each do |column, rec|
-        hsh[column.to_sym] = hsh[column.to_s] = rec.data_type
+      case @column_types[key]
+      when "bigint"   then value.map { |v| Integer(v) }
+      when "integer"  then value.map { |v| Integer(v) }
+      when nil        then value.map(&:to_s) + value.grep(/\A-?\d+\z/).map(&:to_i)
+      else                 value.map(&:to_s)
       end
-      hsh
     end
   end
 
-  def convert_filter_value(value, key:)
-    value = Array(value)
+  # Builds a search scope (see Simple::SQL::Scope) for the passed in filter criteria.
+  #
+  # Parameters:
+  #
+  # - model: the name of the postjob model, e.g. "postjobs", "events", ..
+  # - filter: a Hash of filter values and other options. options are denoted
+  #           by a Symbol key.
+  #
+  # Note that the search scope is unsorted.
+  def search(model, filter = {})
+    expect! model => String
+    expect! filter => [Hash, nil]
 
-    case Postjob::Queue.column_types[key]
-    when "bigint"   then value.map { |v| Integer(v) }
-    when "integer"  then value.map { |v| Integer(v) }
-    when nil        then value.map(&:to_s) + value.grep(/\A-?\d+\z/).map(&:to_i)
-    else                 value.map(&:to_s)
-    end
+    filter = filter ? filter.dup : {}
+
+    root_only  = filter.delete(:root_only)
+    attributes = filter.delete(:attributes) || default_search_attributes(model)
+
+    scope = ScopeBuilder.build(model: model, filter: filter, attributes: attributes)
+    scope = scope.where("root_id=id") if root_only && model == "postjobs"
+    scope
+  end
+
+  private
+
+  # describes which attributes should be returned in addition to a model's columns.
+  EXTRA_SEARCH_ATTRIBUTES = {
+    "postjobs" => [
+      "workflow || COALESCE('@' || workflow_version, '') || args AS job",
+      "COALESCE((results->0)::varchar, error_message) AS result",
+      "(now() at time zone 'utc') - created_at AS age",
+      "updated_at - created_at AS runtime"
+    ]
+  }
+
+  def default_search_attributes(model)
+    DatabaseInfo.table_columns("#{SCHEMA_NAME}.#{model}") + (EXTRA_SEARCH_ATTRIBUTES[model] || [])
   end
 end

data/lib/postjob/worker_session.rb

@@ -14,14 +14,14 @@ end
 
 # A worker worker_session
 class Postjob::WorkerSession < Postjob::Record
-  HOST_ID_STORE = ".postjob.host_id"
+  HOST_ID_PATH = ".postjob.host_id"
 
   class << self
     # Starts a worker session.
     def start!(workflows_with_versions)
       worker_session = nil
 
-      AtomicStore.with(HOST_ID_STORE) do |host_id|
+      AtomicStore.with(HOST_ID_PATH) do |host_id|
         host_id ||= ::Postjob::Host.register
         Postjob.logger.debug "Starting worker_session w/host_id #{host_id.inspect}"
         worker_session = ::Postjob::Queue.start_worker_session(workflows_with_versions, host_id: host_id)

data/spec/postjob/queue/search_spec.rb

@@ -27,7 +27,7 @@ describe "Postjob::Queue.search" do
 
   context "attributes" do
     it "returns a specific set of attributes" do
-      scope = Postjob::Queue.search(id: id)
+      scope = Postjob::Queue.search("postjobs", id: id)
       result = Simple::SQL.ask scope, into: Hash
 
       expected_keys = [
@@ -47,7 +47,7 @@ describe "Postjob::Queue.search" do
     end
 
     it "with attributes: argument it only returns the specified attributes" do
-      scope = Postjob::Queue.search(attributes: %w(id))
+      scope = Postjob::Queue.search("postjobs", attributes: %w(id))
       result = Simple::SQL.ask scope, into: Hash
 
       expected_keys = [
@@ -64,7 +64,7 @@ describe "Postjob::Queue.search" do
     end
 
     it "returns all entries" do
-      scope = Postjob::Queue.search
+      scope = Postjob::Queue.search("postjobs")
       result = Simple::SQL.all(scope, into: OpenStruct)
       expect(result.length).to eq(2)
     end
@@ -72,46 +72,46 @@ describe "Postjob::Queue.search" do
 
   describe "filtering" do
     it "can find a job by id" do
-      scope = Postjob::Queue.search(id: id)
+      scope = Postjob::Queue.search("postjobs", id: id)
       result = Simple::SQL.ask scope, into: Hash
       expect(result[:id]).to eq(id)
     end
 
     it "positive filters by tags" do
-      scope = Postjob::Queue.search("initial" => "yay")
+      scope = Postjob::Queue.search("postjobs", "initial" => "yay")
       result = Simple::SQL.all scope, into: OpenStruct
       expect(result.length).to eq(1)
       expect(result.first.id).to eq(id)
     end
 
     it "negative filters by tags" do
-      scope = Postjob::Queue.search("initial" => "nay")
+      scope = Postjob::Queue.search("postjobs", "initial" => "nay")
       result = Simple::SQL.all(scope)
       expect(result.length).to eq(0)
     end
 
     it "filter tags against empty array" do
-      scope = Postjob::Queue.search("initial" => [])
+      scope = Postjob::Queue.search("postjobs", "initial" => [])
       result = Simple::SQL.all(scope)
       expect(result.length).to eq(0)
     end
 
     it "filter tags against multiple matches" do
-      scope = Postjob::Queue.search("initial" => [ "yay", "nay" ])
+      scope = Postjob::Queue.search("postjobs", "initial" => [ "yay", "nay" ])
       result = Simple::SQL.all(scope)
       expect(result.length).to eq(1)
     end
 
     it "filter tags against a combination of multiple matches" do
-      scope = Postjob::Queue.search("initial" => [ "yay", "nay" ], "multi" => "manyay")
+      scope = Postjob::Queue.search("postjobs", "initial" => [ "yay", "nay" ], "multi" => "manyay")
       result = Simple::SQL.all(scope)
       expect(result.length).to eq(1)
 
-      scope = Postjob::Queue.search("initial" => [ "yay", "nay" ], "multi" => "nay")
+      scope = Postjob::Queue.search("postjobs", "initial" => [ "yay", "nay" ], "multi" => "nay")
       result = Simple::SQL.all(scope)
       expect(result.length).to eq(0)
 
-      scope = Postjob::Queue.search("initial" => [ "yay", "nay" ], "multi" => ["nay", "manyay"])
+      scope = Postjob::Queue.search("postjobs", "initial" => [ "yay", "nay" ], "multi" => ["nay", "manyay"])
       result = Simple::SQL.all(scope)
       expect(result.length).to eq(1)
     end

data/spec/spec_helper.rb

@@ -40,6 +40,6 @@ RSpec.configure do |config|
   config.after {}
 
   config.before(:all) do
-    FileUtils.rm_rf ::Postjob::WorkerSession::HOST_ID_STORE
+    FileUtils.rm_rf ::Postjob::WorkerSession::HOST_ID_PATH
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: postjob
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - radiospiel
@@ -261,6 +261,7 @@ files:
 - lib/postjob/migrations/018_heartbeat.sql
 - lib/postjob/migrations/019_heartbeat_indices.sql
 - lib/postjob/queue.rb
+- lib/postjob/queue/database_info.rb
 - lib/postjob/queue/encoder.rb
 - lib/postjob/queue/notifications.rb
 - lib/postjob/queue/search.rb
@@ -314,7 +315,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: restartable, asynchronous, and distributed processes