marty 0.5.15 → 0.5.16

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

@@ -1,169 +0,0 @@
-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~

@@ -1,86 +0,0 @@
-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~

@@ -1,21 +0,0 @@
-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~

@@ -1,196 +0,0 @@
-class Marty::Promise < Marty::Base
-  class MarshalResult
-    def dump(v)
-      Marshal.dump(v)
-    end
-
-    def load(v)
-      # FIXME: Rails4 bytea interface seems to remove the trailing
-      # \x00 char.
-      v += "\x00" if v
-
-      # Marshal.load can't handle nil
-      v.nil? ? {} : 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 : 2.hours)).destroy_all
-    rescue => exc
-      Marty::Util.logger.error("promise GC error: #{exc}")
-    end
-  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} #{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
-    # 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 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
-        # 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 "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
-end