alondra 0.0.3

data/lib/alondra/event.rb

@@ -0,0 +1,74 @@
+module Alondra
+  class Event
+    attr_reader :channel_name
+    attr_reader :type
+    attr_reader :resource
+    attr_reader :resource_type
+    attr_reader :connection
+
+    def initialize(event_hash, from_json = nil, connection = nil)
+      @connection   = connection
+      @type         = event_hash[:event].to_sym
+      @json_encoded = from_json
+
+      if Hash === event_hash[:resource]
+        @resource = fetch(event_hash[:resource_type], event_hash[:resource])
+      else
+        @resource = event_hash[:resource]
+      end
+
+      @resource_type = event_hash[:resource_type] || resource.class.name
+
+      if event_hash[:channel].present?
+        @channel_name  = event_hash[:channel]
+      else
+        channel_type = type == :updated ? :member : :collection
+        Channel.default_name_for(resource, channel_type)
+      end
+    end
+
+    def channel
+      @channel ||= Channel[channel_name]
+    end
+
+    def fire!
+      if connection
+        # We are inside the Alondra Server
+        EM.schedule do
+          MessageQueue.instance.receive self
+        end
+      else
+        MessageQueueClient.push self
+      end
+    end
+
+    def as_json
+      {
+        :event         => type,
+        :resource_type => resource_type,
+        :resource      => resource.as_json,
+        :channel       => channel_name
+      }
+    end
+
+    def to_json
+      @json_encoded ||= ActiveSupport::JSON.encode(as_json)
+    end
+
+    private
+
+    def fetch(resource_type_name, attributes)
+      attributes.symbolize_keys!
+      resource_class = Kernel.const_get(resource_type_name)
+
+      return attributes unless resource_class < ActiveRecord::Base
+
+      resource = resource_class.new
+
+      filtered_attributes = attributes.delete_if { |k,v| !resource.has_attribute?(k) }
+
+      resource.assign_attributes(filtered_attributes, :without_protection => true)
+      resource
+    end
+  end
+end

data/lib/alondra/event_listener.rb

@@ -0,0 +1,86 @@
+module Alondra
+  class EventListener
+    include Pushing
+
+    attr_accessor :event
+    attr_accessor :resource
+    attr_accessor :channel_name
+
+    class << self
+      def listened_patterns
+        @listened_patterns ||= [default_listened_pattern]
+      end
+
+      def listen_to?(channel_name)
+        listened_patterns.any? { |p| p =~ channel_name }
+      end
+
+      def listen_to(channel_name)
+        unless @custom_pattern_provided
+          listened_patterns.clear
+          @custom_pattern_provided = true
+        end
+
+        if Regexp === channel_name
+          listened_patterns << channel_name
+        else
+          escaped_pattern = Regexp.escape(channel_name)
+          listened_patterns << Regexp.new("^#{escaped_pattern}")
+        end
+      end
+
+      def on(event_type, options = {}, &block)
+        callbacks << ListenerCallback.new(event_type, options, block)
+      end
+
+      def callbacks
+        @callbacks ||= []
+      end
+
+      def default_listened_pattern
+        word = self.name.demodulize
+        word.gsub!(/Listener$/, '')
+        word.gsub!(/::/, '/')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1\/\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1/\2')
+        word.downcase!
+        Regexp.new("^/#{word}")
+      end
+
+      def inherited(subclass)
+        # In development mode Rails will load the same class many times
+        # Delete it first if we already have parsed it
+        EventRouter.listeners.delete_if { |l| l.name == subclass.name }
+        EventRouter.listeners << subclass
+      end
+
+      def matching_callbacks_for(event)
+        callbacks.find_all { |c| c.matches?(event) }
+      end
+
+      def process(event)
+        matching_callbacks_for(event).each do |callback|
+          new_instance = new(event)
+          begin
+            new_instance.instance_exec(event, &callback.proc)
+          rescue Exception => ex
+            Rails.logger.error 'Error while processing event listener callback'
+            Rails.logger.error ex.message
+            Rails.logger.error ex.stacktrace if ex.respond_to? :stacktrace
+          end
+        end
+      end
+    end
+
+    def session
+      @connection.session
+    end
+
+    def initialize(event)
+      @event        = event
+      @resource     = event.resource
+      @channel_name = event.channel_name
+      @connection   = event.connection
+    end
+  end
+end

data/lib/alondra/event_router.rb

