marty 1.0.12 → 1.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cb347975c0c4442e6466f8cbcbd72d431c85f45f
-  data.tar.gz: 4c7de97777049441bbf43ea5d324ed1a4c858315
+  metadata.gz: 6954bc349cc4800a6505d17737f5ddcb91ce16b2
+  data.tar.gz: 8bfff59fcd54425f3f076b0fdc61ec98a5d52b23
 SHA512:
-  metadata.gz: dc0b688584580e74b519a04559d0c3dd6bcbc0d3fc2e00949403a32c54ef25f78380573238f8d80d048ce434d3c936a6c455db94c1a2945065ea4c39525b277d
-  data.tar.gz: 7318c212db79212f25ad3fcfc3f27d28e666f1948d333b93f7ab5d5689e5eb4f16f54873a02d016eff9678bd607a7edce244d3234b94e2229c05b7313149197b
+  metadata.gz: f3d5897c69ee0feb698f467a30095273ba724a030fbeae9032f82129e3341b6905c67ededb6256264079702a68a286076ae216d9384b06eb84edbf3d1b4c7300
+  data.tar.gz: f36961f6208fbdef9d54a9f717cadb04cac2bb5a3d7c956905a650718d7996c155469d93f0ac3dce78d16991fbac1d6947625acb81ca2f0ccaf5458c48821459

data/Gemfile

@@ -9,6 +9,7 @@ gem 'delayed_job_active_record'
 gem 'daemons', '~> 1.1.9'
 gem 'mime-types', '< 3.0', platforms: :ruby_19
 gem 'rails', '~> 4.2.1'
+gem 'pg', '~> 0.18.4'
 
 group :development, :test do
   gem 'pry-rails'

data/app/components/marty/main_auth_app.rb

@@ -57,7 +57,7 @@ class Marty::MainAuthApp < Marty::AuthApp
               :api_auth_view,
               :reload_scripts,
               :load_seed,
-             ],
+             ] + background_jobs_menu
     }
   end
 
@@ -73,6 +73,21 @@ class Marty::MainAuthApp < Marty::AuthApp
     }
   end
 
+  def background_jobs_menu
+    [
+       {
+         text: 'Background Jobs',
+         icon: icon_hack(:clock),
+         disabled: !self.class.has_admin_perm?,
+         menu: [
+                :bg_status,
+                :bg_stop,
+                :bg_restart,
+               ]
+       },
+    ]
+  end
+
   def warped
     Marty::Util.warped?
   end
@@ -181,6 +196,62 @@ class Marty::MainAuthApp < Marty::AuthApp
     a.disabled = !self.class.has_admin_perm?
   end
 
+  action :bg_status do |a|
+    a.text     = 'Show Delayed Jobs Status'
+    a.tooltip  = 'Run delayed_job status script'
+    a.icon     = :monitor
+    a.disabled = !self.class.has_admin_perm?
+  end
+
+  action :bg_stop do |a|
+    a.text     = 'Stop Delayed Jobs'
+    a.tooltip  = 'Run delayed_job stop script'
+    a.icon     = :stop
+    a.disabled = !self.class.has_admin_perm?
+  end
+
+  action :bg_restart do |a|
+    a.text     = 'Restart Delayed Jobs'
+    a.tooltip  = 'Run delayed_job restart script using DELAYED_JOB_PARAMS'
+    a.icon     = :arrow_rotate_clockwise
+    a.disabled = !self.class.has_admin_perm?
+  end
+
+   ######################################################################
+
+  def bg_command(param)
+    e, root, p = ENV['RAILS_ENV'], Rails.root, Marty::Config["RUBY_PATH"]
+    # preserve backward compatability with Gemini
+    # for new Rails apps, use 'bin/delayed_job'
+    dj_path = Marty::Config["DELAYED_JOB_PATH"] || 'script/delayed_job'
+    cmd = "export RAILS_ENV=#{e};"
+    # FIXME: Environment looks to be setup incorrectly - this is a hack
+    cmd += "export PATH=#{p}:$PATH;" if p
+    # 2>&1 redirects STDERR to STDOUT since backticks only captures STDOUT
+    cmd += "#{root}/#{dj_path} #{param} 2>&1"
+    cmd
+  end
+
+  endpoint :bg_status do |params|
+    cmd = bg_command('status')
+    res = `#{cmd}`
+    client.show_detail res.html_safe.gsub("\n","<br/>"), 'Delayed Job Status'
+  end
+
+  endpoint :bg_stop do |params|
+    cmd = bg_command("stop")
+    res = `#{cmd}`
+    res = "delayed_job: no instances running. Nothing to stop." if res.length==0
+    client.show_detail res.html_safe.gsub("\n","<br/>"), 'Delayed Job Stop'
+  end
+
+  endpoint :bg_restart do |params|
+    params = Marty::Config["DELAYED_JOB_PARAMS"] || ""
+    cmd = bg_command("restart #{params}")
+    res = `#{cmd}`
+    client.show_detail res.html_safe.gsub("\n","<br/>"), 'Delayed Job Restart'
+  end
+
   ######################################################################
   # Postings
 
