jason-rails 0.4.1 → 0.6.2

data/lib/jason/subscription.rb

@@ -1,31 +1,317 @@
 class Jason::Subscription
   attr_accessor :id, :config
+  attr_reader :includes_helper, :graph_helper
 
   def initialize(id: nil, config: nil)
     if id
       @id = id
-      raw_config = $redis_jason.hgetall("jason:subscriptions:#{id}").map { |k,v| [k, JSON.parse(v)] }.to_h.with_indifferent_access
+      raw_config = $redis_jason.hgetall("jason:subscriptions:#{id}").map { |k,v| [k, JSON.parse(v)] }.to_h
+      raise "Subscription ID #{id} does not exist" if raw_config.blank?
       set_config(raw_config)
     else
-      @id = Digest::MD5.hexdigest(config.to_json)
+      @id = Digest::MD5.hexdigest(config.sort_by { |key| key }.to_h.to_json)
       configure(config)
     end
+    @includes_helper = Jason::IncludesHelper.new({ model => self.config['includes'] })
+    @graph_helper = Jason::GraphHelper.new(self.id, @includes_helper)
+
+    check_for_missing_keys
+  end
+
+  def broadcaster
+    @broadcaster ||= Jason::Broadcaster.new(channel)
+  end
+
+  def check_for_missing_keys
+    missing_keys = includes_helper.all_models - Jason.schema.keys.map(&:to_s)
+    if missing_keys.present?
+      raise "#{missing_keys.inspect} are not in the schema. Only models in the Jason schema can be subscribed."
+    end
+  end
+
+  def self.upsert_by_config(model, conditions: {}, includes: {})
+    self.new(config: {
+      model: model,
+      conditions: conditions || {},
+      includes: includes || {}
+    })
+  end
+
+  def self.find_by_id(id)
+    self.new(id: id)
+  end
+
+  def self.for_instance_with_child(model_name, id, child_model_name, include_all = true)
+    sub_ids = for_instance(model_name, id, include_all = true)
+    sub_ids.select do |sub_id|
+      find_by_id(sub_id).includes_helper.in_sub(model_name, child_model_name)
+    end
+  end
+
+  def self.for_instance(model_name, id, include_all = true)
+    subs = $redis_jason.smembers("jason:models:#{model_name}:#{id}:subscriptions")
+    if include_all
+      subs += $redis_jason.smembers("jason:models:#{model_name}:all:subscriptions")
+    end
+
+    subs
+  end
+
+  def self.for_model(model_name)
+
+  end
+
+  # Find and update subscriptions affected by a model changing foreign key
+  # comment, comment_id, post, old_post_id, new_post_id
+  def self.update_ids(changed_model_name, changed_model_id, foreign_model_name, old_foreign_id, new_foreign_id)
+    # There are 4 cases to consider.
+    # changed_instance ---/--- foreign_instance
+    #                  \--+--- new_foreign_instance
+    #
+    # foreign instance can either be parent or child for a given subscription
+    # 1. Child swap/add: foreign is child
+    # 2. Stay in the family: foreign is parent + both old and new foreign instances are part of the sub
+    # 3. Join the family: foreign is parent + only new foreign instance are part of the sub
+    # 4. Leave the family: foreign is parent + only the old foreign instance is part of the sub
+
+    #########
+    # Subs where changed is parent
+    sub_ids = for_instance_with_child(changed_model_name, changed_model_id, foreign_model_name, true)
+    sub_ids.each do |sub_id|
+      subscription = find_by_id(sub_id)
+
+      # If foreign key has been nulled, nothing to add
+      add = new_foreign_id.present? ? [
+        {
+          model_names: [changed_model_name, foreign_model_name],
+          instance_ids: [[changed_model_id, new_foreign_id]]
+        },
+        # Add IDs of child models
+        subscription.load_ids_for_sub_models(foreign_model_name, new_foreign_id)
+      ] : nil
+
+      id_changeset = subscription.graph_helper.apply_update({
+        remove: [{
+          model_names: [changed_model_name, foreign_model_name],
+          instance_ids: [[changed_model_id, old_foreign_id]]
+        }],
+        add: add
+      })
+
+      subscription.apply_id_changeset(id_changeset)
+      subscription.broadcast_id_changeset(id_changeset)
+    end
+
+    old_sub_ids = for_instance_with_child(foreign_model_name, old_foreign_id, changed_model_name, true)
+    new_sub_ids = for_instance_with_child(foreign_model_name, new_foreign_id, changed_model_name, true)
+
+    #########
+    # Subs where changed is child
+    # + parent in both old + new
+    # this is simple, only the edges need to change - no IDs can be changed
+    (old_sub_ids & new_sub_ids).each do |sub_id|
+      subscription = find_by_id(sub_id)
+      subscription.graph_helper.apply_update({
+        remove: [{
+          model_names: [changed_model_name, foreign_model_name],
+          instance_ids: [[changed_model_id, old_foreign_id]]
+        }],
+        add: [{
+          model_names: [changed_model_name, foreign_model_name],
+          instance_ids: [[changed_model_id, new_foreign_id]]
+        }]
+      })
+    end
+
+    #########
+    # Subs where changed is child
+    # + old parent wasn't in the sub, but new parent is
+    # IE the changed instance is joining the sub
+    # No edges are removed, just added
+    (new_sub_ids - old_sub_ids).each do |sub_id|
+      subscription = find_by_id(sub_id)
+      id_changeset = subscription.graph_helper.apply_update({
+        add: [
+          {
+            model_names: [changed_model_name, foreign_model_name],
+            instance_ids: [[changed_model_id, new_foreign_id]]
+          },
+          # Add IDs of child models
+          subscription.load_ids_for_sub_models(changed_model_name, changed_model_id)
+        ]
+      })
+
+      subscription.apply_id_changeset(id_changeset)
+      subscription.broadcast_id_changeset(id_changeset)
+    end
+
+    #########
+    # --> Leaving the family
+    # Subs where changed is child
+    # + old parent was in the sub, but new parent isn't
+    # Just need to remove the link, orphan detection will do the rest
+    (old_sub_ids - new_sub_ids).each do |sub_id|
+      subscription = find_by_id(sub_id)
+      id_changeset = subscription.graph_helper.apply_update({
+        remove: [
+          {
+            model_names: [changed_model_name, foreign_model_name],
+            instance_ids: [[changed_model_id, old_foreign_id]]
+          }
+        ]
+      })
+      subscription.apply_id_changeset(id_changeset)
+      subscription.broadcast_id_changeset(id_changeset)
+    end
+  end
+
+  def self.remove_ids(model_name, ids)
+    # td: finish this
+    ids.each do |instance_id|
+      for_instance(model_name, instance_id, false).each do |sub_id|
+        subscription = find_by_id(sub_id)
+
+        id_changeset = subscription.graph_helper.apply_remove_node("#{model_name}:#{instance_id}")
+        subscription.apply_id_changeset(id_changeset)
+        subscription.broadcast_id_changeset(id_changeset)
+      end
+    end
+  end
+
+  # Add ID to any _all_ subscriptions
+  def self.add_id(model_name, id)
+
+  end
+
+  def self.all
+    $redis_jason.smembers('jason:subscriptions').map { |id| Jason::Subscription.find_by_id(id) }
   end
 
   def set_config(raw_config)
