marty 0.5.12

data/lib/marty/promise_job.rb~

@@ -0,0 +1,121 @@
+require 'delorean_lang'
+
+class Delorean::BaseModule::NodeCall
+  def initialize(_e, engine, node, params)
+    super
+
+    # If call has a promise_id (i.e. is from a promise) then that's
+    # our parent.  Otherwise, we use its parent as our parent.
+    params[:_parent_id] = _e[:_promise_id] || _e[:_parent_id]
+    params[:_user_id]   = _e[:_user_id]    || Mcfly.whodunnit.try(:id)
+  end
+
+  # Monkey-patch '|' method for Delorean NodeCall to create promise
+  # jobs and return promise proxy objects.
+  def |(args)
+    if args.is_a?(String)
+      attr = args
+      args = [attr]
+    else
+      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
+
+    begin
+      # make sure params is serialzable before starting a Job
+      Marshal.dump(params)
+    rescue => exc
+      raise "non-serializable parameters"
+    end
+
+    title   = params["p_title"]   || "#{script}::#{nn.demodulize}"
+    timeout = params["p_timeout"] || Marty::Promise::DEFAULT_PROMISE_TIMEOUT
+    hook    = params["p_hook"]
+    promise = Marty::Promise.
+      create(title:     title,
+             user_id:   params[:_user_id],
+             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)
+    rescue => exc
+      # log "CALLERR #{exc}"
+      res = Delorean::Engine.grok_runtime_exception(exc)
+      promise.set_start
+      promise.set_result(res)
+      # log "CALLERRSET #{res}"
+      raise
+    end
+
+    # keep a reference to the job.  This is needed in case we want to
+    # work off a promise job that we're waiting for and which hasn't
+    # been reserved yet.
+    promise.job_id = job.id
+    promise.save!
+
+    Marty::PromiseProxy.new(promise.id, timeout, attr)
+  end
+end
+
+class Delorean::Engine
+  def background_eval(node, params, attrs)
+    nc = Delorean::BaseModule::NodeCall.new({}, self, node, params)
+    # start the background promise
+    nc | attrs
+  end
+end
+
+class Marty::PromiseJob < Struct.new(:promise,
+                                     :title,
+                                     :sname,
+                                     :tag,
+                                     :node,
+                                     :params,
+                                     :attrs,
+                                     :hook,
+                                     )
+  # def log(msg)
+  #   open('/tmp/dj.out', 'a') { |f| f.puts msg }
+  # end
+
+  def perform
+    # log "PERF #{Process.pid} #{title}"
+
+    promise.set_start
+
+    begin
+      # in case the job writes to the the database
+      Mcfly.whodunnit = promise.user
+
+      engine = Marty::ScriptSet.new(tag).get_engine(sname)
+
+      engine.evaluate_attrs(node, attrs, params)
+
+      res = attrs.each_with_object({}) { |attr, h|
+        h[attr] = engine.evaluate(node, attr, params)
+      }
+
+      # log "DONE #{Process.pid} #{promise.id} #{Time.now.to_f} #{res}"
+    rescue => exc
+      res = Delorean::Engine.grok_runtime_exception(exc)
+      # log "ERR- #{Process.pid} #{promise.id} #{Time.now.to_f} #{exc}"
+    end
+    promise.set_result(res)
+
+    begin
+      hook.run(res) if hook
+    rescue => exc
+      Marty::Util.logger.error "promise hook failed: #{exc}"
+    end
+  end
+
+  def max_attempts
+    1
+  end
+end

data/lib/marty/promise_proxy.rb