@@ -0,0 +1,27 @@
+module Alondra
+  class EventRouter
+
+    def self.listeners
+      @listeners ||= []
+    end
+
+    def process(event)
+      event.channel.receive(event)
+
+      # Event listeners callback can manipulate AR objects and so can potentially
+      # block the EM reactor thread. To avoid that, we defer them to another thread.
+      EM.defer do
+
+        # Ensure the connection associated with the thread is checked in
+        # after the callbacks are processed
+        ActiveRecord::Base.connection_pool.with_connection do
+          listening_classes = EventRouter.listeners.select do |ob|
+            ob.listen_to?(event.channel_name)
+          end
+
+          listening_classes.each { |listening_class| listening_class.process(event) }
+        end
+      end
+    end
+  end
+end

data/lib/alondra/listener_callback.rb

@@ -0,0 +1,37 @@
+module Alondra
+  class ListenerCallback
+    attr_reader :event_type
+    attr_reader :options
+    attr_reader :proc
+
+    CHANNEL_NAME_PATTERN = %r{\d+$}
+
+    def initialize(event_type, options = {}, proc)
+      @event_type = event_type
+      @options    = options
+      @proc       = proc
+    end
+
+    def matches?(event)
+      return false unless event.type == event_type
+
+      case options[:to]
+      when nil then true
+      when :member then
+        member_channel? event.channel_name
+      when :collection then
+        !member_channel?(event.channel_name)
+      end
+    end
+
+    def to_proc
+      proc
+    end
+
+    private
+
+    def member_channel?(channel_name)
+      channel_name =~ CHANNEL_NAME_PATTERN
+    end
+  end
+end

data/lib/alondra/message.rb

@@ -0,0 +1,35 @@
+module Alondra
+  class Message
+    attr_reader :content
+    attr_reader :channel_names
+
+    def initialize(content, channel_names)
+      @content       = content
+      @channel_names = channel_names
+    end
+
+    def enqueue
+      MessageQueueClient.push self
+    end
+
+    def send_to_channels
+      channels.each do |channel|
+        channel.receive self
+      end
+    end
+
+    def as_json
+      {:message => content, :channel_names => channel_names}
+    end
+
+    def to_json
+      ActiveSupport::JSON.encode(as_json)
+    end
+
+    private
+
+    def channels
+      channel_names.collect { |name| Channel[name] }
+    end
+  end
+end

data/lib/alondra/message_queue.rb

@@ -0,0 +1,70 @@
+require 'singleton'
+require 'ffi'
+require 'em-zeromq'
+
+module Alondra
+  class MessageQueue
+    include Singleton
+
+    def start_listening
+      Rails.logger.info "Starting message queue"
+
+      if @connection
+        Rails.logger.warn 'Push connection to message queue started twice'
+        reset!
+      end
+
+      @connection = context.bind(ZMQ::SUB, Alondra.config.queue_socket, self)
+      @connection.setsockopt ZMQ::SUBSCRIBE, '' # receive all
+    end
+
+    def on_readable(socket, messages)
+      messages.each do |received|
+        begin
+          parse received.copy_out_string
+        rescue Exception => ex
+          Rails.logger.error "Error raised while processing message"
+          Rails.logger.error "#{ex.class}: #{ex.message}"
+          Rails.logger.error ex.backtrace.join("\n") if ex.respond_to? :backtrace
+        end
+      end
+    end
+
+    def parse(received_string)
+      received_hash = ActiveSupport::JSON.decode(received_string).symbolize_keys
+
+      if received_hash[:event]
+        event = Event.new(received_hash, received_string)
+        receive(event)
+      elsif received_hash[:message]
+        message = Message.new(received_hash[:message], received_hash[:channel_names])
+        message.send_to_channels
+      else
+        Rails.logger.warn "Unrecognized message type #{received_string}"
+      end
+    end
+
+    def receive(event)
+      event_router.process(event)
+    end
+
+    def reset!
+      @connection.close_connection()
+
+      @connection  = nil
+      @context     = nil
+      @push_socket = nil
+    end
+
+    private
+
+    def event_router
+      @event_router ||= EventRouter.new
+    end
+
+    def context
+      @context ||= EM::ZeroMQ::Context.new(1)
+    end
+  end
+end
+

data/lib/alondra/message_queue_client.rb