-    @config =  raw_config.with_indifferent_access.map { |k,v| [k.underscore.to_s, v] }.to_h
+    @config =  raw_config.deep_stringify_keys.deep_transform_values { |v| v.is_a?(Symbol) ? v.to_s : v }
+  end
+
+  def clear_id(model_name, id, parent_model_name)
+    remove_ids(model_name, [id])
+  end
+
+  # Add IDs that aren't present
+  def commit_ids(model_name, ids)
+    $redis_jason.sadd("jason:subscriptions:#{id}:ids:#{model_name}", ids)
+    ids.each do |instance_id|
+      $redis_jason.sadd("jason:models:#{model_name}:#{instance_id}:subscriptions", id)
+    end
+  end
+
+  def remove_ids(model_name, ids)
+    $redis_jason.srem("jason:subscriptions:#{id}:ids:#{model_name}", ids)
+    ids.each do |instance_id|
+      $redis_jason.srem("jason:models:#{model_name}:#{instance_id}:subscriptions", id)
+    end
+  end
+
+  def apply_id_changeset(changeset)
+    changeset[:ids_to_add].each do |model_name, ids|
+      commit_ids(model_name, ids)
+    end
+
+    changeset[:ids_to_remove].each do |model_name, ids|
+      remove_ids(model_name, ids)
+    end
+  end
+
+  def broadcast_id_changeset(changeset)
+    changeset[:ids_to_add].each do |model_name, ids|
+      ids.each { |id| add(model_name, id) }
+    end
+
+    changeset[:ids_to_remove].each do |model_name, ids|
+      ids.each { |id| destroy(model_name, id) }
+    end
+  end
+
+  # Take a model name and IDs and return an edge set of all the models that appear and
+  # their instance IDs
+  def load_ids_for_sub_models(model_name, ids)
+    # Limitation: Same association can't appear twice
+    includes_tree = includes_helper.get_tree_for(model_name)
+    all_models = includes_helper.all_models(model_name)
+
+    relation = model_name.classify.constantize.all.eager_load(includes_tree)
+
+    if model_name == model
+      if conditions.blank?
+        $redis_jason.sadd("jason:models:#{model_name}:all:subscriptions", id)
+        all_models -= [model_name]
+      else
+        relation = relation.where(conditions)
+      end
+    else
+      raise "Must supply IDs for sub models" if ids.nil?
+      return if ids.blank?
+      relation = relation.where(id: ids)
+    end
+
+    pluck_args = all_models.map { |m| "#{m.pluralize}.id" }
+    instance_ids = relation.pluck(*pluck_args)
+
+    # pluck returns only a 1D array if only 1 arg passed
+    if all_models.size == 1
+      instance_ids = [instance_ids]
+    end
+
+    return { model_names: all_models, instance_ids: instance_ids }
+  end
+
+  # 'posts', [post#1, post#2,...]
+  def set_ids_for_sub_models(model_name = model, ids = nil, enforce: false)
+    edge_set = load_ids_for_sub_models(model_name, ids)
+
+    # Build the tree
+    id_changeset = graph_helper.apply_update({
+      add: [edge_set]
+    })
+    apply_id_changeset(id_changeset)
+  end
+
+  def clear_all_ids
+    includes_helper.all_models.each do |model_name|
+      if model_name == model && conditions.blank?
+        $redis_jason.srem("jason:models:#{model_name}:all:subscriptions", id)
+      end
+
+      ids = $redis_jason.smembers("jason:subscriptions:#{id}:ids:#{model_name}")
+      ids.each do |instance_id|
+        $redis_jason.srem("jason:models:#{model_name}:#{instance_id}:subscriptions", id)
+      end
+      $redis_jason.del("jason:subscriptions:#{id}:ids:#{model_name}")
+    end
+  end
+
+  def ids(model_name = model)
+    $redis_jason.smembers("jason:subscriptions:#{id}:ids:#{model_name}")
+  end
+
+  def model
+    @config['model']
+  end
+
+  def model_klass(model_name)
+    model_name.to_s.classify.constantize
+  end
+
+  def conditions
+    @config['conditions']
   end
 
   def configure(raw_config)
     set_config(raw_config)