@@ -0,0 +1,94 @@
+# Promise mechanism shamelessly stolen and modified from
+# https://github.com/bhuga/promising-future/blob/master/lib/promise.rb
+
+class Marty::PromiseProxy < BasicObject
+  NOT_SET = ::Object.new.freeze
+  METH_SET = ::Set[
+                   :marshal_load,
+                   :marshal_dump,
+                   :force,
+                   :__force__,
+                   # Added for Rails 4 -- were causing forced eval.
+                   # This list is very hacky and will depend on how
+                   # ActiveRecord treats assignment to proxy objs.
+                   :is_a?,
+                   :nested_under_indifferent_access,
+                  ]
+
+  instance_methods.each {|m| undef_method m unless m =~ /^(__.*|object_id)$/}
+
+  def initialize(promise_id, timeout, attr=nil)
+    marshal_load([promise_id, timeout, attr])
+  end
+
+  def marshal_dump
+    [@promise.id, @timeout, @attr]
+  end
+
+  def marshal_load(args)
+    promise_id, @timeout, @attr = args
+    @promise = ::Marty::Promise.find(promise_id)
+    @mutex   = ::Mutex.new
+    @result  = NOT_SET
+  end
+
+  def __promise__
+    @promise
+  end
+
+  def is_a?(c)
+    # Marty::PromiseProxy == c
+    # {}.is_a? c
+
+    # FIXME: not sure why this has to return false.  Otherwise, some
+    # spec tests fail.
+    false
+  end
+
+  def nested_under_indifferent_access
+    false
+  end
+
+  ##
+  # Force the evaluation of this promise immediately
+  #
+  # @return [Object]
+  def __force__
+    if @result.equal?(NOT_SET)
+      @mutex.synchronize do
+        if @result.equal?(NOT_SET)
+          begin
+            @result = @promise.wait_for_result(@timeout)
+            @result = @result[@attr] if @attr && !@result["error"]
+          rescue ::Exception => exc
+            @result = ::Delorean::Engine.grok_runtime_exception(exc)
+          end
+        end
+      end
+    end
+
+    # FIXME: the logic for shape of exceptions from Delorean is spread
+    # all over the place.
+    @result.is_a?(::Hash) &&
+      @result["error"] ? ::Kernel.raise(@result["error"]) : @result
+  end
+
+  alias_method :force, :__force__
+
+  ##
+  # Does this promise support the given method?
+  #
+  # @param  [Symbol]
+  # @return [Boolean]
+  def respond_to?(method, include_all=false)
+    METH_SET.member?(method) || __force__.respond_to?(method, include_all)
+  end
+
+  private
+
+  def method_missing(method, *args, &block)
+    # ::File.open('/tmp/dj.out', 'a') { |f| f.puts "FORCE MISS #{method}" }
+
+    __force__.__send__(method, *args, &block)
+  end
+end

data/lib/marty/promise_proxy.rb~

@@ -0,0 +1,69 @@
+# Promise mechanism shamelessly stolen and modified from
+# https://github.com/bhuga/promising-future/blob/master/lib/promise.rb
+
+class Marty::PromiseProxy < BasicObject
+  NOT_SET = ::Object.new.freeze
+  METH_SET = ::Set[:marshal_load, :marshal_dump, :force, :__force__]
+
+  instance_methods.each {|m| undef_method m unless m =~ /^(__.*|object_id)$/}
+
+  def initialize(promise_id, timeout, attr=nil)
+    marshal_load([promise_id, timeout, attr])
+  end
+
+  def marshal_dump
+    [@promise.id, @timeout, @attr]
+  end
+
+  def marshal_load(args)
+    promise_id, @timeout, @attr = args
+    @promise = ::Marty::Promise.find(promise_id)
+    @mutex   = ::Mutex.new
+    @result  = NOT_SET
+  end
+
+  def __promise_id__
+    @promise.id
+  end
+
+  ##
+  # Force the evaluation of this promise immediately
+  #
+  # @return [Object]
+  def __force__
+    if @result.equal?(NOT_SET)
+      @mutex.synchronize do
+        if @result.equal?(NOT_SET)
+          begin
+            @result = @promise.wait_for_result(@timeout)
+            @result = @result[@attr] if @attr && !@result["error"]
+          rescue ::Exception => exc
+            @result = ::Delorean::Engine.grok_runtime_exception(exc)
+          end
+        end
+      end
+    end
+
+    # FIXME: the logic for shape of exceptions from Delorean is spread
+    # all over the place.
+    @result.is_a?(::Hash) &&
+      @result["error"] ? ::Kernel.raise(@result["error"]) : @result
+  end
+
+  alias_method :force, :__force__
+
+  ##
+  # Does this promise support the given method?
+  #
+  # @param  [Symbol]
+  # @return [Boolean]
+  def respond_to?(method, include_all=false)
+    METH_SET.member?(method) || __force__.respond_to?(method, include_all)
+  end
+
+  private
+
+  def method_missing(method, *args, &block)
+    __force__.__send__(method, *args, &block)
+  end
+end