@@ -192,6 +263,38 @@ class Marty::MainAuthApp < Marty::AuthApp
   end
 
   client_class do |c|
+    c.show_detail = l(<<-JS)
+    function(details, title) {
+       this.hideLoadmask();
+       Ext.create('Ext.Window', {
+          height:        400,
+          minWidth:      400,
+          maxWidth:      1200,
+          autoWidth:     true,
+          modal:         true,
+          autoScroll:    true,
+          html:          details,
+          title:         title || "Details"
+      }).show();
+    }
+    JS
+
+    c.show_loadmask = l(<<-JS)
+    function(msg) {
+      this.maskCmp = new Ext.LoadMask( {
+        msg: msg || 'Loading...',
+        target: this,
+      });
+      this.maskCmp.show();
+    }
+    JS
+
+    c.hide_loadmask = l(<<-JS)
+    function() {
+      if (this.maskCmp) { this.maskCmp.hide(); };
+    }
+    JS
+
     c.netzke_on_new_posting = l(<<-JS)
     function(params) {
       this.netzkeLoadComponent("new_posting_window",
@@ -241,6 +344,47 @@ class Marty::MainAuthApp < Marty::AuthApp
        });
     }
     JS
+
+    c.netzke_on_bg_stop = l(<<-JS)
+    function(params) {
+       var me = this;
+       me.showLoadmask('Stopping delayed job...');
+       Ext.Msg.show({
+         title: 'Stop Delayed Jobs',
+         msg: 'Enter STOP and press OK to force a stop of delayed_job',
+         width: 375,
+         buttons: Ext.Msg.OKCANCEL,
+         prompt: true,
+         fn: function (btn, value) {
+           btn == "ok" && value == "STOP" && me.server.bgStop({});
+         }
+       });
+    }
+    JS
+
+    c.netzke_on_bg_restart = l(<<-JS)
+    function(params) {
+       var me = this;
+       me.showLoadmask('Restarting delayed job...');
+       Ext.Msg.show({
+         title: 'Restart Delayed Jobs',
+         msg: 'Enter RESTART and press OK to force a restart of delayed_job',
+         width: 375,
+         buttons: Ext.Msg.OKCANCEL,
+         prompt: true,
+         fn: function (btn, value) {
+           btn == "ok" && value == "RESTART" && me.server.bgRestart({});
+         }
+       });
+    }
+    JS
+
+    c.netzke_on_bg_status = l(<<-JS)
+    function() {
+      this.showLoadmask('Checking delayed job status...');
+      this.server.bgStatus({});
+    }
+    JS
   end
 
   action :select_posting do |a|

data/app/models/marty/enum_event_operation.rb

@@ -0,0 +1,5 @@
+class Marty::EnumEventOperation < Marty::Base
+  extend Marty::PgEnum
+
+  VALUES = Set['UNKNOWN']
+end

data/app/models/marty/event.rb

