marty 0.5.12

data/app/models/marty/poop.rb~

@@ -0,0 +1,169 @@
+class Marty::Promise < Marty::Base
+
+  # default timeout (seconds) to wait for promise values
+  DEFAULT_PROMISE_TIMEOUT = 30
+
+  # default timeout (seconds) to wait for jobs to start
+  DEFAULT_JOB_TIMEOUT = 10
+
+  attr_accessible :title,
+  :cformat,
+  :parent_id,
+  :job_id,
+  :status,
+  :result,
+  :start_dt,
+  :end_dt
+
+  serialize :result, Hash
+
+  validates_presence_of :title
+
+  has_many :children, foreign_key: 'parent_id', class_name: "Marty::Promise"
+  belongs_to :parent, class_name: "Marty::Promise"
+
+  def raw_conn
+    self.class.connection.raw_connection
+  end
+
+  def pg_notify
+    raw_conn.async_exec("NOTIFY promise_#{id}")
+  end
+
+  def set_start
+    log "LOGLOG #{Rails.logger}"
+
+    if self.start_dt || self.result != {}
+      Marty::Util.logger.error("promise already started: #{self}")
+      return
+    end
+
+    # mark promise as started
+    self.start_dt = DateTime.now
+    self.save!
+  end
+
+  def set_result(res)
+    log "SETRES #{Process.pid} #{res} #{self}"
+
+    # promise must have been started and not yet ended
+    if !self.start_dt || self.end_dt || self.result != {}
+      log "SETERR #{Process.pid} #{self}"
+      Marty::Util.logger.error("unexpected promise state: #{self}")
+      return
+    end
+
+    raise "bad result" unless res.is_a?(Hash)
+
+    self.status = res["error"].nil?
+    self.result = res
+
+    # update title/format from result hash (somewhat hacky)
+    self.title 		= res["title"].to_s 	if res["title"]
+    self.cformat	= res["format"].to_s 	if res["format"]
+
+    # mark promise as ended
+    self.end_dt = DateTime.now
+    self.save!
+
+    log "NOTIFY #{Process.pid}"
+    pg_notify
+  end
+
+  def to_s
+    inspect
+  end
+
+  def log(msg)
+    open('/tmp/dj.out', 'a') { |f| f.puts msg }
+  end
+
+  def wait_for_my_notify(timeout)
+    while true do
+      # FIXME: we keep using the same timeout.  The timeout should be
+      # reduced by total time spent here.
+      n = raw_conn.wait_for_notify(timeout)
+      return n if !n || n=="promise_#{id}"
+    end
+  end
+
+  def latest
+    # latest uncached version
+    Marty::Promise.uncached {Marty::Promise.find(id)}
+  end
+
+  def work_off_job(job)
+    # Create a temporary worker to work off the job 
+    Delayed::Job.where(id: job.id).
+      update_all(locked_at: Delayed::Job.db_time_now, locked_by: "Temp")
+    w = Delayed::Worker.new
+    w.run(job)
+  end
+
+  def wait_for_result(timeout)
+    return self.result if self.result != {}
+
+    # FIXME: instead of using latest(), should look at how delayed
+    # jobs are loaded.  i.e. use reset+reload.
+
+    begin
+      # start listening on promise's notification
+      raw_conn.exec("LISTEN promise_#{id}")
+
+      last = latest
+
+      # if job hasn't started yet, wait for it to start
+      if !last.start_dt
+        log "AAAA #{Process.pid} #{last}"
+        
+        job = Delayed::Job.find_by_id(last.job_id)
+        job.reload if job # paranoid
+
+        if !job && job.locked_at
+          # job has been locked, so it looks like it started already
+          # and we need to wait for it.
+          wait_for_my_notify(Marty::Promise::DEFAULT_JOB_TIMEOUT)
+        else
+          # work off the job instead of waiting for a real worker to
+          # pick it up.
+          log "OFFF #{Process.pid} #{last}"
+          work_off_job(job)
+        end
+
+        last = latest
+
+        # we waited for it but it never started.  So, mark it with a
+        # timeout error.
+        if !last.start_dt
+          log "TO11 #{Process.pid} #{last}"
+          return {"error" => "promise #{last.id} timed out (never started)"}
+        end
+      end
+      
+      # reload promise in case out copy doesn't have a result yet
+      last = latest unless last.end_dt
+
+      # at this point, we know the promise has already started
+      if !last.end_dt
+        wait_for_my_notify(timeout)
+        log "UUUU #{Process.pid} #{id} #{Time.now.to_f}"
+        last = latest
+
+        log "XXXX #{Process.pid} #{Time.now.to_f} #{last}"
+
+        if !last.end_dt
+          log "TO22 #{Process.pid} #{last}"
+          return {"error" => "promise #{last.id} timed out (didn't end)"}
+        end
+      end
+
+      log "RRRR #{Process.pid} #{last} #{Time.now.to_f}"
+
+      last.result
+    ensure
+      # Stop listening to the promise notifications
+      raw_conn.exec("UNLISTEN promise_#{id}")
+    end
+
+  end
+end

