fragmentary 0.2.2 → 0.4.0

data/lib/fragmentary/fragment.rb

@@ -24,8 +24,6 @@ module Fragmentary
         # redundant duplicate request.
         after_commit :touch_parent, :on => [:update, :destroy]
 
-        attr_accessible :parent_id, :root_id, :record_id, :user_id, :user_type, :key
-
         attr_accessor :indexed_children
 
         # Set cache timestamp format to :usec instead of :nsec because the latter is greater precision than Postgres supports,
@@ -73,8 +71,14 @@ module Fragmentary
         # Collect the attributes to be used when searching for an existing fragment. Fragments are unique by these values.
         search_attributes = {}
 
-        parent_id = options.delete(:parent_id)
-        search_attributes.merge!(:parent_id => parent_id) if parent_id
+        if (parent_id = options.delete(:parent_id))
+          search_attributes.merge!(:parent_id => parent_id)
+        else
+          application_root_url_column = Fragmentary.config.application_root_url_column
+          if (application_root_url = options.delete(application_root_url_column)) && column_names.include?(application_root_url_column.to_s)
+            search_attributes.merge!(application_root_url_column => application_root_url)
+          end
+        end
 
         [:record_id, :user_id, :user_type, :key].each do |attribute_name|
           if klass.needs?(attribute_name)
@@ -117,20 +121,53 @@ module Fragmentary
         self
       end
 
+      # There is one queue per user_type per application instance (the current app and any external instances). The queues
+      # for all fragments are held in common by the Fragment base class here in @@request_queues but are also indexed on a
+      # subclass basis by an individual subclass's user_types (see the inherited hook below). As well as being accessible
+      # here as Fragment.request_queues, the queues are also available without indexation as RequestQueue.all.
       def request_queues
-        @@request_queues ||= Hash.new do |hash, user_type|
-          hash[user_type] = RequestQueue.new(user_type)
+        @@request_queues ||= Hash.new do |hsh, host_url|
+          # As well as acting as a hash key to index the set of request queues for a given target application instance
+          # (for which its uniqueness is the only requirement), host_url is also passed to the RequestQueue constructor,
+          # from which it is used:
+          #   (i) by the RequestQueue::Sender to derive the name of the delayed_job queue that will be used to process the
+          #       queued requests if the sender is invoked in asynchronous mode - see RequestQueue::Sender#schedulerequests.
+          #   (ii) by the Fragmentary::InternalUserSession instantiated by the Sender to configure the session_host.
+          hsh[host_url] = Hash.new do |hsh2, user_type|
+            hsh2[user_type] = RequestQueue.new(user_type, host_url)
+          end
         end
-        if self == base_class
-          @@request_queues
-        else
-          return nil unless (requestable? or new.requestable?)
-          user_types.each_with_object({}){|user_type, queues| queues[user_type] = @@request_queues[user_type]}
+      end
+
+      # Subclass-specific request_queues
+      def inherited(subclass)
+        subclass.instance_eval do
+
+          def request_queues
+            super  # ensure that @@request_queues has been defined
+            @request_queues ||= begin
+              app_root_url = Fragmentary.application_root_url
+              remote_urls = Fragmentary.config.remote_urls
+              user_types.each_with_object( Hash.new {|hsh0, url| hsh0[url] = {}} ) do |user_type, hsh|
+                # Internal request queues
+                hsh[app_root_url][user_type] = @@request_queues[app_root_url][user_type]
+                # External request queues
+                if remote_urls.any?
+                  unless Rails.application.routes.default_url_options[:host]
+                    raise "Can't create external request queues without setting Rails.application.routes.default_url_options[:host]"
+                  end
+                  remote_urls.each {|remote_url| hsh[remote_url][user_type] = @@request_queues[remote_url][user_type]}
+                end
+              end
+            end
+          end
+
         end
+        super
       end
 
       def remove_queued_request(user:, request_path:)
-        request_queues[user_type(user)].remove_path(request_path)
+        request_queues.each{|key, hsh| hsh[user_type(user)].remove_path(request_path)}
       end
 
       def subscriber
@@ -158,6 +195,11 @@ module Fragmentary
       # signed in. When the fragment is instantiated using FragmentsHelper methods 'cache_fragment' or 'CacheBuilder.cache_child',
       # a :user option is added to the options hash automatically from the value of 'current_user'. The user_type is extracted
       # from this option in Fragment.attributes.