@@ -0,0 +1,71 @@
+require 'singleton'
+require 'ffi-rzmq'
+require 'em-zeromq'
+
+module Alondra
+  class MessageQueueClient
+
+    def self.push(message)
+      instance.send_message(message)
+    end
+
+    def self.instance
+      if EM.reactor_running?
+        async_instance
+      else
+        sync_instance
+      end
+    end
+
+    def self.async_instance
+      @async_instance ||= AsyncMessageQueueClient.new
+    end
+
+    def self.sync_instance
+      @sync_instance ||= SyncMessageQueueClient.new
+    end
+  end
+
+  class AsyncMessageQueueClient < MessageQueueClient
+    def send_message(message)
+      EM.schedule do
+        begin
+          push_socket.send_msg(message.to_json)
+        rescue Exception => ex
+          Rails.logger.error "Exception while sending message to message queue: #{ex.message}"
+        end
+      end
+    end
+
+    def push_socket
+      @push_socket ||= context.connect(ZMQ::PUB, Alondra.config.queue_socket)
+    end
+
+    def context
+      @context ||= EM::ZeroMQ::Context.new(1)
+    end
+  end
+
+  class SyncMessageQueueClient < MessageQueueClient
+
+    def send_message(message)
+      begin
+        push_socket.send_string(message.to_json)
+      rescue Exception => ex
+        Rails.logger.error "Exception while sending message to message queue: #{ex.message}"
+      end
+    end
+
+    def push_socket
+      @push_socket ||= begin
+        socket = context.socket(ZMQ::PUB)
+        socket.connect(Alondra.config.queue_socket)
+        socket
+      end
+    end
+
+    def context
+      @context ||= ZMQ::Context.new(1)
+    end
+  end
+end

data/lib/alondra/push_controller.rb

@@ -0,0 +1,53 @@
+module Alondra
+  class PushController
+    include ActiveSupport::Configurable
+    include AbstractController::Logger
+    include AbstractController::Rendering
+    include AbstractController::Helpers
+    include AbstractController::Translation
+    include AbstractController::AssetPaths
+    include AbstractController::ViewPaths
+
+    attr_accessor :channel_names
+
+    def initialize(context, to)
+      @channel_names = Channel.names_for(to)
+
+      self.class.view_paths = ActionController::Base.view_paths
+      copy_instance_variables_from(context)
+    end
+
+    def render_push(options)
+
+      if EM.reactor_thread?
+        Rails.logger.warn('Your are rendering a view from the Event Machine reactor thread')
+        Rails.logger.warn('Rendering a view is a possibly blocking operation, so be careful')
+      end
+
+      message_content = render_to_string(*options)
+      msg = Message.new(message_content, channel_names)
+      msg.enqueue
+    end
+
+    def _prefixes
+      ['application']
+    end
+
+    def view_paths
+      @view_paths ||= ApplicationController.send '_view_paths'
+    end
+
+    def action_name
+      'push'
+    end
+
+    private
+
+    def copy_instance_variables_from(context)
+      context.instance_variables.each do |var|
+        value = context.instance_variable_get(var)
+        instance_variable_set(var, value)
+      end
+    end
+  end
+end

data/lib/alondra/pushing.rb

@@ -0,0 +1,14 @@
+module Alondra
+
+  class PushingException < StandardError; end
+
+  module Pushing
+    def push(*args)
+      raise PushingException.new('You need to specify the channel to push') unless args.last[:to].present?
+
+      to = args.last.delete(:to)
+      controller = PushController.new(self, to)
+      controller.render_push(args)
+    end
+  end
+end

data/lib/alondra/server.rb

@@ -0,0 +1,44 @@
+require 'em-websocket'
+
+module Alondra
+  module Server
+    extend self
+
+    def run
+      Rails.logger.info "Server starting on port #{Alondra.config.port}"
+
+      EM::WebSocket.start(:host => '0.0.0.0', :port => Alondra.config.port) do |websocket|
+
+        websocket.onopen do
+          session = SessionParser.parse(websocket)
+          
+          Rails.logger.info "client connected."
+          Connection.new(websocket, session)
+        end
+
+        websocket.onclose do
+          Rails.logger.info "Connection closed"
+          Connections[websocket].destroy! if Connections[websocket].present?
+        end
+
+        websocket.onerror do |ex|
+          puts "Error: #{ex.message}"
+          Rails.logger.error "Error: #{ex.message}"
+          Rails.logger.error ex.backtrace.join("\n")
+          Connections[websocket].destroy! if Connections[websocket]
+        end
+
+        websocket.onmessage do |msg|
+          Rails.logger.info "received: #{msg}"
+          CommandDispatcher.dispatch(msg, Connections[websocket])
+        end
+      end
+
+      EM.error_handler do |error|
+        puts "Error raised during event loop: #{error.message}"
+        Rails.logger.error "Error raised during event loop: #{error.message}"
+        Rails.logger.error error.stacktrace if error.respond_to? :stacktrace
+      end
+    end
+  end
+end