data/app/models/marty/posting.rb

@@ -0,0 +1,101 @@
+class Marty::Posting < Marty::Base
+  has_mcfly append_only: true
+
+  mcfly_validates_uniqueness_of :name
+  validates_presence_of :name, :posting_type_id, :comment
+
+  belongs_to :user, class_name: "Marty::User"
+  belongs_to :posting_type
+
+  def self.make_name(posting_type, dt)
+    return 'NOW' if Mcfly.is_infinity(dt)
+
+    return unless posting_type
+
+    # If no dt is provided (which is the usual non-testing case), we
+    # use Time.now.strftime to name the posting.  This has the effect
+    # of using the host's timezone. i.e. since we're in PST8PDT, names
+    # will be based off of the Pacific TZ.
+    dt ||= Time.now
+    "#{posting_type.name}-#{dt.strftime('%Y%m%d-%H%M')}"
+  end
+
+  before_validation :set_posting_name
+  def set_posting_name
+    posting_type = Marty::PostingType.find_by_id(self.posting_type_id)
+    self.name = self.class.make_name(posting_type, self.created_dt)
+    true
+  end
+
+  def self.do_create(type_name, dt, comment)
+    posting_type = Marty::PostingType.find_by_name(type_name)
+
+    raise "unknown posting type #{name}" unless posting_type
+
+    o              = new
+    o.posting_type = posting_type
+    o.comment      = comment
+    o.created_dt   = dt
+    o.save!
+    o
+  end
+
+  # Not using mcfly_lookup since we don't want these time-warp markers
+  # time-warped. FIXME: perhaps this should use mcfly_lookup since we
+  # may allow deletion of postings.  i.e. a new one with same name
+  # might be created.  Or, use regular validates_uniqueness_of instead
+  # of mcfly_validates_uniqueness_of.
+  delorean_fn :lookup, sig: 1 do
+    |name|
+    self.find_by_name(name)
+  end
+
+  delorean_fn :lookup_dt, sig: 1 do
+    |name|
+    lookup(name).try(:created_dt)
+  end
+
+  delorean_fn :first_match, sig: [1, 2] do
+    |dt, posting_type=nil|
+    raise "bad posting type" if
+      posting_type && !posting_type.is_a?(Marty::PostingType)
+
+    q = where("created_dt <= ?", dt)
+    q = q.where(posting_type_id: posting_type.id) if posting_type
+    q.order("created_dt DESC").first
+  end
+
+  delorean_fn :get_latest, sig: [1, 2] do
+    |limit, is_test=nil|
+    # IMPORTANT: is_test arg is ignored (KEEP for backward compat.)
+
+    where("created_dt <> 'infinity'").
+      order("created_dt DESC").limit(limit).to_a
+  end
+
+  delorean_fn :get_latest_by_type, sig: [2, 2] do
+    |limit, posting_types=[]|
+    raise "missing posting types list" unless posting_types
+    raise "bad posting types list" unless posting_types.is_a?(Array)
+
+    joins(:posting_type).where("created_dt <> 'infinity'").
+      where(marty_posting_types: { name: posting_types } ).
+      order("created_dt DESC").limit(limit || 1).to_a
+  end
+
+  delorean_fn :get_last, sig: [0, 1] do
+    |posting_type=nil|
+
+    raise "bad posting type" if
+      posting_type && !posting_type.is_a?(Marty::PostingType)
+
+    q = where("created_dt <> 'infinity'")
+    q = q.where(posting_type_id: posting_type.id) if posting_type
+    q.order("created_dt DESC").first
+  end
+
+  delorean_fn :is_today, sig: 1 do
+    |posting|
+    posting.created_dt.to_date == Date.today
+  end
+end

