tekeya 0.0.1

data/lib/tekeya/entity/group.rb

@@ -0,0 +1,22 @@
+module Tekeya
+  module Entity
+    module Group
+      extend ActiveSupport::Concern
+      include Entity
+
+      included do
+        belongs_to :owner, polymorphic: true
+
+        validates_presence_of :owner
+      end
+
+      def is_tekeya_group?
+        return true
+      end
+
+      def members(type = nil)
+        tekeya_relations_of(self, :joins, type, true)
+      end
+    end
+  end
+end

data/lib/tekeya/errors/tekeya_error.rb

@@ -0,0 +1,11 @@
+module Tekeya
+  module Errors
+    class TekeyaError < ::StandardError
+      def initialize(message)
+        super(message)
+        ::ActiveSupport::Notifications.
+          instrument('tekeya_error.tekeya', :message => message)
+      end
+    end
+  end
+end

data/lib/tekeya/errors/tekeya_fatal.rb

@@ -0,0 +1,11 @@
+module Tekeya
+  module Errors
+    class TekeyaFatal < ::StandardError
+      def initialize(message)
+        super(message)
+        ::ActiveSupport::Notifications.
+          instrument('tekeya_fatal.tekeya', :message => message)
+      end
+    end
+  end
+end

data/lib/tekeya/errors/tekeya_non_entity.rb

@@ -0,0 +1,6 @@
+module Tekeya
+  module Errors
+    class TekeyaNonEntity < TekeyaError
+    end
+  end
+end

data/lib/tekeya/errors/tekeya_non_group.rb

@@ -0,0 +1,6 @@
+module Tekeya
+  module Errors
+    class TekeyaNonGroup < TekeyaError
+    end
+  end
+end

data/lib/tekeya/errors/tekeya_relation_already_exists.rb

@@ -0,0 +1,6 @@
+module Tekeya
+  module Errors
+    class TekeyaRelationAlreadyExists < TekeyaError
+    end
+  end
+end

data/lib/tekeya/errors/tekeya_relation_non_existent.rb

@@ -0,0 +1,6 @@
+module Tekeya
+  module Errors
+    class TekeyaRelationNonExistent < TekeyaError
+    end
+  end
+end

data/lib/tekeya/feed/activity.rb