data/lib/alondra/session_parser.rb

@@ -0,0 +1,57 @@
+require 'cgi'
+
+module Alondra
+  module SessionParser
+    extend self
+
+    def verifier
+      @verifier ||= ActiveSupport::MessageVerifier.new(Rails.application.config.secret_token)
+    end
+
+    def parse(websocket)
+      cookie = websocket.request['cookie'] || websocket.request['Cookie']
+      token  = websocket.request['query']['token']
+
+      if token.present?
+        SessionParser.parse_token(token)
+      elsif cookie.present?
+        SessionParser.parse_cookie(cookie)
+      else
+        Hash.new
+      end
+    end
+
+    def parse_cookie(cookie)
+      begin
+        cookies = cookie.split(';')
+        session_key = Rails.application.config.session_options[:key]
+
+        encoded_session = cookies.detect{|c| c.include?(session_key)}.gsub("#{session_key}=",'').strip
+        verifier.verify(CGI.unescape(encoded_session))
+      rescue ActiveSupport::MessageVerifier::InvalidSignature => ex
+        Rails.logger.error "invalid session cookie: #{cookie}"
+        Hash.new
+      rescue Exception => ex
+        Rails.logger.error "Exception parsing session from cookie: #{ex.message}"
+      end
+    end
+
+    def parse_token(token)
+      begin
+        decoded_token = verifier.verify(token)
+        ActiveSupport::JSON.decode(decoded_token)
+      rescue ActiveSupport::MessageVerifier::InvalidSignature => ex
+        Rails.logger.error "invalid session token: #{token}"
+        Hash.new
+      end
+    end
+
+    def session_key
+      Rails.application.config.session_options.key
+    end
+
+    def marshall
+      Rails.application.config.session_options[:coder]
+    end
+  end
+end

data/lib/alondra.rb

@@ -0,0 +1,80 @@
+require_relative 'alondra/message'
+require_relative 'alondra/event'
+require_relative 'alondra/connection'
+require_relative 'alondra/channel'
+require_relative 'alondra/command'
+require_relative 'alondra/command_dispatcher'
+require_relative 'alondra/event_router'
+require_relative 'alondra/message_queue_client'
+require_relative 'alondra/message_queue'
+require_relative 'alondra/pushing'
+require_relative 'alondra/event_listener'
+require_relative 'alondra/session_parser'
+require_relative 'alondra/listener_callback'
+require_relative 'alondra/push_controller'
+require_relative 'alondra/changes_callbacks'
+require_relative 'alondra/changes_push'
+require_relative 'alondra/server'
+
+module Alondra
+
+  ActiveRecord::Base.extend ChangesPush
+  ActionController::Base.send :include, Pushing
+
+  class Alondra < Rails::Engine
+
+    # Setting default configuration values
+    config.port         = Rails.env == 'test' ? 12346 : 12345
+    config.host         = 'localhost'
+    config.queue_socket = 'ipc:///tmp/alondra.ipc'
+
+    initializer "enable sessions for flash websockets" do
+      Rails.application.config.session_store :cookie_store, httponly: false
+    end
+
+    initializer "load listeners" do
+      listeners_dir = File.join(Rails.root, 'app', 'listeners')
+      
+      Rails.logger.info "Loading event listeners in #{listeners_dir}"
+      Dir[File.join(listeners_dir, '*.rb')].each { |file| require_dependency file }
+    end
+
+    def self.start_server_in_new_thread!
+      Thread.new do
+        start_server!
+      end
+    end
+
+    def self.start_server!
+      if EM.reactor_running?
+        EM.schedule do
+          MessageQueue.instance.start_listening
+          Server.run
+        end
+      else
+        Rails.logger.info "starting EM reactor"
+        EM.run do
+          MessageQueue.instance.start_listening
+          Server.run
+        end
+        die_gracefully_on_signal
+      end
+    end
+
+    def self.die_gracefully_on_signal
+      Signal.trap("INT")  do
+        Rails.logger.warn "INT signal trapped. Shutting down EM reactor"
+        EM.stop
+      end
+
+      Signal.trap("TERM") do
+        Rails.logger.warn "TERM signal trapped. Shutting down EM reactor"
+        EM.stop
+      end
+    end
+  end
+end
+
+
+
+

data/lib/generators/alondra/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate alondra Thing
+
+    This will create:
+        what/will/it/create

data/lib/generators/alondra/alondra_generator.rb

@@ -0,0 +1,7 @@
+class AlondraGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('../templates', __FILE__)
+
+  def generate_install
+    copy_file "alondra", "script/alondra"
+  end
+end