+      #
+      # For each class that declares 'needs_user_type', a set of user_types is defined that determines the set of request_queues
+      # that will be used to send requests to the application when a fragment is touched. By default these user_types are defined
+      # globally using 'Fragmentary.setup' but they can alternatively be set on a class-specific basis by passing a :session_users
+      # option to 'needs_user_type'. See 'Fragmentary.parse_session_users' for details.
       def needs_user_type(options = {})
         self.extend NeedsUserType
         instance_eval do
@@ -218,28 +260,25 @@ module Fragmentary
             # by the fragment.
             class << record_type_subscription
               set_callback :after_destroy, :after, ->{subscriber.client.remove_fragments_for_record(record.id)}
+              set_callback :after_create, :after, ->{subscriber.client.try_request_for_record(record.id)}
             end
           end
 
-          if requestable?
-            record_class = record_type.constantize
-            instance_eval <<-HEREDOC
-              subscribe_to #{record_class} do
-                def create_#{record_class.model_name.param_key}_successful(record)
-                  request = Fragmentary::Request.new(request_method, request_path(record.id),
-                                                     request_parameters(record.id), request_options)
-                  queue_request(request)
-                end
-              end
-            HEREDOC
-          end
-
+          self.extend RecordClassMethods
           define_method(:record){record_type.constantize.find(record_id)}
         end
       end
 
-      def remove_fragments_for_record(record_id)
-        where(:record_id => record_id).each(&:destroy)
+      module RecordClassMethods
+        def remove_fragments_for_record(record_id)
+          where(:record_id => record_id).each(&:destroy)
+        end
+
+        def try_request_for_record(record_id)
+          if requestable?
+            queue_request(request(record_id))
+          end
+        end
       end
 
       def needs_record_id?
@@ -288,9 +327,7 @@ module Fragmentary
       end
 
       def queue_request(request=nil)
-        if request
-          request_queues.each{|key, queue| queue << request}
-        end
+        request_queues.each{|key, hsh| hsh.each{|key2, queue| queue << request}} if request
       end
 
       def requestable?
@@ -308,7 +345,11 @@ module Fragmentary
 
       # The instance method 'request_options' is defined in terms of this.
       def request_options
-        nil
+        {}
+      end
+
+      def request
+        raise NotImplementedError
       end
 
       # This method defines the handler for the creation of new list items. The method takes:
@@ -453,12 +494,15 @@ module Fragmentary
     end
 
     def touch(*args, no_request: false)
-      request_queues.each{|key, queue| queue << request} if request && !no_request
+      @no_request = no_request  # stored for use in #touch_parent via the after_commit callback
+      request_queues.each{|key, hsh| hsh.each{|key2, queue| queue << request}} if request && !no_request
       super(*args)
     end
 
+    # delete the associated cache content before destroying the fragment
     def destroy(options = {})
       options.delete(:delete_matches) ? delete_matched_cache : delete_cache
+      @no_request = options.delete(:no_request)  # stored for use in #touch_parent via the after_commit callback
       super()
     end
 
@@ -467,9 +511,17 @@ module Fragmentary
     end
 
     def delete_cache
-      cache_store.delete(ActiveSupport::Cache.expand_cache_key(self, 'views'))
+      cache_store.delete(fragment_key)
+    end
+
+    # Recursively delete the cache entry for this fragment and all of its children
+    # Does NOT destroy the fragment or its children
+    def delete_cache_tree
+      children.each(&:delete_cache_tree)
+      delete_cache if cache_exist?
     end
 
+    # Recursively touch the fragment and all of its children
     def touch_tree(no_request: false)
       children.each{|child| child.touch_tree(:no_request => no_request)}
       # If there are children, we'll have already touched this fragment in the process of touching them.
@@ -479,19 +531,34 @@ module Fragmentary
     # Touch this fragment and all descendants that have entries in the cache. Destroy any that
     # don't have cache entries.
     def touch_or_destroy
-      puts "  touch_or_destroy #{self.class.name} #{id}"
       if cache_exist?
         children.each(&:touch_or_destroy)
         # if there are children, this will be touched automatically once they are.
         touch(:no_request => true) unless children.any?
       else
-        destroy  # will also destroy all children because of :dependent => :destroy
+        destroy(:no_request => true)  # will also destroy all children because of :dependent => :destroy
       end
     end
 
     def cache_exist?
       # expand_cache_key calls cache_key and prepends "views/"
