marty 0.5.12

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

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

data/app/models/marty/role.rb

@@ -0,0 +1,6 @@
+class Marty::Role < Marty::Base
+  extend Marty::Enum
+
+  validates_uniqueness_of :name
+  # FIXME: should have before_destroy
+end

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

@@ -0,0 +1,10 @@
+class Marty::Role < Marty::Base
+  extend Marty::Enum
+
+<<<<<<< HEAD
+  # attr_accessible :name
+=======
+>>>>>>> master
+  validates_uniqueness_of :name
+  # FIXME: should have before_destroy
+end

data/app/models/marty/script.rb

@@ -0,0 +1,144 @@
+require 'mcfly'
+
+class Marty::Script < Marty::Base
+  has_mcfly
+
+  validates_presence_of :name, :body
+  mcfly_validates_uniqueness_of :name
+  validates_format_of :name, {
+    with: /\A[A-Z][a-zA-Z0-9]*\z/,
+    message: I18n.t('script.save_error'),
+  }
+
+  belongs_to :user, class_name: "Marty::User"
+
+  gen_mcfly_lookup :lookup, {
+    name: false,
+  }
+
+  gen_mcfly_lookup :get_all, {}, mode: :all
+
+  # find script by name/tag
+  def self.find_script(sname, tag=nil)
+    tag = Marty::Tag.map_to_tag(tag)
+    Marty::Script.lookup(tag.created_dt, sname)
+  end
+
+  def find_tag
+    # find the first tag created after this script.
+    Marty::Tag.where("created_dt >= ?", created_dt).order(:created_dt).first
+  end
+
+  def self.create_script(name, body)
+    script      = new
+    script.name = name
+    script.body = body
+    script.save
+    script
+  end
+
+  def self.load_a_script(sname, body, dt=nil)
+    s = Marty::Script.lookup('infinity', sname)
+
+    if !s
+      s = Marty::Script.new
+      s.body = body
+      s.name = sname
+      s.created_dt = dt if dt
+      s.save!
+    elsif s.body != body
+      s.body = body
+      s.created_dt = dt if dt
+      s.save!
+    end
+  end
+
+  def self.load_script_bodies(bodies, dt=nil)
+    bodies.each {
+      |sname, body|
+      load_a_script(sname, body, dt)
+    }
+
+    # Create a new tag if scripts were modified after the last tag
+    tag = Marty::Tag.get_latest1
+    latest = Marty::Script.order("created_dt DESC").first
+
+    tag_time = (dt || [latest.try(:created_dt), Time.now].compact.max) +
+      1.second
+
+    # If no tag_time is provided, the tag created_dt will be the same
+    # as the scripts.
+    tag = Marty::Tag.do_create(tag_time, "tagged from load scripts") if
+      !(tag && latest) || tag.created_dt <= latest.created_dt
+
+    tag
+  end
+
+  def self.load_scripts(path=nil, dt=nil)
+    files = get_script_filenames(path)
+
+    bodies = read_script_files(files)
+
+    load_script_bodies(bodies, dt)
+  end
+
+  def self.read_script_files(files)
+    files.collect { |fpath|
+      fname = File.basename(fpath)[0..-4].camelize
+      [fname, File.read(fpath)]
+    }
+  end
+
+  def self.get_script_filenames(paths = nil)
+    paths = get_script_paths(paths)
+
+    filenames = {}
+    paths.each do |path|
+      Dir.glob("#{path}/*.dl").each do |filename|
+        basename = File.basename(filename)
+        filenames[basename] = filename unless filenames.has_key?(basename)
+      end
+    end
+
+    filenames.values
+  end
+
+  def self.get_script_paths(paths)
+    if paths
+      paths = Array(paths)
+    elsif Rails.configuration.marty.delorean_scripts_path
+      paths = Rails.configuration.marty.delorean_scripts_path
+    else
+      paths = ["#{Rails.root}/delorean",
+                File.expand_path('../../../../delorean', __FILE__)]
+    end
+  end
+
+
+  def self.delete_scripts
+    ActiveRecord::Base.connection.
+      execute("ALTER TABLE marty_scripts DISABLE TRIGGER USER;")
+    Marty::Script.delete_all
+    ActiveRecord::Base.connection.
+      execute("ALTER TABLE marty_scripts ENABLE TRIGGER USER;")
+  end
+
+  delorean_fn :eval_to_hash, sig: 5 do
+    |dt, script, node, attrs, params|
+    tag = Marty::Tag.find_match(dt)
+
+    # IMPORTANT: engine evals (e.g. eval_to_hash) modify the
+    # params. So, need to clone it.
+    params = params.clone
+
+    raise "no tag found for #{dt}" unless tag
+
+    engine = Marty::ScriptSet.new(tag).get_engine(script)
+    res = engine.eval_to_hash(node, attrs, params)
+
+    # FIXME: should sanitize res to make sure that no nodes are being
+    # passed back.  It's likely that nodes which are not from the
+    # current tag can caused problems.
+    res
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'mcfly'
+
+class Marty::Script < Marty::Base
+  has_mcfly
+
+<<<<<<< HEAD
+  # attr_accessible :name, :body
+=======
+>>>>>>> master
+  validates_presence_of :name, :body
+  mcfly_validates_uniqueness_of :name
+  validates_format_of :name, {
+    with: /\A[A-Z][a-zA-Z0-9]*\z/,
+    message: I18n.t('script.save_error'),
+  }
+
+  belongs_to :user, class_name: "Marty::User"
+
+  gen_mcfly_lookup :lookup, {
+    name: false,
+  }
+
+  gen_mcfly_lookup :get_all, {}, mode: :all
+
+  # find script by name/tag
+  def self.find_script(sname, tag=nil)
+    tag = Marty::Tag.map_to_tag(tag)
+    Marty::Script.lookup(tag.created_dt, sname)
+  end
+
+  def find_tag
+    # find the first tag created after this script.
+    Marty::Tag.where("created_dt >= ?", created_dt).order(:created_dt).first
+  end
+
+  def self.create_script(name, body)
+    script      = new
+    script.name = name
+    script.body = body
+    script.save
+    script
+  end
+
+  delorean_fn :eval_to_hash, sig: 5 do
+    |dt, script, node, attrs, params|
+    tag = Marty::Tag.find_match(dt)
+
+    # IMPORTANT: engine evals (e.g. eval_to_hash) modify the
+    # params. So, need to clone it.
+    params = params.clone
+
+    raise "no tag found for #{dt}" unless tag
+
+    engine = Marty::ScriptSet.new(tag).get_engine(script)
+    res = engine.eval_to_hash(node, attrs, params)
+
+    # FIXME: should sanitize res to make sure that no nodes are being
+    # passed back.  It's likely that nodes which are not from the
+    # current tag can caused problems.
+    res
+  end
+end

