atr 0.0.1

data/bin/atr_server

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require 'atr'
+require './config/environment.rb'
+
+class AtrServer < ::Thor
+  class_option :server_host, :default => "127.0.0.1"
+  class_option :server_port, :default => 7777
+
+  desc "start", "Start ATR"
+  def start
+    puts "Starting ATR SERVER"
+    ::Dir.glob(::Rails.root.join('app', 'models', "**", "*.rb")).each{ |file| load file }
+
+    ::Atr::Server.supervise_as :websocket_server
+
+    ::ActiveRecord::Base.clear_active_connections!
+  end
+end
+
+::AtrServer.start
+
+sleep

data/lib/atr.rb

@@ -0,0 +1,43 @@
+require "atr/version"
+
+require "celluloid"
+require "reel"
+require "active_support"
+require 'active_support/concern'
+require "active_attr"
+
+require "atr/config"
+require "atr/event"
+require "atr/reactor"
+require "atr/server"
+require "atr/redis"
+require "atr/request_authenticator"
+require "atr/request_scope"
+require "atr/publishable"
+require "atr/publisher"
+require "atr/registry"
+
+module Atr
+  class << self
+    attr_accessor :configuration
+    alias_method :config, :configuration
+  end
+
+  def self.publish_event(event)
+    ::Celluloid::Actor[:atr_publisher].publish_event(event)
+  end
+
+  def self.channels
+    ::Atr::Registry.channels
+  end
+
+  def self.configure
+    self.configuration ||= ::Atr::Config.new
+
+    yield(configuration)
+
+    ::ActiveSupport.run_load_hooks(:atr, self)
+  end
+end
+
+require 'atr/railtie' if defined?(Rails)

data/lib/atr/config.rb

@@ -0,0 +1,25 @@
+require 'active_support/ordered_options'
+
+module Atr
+  class Config < ::ActiveSupport::OrderedOptions
+    def initialize(options = {})
+      super
+    end
+
+    def authenticate?
+      has_key?(:authenticate_with)
+    end
+
+    def scope?
+      has_key?(:scope_with)
+    end
+
+    def event_serializer?
+      has_key?(:event_serializer)
+    end
+
+    def serialize_events_with?
+      has_key?(:serialize_events_with)
+    end
+  end
+end

data/lib/atr/errors.rb

@@ -0,0 +1,4 @@
+module Atr
+  class AtrError < StandardError; end
+  class MustImplementMethodError < AtrError; end
+end

data/lib/atr/event.rb

@@ -0,0 +1,24 @@
+require 'active_model'
+module Atr
+  class Event
+    include ::ActiveAttr::Model
+    include ::ActiveModel::AttributeMethods
+
+    attribute :id
+    attribute :name
+    attribute :occured_at
+    attribute :record
+    attribute :record_type
+    attribute :routing_key
+
+    def initialize(routing_key, name, record)
+      self[:routing_key] = routing_key
+      self[:name] = name
+      self[:record] = record
+      self[:id] = ::SecureRandom.hex
+      self[:record_type] = record.class.name
+      self[:occured_at] ||= ::DateTime.now
+    end
+
+  end
+end

data/lib/atr/publishable.rb