-    $redis_jason.hmset("jason:subscriptions:#{id}", *config.map { |k,v| [k, v.to_json]}.flatten)
+    $redis_jason.sadd("jason:subscriptions", id)
+    $redis_jason.hmset("jason:subscriptions:#{id}", *config.map { |k,v| [k, v.to_json] }.flatten)
   end
 
   def destroy
-    config.each do |model, value|
-      $redis_jason.srem("jason:#{model.to_s.underscore}:subscriptions", id)
-    end
-    $redis_jason.del("jason:subscriptions:#{id}")
+    raise
   end
 
   def add_consumer(consumer_id)
@@ -33,8 +319,9 @@ class Jason::Subscription
     $redis_jason.sadd("jason:subscriptions:#{id}:consumers", consumer_id)
     $redis_jason.hset("jason:consumers", consumer_id, Time.now.utc)
 
-    add_subscriptions
-    publish_all
+    if before_consumer_count == 0
+      set_ids_for_sub_models
+    end
   end
 
   def remove_consumer(consumer_id)
@@ -42,7 +329,7 @@ class Jason::Subscription
     $redis_jason.hdel("jason:consumers", consumer_id)
 
     if consumer_count == 0
-      remove_subscriptions
+      clear_all_ids
     end
   end
 
@@ -51,119 +338,84 @@ class Jason::Subscription
   end
 
   def channel
-    "jason:#{id}"
+    "jason-#{id}"
   end
 
-  def publish_all
-    config.each do |model, model_config|
-      klass = model.to_s.classify.constantize
-      conditions = model_config['conditions'] || {}
-      klass.where(conditions).find_each(&:cache_json)
-      update(model)
-    end
+  def user_can_access?(user)
+    # td: implement the authorization logic here
+    return true if Jason.authorization_service.blank?
+    Jason.authorization_service.call(user, model, conditions, includes_helper.all_models - [model])
   end
 
-  def add_subscriptions
-    config.each do |model, value|
-      $redis_jason.hset("jason:#{model.to_s.underscore}:subscriptions", id, value.to_json)
-      update(model)
-    end
+  def get
+    includes_helper.all_models.map { |model_name| [model_name, get_for_model(model_name)] }.to_h
   end
 