data/app/models/marty/posting.rb~

@@ -0,0 +1,86 @@
+class Marty::Posting < Marty::Base
+  has_mcfly append_only: true
+
+  mcfly_validates_uniqueness_of :name
+  validates_presence_of :name, :posting_type_id, :comment
+
+  belongs_to :user, class_name: "Marty::User"
+  belongs_to :posting_type
+
+  def self.make_name(posting_type, dt)
+    return 'NOW' if Mcfly.is_infinity(dt)
+
+    return unless posting_type
+
+    # If no dt is provided (which is the usual non-testing case), we
+    # use Time.now.strftime to name the posting.  This has the effect
+    # of using the host's timezone. i.e. since we're in PST8PDT, names
+    # will be based off of the Pacific TZ.
+    dt ||= Time.now
+    "#{posting_type.name}-#{dt.strftime('%Y%m%d-%H%M')}"
+  end
+
+  before_validation :set_posting_name
+  def set_posting_name
+    posting_type = Marty::PostingType.find_by_id(self.posting_type_id)
+    self.name = self.class.make_name(posting_type, self.created_dt)
+    true
+  end
+
+  def self.do_create(type_name, dt, comment)
+    posting_type = Marty::PostingType.find_by_name(type_name)
+
+    raise "unknown posting type #{name}" unless posting_type
+
+    o              = new
+    o.posting_type = posting_type
+    o.comment      = comment
+    o.created_dt   = dt
+    o.save!
+    o
+  end
+
+  # Not using mcfly_lookup since we don't want these time-warp markers
+  # time-warped. FIXME: perhaps this should use mcfly_lookup since we
+  # may allow deletion of postings.  i.e. a new one with same name
+  # might be created.  Or, use regular validates_uniqueness_of instead
+  # of mcfly_validates_uniqueness_of.
+  delorean_fn :lookup, sig: 1 do
+    |name|
+    self.find_by_name(name)
+  end
+
+  delorean_fn :lookup_dt, sig: 1 do
+    |name|
+    lookup(name).try(:created_dt)
+  end
+
+  delorean_fn :first_match, sig: 1 do
+    |dt|
+    where("created_dt <= ?", dt).order("created_dt DESC").first
+  end
+
+  delorean_fn :get_latest, sig: [1, 2] do
+    |limit, is_test=nil|
+    # IMPORTANT: is_test arg is ignored (KEEP for backward compat.)
+
+    where("created_dt <> 'infinity'").
+      order("created_dt DESC").limit(limit).to_a
+  end
+
+  delorean_fn :get_last, sig: [0, 1] do
+    |posting_type=nil|
+
+    raise "bad posting type" if
+      posting_type && !posting_type.is_a?(Marty::PostingType)
+
+    q = where("created_dt <> 'infinity'")
+    q = q.where(posting_type_id: posting_type.id) if posting_type
+    q.order("created_dt DESC").first
+  end
+
+  delorean_fn :is_today, sig: 1 do
+    |posting|
+    posting.created_dt.to_date == Date.today
+  end
+end

data/app/models/marty/posting_type.rb

@@ -0,0 +1,12 @@
+class Marty::PostingType < Marty::Base
+  extend Marty::Enum
+
+  validates_presence_of :name
+  validates_uniqueness_of :name
+
+  # NOTE: lookup fn for backward compat -- to index enums, use []
+  delorean_fn :lookup, sig: 1 do
+    |name|
+    self.find_by_name(name)
+  end
+end