-      cache_store.exist?(ActiveSupport::Cache.expand_cache_key(self, 'views'))
+      cache_store.exist?(fragment_key)
+    end
+
+
+    # Typically used along with #cache_exist? when testing from the console.
+    # Note that both methods will only return correct results for fragments associated with the application_root_url
+    # (either root or children) corresponding to the particular console session in use. i.e. you can't see into the
+    # production cache from a prerelease console session and vice versa.
+    def content
+      cache_store.read(fragment_key)
+    end
+
+    # This emulates the result of passing the fragment object to AbstractController::Caching::Fragments#combined_fragment_cache_key
+    # when the cache helper method invokes controller.read_fragment from the view. The result can be passed to ActiveSupport::Cache methods
+    # #read, #write, #fetch, #delete, and #exist?
+    def fragment_key
+      ['views', self]
     end
 
     # Request-related methods...
@@ -529,7 +596,8 @@ module Fragmentary
 
     private
     def touch_parent
-      parent.try :touch unless previous_changes["memo"]
+      parent.try(:touch, {:no_request => @no_request}) unless previous_changes["memo"]
+      @no_request = false
     end
 
     module NeedsRecordId

data/lib/fragmentary/fragments_helper.rb

@@ -3,6 +3,7 @@ module Fragmentary
   module FragmentsHelper
 
     def cache_fragment(options, &block)