@@ -0,0 +1,101 @@
+module Tekeya
+  module Feed
+    module Activity
+      extend ActiveSupport::Concern
+
+      included do
+        belongs_to    :entity, polymorphic: true, autosave: true
+        has_many      :attachments, as: :attache, class_name: 'Tekeya::Attachment'
+
+        before_create :group_activities
+        after_create  :write_activity_in_redis
+        after_destroy :delete_activity_from_redis
+
+        accepts_nested_attributes_for :attachments
+
+        validates_presence_of :attachments
+
+        attr_writer :group_with_recent
+      end
+
+      # Check if this activity is cached in redis
+      #
+      # @return [Boolean] true if an aggregate of the activity exists in redis, false otherwise
+      def cached_in_redis?
+        ::Tekeya.redis.scard(activity_key) > 0
+      end
+
+      # Approximates the timestamp to the nearest 15 minutes for grouping activities
+      #
+      # @param  [Datetime] from_time the time to approximate
+      # @return [Integer] the timestamp approximated to the nearest 15 minutes
+      def score(from_time = nil)
+        if from_time.present?
+          stamp = from_time.to_i
+
+          # floors the timestamp to the nearest 15 minute
+          return (stamp.to_f / 15.minutes).floor * 15.minutes
+        else
+          return current_time_from_proper_timezone.to_i
+        end
+      end
+
+      # Returns an activity key for usage in caching
+      #
+      # @return [String] the activity key
+      def activity_key
+        "activity:#{self.id}:#{self.entity_type}:#{self.entity.send(self.entity.entity_primary_key)}:#{self.activity_type}:#{score}"
+      end
+
+      # @private
+      #
+      # returns if the activity should be grouped with similar recent activities
+      def group_with_recent
+        @group_with_recent.nil? ? true : @group_with_recent
+      end
+
+      private
+
+      # @private
+      # Writes to the activity's aggregate set (a set of attachments associated with the activity)
+      def write_activity_in_redis
+        akey = activity_key
+        tscore = score
+        ::Resque.enqueue(::Tekeya::Feed::Activity::Resque::ActivityFanout, self.entity_id, self.entity_type, akey, tscore, self.attachments.map{ |att| att.to_json(root: false, only: [:attachable_id, :attachable_type]) })
+      end
+
+      # @private
+      # Checks if the activity should be grouped and aborts the creation of a new record
+      def group_activities
+        if self.group_with_recent
+          self.created_at = current_time_from_proper_timezone
+          rel = self.class.where(created_at: self.created_at, activity_type: self.activity_type, entity_id: self.entity_id, entity_type: entity_type)
+          if rel.count > 0
+            activity = rel.first
+            activity.attachments << self.attachments
+            self.id = activity.id
+            self.reload
+            return false
+          end
+        end
+      end
+
+      # @private
+      # Deletes the activity's aggregate set when its deleted from the DB
+      def delete_activity_from_redis
+        ::Resque.enqueue(::Tekeya::Feed::Activity::Resque::DeleteActivity, self.activity_key)
+      end
+
+      # @private
+      # Override AR's default created_at calculation formula
+      def current_time_from_proper_timezone #:nodoc:
+        zone = self.class.respond_to?(:default_timezone) ? self.class.default_timezone : :utc
+        ctime = zone == :utc ? Time.now.utc : Time.now
+        stamp = ctime.to_i
+
+        # floors the timestamp to the nearest 15 minute
+        return Time.at((stamp.to_f / 15.minutes).floor * 15.minutes)
+      end
+    end
+  end
+end

data/lib/tekeya/feed/activity/feed_item.rb

@@ -0,0 +1,58 @@
+module Tekeya
+  module Feed
+    module Activity
+      class FeedItem
+        attr_reader :activity_id, :activity_type, :attachments, :actor, :timestamp
+
+        def initialize(activity_id, activity_type, attachments, actor, timestamp)
+          @activity_id = activity_id
+          @activity_type = activity_type
+          @attachments = attachments
+          @actor = actor
+          @timestamp = timestamp
+        end
+
+        # Builds a feed item from a redis activity
+        # 
+        # @param  [String] key the aggregate key of the activity
+        # @param  [Tekeya::Entity] act_actor the activty actor; when nil the actor is retrieved from the aggregate key
+        # @return [Tekeya::Feed::FeedItem] the feed item
+        def self.from_redis(key, act_actor = nil)
+          key_components  = key.split(':')
+          
+          act_id          = key_components[1]
+          act_type        = key_components[4].to_sym
+          act_time        = Time.at(key_components[5].to_i)
+          
+          if act_actor.nil?
+            actor_class = key_components[2].safe_constantize
+            act_actor = actor_class.where(:"#{actor_class.entity_primary_key}" => key_components[3]).first
+          end
+
+          act_attachments = ::Tekeya.redis.smembers(key).map{|act| 
+            ActiveSupport::JSON.decode(act)
+          }.map{|att| 
+            att['attachable_type'].safe_constantize.find att['attachable_id']
+          }
+
+          return self.new(act_id, act_type, act_attachments, act_actor, act_time)
+        end
+
+        # Builds a feed item a DB activity
+        # 
+        # @param  [Tekeya::Activity] activity the source activity
+        # @param  [Tekeya::Entity] act_actor the activty actor; when nil the actor is retrieved from the activity
+        # @return [Tekeya::Feed::FeedItem] the feed item
+        def self.from_db(activity, act_actor = nil)
+          act_id            = activity.id.to_s
+          act_type          = activity.activity_type.to_sym
+          act_time          = activity.created_at
+          act_actor       ||= activity.entity
+          act_attachments   = activity.attachments.map(&:attachable)
+
+          return self.new(act_id, act_type, act_attachments, act_actor, act_time)
+        end
+      end
+    end
+  end
+end