data/lib/marty/railtie.rb

@@ -0,0 +1,5 @@
+module Marty
+  class Railtie < Rails::Railtie
+    config.marty = ActiveSupport::OrderedOptions.new
+  end
+end

data/lib/marty/relation.rb

@@ -0,0 +1,39 @@
+require 'mcfly'
+
+class Marty::Relation
+  # Given a Mcfly class (klass) and a list of classes which can
+  # reference klass, returns instaces of klass which have no references.
+  def self.not_referenced(klass, ref_classes)
+    col = (klass.name.split('::').last.snakecase + "_id").to_sym
+
+    ids = klass.where(obsoleted_dt: 'infinity').pluck(:group_id)
+
+    ref_ids = ref_classes.map { |rclass|
+      rclass.where(obsoleted_dt: 'infinity', col => ids).pluck(col)
+    }.flatten.uniq
+
+    klass.where(id: ids - ref_ids).to_a
+  end
+
+  # Find Mcfly references from klass instances which have been
+  # obsoleted.  A hash is returned with a key for each
+  # mcfly_belongs_to reference from klass.
+  def self.obsoleted_references(klass)
+    assoc_h = Marty::DataConversion.associations(klass)
+    assoc_h.each_with_object({}) do
+      |(a, ah), h|
+      assoc_class = ah[:assoc_class]
+      foreign_key = ah[:foreign_key]
+
+      next unless Mcfly.has_mcfly? assoc_class
+
+      h[a] = klass.where(obsoleted_dt: 'infinity').map do
+        |obj|
+        ref_key = obj.send(foreign_key)
+        next unless ref_key
+        ref = assoc_class.find(ref_key)
+        obj unless Mcfly.is_infinity(ref.obsoleted_dt)
+      end.compact
+    end
+  end
+end

data/lib/marty/util.rb

@@ -0,0 +1,110 @@
+module Marty::Util
+  def self.set_posting_id(sid)
+    snap = Marty::Posting.find_by_id(sid)
+    sid = nil if snap && (snap.created_dt == Float::INFINITY)
+    Netzke::Base.session[:posting] = sid
+  end
+
+  def self.get_posting
+    sid = Netzke::Base.session && Netzke::Base.session[:posting]
+    return unless sid.is_a? Fixnum
+    sid && Marty::Posting.find_by_id(sid)
+  end
+
+  def self.get_posting_time
+    snap = self.get_posting
+    snap ? snap.created_dt : Float::INFINITY
+  end
+
+  def self.warped?
+    self.get_posting_time != Float::INFINITY
+  end
+
+  def self.logger
+    @@s_logger ||= Rails.logger || Logger.new($stderr)
+  end
+
+  # route path to where Marty is mounted
+  def self.marty_path
+    Rails.application.routes.named_routes[:marty].path.spec
+  end
+
+  def self.pg_range_match(r)
+    /\A(?<open>\[|\()(?<start>.*?),(?<end>.*?)(?<close>\]|\))\z/.match(r)
+  end
+
+  def self.pg_range_to_human(r)
+    return r if r == "empty" || r.nil?
+
+    m = pg_range_match(r)
+
+    raise "bad PG range #{r}" unless m
+
+    if m[:start] == ""
+      res = ""
+    else
+      op = m[:open] == "(" ? ">" : ">="
+      res = "#{op}#{m[:start]}"
+    end
+
+    if m[:end] != ""
+      op = m[:close] == ")" ? "<" : "<="
+      res += "#{op}#{m[:end]}"
+    end
+
+    res
+  end
+
+  def self.human_to_pg_range(r)
+    return r if r == "empty"
+
+    m = /\A
+    ((?<op0>\>|\>=)(?<start>[^\<\>\=]*?))?
+    ((?<op1>\<|\<=)(?<end>[^\<\>\=]*?))?
+    \z/x.match(r)
+
+    raise "bad range #{r}" unless m
+
+    if m[:op0]
+      open = m[:op0] == ">" ? "(" : "["
+      start = "#{open}#{m[:start]}"
+    else
+      start = "["
+    end
+
+    if m[:op1]
+      close = m[:op1] == "<" ? ")" : "]"
+      ends = "#{m[:end]}#{close}"
+    else
+      ends = "]"
+    end
+
+    "#{start},#{ends}"
+  end
+
+  def self.db_in_recovery?
+    status = false
+    begin
+      sql = 'select pg_is_in_recovery();'
+      result = ActiveRecord::Base.connection.execute(sql)
+      status = result[0]['pg_is_in_recovery'] == 't' if result && result[0]
+    rescue => e
+      Marty::Util.logger.error 'unable to determine recovery status'
+    end
+    status
+  end
+
+  def self.deep_round(obj, digits)
+    case obj
+    when Array
+      obj.map {|o| deep_round(o, digits)}
+    when Hash
+      obj.inject({}) { |result, (key, value)|
+        result[key] = deep_round(value, digits)
+        result
+      }
+    else
+      obj.is_a?(Float)? obj.round(digits) : obj
+    end
+  end
+end