+      options.reverse_merge!(Fragmentary.config.application_root_url_column => Fragmentary.application_root_url.gsub(%r{https?://}, ''))
       CacheBuilder.new(self).cache_fragment(options, &block)
     end
 
@@ -10,6 +11,7 @@ module Fragmentary
       # the template option is deprecated but avoids breaking prior usage
       template = options.delete(:template) || self
       options.reverse_merge!(:user => Template.new(template).current_user)
+      options.reverse_merge!(Fragmentary.config.application_root_url_column => Fragmentary.application_root_url.gsub(%r{https?://}, ''))
       CacheBuilder.new(template, Fragmentary::Fragment.base_class.existing(options))
     end
 
@@ -34,7 +36,16 @@ module Fragmentary
         builder = CacheBuilder.new(@template, next_fragment)
         unless no_cache
           @template.cache next_fragment, :skip_digest => true do
-            yield(builder)
+            if Fragmentary.config.insert_timestamps
+              @template.safe_concat("<!-- #{next_fragment.type} #{next_fragment.id} cached by Fragmentary version #{VERSION} at #{Time.now.utc} -->")
+              if deployed_at && release_name
+                @template.safe_concat("<!-- Cached using application release #{release_name} deployed at #{deployed_at} -->")
+              end
+              yield(builder)
+              @template.safe_concat("<!-- #{next_fragment.type} #{next_fragment.id} ends -->")
+            else
+              yield(builder)
+            end
           end
         else
           yield(builder)
@@ -50,6 +61,13 @@ module Fragmentary
         @fragment.send(method, *args)
       end
 
+      def deployed_at
+        @deployed_at ||= Fragmentary.config.deployed_at
+      end
+
+      def release_name
+        @release_name ||= Fragmentary.config.release_name
+      end
     end
 
   end

data/lib/fragmentary/handler.rb

@@ -1,4 +1,26 @@
 module Fragmentary
+
+  class HandlerSerializer < ActiveJob::Serializers::ObjectSerializer
+
+    def serialize?(arg)
+      arg.is_a? Fragmentary::Handler
+    end
+
+    def serialize(handler)
+      super(
+        {
+        :class_name => handler.class.name,
+        :args => handler.args
+        }
+      )
+    end
+
+    def deserialize(hsh)
+      hsh[:class_name].constantize.new(hsh[:args])
+    end
+
+  end
+
   class Handler
     def self.all
       @@all
@@ -14,6 +36,8 @@ module Fragmentary
       handler
     end
 
+    attr_reader :args
+
     def initialize(**args)
       @args = args
     end

data/lib/fragmentary/{dispatcher.rb → jobs/dispatch_handlers_job.rb}

@@ -1,12 +1,11 @@
+require 'fragmentary/serializers/handler_serializer'
+
 module Fragmentary
 
-  class Dispatcher
-    def initialize(tasks)
-      @tasks = tasks
-    end
+  class DispatchHandlersJob < ActiveJob::Base
 
-    def perform
-      @tasks.each do |task|
+    def perform(tasks)
+      tasks.each do |task|
         Rails.logger.info "***** Dispatching task for handler class #{task.class.name}"
         task.call
       end
@@ -14,6 +13,7 @@ module Fragmentary
         queue.start
       end
     end
+
   end
 
 end

data/lib/fragmentary/jobs/send_requests_job.rb

@@ -0,0 +1,26 @@
+require 'fragmentary/serializers/request_queue_serializer'
+
+module Fragmentary
+
+  class SendRequestsJob < ActiveJob::Base
+
+    after_perform :schedule_next
+
+    def perform(queue, delay: nil, between: nil, queue_suffix: '', priority: 0)
+      @queue = queue
+      @delay = delay
+      @between = between
+      @queue_suffix = queue_suffix
+      @priority = priority
+      @between ? @queue.send_next_request : @queue.send_all_requests
+    end
+
+    def schedule_next
+      if @queue.size > 0
+        self.enqueue(:wait => @between, :queue => @queue.target.queue_name + @queue_suffix, :priority => @priority)
+      end
+    end
+
+  end
+
+end

data/lib/fragmentary/publisher.rb

@@ -33,7 +33,9 @@ module Fragmentary
       end
 
       def after_update_broadcast
+        Rails.logger.info "\n***** #{start = Time.now} broadcasting :after_update from #{self.class.name} #{self.id}\n"
         broadcast(:after_update, self) if self.previous_changes.any?
+        Rails.logger.info "\n***** #{Time.now} broadcast :after_update from #{self.class.name} #{self.id} took #{(Time.now - start) * 1000} ms\n"
       end
 
       def after_destroy_broadcast

data/lib/fragmentary/request.rb

@@ -3,28 +3,13 @@ module Fragmentary
   class Request
     attr_reader :method, :path, :options, :parameters
 
-    def initialize(method, path, parameters=nil, options=nil)
+    def initialize(method, path, parameters=nil, options={})
       @method, @path, @parameters, @options = method, path, parameters, options
     end
 
     def ==(other)
       method == other.method and path == other.path and parameters == other.parameters and options == other.options
     end
-
-    def to_proc
-      method = @method; path = @path; parameters = @parameters; options = @options.try :dup
-      if @options.try(:[], :xhr)
-        Proc.new do
-          puts "      * Sending xhr request '#{method.to_s} #{path}'" + (!parameters.nil? ? " with #{parameters.inspect}" : "")
-          send(:xhr, method, path, parameters, options)
-        end
-      else
-        Proc.new do
-          puts "      * Sending request '#{method.to_s} #{path}'" + (!parameters.nil? ? " with #{parameters.inspect}" : "")
-          send(method, path, parameters, options)
-        end
-      end
-    end
   end
 
 end

data/lib/fragmentary/request_queue.rb

@@ -1,5 +1,3 @@
-require 'fragmentary/user_session'
-
 module Fragmentary
 
   class RequestQueue
@@ -8,12 +6,27 @@ module Fragmentary
       @@all ||= []
     end
 
-    attr_reader :requests, :user_type, :sender
+    def self.send_all(between: nil)
+      unless between
+        all.each{|q| q.start}
+      else
+        unless between.is_a? ActiveSupport::Duration
+          raise TypeError, "Fragmentary::RequestQueue.send_all requires the keyword argument :between to be of class ActiveSupport::Duration. The value provided is of class #{between.class.name}."
+        end
+        delay = 0.seconds
+        all.each{|q| q.start(:delay => delay += between)}
+      end
+    end
+
+    attr_reader :requests, :user_type, :host_root_url
 
-    def initialize(user_type)
+    def initialize(user_type, host_root_url)
       @user_type = user_type
+      # host_root_url represents where the queued *requests* are to be processed. For internal sessions it also represents where
+      # the *queue* will be processed by delayed_job. For external requests, the queue will be processed by the host creating the
+      # queue and the requests will be explicitly sent to the host_root_url.
+      @host_root_url = host_root_url
       @requests = []
-      @sender = Sender.new(self)
       self.class.all << self
     end
 
@@ -40,6 +53,10 @@ module Fragmentary
       requests.delete_if{|r| r.path == path}
     end
 
+    def sender
+      @sender ||= Sender.new(self)
+    end
+
     def send(**args)
       sender.start(args)
     end
@@ -49,22 +66,46 @@ module Fragmentary
     end
 
     class Sender
+
       class << self
         def jobs
           ::Delayed::Job.where("(handler LIKE ?) OR (handler LIKE ?)", "--- !ruby/object:#{name} %", "--- !ruby/object:#{name}\n%")
         end
       end
 
-      attr_reader :queue
+      class Target
+
+        attr_reader :url
+
+        def initialize(url)
+          @url = url
+        end
+
+        def queue_name
+          @url.gsub(%r{https?://}, '')
+        end
+
+      end
+
+      attr_reader :queue, :target, :delay, :between, :queue_suffix, :priority
 
       def initialize(queue)
         @queue = queue
+        @target = Target.new(queue.host_root_url)
+      end
+
+      def session_user
+        @session_user ||= Fragmentary::SessionUser.fetch(queue.user_type)
+      end
+
+      def session
+        @session ||= InternalUserSession.new(@target.url, session_user)
       end
 
       # Send all requests, either directly or by schedule
-      def start(delay: nil, between: nil)
+      def start(delay: nil, between: nil, queue_suffix: '', priority: 0)
         Rails.logger.info "\n***** Processing request queue for user_type '#{queue.user_type}'\n"
-        @delay = delay; @between = between
+        @delay = delay; @between = between; @queue_suffix = queue_suffix; @priority = priority
         if @delay or @between
           schedule_requests(@delay)
           # sending requests by schedule makes a copy of the sender and queue objects for
@@ -80,22 +121,15 @@ module Fragmentary
         @between ? send_next_request : send_all_requests
       end
 
-      def success
-        schedule_requests(@between) if queue.size > 0
-      end
-
-      private
-
-      def next_request
-        queue.next_request.to_proc
-      end
-
       def send_next_request
         if queue.size > 0
-          session.instance_exec(&(next_request))
+          request = queue.next_request
+          session.send_request(:method => request.method, :path => request.path, :parameters => request.parameters, :options => request.options)
         end
       end
 
+      private
+
       def send_all_requests
         while queue.size > 0
           send_next_request
@@ -105,22 +139,11 @@ module Fragmentary
       def schedule_requests(delay=0.seconds)
         if queue.size > 0
           clear_session
-          Delayed::Job.transaction do
-            self.class.jobs.destroy_all
-            Delayed::Job.enqueue self, :run_at => delay.from_now
-          end
+          job = SendRequestsJob.new(queue, delay: delay, between: between, queue_suffix: queue_suffix, priority: priority)
+          job.enqueue(:wait => delay, :queue => target.queue_name + queue_suffix, :priority => priority)
         end
       end
 
-      def session
-        @session ||= new_session
-      end
-
-      def new_session
-        session_user = Fragmentary::SessionUser.fetch(queue.user_type)
-        UserSession.new(session_user)
-      end
-
       def clear_session
         @session = nil
       end
@@ -128,4 +151,5 @@ module Fragmentary
     end
 
   end
+
 end

data/lib/fragmentary/serializers/handler_serializer.rb

@@ -0,0 +1,24 @@
+module Fragmentary
+
+  class HandlerSerializer < ActiveJob::Serializers::ObjectSerializer
+
+    def serialize?(arg)
+      arg.is_a? Fragmentary::Handler
+    end
+
+    def serialize(handler)
+      super(
+        {
+        :class_name => handler.class.name,
+        :args => handler.args
+        }
+      )
+    end
+
+    def deserialize(hsh)
+      hsh[:class_name].constantize.new(hsh[:args])
+    end
+
+  end
+
+end

data/lib/fragmentary/serializers/request_queue_serializer.rb

@@ -0,0 +1,36 @@
+module Fragmentary
+
+  class RequestQueueSerializer < ActiveJob::Serializers::ObjectSerializer
+
+    def serialize?(arg)
+      arg.is_a? Fragmentary::RequestQueue
+    end
+
+    def serialize(queue)
+      super(
+        {
+        :user_type => queue.user_type,
+        :host_root_url => queue.host_root_url,
+        :requests => queue.requests.map do |r|
+          {
+          :method => r.method,
+          :path => r.path,
+          :parameters => r.parameters,
+          :opinions => r.options
+          }
+        end
+        }
+      )
+    end
+
+    def deserialize(hsh)
+      queue = RequestQueue.new(hsh[:user_type], hsh[:host_root_url])
+      hsh[:requests].each do |r|
+        queue << Request.new(r[:method], r[:path], r[:parameters], r[:options] || {})
+      end
+      queue
+    end
+
+  end
+
+end

data/lib/fragmentary/session_user.rb

@@ -0,0 +1,38 @@
+module Fragmentary
+
+  class SessionUser
+
+    def self.all
+      @@all ||= Hash.new
+    end
+
+    def self.fetch(key)
+      all[key]
+    end
+
+    def initialize(user_type, options={})
+      if user = self.class.fetch(user_type)
+        if user.options != options
+          raise RangeError, "You can't redefine an existing SessionUser object: #{user_type.inspect}"
+        else
+          user
+        end
+      else
+        @user_type = user_type
+        @options = options
+        self.class.all.merge!({user_type => self})
+      end
+    end
+
+    def credentials
+      options[:credentials]
+    end
+
+    protected
+    def options
+      @options
+    end
+
+  end
+
+end