jason-rails 0.6.6 → 0.7.2

data/lib/jason/publisher_old.rb

@@ -1,112 +0,0 @@
-module Jason::PublisherOld
-  extend ActiveSupport::Concern
-
-  def cache_json
-    as_json_config = api_model.as_json_config
-    scope = api_model.scope
-
-    if self.persisted? && (scope.blank? || self.class.unscoped.send(scope).exists?(self.id))
-      payload = self.reload.as_json(as_json_config)
-      $redis_jason.hset("jason:#{self.class.name.underscore}:cache", self.id, payload.to_json)
-    else
-      $redis_jason.hdel("jason:#{self.class.name.underscore}:cache", self.id)
-    end
-  end
-
-  def publish_json
-    cache_json
-    return if skip_publish_json
-
-    self.class.jason_subscriptions.each do |id, config_json|
-      config = JSON.parse(config_json)
-
-      if (config['conditions'] || {}).all? { |field, value| self.send(field) == value }
-        Jason::Subscription.new(id: id).update(self.class.name.underscore)
-      end
-    end
-  end
-
-  def publish_json_if_changed
-    subscribed_fields = api_model.subscribed_fields
-    publish_json if (self.previous_changes.keys.map(&:to_sym) & subscribed_fields).present? || !self.persisted?
-  end
-
-  class_methods do
-    def subscriptions
-      $redis_jason.hgetall("jason:#{self.name.underscore}:subscriptions")
-    end
-
-    def jason_subscriptions
-      $redis_jason.hgetall("jason:#{self.name.underscore}:subscriptions")
-    end
-
-    def publish_all(instances)
-      instances.each(&:cache_json)
-
-      subscriptions.each do |id, config_json|
-        Jason::Subscription.new(id: id).update(self.name.underscore)
-      end
-    end
-
-    def flush_cache
-      $redis_jason.del("jason:#{self.name.underscore}:cache")
-    end
-
-    def setup_json
-      self.after_initialize -> {
-        @api_model = Jason::ApiModel.new(self.class.name.underscore)
-      }
-      self.after_commit :publish_json_if_changed
-
-      include_models = Jason::ApiModel.new(self.name.underscore).include_models
-
-      include_models.map do |assoc|
-        puts assoc
-        reflection = self.reflect_on_association(assoc.to_sym)
-        reflection.klass.after_commit -> {
-          subscribed_fields = Jason::ApiModel.new(self.class.name.underscore).subscribed_fields
-          puts subscribed_fields.inspect
-
-          if (self.previous_changes.keys.map(&:to_sym) & subscribed_fields).present?
-            self.send(reflection.inverse_of.name)&.publish_json
-          end
-        }
-      end
-    end
-
-    def find_or_create_by_id(params)
-      object = find_by(id: params[:id])
-
-      if object
-        object.update(params)
-      elsif params[:hidden]
-        return false ## If an object is passed with hidden = true but didn't already exist, it's safe to never create it
-      else
-        object = create!(params)
-      end
-
-      object
-    end
-
-    def find_or_create_by_id!(params)
-      object = find_by(id: params[:id])
-
-      if object
-        object.update!(params)
-      elsif params[:hidden]
-        ## TODO: We're diverging from semantics of the Rails bang! methods here, which would normally either raise or return an object. Find a way to make this better.
-        return false ## If an object is passed with hidden = true but didn't already exist, it's safe to never create it
-      else
-        object = create!(params)
-      end
-
-      object
-    end
-  end
-
-  included do
-    attr_accessor :skip_publish_json, :api_model
-
-    setup_json
-  end
-end

data/lib/jason/subscription_old.rb

@@ -1,171 +0,0 @@
-class Jason::SubscriptionOld
-  attr_accessor :id, :config
-
-  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
-      set_config(raw_config)
-    else
-      @id = Digest::MD5.hexdigest(config.to_json)
-      configure(config)
-    end
-  end
-
-  def set_config(raw_config)
-    @config =  raw_config.with_indifferent_access.map { |k,v| [k.underscore.to_s, v] }.to_h
-  end
-
-  def configure(raw_config)
-    set_config(raw_config)
-    $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}")
-  end
-
-  def add_consumer(consumer_id)
-    before_consumer_count = consumer_count
-    $redis_jason.sadd("jason:subscriptions:#{id}:consumers", consumer_id)
-    $redis_jason.hset("jason:consumers", consumer_id, Time.now.utc)
-
-    add_subscriptions
-    publish_all
-  end
-
-  def remove_consumer(consumer_id)
-    $redis_jason.srem("jason:subscriptions:#{id}:consumers", consumer_id)
-    $redis_jason.hdel("jason:consumers", consumer_id)
-
-    if consumer_count == 0
-      remove_subscriptions
-    end
-  end
-
-  def consumer_count
-    $redis_jason.scard("jason:subscriptions:#{id}:consumers")
-  end
-
-  def channel
-    "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
-  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
-  end
-
-  def remove_subscriptions
-    config.each do |model, _|
-      $redis_jason.hdel("jason:#{model.to_s.underscore}:subscriptions", 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)
-    end
-  end
-
-  def get(model_name)
-    LuaGenerator.new.index_hash_by_set("jason:cache:#{model_name}", "")
-
-    value = JSON.parse($redis_jason.get("#{channel}:#{model}:value") || '[]')
-    idx = $redis_jason.get("#{channel}:#{model}:idx").to_i
-
-    {
-      type: 'payload',
-      md5Hash: id,
-      model: model,
-      value: value,
-      idx: idx
-    }
-  end
-
-  def get_diff(old_value, value)
-    JsonDiff.generate(old_value, value)
-  end
-
-  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
-
-  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
-  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)
-
-    # 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?
-
-    idx = result[0]
-    old_value = JSON.parse(result[1] || '[]')
-    diff = get_diff(old_value, value)
-
-    end_time = Time.now.utc
-
-    payload = {
-      model: model,
-      md5Hash: id,
-      diff: diff,
-      idx: idx.to_i,
-      latency: ((end_time - start_time)*1000).round
-    }
-
-    ActionCable.server.broadcast("jason:#{id}", payload)
-  end
-end