@@ -0,0 +1,206 @@
+class Marty::Event < Marty::Base
+
+  class EventValidator < ActiveModel::Validator
+    def validate(event)
+      event.errors[:base] = "Must have promise_id or start_dt" unless
+        event.promise_id || event.start_dt
+    end
+  end
+
+  validates_presence_of :klass, :subject_id, :enum_event_operation
+
+  belongs_to :promise
+
+  validates_with EventValidator
+
+  BASE_QUERY = "SELECT ev.id,
+                   ev.klass,
+                   ev.subject_id,
+                   ev.enum_event_operation,
+                   ev.comment,
+                   coalesce(pr.start_dt, ev.start_dt) start_dt,
+                   coalesce(pr.end_dt, ev.end_dt) end_dt,
+                   expire_secs
+                FROM marty_events ev
+                LEFT JOIN marty_promises pr ON ev.promise_id = pr.id "
+
+  def self.running_query(time_now_s)
+    "SELECT * FROM
+       (#{BASE_QUERY}
+        WHERE coalesce(pr.start_dt, ev.start_dt, '1900-1-1') >=
+                   '#{time_now_s}'::timestamp - interval '24 hours') sub
+     WHERE (end_dt IS NULL or end_dt > '#{time_now_s}'::timestamp)
+       AND (expire_secs IS NULL
+        OR expire_secs > EXTRACT (EPOCH FROM '#{time_now_s}'::timestamp - start_dt))
+      ORDER BY start_dt"
+  end
+
+
+  def self.op_is_running?(klass, subject_id, operation)
+    all_running.detect do |pm|
+      pm["klass"] == klass && pm["subject_id"].to_i == subject_id.to_i &&
+        pm["enum_event_operation"] == operation
+    end
+  end
+
+  def self.create_event(klass,
+                        subject_id,
+                        operation,
+                        start_dt,
+                        expire_secs,
+                        comment=nil)
+
+    # use lookup_event instead of all_running which is throttled
+    evs = self.lookup_event(klass, subject_id, operation)
+    running = evs.detect do
+      |ev|
+      next if ev["end_dt"]
+      next true unless ev["expire_secs"]
+      (Time.zone.now - ev["start_dt"]).truncate < ev["expire_secs"]
+    end
+
+    raise "#{operation} is already running for #{klass}/#{subject_id}" if
+      running
+
+    self.create!(klass:                klass,
+                 subject_id:           subject_id,
+                 enum_event_operation: operation,
+                 start_dt:             start_dt,
+                 expire_secs:          expire_secs,
+                 comment:              comment,
+                )
+  end
+
+  def self.lookup_event(klass, subject_id, operation)
+    get_data(BASE_QUERY +
+             " WHERE klass = '#{klass}'
+                AND subject_id = #{subject_id}
+                and enum_event_operation = '#{operation}'")
+
+    #For now we return a bare hash
+    #Marty::Event.find_by_id(hash["id"])
+  end
+
+  def self.finish_event(klass, subject_id, operation, comment=nil)
+    time_now_s = Time.zone.now.strftime('%Y-%m-%d %H:%M:%S.%6N')
+
+    event = get_data(running_query(time_now_s)).detect do |ev|
+      ev["klass"] == klass && ev["subject_id"] == subject_id.to_i &&
+        ev["enum_event_operation"] == operation
+    end
+    raise "event #{klass}/#{subject_id}/#{operation} not found" unless
+      event
+
+    ev = Marty::Event.find_by_id(event["id"])
+    raise "can't explicitly finish a promise event" if ev.promise_id
+    ev.end_dt = Time.zone.now
+    ev.comment = comment if comment
+    ev.save!
+  end
+
+  def self.last_event(klass, subject_id, operation=nil)
+    hash = all_running.select do |pm|
+      pm["klass"] == klass && pm["subject_id"] == subject_id.to_i &&
+        (operation.nil? || pm["enum_event_operation"] == operation)
+    end.sort { |a, b| b["start_dt"] <=> a["start_dt"] }.first
+
+    return hash if hash
+
+    op_sql = "AND enum_event_operation = '#{operation}'" if operation
+
+    get_data("SELECT * FROM (#{BASE_QUERY}) sub
+              WHERE klass = '#{klass}'
+                AND subject_id = #{subject_id} #{op_sql}
+             ORDER BY start_dt desc").first
+  end
+
+  def self.currently_running(klass, subject_id)
+    all_running.select do |pm|
+      pm["klass"] == klass && pm["subject_id"] == subject_id.to_i
+    end.map { |e| e["enum_event_operation"] }
+  end
+
+  def self.update_comment(hash, comment)
+    hid = hash.is_a?(Hash) ? hash['id'] : hash
+    e = Marty::Event.find_by_id(hid)
+    e.comment = comment
+    e.save!
+  end
+
+  def self.pretty_op(hash)
+    d = hash['enum_event_operation'].downcase.capitalize
+
+    #&& !(hash['comment'] =~ /^ERROR/)
+    hash['end_dt'] ? d.sub(/ing/, 'ed') : d
+  end
+
+  def self.compact_end_dt(hash)
+    hash['end_dt'] ? hash['end_dt'].strftime("%H:%M") : '---'
+  end
+
+  def self.get_data(sql)
+    ActiveRecord::Base.connection.execute(sql).to_a.map do |h|
+      h["id"]          = h["id"].to_i
+      h["subject_id"]  = h["subject_id"].to_i
+      h["start_dt"]    = Time.zone.parse(h["start_dt"]) if h["start_dt"]
+      h["end_dt"]      = Time.zone.parse(h["end_dt"]) if h["end_dt"]
+      h["expire_secs"] = h["expire_secs"].to_i if h["expire_secs"]
+      h["comment"]     = h["comment"]
+      h
+    end
+  end
+  private_class_method :get_data
+
+  def self.clear_cache
+    @poll_secs = @all_running = @all_finished = nil
+  end
+
+  def self.all_running
+    @all_running ||= { timestamp: 0, data: [] }
+    @poll_secs ||= Marty::Config['MARTY_EVENT_POLL_SECS'] || 0
+    time_now = Time.zone.now
+    time_now_i = time_now.to_i
+    time_now_s = time_now.strftime('%Y-%m-%d %H:%M:%S.%6N')
+    if time_now_i - @all_running[:timestamp] > @poll_secs
+      @all_running[:data] = get_data(running_query(time_now_s))
+      @all_running[:timestamp] = time_now_i
+    end
+    @all_running[:data]
+  end
+  private_class_method :all_running
+
+  def self.all_finished
+    @all_finished ||= {
+      data:      {},
+      timestamp: Time.zone.parse('1970-1-1 00:00:00').to_i,
+    }
+    @poll_secs ||= Marty::Config['MARTY_EVENT_POLL_SECS'] || 0
+    time_now_i = Time.zone.now.to_i
+    cutoff = Time.zone.at(@all_finished[:timestamp]).
+             strftime('%Y-%m-%d %H:%M:%S.%6N')
+
+    if time_now_i - @all_finished[:timestamp] > @poll_secs
+      raw = get_data(
+        "SELECT * FROM
+            (SELECT ROW_NUMBER() OVER (PARTITION BY klass,
+                                                    subject_id,
+                                                    enum_event_operation
+                                       ORDER BY end_dt DESC) rownum, *
+             FROM (#{BASE_QUERY}) sub2
+             WHERE end_dt IS NOT NULL and end_dt > '#{cutoff}') sub1
+         WHERE rownum = 1"
+      )
+      @all_finished[:timestamp] = time_now_i
+      raw.each_with_object(@all_finished[:data]) do |ev, hash|
+        subhash = hash[[ev["klass"], ev["subject_id"]]] ||= {}
+        subhash[ev["enum_event_operation"]] =
+          ev["end_dt"].strftime("%Y-%m-%d %H:%M:%S")
+      end
+    end
+    @all_finished[:data]
+  end
+
+  def self.get_finished(klass, id)
+    all_finished[[klass, id]]
+  end
+end

data/db/migrate/200_create_marty_event_operation_enum.rb

@@ -0,0 +1,9 @@
+class CreateMartyEventOperationEnum < ActiveRecord::Migration
+  def change
+      values = Marty::EnumEventOperation::VALUES
+      str_values = values.map {|v| ActiveRecord::Base.connection.quote v}.join ','
+      execute <<-SQL
+         CREATE TYPE enum_event_operations AS ENUM (#{str_values})
+      SQL
+  end
+end

data/db/migrate/201_create_marty_events.rb

@@ -0,0 +1,30 @@
+class CreateMartyEvents < ActiveRecord::Migration
+  def change(*args)
+    # Giant hack to monkey patch connection so that we can create an
+    # UNLOGGED table in PostgreSQL.
+    class << @connection
+      alias_method :old_execute, :execute
+      define_method(:execute) { |sql, name=nil|
+        old_execute(sql.sub('CREATE', 'CREATE UNLOGGED'), name)
+      }
+    end
+    create_table :marty_events do |t|
+      t.integer  :promise_id, null: true
+      t.string   :klass, null: false, limit: 255
+      t.integer  :subject_id, null: false
+      t.pg_enum  :enum_event_operation, null: false
+      t.datetime :start_dt, null: true
+      t.datetime :end_dt, null: true
+      t.integer  :expire_secs, null: true
+      t.string   :comment, null: true
+    end
+    class << @connection
+      alias_method :execute, :old_execute
+    end
+    add_index :marty_events, [:klass, :subject_id,
+                             :enum_event_operation],
+              name: 'idx_klass_id_op'
+    add_index :marty_events, [:klass, :subject_id],
+              name: 'idx_klass_id'
+  end
+end

data/db/seeds.rb

@@ -46,3 +46,7 @@ unless Marty::Tag.find_by_name('DEV')
   tag.created_dt = 'infinity'
   tag.save!
 end
+
+# one time set up for delayed_job/promises, override as needed
+Marty::Config["DELAYED_JOB_PARAMS"] = "-n 4"
+Marty::Config["DELAYED_JOB_PATH"]   = "bin/delayed_job"

data/lib/marty/migrations.rb

@@ -3,6 +3,59 @@ module Marty::Migrations
     "marty_"
   end
 
+  def new_enum(klass, prefix_override = nil)
+    raise "bad class arg #{klass}" unless
+      klass.is_a?(Class) && klass < ActiveRecord::Base
+
+    raise "model class needs VALUES (as Set)" unless
+      klass.const_defined?(:VALUES)
+
+    values = klass::VALUES
+    str_values =
+      values.map {|v| ActiveRecord::Base.connection.quote v}.join ','
+
+    #hacky way to get name
+    prefix = prefix_override || tb_prefix
+    enum_name = klass.table_name.sub(/^#{prefix}_*/, '')
+
+    execute <<-SQL
+      CREATE TYPE #{enum_name} AS ENUM (#{str_values});
+    SQL
+  end
+
+  def update_enum(klass, prefix_override = nil)
+    raise "bad class arg #{klass}" unless
+      klass.is_a?(Class) && klass < ActiveRecord::Base
+
+    raise "model class needs VALUES (as Set)" unless
+      klass.const_defined?(:VALUES)
+
+    #hacky way to get name
+    prefix = prefix_override || tb_prefix
+    enum_name = klass.table_name.sub(/^#{prefix}/, '')
+
+    #check values against underlying values
+    res = execute <<-SQL
+      SELECT ENUM_RANGE(null::#{enum_name});
+    SQL
+
+    db_values = res.first['enum_range'].gsub(/[{}]/, '').split(',')
+    ex_values = klass::VALUES - db_values
+
+    puts "no new #{klass}::VALUES to add" if ex_values.empty?
+
+    #hack to prevent transaction
+    execute("COMMIT;")
+    ex_values.each do |v|
+      prepped_v = ActiveRecord::Base.connection.quote(v)
+
+      execute <<-SQL
+        ALTER TYPE #{enum_name} ADD VALUE #{prepped_v};
+      SQL
+    end
+    execute("BEGIN;")
+  end
+
   def add_fk(from_table, to_table, options = {})
     options[:column] ||= "#{to_table.to_s.singularize}_id"
 

data/lib/marty/promise_job.rb

@@ -20,7 +20,6 @@ class Delorean::BaseModule::NodeCall
       raise "bad arg to %" unless args.is_a?(Array)
       attr = nil
     end
-
     script, tag = engine.module_name, engine.sset.tag
     nn = node.is_a?(Class) ? node.name : node.to_s
 
@@ -40,7 +39,6 @@ class Delorean::BaseModule::NodeCall
              parent_id: params[:_parent_id],
              )
     params[:_promise_id] = promise.id
-
     begin
       job = Delayed::Job.enqueue Marty::PromiseJob.
         new(promise, title, script, tag, nn, params, args, hook)
@@ -58,15 +56,22 @@ class Delorean::BaseModule::NodeCall
     # been reserved yet.
     promise.job_id = job.id
     promise.save!
-
+    event = Marty::Event.
+                   create!(promise_id: promise.id,
+                           klass:      params[:__metadata__][:klass],
+                           subject_id: params[:__metadata__][:id],
+                           enum_event_operation:
+                             params[:__metadata__][:operation]) if
+      params[:__metadata__]
     Marty::PromiseProxy.new(promise.id, timeout, attr)
   end
 end
 
+
 class Delorean::Engine
-  def background_eval(node, params, attrs)
+  def background_eval(node, params, attrs, meta = {})
     raise "background_eval bad params" unless params.is_a?(Hash)
-
+    params[:__metadata__] = meta unless meta.empty?
     nc = Delorean::BaseModule::NodeCall.new({}, self, node, params)
     # start the background promise
     nc | attrs

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "1.0.12"
+  VERSION = "1.0.13"
 end

data/spec/dummy/app/models/gemini/enum_event_operation.rb

@@ -0,0 +1,5 @@
+class Gemini::EnumEventOperation < Gemini::Base
+  extend Marty::EnumEventOperation
+
+  VALUES = set['PRICING', 'CRA', 'AVM']
+end

data/spec/dummy/db/migrate/20140000000000_create_enums.rb

@@ -1,16 +1,6 @@
 class CreateEnums < ActiveRecord::Migration
+  include Marty::Migrations
   def change
-    values = Gemini::EnumState::VALUES
-      str_values =
-        values.map {|v| ActiveRecord::Base.connection.quote v}.join ','
-
-      ActiveRecord::Base.schema_migrations_table_name
-
-      # FIXME: very crude
-      name = 'enum_states'
-
-      execute <<-SQL
-         CREATE TYPE #{name} AS ENUM (#{str_values});
-      SQL
+    new_enum(Gemini::EnumState, 'gemini')
   end
 end

data/spec/dummy/db/migrate/20160923183516_add_bulk_pricing_event_ops.rb

@@ -0,0 +1,9 @@
+class AddBulkPricingEventOps < ActiveRecord::Migration
+  def change
+    execute("COMMIT;")
+    execute "ALTER TYPE enum_event_operations ADD VALUE 'PRICING';"
+    execute "ALTER TYPE enum_event_operations ADD VALUE 'CRA';"
+    execute "ALTER TYPE enum_event_operations ADD VALUE 'AVM';"
+    execute("BEGIN;")
+  end
+end

data/spec/job_helper.rb

@@ -88,6 +88,13 @@ Y:
     d = [Y(q=i) | ['a'] for i in [1, 2]]
 EOS
 
+NAME_I = "PromiseI"
+SCRIPT_I = <<EOS
+SLEEPER:
+    secs =? nil
+    a = Gemini::Helper.sleep(secs) && secs
+EOS
+
 def promise_bodies
   {
     NAME_A => SCRIPT_A,
@@ -98,5 +105,6 @@ def promise_bodies
     NAME_F => SCRIPT_F,
     NAME_G => SCRIPT_G,
     NAME_H => SCRIPT_H,
+    NAME_I => SCRIPT_I,
   }
 end

data/spec/models/event_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+require 'job_helper'
+
+describe Marty::Event do
+  before(:all) do
+    @clean_file = "/tmp/clean_#{Process.pid}.psql"
+    save_clean_db(@clean_file)
+
+    # transactional fixtures interfere with queueing jobs
+    self.use_transactional_fixtures = false
+
+    # Needed here because shutting transactional fixtures off
+    # means we lose the globally set user
+    Mcfly.whodunnit = UserHelpers.system_user
+
+    Marty::Script.load_script_bodies(promise_bodies, Date.today)
+    start_delayed_job
+    Marty::Config["MARTY_EVENT_POLL_SECS"] = 1
+
+    @time = Time.zone.now
+    @date_string = @time.strftime('%Y-%m-%d')
+    @old_start = '1970-01-01 08:00:00'
+    @old_end = '1970-01-01 09:00:00'
+    # add events
+    [['testcl1',  123, @time, nil,            nil,     'AVM',     'a comment'],
+     ['testcl1',  123, @time + 2.second, nil,nil,     'CRA',     'b comment'],
+     ['testcl1',  123, @time + 4.seconds, nil,10000,     'PRICING', 'c comment'],
+     ['testcl2', 123, @time, nil,             2, 'AVM',     'e comment'],
+     ['testcl2', 123, @time + 1.second, nil,  4, 'CRA',     'f comment'],
+     ['testcl2', 123, Time.zone.parse(@old_start),
+      Time.zone.parse(@old_end), nil, 'PRICING', 'old event'],
+    ].each do
+      |klass, subjid, startdt, enddt, expire, op, comment|
+      Marty::Event.create!(klass: klass,
+                         subject_id: subjid,
+                         start_dt: startdt,
+                         end_dt: enddt,
+                         expire_secs: expire,
+                         comment: comment,
+                         enum_event_operation: op)
+    end
+
+
+    engine = Marty::ScriptSet.new.get_engine(NAME_I)
+    res = engine.background_eval("SLEEPER", {"secs" => 5}, ["a"],
+                                {klass: "testcl3",
+                                 id: 987,
+                                 operation: 'PRICING'})
+    res.force
+    sleep 5
+  end
+
+  after(:all) do
+    self.use_transactional_fixtures = true
+    restore_clean_db(@clean_file)
+    stop_delayed_job
+  end
+
+
+  it "Event tests" do
+    expect(Marty::Event.currently_running('testcl1', 123)).to eq(
+      ['AVM', 'CRA', 'PRICING'])
+    expect(Marty::Event.currently_running('testcl2', 123)).to eq([])
+    expect(Marty::Event.currently_running('testcl3', 987)).to eq([])
+
+    expect(Marty::Event.last_event('testcl1', 123)).to include(
+      {"klass"=>"testcl1",
+       "subject_id"=>123,
+       "enum_event_operation"=>"PRICING",
+       "comment"=>"c comment", "expire_secs"=>10000})
+    expect(Marty::Event.last_event('testcl2', 123)).to include(
+      {"klass"=>"testcl2",
+       "subject_id"=>123,
+       "enum_event_operation"=>"CRA",
+       "comment"=>"f comment",
+       "expire_secs"=>4})
+    expect(Marty::Event.last_event('testcl3', 987)).to include(
+      {"klass"=>"testcl3",
+        "subject_id"=>987,
+        "enum_event_operation"=>"PRICING",
+        "comment"=>nil,
+        "expire_secs"=>nil})
+
+    Timecop.freeze(@time+1.second)
+    Marty::Event.clear_cache
+    expect(Marty::Event.currently_running('testcl1', 123)).to eq(
+      ['AVM', 'CRA', 'PRICING'])
+    expect(Marty::Event.currently_running('testcl2', 123)).to eq(
+      ['AVM', 'CRA'])
+
+    Timecop.freeze(@time+3.seconds)
+    Marty::Event.clear_cache
+    expect(Marty::Event.currently_running('testcl1', 123)).to eq(
+      ['AVM', 'CRA', 'PRICING'])
+    expect(Marty::Event.currently_running('testcl2', 123)).to eq(
+      ['CRA'])
+
+    Timecop.freeze(@time+6.seconds)
+    expect(Marty::Event.currently_running('testcl1', 123)).to eq(
+      ['AVM', 'CRA', 'PRICING'])
+    expect(Marty::Event.currently_running('testcl2', 123)).to eq(
+      [])
+
+    Timecop.return
+
+    af = Marty::Event.all_finished
+    expect(af.count).to eq(2)
+    expect(af).to include(['testcl3', 987])
+    expect(af).to include(['testcl2', 123])
+    expect(af[['testcl3', 987]]).to include('PRICING')
+    expect(af[['testcl3', 987]]['PRICING']).to start_with(@date_string)
+    expect(af[['testcl2', 123]]).to include('PRICING')
+    expect(af[['testcl2', 123]]['PRICING']).to eq(@old_end)
+
+    expect(Marty::Event.currently_running('testcl1', 123)).to eq(
+      ['AVM', 'CRA', 'PRICING'])
+    expect(Marty::Event.op_is_running?('testcl1', 123, 'AVM')).to be_truthy
+    Marty::Event.finish_event('testcl1', 123, 'AVM', 'wassup')
+    Marty::Event.clear_cache
+    expect(Marty::Event.currently_running('testcl1', 123)).to eq(
+      ['CRA', 'PRICING'])
+    expect(Marty::Event.op_is_running?('testcl1', 123, 'AVM')).to be_falsey
+    expect(Marty::Event.op_is_running?('testcl1', 123, 'CRA')).to be_truthy
+
+    ev = Marty::Event.lookup_event('testcl1', 123, 'AVM')
+    expect(ev.length).to eq(1)
+    expect(ev.first).to include({"klass"=>"testcl1",
+                                 "subject_id"=>123,
+                                 "enum_event_operation"=>"AVM",
+                                 "comment"=>"wassup",
+                                 "expire_secs"=>nil})
+    Marty::Event.update_comment(ev.first, "updated")
+    ev = Marty::Event.lookup_event('testcl1', 123, 'AVM')
+    expect(ev.first).to include({"comment"=>"updated"})
+    expect(Marty::Event.compact_end_dt(ev.first)).to match(/\d\d:\d\d/)
+    expect(Marty::Event.pretty_op(ev.first)).to eq('Avm')
+    ev = Marty::Event.lookup_event('testcl1', 123, 'PRICING').first
+    expect(Marty::Event.pretty_op(ev)).to eq('Pricing')
+
+    af = Marty::Event.all_finished
+    expect(af.count).to eq(3)
+    expect(af[['testcl3', 987]]).to include('PRICING')
+    expect(af[['testcl1', 123]]).to include('AVM')
+    expect(af[['testcl1', 123]]['AVM']).to start_with(@date_string)
+
+    expect {Marty::Event.create_event('testcl', 1234, 'AVM', Time.zone.now, 600,
+                                      "the comment") }.not_to raise_error
+
+    expect {Marty::Event.create_event('testcl', 1234, 'AVM', Time.zone.now, 600,
+                                      "the comment") }.
+      to raise_error(%r!AVM is already running for testcl/1234!)
+    expect {Marty::Event.create_event('testcl', 2345, 'AVM', Time.zone.now, 600,
+                                     "the comment") }.not_to raise_error
+    expect {Marty::Event.finish_event('testcl', 1234, 'AVM', "new comment") }.
+      not_to raise_error
+    expect {Marty::Event.finish_event('testcl', 1234, 'AVM', "new comment") }.
+      to raise_error(%r!event testcl/1234/AVM not found!)
+    expect {Marty::Event.finish_event('testcl', 2345, 'AVM', 'foobar') }.
+      not_to raise_error
+    expect {Marty::Event.finish_event('testcl', 2345, 'AVM', 'foobar') }.
+      to raise_error(%r!event testcl/2345/AVM not found!)
+    expect {Marty::Event.create_event('testcl', 1234, 'AMV', Time.zone.now, 600,
+                                      "the comment") }.
+      to raise_error(%r!PG::.*invalid input value for enum.*"AMV"!)
+    Marty::Event.clear_cache
+    af = Marty::Event.all_finished
+    expect(af.count).to eq(5)
+    expect(af).to include(['testcl', 1234])
+    expect(af).to include(['testcl', 2345])
+    expect(af[['testcl', 1234]]).to include('AVM')
+    expect(af[['testcl', 2345]]).to include('AVM')
+    expect(af[['testcl', 1234]]['AVM']).to start_with(@date_string)
+    expect(af[['testcl', 2345]]['AVM']).to start_with(@date_string)
+
+  end
+end

data/spec/models/promise_spec.rb

@@ -1,6 +1,4 @@
 require 'spec_helper'
-require 'marty'
-require 'delorean_lang'
 require 'job_helper'
 
 describe Marty::Promise, slow: true do

data/spec/spec_helper.rb

@@ -30,6 +30,11 @@ class ActiveRecord::Base
 end
 
 Capybara.register_driver :selenium do |app|
+  # use personal firefox if it exists
+  personal_firefox = File.expand_path('~/firefox/firefox')
+  Selenium::WebDriver::Firefox::Binary.path = personal_firefox if
+    File.exists?(personal_firefox)
+
   client = Selenium::WebDriver::Remote::Http::Default.new
   profile = Selenium::WebDriver::Firefox::Profile.new
   profile.load_no_focus_lib = true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marty
 version: !ruby/object:Gem::Version
-  version: 1.0.12
+  version: 1.0.13
 platform: ruby
 authors:
 - Arman Bostani
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-21 00:00:00.000000000 Z
+date: 2016-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -382,6 +382,8 @@ files:
 - app/models/marty/config.rb
 - app/models/marty/data_grid.rb
 - app/models/marty/enum.rb
+- app/models/marty/enum_event_operation.rb
+- app/models/marty/event.rb
 - app/models/marty/grid_index_boolean.rb
 - app/models/marty/grid_index_int4range.rb
 - app/models/marty/grid_index_integer.rb
@@ -432,6 +434,8 @@ files:
 - db/migrate/104_create_marty_grid_index_strings.rb
 - db/migrate/105_create_marty_grid_index_booleans.rb
 - db/migrate/106_make_grid_indexes_nullable.rb
+- db/migrate/200_create_marty_event_operation_enum.rb
+- db/migrate/201_create_marty_events.rb
 - db/seeds.rb
 - gemini_deprecations.md
 - lib/marty.rb
@@ -480,6 +484,7 @@ files:
 - spec/dummy/app/models/gemini/amortization_type.rb
 - spec/dummy/app/models/gemini/bud_category.rb
 - spec/dummy/app/models/gemini/entity.rb
+- spec/dummy/app/models/gemini/enum_event_operation.rb
 - spec/dummy/app/models/gemini/enum_state.rb
 - spec/dummy/app/models/gemini/extras/data_import.rb
 - spec/dummy/app/models/gemini/extras/settlement_import.rb
@@ -522,6 +527,7 @@ files:
 - spec/dummy/db/migrate/20150420000003_create_grouping_head_versions.rb
 - spec/dummy/db/migrate/20151023000001_create_simple.rb
 - spec/dummy/db/migrate/20160100000038_create_gemini_states.rb
+- spec/dummy/db/migrate/20160923183516_add_bulk_pricing_event_ops.rb
 - spec/dummy/db/seeds.rb
 - spec/dummy/delorean/blame_report.dl
 - spec/dummy/delorean/data_report.dl
@@ -1562,6 +1568,7 @@ files:
 - spec/models/api_auth_spec.rb
 - spec/models/config_spec.rb
 - spec/models/data_grid_spec.rb
+- spec/models/event_spec.rb
 - spec/models/import_type_spec.rb
 - spec/models/posting_spec.rb
 - spec/models/promise_spec.rb