-  def remove_subscriptions
-    config.each do |model, _|
-      $redis_jason.hdel("jason:#{model.to_s.underscore}:subscriptions", id)
+  def get_for_model(model_name)
+    if $redis_jason.sismember("jason:models:#{model_name}:all:subscriptions", id)
+      instance_jsons_hash, idx = $redis_jason.multi do |r|
+        r.hgetall("jason:cache:#{model_name}")
+        r.get("jason:subscription:#{id}:#{model_name}:idx")
+      end
+      instance_jsons = instance_jsons_hash.values
+    else
+      instance_jsons, idx = Jason::LuaGenerator.new.get_payload(model_name, id)
     end
-  end
 
-  def self.publish_all
-    JASON_API_MODEL.each do |model, _v|
-      klass = model.to_s.classify.constantize
-      klass.publish_all(klass.all) if klass.respond_to?(:publish_all)
+    payload = instance_jsons.map do |instance_json|
+      instance_json ? JSON.parse(instance_json) : {}
     end
-  end
-
-  def get(model)
-    value = JSON.parse($redis_jason.get("#{channel}:#{model}:value") || '[]')
-    idx = $redis_jason.get("#{channel}:#{model}:idx").to_i
 
     {
       type: 'payload',
+      model: model_name,
+      payload: payload,
       md5Hash: id,
-      model: model,
-      value: value,
-      idx: idx
+      idx: idx.to_i
     }
   end
 
-  def get_diff(old_value, value)
-    JsonDiff.generate(old_value, value)
-  end
+  def add(model_name, instance_id)
+    idx = $redis_jason.incr("jason:subscription:#{id}:#{model_name}:idx")
+    payload = JSON.parse($redis_jason.hget("jason:cache:#{model_name}", instance_id) || '{}')
 
-  def deep_stringify(value)
-    if value.is_a?(Hash)
-      value.deep_stringify_keys
-    elsif value.is_a?(Array)
-      value.map { |x| x.deep_stringify_keys }
-    end
-  end
+    payload = {
+      id: instance_id,
+      model: model_name,
+      payload: payload,
+      md5Hash: id,
+      idx: idx.to_i
+    }
 
-  def get_throttle
-    if !$throttle_rate || !$throttle_timeout || Time.now.utc > $throttle_timeout
-      $throttle_timeout = Time.now.utc + 5.seconds
-      $throttle_rate = ($redis_jason.get('global_throttle_rate') || 0).to_i
-    else
-      $throttle_rate
-    end
+    broadcaster.broadcast(payload)
   end
 
-  # Atomically update and return patch
-  def update(model)
-    start_time = Time.now.utc
-    conditions = config[model]['conditions']
-
-    value = $redis_jason.hgetall("jason:#{model}:cache")
-      .values.map { |v| JSON.parse(v) }
-      .select { |v| (conditions || {}).all? { |field, value| v[field] == value } }
-      .sort_by { |v| v['id'] }
-
-    # lfsa = last finished, started at
-    # If another job that started after this one, finished before this one, skip sending this state update
-    if Time.parse($redis_jason.get("jason:#{channel}:lfsa") || '1970-01-01 00:00:00 UTC') < start_time
-      $redis_jason.set("jason:#{channel}:lfsa", start_time)
-    else
-      return
-    end
-
-    value = deep_stringify(value)
+  def update(model_name, instance_id, payload, gidx)
+    idx = Jason::LuaGenerator.new.get_subscription(model_name, instance_id, id, gidx)
+    return if idx.blank?
 
-    # If value has changed, return old value and new idx. Otherwise do nothing.
-    cmd = <<~LUA
-      local old_val=redis.call('get', ARGV[1] .. ':value')
-      if old_val ~= ARGV[2] then
-        redis.call('set', ARGV[1] .. ':value', ARGV[2])
-        local new_idx = redis.call('incr', ARGV[1] .. ':idx')
-        return { new_idx, old_val }
-      end
-    LUA
-
-    result = $redis_jason.eval cmd, [], ["#{channel}:#{model}", value.to_json]
-    return if result.blank?
+    payload = {
+      id: instance_id,
+      model: model_name,
+      payload: payload,
+      md5Hash: id,
+      idx: idx.to_i
+    }
 
-    idx = result[0]
-    old_value = JSON.parse(result[1] || '[]')
-    diff = get_diff(old_value, value)
+    broadcaster.broadcast(payload)
+  end
 
-    end_time = Time.now.utc
+  def destroy(model_name, instance_id)
+    idx = $redis_jason.incr("jason:subscription:#{id}:#{model_name}:idx")
 
     payload = {
-      model: model,
+      id: instance_id,
+      model: model_name,
+      destroy: true,
       md5Hash: id,
-      diff: diff,
-      idx: idx.to_i,
-      latency: ((end_time - start_time)*1000).round
+      idx: idx.to_i
     }
 
-    ActionCable.server.broadcast("jason:#{id}", payload)
+    broadcaster.broadcast(payload)
   end
 end