@@ -0,0 +1,95 @@
+module Atr
+  module Publishable
+    extend ActiveSupport::Concern
+
+    PUBLISHABLE_ACTIONS = ["updated", "created", "destroyed"]
+
+    included do
+      include ::ActiveModel::Dirty
+
+      after_create :publish_created_event
+      after_update :publish_updated_event
+      after_destroy :publish_destroyed_event
+
+      class << self
+        attr_accessor :publication_scopes
+      end
+
+      self.publication_scopes ||= []
+      self.publishable_actions ||= []
+
+      ::Atr::Publishable::PUBLISHABLE_ACTIONS.each do |action|
+        ::Atr::Registry.channels << "#{routing_key}.#{action}" unless ::Atr::Registry.channels.include?("#{routing_key}.#{action}")
+      end
+    end
+
+    private
+
+    def publish_updated_event
+      routing_key = self.class.build_routing_key_for_record_action(self, "updated")
+      event_name = self.class.resource_action_routing_key("updated")
+      record_updated_event = ::Atr::Event.new(routing_key, event_name, self)
+
+      ::Atr.publish_event(record_updated_event)
+    end
+
+    def publish_created_event
+      routing_key = self.class.build_routing_key_for_record_action(self, "created")
+      event_name = self.class.resource_action_routing_key("created")
+      record_created_event = ::Atr::Event.new(routing_key, event_name, self)
+
+      ::Atr.publish_event(record_created_event)
+    end
+
+    def publish_destroyed_event
+      routing_key = self.class.build_routing_key_for_record_action(self, "destroyed")
+      event_name = self.class.resource_action_routing_key("destroyed")
+      record_destroyed_event = ::Atr::Event.new(routing_key, event_name, self)
+
+      ::Atr.publish_event(record_destroyed_event)
+    end
+
+    module ClassMethods
+      def publishable_actions(*actions)
+        @publishable_actions = actions
+      end
+
+      def routing_key
+        resource_routing_keys.join(".")
+      end
+
+      def resource_routing_keys
+        name.split("::").map(&:underscore)
+      end
+
+      def resource_action_routing_keys(action_routing_key)
+        [resource_routing_keys, action_routing_key]
+      end
+
+      def resource_action_routing_key(action_routing_key)
+        resource_action_routing_keys(action_routing_key).join(".")
+      end
+
+      def build_routing_key_for_record_action(record, action_routing_key)
+        publication_scope_routing_keys = build_publication_scope_for_record(record)
+        [publication_scope_routing_keys, resource_routing_keys, action_routing_key].flatten.join(".")
+      end
+
+      def build_publication_scope_for_record(record)
+        publication_scopes.map do |arg|
+          key = arg.to_s.split("_id").first
+          value = record.__send__(arg)
+          [key, value]
+        end.try(:flatten)
+      end
+
+      def publication_scope(*args)
+        self.publication_scopes = args
+      end
+
+      def scope_publication?
+        publication_scopes.present?
+      end
+    end
+  end
+end

data/lib/atr/publisher.rb

@@ -0,0 +1,11 @@
+module Atr
+  class Publisher
+    include ::Celluloid
+
+    def publish_event(event)
+      ::ActiveRecord::Base.connection_pool.with_connection do
+        ::Atr::Redis.connection.publish(event["routing_key"], Marshal.dump(event))
+      end
+    end
+  end
+end

data/lib/atr/railtie.rb

@@ -0,0 +1,29 @@
+require 'rails/railtie'
+
+module Atr
+  class Railtie < ::Rails::Railtie
+    config.after_initialize do
+      ::Atr::Redis.connect unless ::Atr::Redis.connected?
+
+      ::Atr::Publisher.supervise_as :atr_publisher
+    end
+
+    ::ActiveSupport.on_load(:atr) do
+      puts "ATR LOADED"
+    end
+
+    #todo: make redis configurable
+    def self.load_config_yml
+      config_file = ::YAML.load_file(config_yml_filepath)
+      return unless config_file.is_a?(Hash)
+    end
+
+    def self.config_yml_exists?
+      ::File.exists? config_yml_filepath
+    end
+
+    def self.config_yml_filepath
+      ::Rails.root.join('config', 'atr.yml')
+    end
+  end
+end

data/lib/atr/reactor.rb