data/lib/tekeya/feed/activity/resque.rb

@@ -0,0 +1,56 @@
+module Tekeya
+  module Feed
+    module Activity
+      module Resque
+        extend ActiveSupport::Concern
+
+        included do
+          MAXTIMESTAMP = 10.days.ago.to_i unless defined?(MAXTIMESTAMP)
+        end
+
+        module ClassMethods
+          private
+          # Writes the activity reference to the feed with the supplied key
+          #
+          # @param [String]  feed_key the key of the feed where the activity will be referenced
+          # @param [Integer] score the score of the activity (timestamp) used to order the feed
+          # @param [String]  activity_key a string containing the key to reference the activity
+          def write_to_feed(feed_key, score, activity_key)
+            # add the activity to the owner's profile feed
+            ::Tekeya.redis.zadd(feed_key, score, activity_key)
+            # increment the activity counter to keep track of its presence in feeds
+            activity_counter_key = "#{activity_key}:counter"
+            ::Tekeya.redis.incr(activity_counter_key)
+          end
+
+          # Trims the feed according to the MAXTIMESTAMP set and returns the removed keys (for garbage collection)
+          #
+          # @param [String] feed_key a string containing the key of the feed to be trimed
+          def trim_feed(feed_key)
+            removed_keys = ::Tekeya.redis.zrevrangebyscore(feed_key, '-inf', MAXTIMESTAMP)
+            ::Tekeya.redis.zremrangebyscore(feed_key, '-inf', MAXTIMESTAMP)
+
+            return removed_keys
+          end
+
+          # Checks if the given keys are referenced in any feed otherwise removes the activity
+          #
+          # @param [Array] keys an array of activity keys to be removed
+          def collect_garbage(keys)
+            keys.each do |key|
+              activity_counter_key = "#{key}:counter"
+              # Check if the key is referenced anywhere
+              if ::Tekeya.redis.get(activity_counter_key).to_i <= 0
+                # Delete the activity and the counter
+                ::Tekeya.redis.multi do
+                  ::Tekeya.redis.del(key)
+                  ::Tekeya.redis.del(activity_counter_key)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tekeya/feed/activity/resque/activity_fanout.rb

@@ -0,0 +1,61 @@
+module Tekeya
+  module Feed
+    module Activity
+      module Resque
+        # A resque worker to perform the activity fanout operation
+        class ActivityFanout
+          include Tekeya::Feed::Activity::Resque
+
+          @queue = :activity_queue
+
+          # @private
+          def self.perform(entity_id, entity_type, activity_key, score, attachments)
+            # get the entity class
+            entity_type = entity_type.safe_constantize
+            entity = entity_type.where(entity_type.entity_primary_key.to_sym => entity_id).first
+            # we only need the feed keys of the trackers
+            entity_trackers_feeds = entity.trackers.map(&:feed_key)
+            # keep track of the keys we delete in the trim operation for garbage collection
+            removed_keys = []
+
+            # write the activity to the aggregate set and the owner's feed
+            ::Tekeya.redis.multi do
+              write_aggregate(activity_key, attachments)
+              write_to_feed(entity.profile_feed_key, score, activity_key)
+            end
+
+            # trim the profile feed
+            removed_keys += trim_feed(entity.profile_feed_key)
+
+            # Fanout the activity to the owner's trackers
+            entity_trackers_feeds.each do |feed_key|
+              # write the activity to the tracker's feed
+              ::Tekeya.redis.multi do
+                write_to_feed(feed_key, score, activity_key)
+              end
+
+              # trim the tracker's feed
+              removed_keys += trim_feed(feed_key)
+            end
+
+            # cleanup the garbage
+            collect_garbage removed_keys
+          end
+
+          private
+
+          # Writes the activity and its' attachments to the aggregate set
+          #
+          # @param [String] activity_key the key of the activity to be added
+          # @param [Array]  attachments an array of attachments associated with the activity
+          def self.write_aggregate(activity_key, attachments)
+            # save the aggregate set
+            attachments.each do |attachment|
+              ::Tekeya.redis.sadd(activity_key, attachment)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tekeya/feed/activity/resque/delete_activity.rb