data/app/models/marty/posting_type.rb~

@@ -0,0 +1,21 @@
+class Marty::PostingType < Marty::Base
+  extend Marty::Enum
+
+<<<<<<< HEAD
+  # attr_accessible :name
+=======
+>>>>>>> master
+  validates_presence_of :name
+  validates_uniqueness_of :name
+
+  delorean_fn :lookup, sig: 1 do
+    |name|
+    self.find_by_name(name)
+  end
+
+  def self.seed
+    ['BASE', 'CLOSE', 'INTRA', 'RULE'].each { |type|
+      create name: type
+    }
+  end
+end

data/app/models/marty/promise.rb

@@ -0,0 +1,252 @@
+class Marty::Promise < Marty::Base
+  class MarshalResult
+    def dump(v)
+      Marshal.dump(v)
+    end
+
+    def load(v)
+      # Marshal.load can't handle nil
+      v ? Marshal.load(v) : {}
+    end
+  end
+
+  # default timeout (seconds) to wait for promise values
+  DEFAULT_PROMISE_TIMEOUT = Rails.configuration.marty.promise_timeout || 30
+
+  # default timeout (seconds) to wait for jobs to start
+  DEFAULT_JOB_TIMEOUT = Rails.configuration.marty.job_timeout || 10
+
+  lazy_load :result
+
+  serialize :result, MarshalResult.new
+
+  validates_presence_of :title
+
+  has_many :children,
+  foreign_key: 'parent_id',
+  class_name: "Marty::Promise",
+  dependent: :destroy
+
+  belongs_to :parent, class_name: "Marty::Promise"
+  belongs_to :user, class_name: "Marty::User"
+
+  def self.cleanup(all=false)
+    begin
+      where('start_dt < ? AND parent_id IS NULL',
+            DateTime.now - (all ? 0.hours : 4.hours)).destroy_all
+    rescue => exc
+      Marty::Util.logger.error("promise GC error: #{exc}")
+    end
+  end
+
+  class VirtualRoot
+    def self.primary_key
+      'id'
+    end
+
+    def id
+      'root'
+    end
+
+    def user_id
+      0
+    end
+    alias_method :job_id, :user_id
+
+    def result
+      nil
+    end
+    [:start_dt, :end_dt].each { |m| alias_method m, :result }
+
+    def status
+      true
+    end
+  end
+
+  def self.root
+    VirtualRoot.new
+  end
+
+  def self.children_for_id(id, search_order)
+    if id == 'root'
+      where(parent_id: nil).live_search(search_order).order(id: :desc).includes(:children, :user)
+    else
+      find(id).children.live_search(search_order).order(id: :desc).includes(:children, :user)
+    end
+  end
+
+  def leaf
+    children.empty?
+  end
+
+  def raw_conn
+    self.class.connection.raw_connection
+  end
+
+  def pg_notify
+    raw_conn.async_exec("NOTIFY promise_#{id}")
+  end
+
+  def set_start
+    if self.start_dt || self.result != {}
+      Marty::Util.logger.error("promise already started: #{self}")
+      return
+    end
+
+    # mark promise as started
+    self.start_dt = DateTime.now
+    self.save!
+  end
+
+  def set_result(res)
+    # log "SETRES #{Process.pid} #{self}"
+
+    # promise must have been started and not yet ended
+    if !self.start_dt || self.end_dt || self.result != {}
+      # log "SETERR #{Process.pid} #{self}"
+      Marty::Util.logger.error("unexpected promise state: #{self}")
+      return
+    end
+
+    raise "bad result" unless res.is_a?(Hash)
+
+    self.status = res["error"].nil?
+    self.result = res
+
+    # update title/format from result hash (somewhat hacky)
+    self.title   = res["title"].to_s  if res["title"]
+    self.cformat = res["format"].to_s if res["format"]
+
+    # mark promise as ended
+    self.end_dt = DateTime.now
+    self.save!
+
+    # log "NOTIFY #{Process.pid}"
+    pg_notify
+  end
+
+  def to_s
+    inspect
+  end
+
+  # def log(msg)
+  #   open('/tmp/dj.out', 'a') { |f| f.puts msg }
+  # end
+
+  def wait_for_my_notify(timeout)
+    while true do
+      # FIXME: we keep using the same timeout.  The timeout should be
+      # reduced by total time spent here.
+      n = raw_conn.wait_for_notify(timeout)
+      return n if !n || n=="promise_#{id}"
+    end
+  end
+
+  def latest
+    # FIXME: Not sure if this is idiomatic.  What's the best way to
+    # force AR to reload the promise object?  reset+reload doesn't
+    # seems to work.
+
+    # get latest uncached version
+    Marty::Promise.uncached {Marty::Promise.find(id)}
+  end
+
+  def self.job_by_id(job_id)
+    Delayed::Job.uncached {Delayed::Job.find_by_id(job_id)}
+  end
+
+  def work_off_job(job)
+    # Create a temporary worker to work off the job
+    Delayed::Job.where(id: job.id).
+      update_all(locked_at: Delayed::Job.db_time_now, locked_by: "Temp")
+    w = Delayed::Worker.new
+    w.run(job)
+  end
+
+  def wait_for_result(timeout)
+    return self.result if self.result != {}
+
+    begin
+      # start listening on promise's notification
+      raw_conn.exec("LISTEN promise_#{id}")
+
+      last = latest
+
+      # if job hasn't started yet, wait for it to start
+      if !last.start_dt
+        job = Marty::Promise.job_by_id(last.job_id)
+
+        # log "AAAA #{Process.pid} #{last} #{job}"
+
+        if !job || job.locked_at
+          # job has been locked, so it looks like it started already
+          # and we need to wait for it.
+          wait_for_my_notify(Marty::Promise::DEFAULT_JOB_TIMEOUT)
+        else
+          # work off the job instead of waiting for a real worker to
+          # pick it up.
+          # log "OFF0 #{Process.pid} #{last}"
+          begin
+            work_off_job(job)
+          rescue => exc
+            # log "OFFERR #{exc}"
+            res = Delorean::Engine.grok_runtime_exception(exc)
+            last.set_result(res)
+          end
+          # log "OFF1 #{Process.pid} #{last}"
+        end
+
+        last = latest
+
+        # we waited for it but it never started.  So, mark it with a
+        # timeout error.
+        if !last.start_dt
+          # log "TO11 #{Process.pid} #{last}"
+          return {"error" => "promise #{last.id} timed out (never started)"}
+        end
+      end
+
+      # reload promise in case out copy doesn't have a result yet
+      last = latest unless last.end_dt
+
+      # at this point, we know the promise has already started
+      if !last.end_dt
+        wait_for_my_notify(timeout)
+        # log "UUUU #{Process.pid} #{id} #{Time.now.to_f}"
+        last = latest
+
+        # log "XXXX #{Process.pid} #{Time.now.to_f} #{last}"
+
+        if !last.end_dt
+          # log "TO22 #{Process.pid} #{last}"
+          return {"error" => "promise #{last.id} timed out (didn't end)"}
+        end
+      end
+
+      # log "RRRR #{Process.pid} #{last} #{Time.now.to_f}"
+
+      last.result
+    ensure
+      # Stop listening to the promise notifications
+      raw_conn.exec("UNLISTEN promise_#{id}")
+    end
+  end
+
+  # Support UI live search -- FIXME: hacky to have UI scoping here
+  scope :live_search, lambda { |search_text|
+    return if !search_text || search_text.strip.length < 1
+
+    # Searches user login/firstname/lastname
+    query = [
+             "marty_users.login ILIKE ?",
+             "marty_users.firstname ILIKE ?",
+             "marty_users.lastname ILIKE ?",
+             "marty_roles.name ILIKE ?",
+            ].join(' OR ')
+
+    st = "%#{search_text}%"
+    # Convert "Role Name" or "Role name" to "role_name" (underscore is key)
+    st2 = "%#{search_text.titleize.gsub(/\s/, '').underscore}%"
+    joins({:user => :roles}).where(query, st, st, st, st2).distinct
+  }
+end