@@ -0,0 +1,119 @@
+require 'reel'
+
+module Atr
+  class Reactor
+    include Celluloid
+    include Celluloid::IO
+    include Celluloid::Logger
+
+    attr_accessor :websocket
+    attr_accessor :routing_key_scope
+    attr_accessor :subscribers
+
+    def initialize(websocket, routing_key_scope = nil)
+      info "Streaming changes"
+
+      @routing_key_scope = routing_key_scope
+      @websocket = websocket
+
+      @subscribers = ::Atr::Registry.scoped_channels(routing_key_scope).map do |channel|
+        async.start_subscriber(channel)
+      end
+
+      async.run
+    end
+
+    def dispatch_message(message)
+      puts message.inspect
+    end
+
+    def run
+      while message = @websocket.read
+        if message == "unsubscribe"
+          unsubscribe_all
+        else
+          dispatch_message(message)
+        end
+      end
+    end
+
+    #todo: decide between starting individually or subscribing all at once and remove one of the methods
+    def start_subscribers
+      ::Atr::Redis.connect unless ::Atr::Redis.connected?
+
+      ::Atr::Redis.connection.subscribe(::Atr::Registry.scoped_channels(routing_key_scope)) do |on|
+        on.subscribe do |channel, subscriptions|
+          puts "Subscribed to ##{channel} (#{subscriptions} subscriptions)"
+        end
+
+        on.unsubscribe do |channel, subscriptions|
+          ::ActiveRecord::Base.clear_active_connections!
+          terminate
+        end
+
+        on.message do |channel, message|
+          shutdown if message == "exit"
+
+          event = Marshal.load(message)
+
+          if ::Atr.config.event_serializer?
+
+            websocket << ::Atr.config.event_serializer.new(event).to_json
+          else
+            websocket << event.to_json
+          end
+        end
+      end
+    rescue Reel::SocketError
+      info "Client disconnected"
+      ::ActiveRecord::Base.clear_active_connections!
+      terminate
+    end
+
+    def shutdown
+      ::Atr::Redis.connection.unsubscribe
+      ::ActiveRecord::Base.clear_active_connections!
+      terminate
+    end
+
+    def start_subscriber(channel)
+      ::Atr::Redis.connect unless ::Atr::Redis.connected?
+
+      ::Atr::Redis.connection.subscribe(channel) do |on|
+        on.subscribe do |channel, subscriptions|
+          puts "Subscribed to ##{channel} (#{subscriptions} subscriptions)"
+        end
+
+        on.unsubscribe do |channel, subscriptions|
+          puts "Unsubscribed from ##{channel} (#{subscriptions} subscriptions)"
+          ::ActiveRecord::Base.clear_active_connections!
+          terminate
+        end
+
+        on.message do |channel, message|
+          shutdown if message == "exit"
+
+          event = Marshal.load(message)
+
+          if ::Atr.config.event_serializer?
+            puts "FOUND SERIUALIZER"
+            puts ::Atr.config.event_serializer.inspect
+            puts ::Atr.config.event_serializer.new(event).to_json
+            websocket << ::Atr.config.event_serializer.new(event).to_json
+          else
+            websocket << event.to_json
+          end
+        end
+      end
+    end
+
+    def unsubscribe_all
+      ::Atr::Registry.scoped_channels(routing_key_scope).map do |channel|
+        ::Atr::Redis.connection.unsubscribe(channel)
+      end
+
+      info "clearing connections"
+      terminate
+    end
+  end
+end

data/lib/atr/redis.rb

@@ -0,0 +1,18 @@
+require 'redis'
+require 'celluloid/redis'
+require 'redis/connection/celluloid'
+
+module Atr
+  class Redis
+    class << self
+      @connected ||= false
+      attr_accessor :connected, :connection
+
+      alias_method :connected?, :connected
+    end
+
+    def self.connect(options={})
+      @connection = ::Redis.new(:driver => :celluloid)
+    end
+  end
+end

data/lib/atr/registry.rb

@@ -0,0 +1,15 @@
+module Atr
+  class Registry
+    include ActiveSupport::Configurable
+
+    class << self
+      attr_accessor :channels
+    end
+
+    @channels = []
+
+    def self.scoped_channels(routing_key)
+      channels.map{ |channel| "#{routing_key}.#{channel}" }
+    end
+  end
+end

data/lib/atr/request_authenticator.rb

@@ -0,0 +1,17 @@
+module Atr
+  class RequestAuthenticator
+    attr_accessor :request
+
+    def initialize(request)
+      @request = request
+    end
+
+    def matches?
+      false
+    end
+
+    def params
+      ::Hash[request.query_string.split("&").map{|seg| seg.split("=") }].with_indifferent_access
+    end
+  end
+end

data/lib/atr/request_scope.rb

@@ -0,0 +1,17 @@
+module Atr
+  class RequestScope
+    attr_accessor :request
+
+    def initialize(request)
+      @request = request
+    end
+
+    def matches?
+      false
+    end
+
+    def params
+      ::Hash[request.query_string.split("&").map{|seg| seg.split("=") }].with_indifferent_access
+    end
+  end
+end