@@ -0,0 +1,43 @@
+module Tekeya
+  module Feed
+    module Activity
+      module Resque
+        # A resque worker to copy activities when an entity tracks another
+        class DeleteActivity
+          include Tekeya::Feed::Activity::Resque
+
+          @queue = :activity_queue
+
+          # @private
+          def self.perform(activity_aggregate_key)
+            # get the activity properties from the key
+            key_components  = activity_aggregate_key.split(':')
+            entity_type     = key_components[2].safe_constantize
+            entity_id       = key_components[3]
+
+            # get the entity
+            entity = entity_type.where(entity_type.entity_primary_key.to_sym => entity_id).first
+            # we only need the feed keys of the trackers
+            entity_trackers_feeds = entity.trackers.map(&:feed_key)
+            entity_trackers_feeds << entity.profile_feed_key
+
+            # remove the aggregate key from the trackers' feeds and prepare the activity for garbage collection
+            ::Tekeya.redis.multi do
+              entity_trackers_feeds.each do |feed_key|
+                if ::Tekeya.redis.zrank(feed_key, activity_aggregate_key)
+                  # remove the activity aggregate key from the feed
+                  ::Tekeya.redis.zrem(feed_key, activity_aggregate_key)
+                  # decrement the activity counter
+                  ::Tekeya.redis.decr("#{activity_aggregate_key}:counter")
+                end
+              end
+            end
+
+            # trim the tracker feed and cleanup
+            collect_garbage [activity_aggregate_key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tekeya/feed/activity/resque/feed_copy.rb

@@ -0,0 +1,34 @@
+module Tekeya
+  module Feed
+    module Activity
+      module Resque
+        # A resque worker to copy activities when an entity tracks another
+        class FeedCopy
+          include Tekeya::Feed::Activity::Resque
+
+          @queue = :activity_queue
+
+          # @private
+          def self.perform(tracked_feed_key, tracker_feed_key)
+            # get the keys to the activities so we can increment the counters later
+            activity_keys = ::Tekeya.redis.zrange(tracked_feed_key, 0, -1)
+
+            ::Tekeya.redis.multi do
+              # copy the latest activities from the tracked entity to the tracker feed
+              ::Tekeya.redis.zunionstore(tracker_feed_key, [tracker_feed_key, tracked_feed_key])
+
+              # increment the activity counter
+              activity_keys.each do |activity_key|
+                activity_counter_key = "#{activity_key}:counter"
+                ::Tekeya.redis.incr(activity_counter_key)
+              end
+            end
+
+            # trim the tracker feed and cleanup
+            collect_garbage trim_feed(tracker_feed_key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tekeya/feed/activity/resque/untrack_feed.rb

@@ -0,0 +1,34 @@
+module Tekeya
+  module Feed
+    module Activity
+      module Resque
+        # A resque worker to copy activities when an entity tracks another
+        class UntrackFeed
+          include Tekeya::Feed::Activity::Resque
+
+          @queue = :activity_queue
+
+          # @private
+          def self.perform(untracked_feed_key, untracker_feed_key)
+            # get the keys to the activities so we can decrement the counters later
+            activity_keys = ::Tekeya.redis.zrange(untracked_feed_key, 0, -1)
+
+            ::Tekeya.redis.multi do
+              # delete the latest activities of the untracked entity from the tracker feed
+              ::Tekeya.redis.zrem(untracker_feed_key, activity_keys)
+
+              # increment the activity counter
+              activity_keys.each do |activity_key|
+                activity_counter_key = "#{activity_key}:counter"
+                ::Tekeya.redis.decr(activity_counter_key)
+              end
+            end
+
+            # trim the tracker feed and cleanup
+            collect_garbage trim_feed(untracker_feed_key)
+          end
+        end
+      end
+    end
+  end
+end