data/app/models/marty/tag.rb

@@ -0,0 +1,96 @@
+class Marty::Tag < Marty::Base
+  has_mcfly append_only: true
+
+  mcfly_validates_uniqueness_of :name
+  validates_presence_of :name, :comment
+
+  belongs_to :user, class_name: "Marty::User"
+
+  def self.make_name(dt)
+    return 'DEV' if Mcfly.is_infinity(dt)
+
+    # 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
+    dt.strftime('%Y%m%d-%H%M')
+  end
+
+  before_validation :set_tag_name
+  def set_tag_name
+    self.name = self.class.make_name(self.created_dt)
+    true
+  end
+
+  def self.do_create(dt, comment)
+    o            = new
+    o.comment    = comment
+    o.created_dt = dt
+    o.save!
+    o
+  end
+
+  def isdev?
+    Mcfly.is_infinity(created_dt)
+  end
+
+  def self.map_to_tag(tag_id)
+    case tag_id
+    when String
+      tag = find_by_name(tag_id)
+      # if tag name wasn't found, look for a matching
+      # posting, then find the tag whose created_dt <= posting dt.
+      if !tag
+        posting = Marty::Posting.lookup(tag_id)
+        tag = find_match(Mcfly.normalize_infinity(posting.created_dt)) if
+          posting
+      end
+    when Fixnum
+      tag = find_by_id(tag_id)
+    when nil
+      tag = get_latest1
+    else
+      tag = tag_id
+    end
+
+    raise "bad tag identifier #{tag_id || 'nil'}" unless tag.is_a? Marty::Tag
+    tag
+  end
+
+  cached_delorean_fn :lookup, sig: 1 do
+    |name|
+    self.find_by_name(name)
+  end
+
+  # Performance hack to cache AR object
+  cached_delorean_fn :lookup_id, sig: 1 do
+    |id|
+    find_by_id(id)
+  end
+
+  delorean_fn :lookup_dt, sig: 1 do
+    |name|
+    lookup(name).try(:created_dt)
+  end
+
+  delorean_fn :get_latest1, sig: 0 do
+    where("created_dt <> 'infinity'").order("created_dt DESC").first
+  end
+
+  delorean_fn :find_match, sig: 1 do
+    |dt|
+    id = select(:id).where("created_dt <= ?", dt).order("created_dt DESC").first.id
+
+    # performance hack to use cached version
+    id && lookup_id(id)
+  end
+
+  # Performance hack for script sets -- FIXME: making find_mtach
+  # cached breaks Gemini tests.  Need to look into it.
+  cached_delorean_fn :cached_find_match, sig: 1 do
+    |dt|
+
+    find_match dt
+  end
+end