data/lib/marty/util.rb~

@@ -0,0 +1,80 @@
+module Marty::Util
+  def self.set_posting_id(sid)
+    snap = Marty::Posting.find_by_id(sid)
+    sid = nil if snap && (snap.created_dt == Float::INFINITY)
+    Netzke::Base.session[:posting] = sid
+  end
+
+  def self.get_posting
+    sid = Netzke::Base.session && Netzke::Base.session[:posting]
+    return unless sid.is_a? Fixnum
+    sid && Marty::Posting.find_by_id(sid)
+  end
+
+  def self.get_posting_time
+    snap = self.get_posting
+    snap ? snap.created_dt : Float::INFINITY
+  end
+
+  def self.warped?
+    self.get_posting_time != Float::INFINITY
+  end
+
+  def self.logger
+    @@s_logger ||= Rails.logger || Logger.new($stderr)
+  end
+
+  # route path to where Marty is mounted
+  def self.marty_path
+    Rails.application.routes.named_routes[:marty].path.spec
+  end
+
+  def self.pg_range_to_human(r)
+    return r if r == "empty" || r.nil?
+
+    m = /\A(?<open>\[|\()(?<start>.*?),(?<end>.*?)(?<close>\]|\))\z/.match(r)
+
+    raise "bad PG range #{r}" unless m
+
+    if m[:start] == ""
+      res = ""
+    else
+      op = m[:open] == "(" ? ">" : ">="
+      res = "#{op}#{m[:start]}"
+    end
+
+    if m[:end] != ""
+      op = m[:close] == ")" ? "<" : "<="
+      res += "#{op}#{m[:end]}"
+    end
+
+    res
+  end
+
+  def self.human_to_pg_range(r)
+    return r if r == "empty"
+
+    m = /\A
+    ((?<op0>\>|\>=)(?<start>[^\<\>\=]*?))?
+    ((?<op1>\<|\<=)(?<end>[^\<\>\=]*?))?
+    \z/x.match(r)
+
+    raise "bad range #{r}" unless m
+
+    if m[:op0]
+      open = m[:op0] == ">" ? "(" : "["
+      start = "#{open}#{m[:start]}"
+    else
+      start = "["
+    end
+
+    if m[:op1]
+      close = m[:op1] == "<" ? ")" : "]"
+      ends = "#{m[:end]}#{close}"
+    else
+      ends = "]"
+    end
+
+    "#{start},#{ends}"
+  end
+end