colossus 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9ea35d4325a20e16ba03e449605e9afb9fef70cb
+  data.tar.gz: 4624e6e7bea9aab4bc858cd81663e7f5f4e28b42
+SHA512:
+  metadata.gz: e4d5d0f2cb89a7a033ab391d5d93c865bc743d5a19934227a134442d25508018249229334559ee48fedd57cc0d15a3fe59e781f3ac39618819ffd841682a3ea3
+  data.tar.gz: ab60db5e7d318ef1f32934dba3e0076773e2b50fafc01f2e3ba689ccdbc7fd5841dab8cedd7e1bc557d80e64534e1fb23328f945571afbec002368d97e3a4e1a

data/lib/colossus.rb

@@ -0,0 +1,95 @@
+require 'observer'
+require 'openssl'
+
+require 'colossus/configuration'
+require 'colossus/verifier'
+require 'colossus/writer_client'
+
+require 'colossus/engines/memory/memory'
+require 'colossus/engines/memory/client_session'
+require 'colossus/engines/memory/client_session_store'
+
+require 'colossus/faye/extension'
+
+# Top Level Class.
+# The public API of the Gem.
+class Colossus
+  include Observable
+
+  attr_reader :engine, :verifier
+
+  # Initialize Colossus
+  #
+  # @param ttl [Integer] the seconds before a user without emitting heartbeat
+  #   is considered disconnected
+  #
+  # @param engine [Engine] the engine which implements the needed methods
+  #   to work with Colossus
+  #
+  # @return [Colossus]
+  def initialize(ttl          = Colossus.config.ttl,
+                 engine       = Colossus.config.engine,
+                 secret       = Colossus.config.secret_key,
+                 writer_token = Colossus.config.writer_token)
+    @engine = engine.new(ttl.to_i)
+    @engine.add_observer(self)
+    @verifier = Colossus::Verifier.new(secret, writer_token)
+  end
+
+  # Set the status of a user on a specificed client. A client could be
+  # a Websocket session (if the user has 2 tabs opened) or anything else.
+  #
+  # @param user_id [#to_s] The unique identifier of a user
+  # @param client_id [#to_s] The unique identifier of a client
+  # @param status [#to_s] The status of a the user, it can be active,
+  #   away or disconnected.
+  #
+  # @return [Boolean] Return true if the status has changed if not false.
+  def set(user_id, client_id, status)
+    engine.set(user_id.to_s, client_id.to_s, status.to_s)
+  end
+
+  # Get the status of a specified user, it analyzes the status
+  #   of all the sessions.
+  #   It returns :
+  #
+  #   - active if one or more clients are active.
+  #   - away if one or more clients are away.
+  #   - disconnected.
+  #
+  # @param user_id [#to_s] The unique identifier of a user
+  #
+  # @return status [String]
+  def get(user_id)
+    engine.get(user_id.to_s)
+  end
+
+  # @param user_ids [Array<#to_s>] An array of user ids
+  # (see #get)
+  def get_multi(*user_ids)
+    engine.get_multi(user_ids.map(&:to_s))
+  end
+
+  # @return Hash{String => String} User_id keys, statuses values
+  def get_all
+    engine.get_all
+  end
+
+  # Reset all the data (useful for specs)
+  def reset!
+    engine.reset!
+  end
+
+  # Generate a token for the given user_id
+  def generate_user_token(user_id)
+    verifier.generate_user_token(user_id)
+  end
+
+  # Method used when the engine notify a change
+  #
+  # @!visibility private
+  def update(user_id, status)
+    changed
+    notify_observers(user_id, status)
+  end
+end

data/lib/colossus/configuration.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# Main Colossus module
+class Colossus
+  # Handles all the configuration
+  class Configuration
+    attr_accessor :ttl, :seconds_before_ttl_check, :engine,
+                  :secret_key, :writer_token
+
+    def initialize
+      @ttl = 10
+      @seconds_before_ttl_check = 2
+      @engine = Colossus::Engine::Memory
+      @secret_key = ''
+      @writer_token = ''
+    end
+  end # class Configuration
+
+  def self.configure
+    yield(configuration) if block_given?
+    configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.config
+    configuration
+  end
+
+  # Help ?
+  # rubocop:disable TrivialAccessors
+  def self.configuration=(configuration)
+    @configuration = configuration
+  end
+  # rubocop:enable
+
+  def self.config=(configuration)
+    self.configuration = configuration
+  end
+
+  def self.reset_configuration
+    @configuration = Configuration.new
+  end
+end # Colossus

data/lib/colossus/engines/memory/client_session.rb

@@ -0,0 +1,20 @@
+class Colossus
+  module Engine
+    class Memory
+      # Represent the status and the information of a given user.
+      class ClientSession
+        attr_reader :status, :last_seen
+
+        def initialize
+          @status = 'disconnected'
+          @last_seen = Time.now
+        end
+
+        def status=(given_status)
+          @last_seen = Time.now
+          @status    = given_status
+        end
+      end
+    end
+  end
+end

data/lib/colossus/engines/memory/client_session_store.rb

@@ -0,0 +1,55 @@
+class Colossus
+  module Engine
+    class Memory
+      # Represents all the different sessions of a user. It can find
+      #  the global status of the user given all the different status.
+      class ClientSessionStore
+        attr_reader :last_status
+        attr_accessor :sessions
+
+        def initialize
+          @sessions = Hash.new do |hash, key|
+            hash[key] = Colossus::Engine::Memory::ClientSession.new
+          end
+          @last_status = 'disconnected'
+        end
+
+        def status
+          sessions.values.reduce('disconnected') do |memo, session|
+            case session.status
+            when 'active'
+              session.status
+            when 'away'
+              memo == 'active' ? memo : session.status
+            else
+              memo
+            end
+          end
+        end
+
+        def last_seen
+          sessions.values.reduce(Time.new(0)) do |memo, session|
+            session.last_seen > memo ? session.last_seen : memo
+          end
+        end
+
+        def status_changed?
+          last_status != status
+        end
+
+        def [](session_id)
+          sessions[session_id]
+        end
+
+        def []=(session_id, session_status)
+          @last_status = status
+          sessions[session_id].status = session_status
+        end
+
+        def delete(session_id)
+          sessions.delete(session_id)
+        end
+      end
+    end
+  end
+end

data/lib/colossus/engines/memory/memory.rb

@@ -0,0 +1,96 @@
+class Colossus
+  module Engine
+    # The Memory Engine is a non-distributed engine.
+    # Based on EventMachine in order to provide the ttl to
+    # disconnect clients.
+    class Memory
+      include Observable
+
+      attr_reader :client_sessions, :ttl, :mutex
+
+      def initialize(ttl)
+        @client_sessions = Hash.new do |hash, key|
+          hash[key] = Colossus::Engine::Memory::ClientSessionStore.new
+        end
+        @ttl       = ttl
+        @mutex     = Mutex.new
+      end
+
+      def user_changed(user_id, status)
+        changed
+        notify_observers(user_id, status)
+      end
+
+      def set(user_id, client_id, given_status)
+        mutex.synchronize do
+          if given_status == 'disconnected'
+            client_sessions[user_id].delete(client_id)
+          else
+            client_sessions[user_id][client_id] = given_status
+          end
+        end
+
+        if client_sessions[user_id].status_changed?
+          status = client_sessions[user_id].status
+          delete(user_id) if status == 'disconnected'
+          user_changed(user_id, status)
+          return true
+        end
+
+        false
+      end
+
+      def get(user_id)
+        client_sessions[user_id]
+      end
+
+      def get_multi(*user_ids)
+        user_ids.map { |user_id| get(user_id) }
+      end
+
+      def get_all
+        statuses = {}
+        client_sessions.each_pair do |user_id, session_store|
+          statuses[user_id] = session_store.status
+        end
+        statuses
+      end
+
+      def delete(user_id)
+        mutex.synchronize do
+          client_sessions.delete(user_id)
+        end
+      end
+
+      def reset!
+        mutex.synchronize do
+          @client_sessions = Hash.new do |hash, key|
+            hash[key] = Colossus::Engine::Memory::ClientSessionStore.new
+          end
+        end
+      end
+
+      def new_periodic_ttl
+        secs_ttl = Colossus.config.seconds_before_ttl_check
+        @periodic_ttl = EM::Synchrony.add_periodic_timer(secs_ttl) do
+          client_sessions.each_pair do |user_id, session_store|
+            sessions_dupped = session_store.sessions.dup
+
+            session_store.sessions.each_pair do |session_id, session|
+              if (session.last_seen + ttl) < Time.now
+                sessions_dupped.delete(session_id)
+              end
+            end
+
+            mutex.synchronize { session_store.sessions = sessions_dupped }
+
+            if (session_store.last_seen + ttl) < Time.now
+              delete(user_id)
+              user_changed(user_id, 'disconnected')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/colossus/faye/extension.rb

@@ -0,0 +1,162 @@
+class Colossus
+  module Faye
+    # Faye extension implementing all the presence, authorization,
+    # authentification and push logic.
+    class Extension
+      attr_reader :colossus, :faye, :faye_client
+
+      VALID_STATUSES = %w(disconnected away active).freeze
+
+      def initialize(faye, colossus = Colossus.new)
+        @colossus = colossus
+        @faye     = faye
+        faye.add_extension(self)
+        @faye_client = faye.get_client
+        colossus_faye_extension = Colossus::WriterClient::FayeExtension.
+          new(colossus.verifier.writer_token)
+        faye_client.add_extension(colossus_faye_extension)
+      end
+
+      def incoming(message, _request, callback)
+        if !acceptable?(message)
+          handle_invalid_token(message)
+          message.delete('data')
+          message.delete('ext')
+        elsif message['ext']['user_token']
+          handle_user_action(message)
+          message.delete('data')
+          message.delete('ext')
+        elsif message['ext']['writer_token']
+          handle_server_action(message)
+          message.delete('ext')
+        end
+
+        callback.call(message)
+      end
+
+      def acceptable?(message)
+        message['ext'] &&
+          (message['ext']['user_token'] ||
+           message['ext']['writer_token'])
+      end
+
+      def handle_user_action(message)
+        if message['channel'] == '/meta/subscribe'
+          handle_subscribe(message)
+        elsif message['channel'].start_with?('/meta/')
+          message
+        elsif message['channel'].start_with?('/users/')
+          handle_set_status(message)
+        else
+          message['error'] = 'Unknown Action'
+        end
+
+        message
+      end
+
+      def handle_server_action(message)
+        token = message['ext'] && message['ext']['writer_token']
+
+        unless token && colossus.verifier.verify_writer_token(token)
+          message['error'] = 'Invalid Token'
+          message.delete('data')
+          return message
+        end
+
+        if message['channel'].start_with?('/meta/')
+          message.delete('data')
+          message
+        elsif message['channel'].start_with?('/presences/request/')
+          handle_presence_request(message)
+        elsif message['channel'].start_with?('/presences/response/')
+          handle_presence_response(message)
+        elsif message['channel'].start_with?('/users/')
+          handle_publish(message)
+        else
+          message['error'] = 'Unknown Action'
+          message.delete('data')
+        end
+
+        message
+      end
+
+      def handle_presence_request(message)
+        user_ids    = message['data'] && message['data']['user_ids']
+        presence_id = message['channel'].partition('/presences/request/').last
+
+        if user_ids && user_ids.is_a?(Array)
+          statuses = colossus.get_multi(user_ids)
+          message['data'].delete('user_ids')
+          faye_client.publish("/presences/response/#{presence_id}", { 'statuses' => Hash[user_ids.zip(statuses)] })
+          message
+        elsif user_ids == nil
+          statuses = colossus.get_all
+          faye_client.publish("/presences/response/#{presence_id}", { 'statuses' => statuses })
+          message
+        else
+          message.delete('data')
+          message['error'] = 'Invalid user_ids data'
+          message
+        end
+      end
+
+      def handle_presence_response(message)
+        message
+      end
+
+      def handle_publish(message)
+        message
+      end
+
+      def handle_invalid_token(message)
+        message['error'] = 'Invalid Token'
+        message
+      end
+
+      def handle_subscribe(message)
+        token   = message['ext']['user_token']
+        user_id = message['subscription'].partition('/users/').last
+
+        if invalid_user_channel?(user_id)
+          message['error'] = 'The only accepted channel_name is users/:user_id'
+          return message
+        end
+
+        unless colossus.verifier.verify_token(token, user_id)
+          message['error'] = 'Invalid Token'
+        end
+
+        message
+      end
+
+      def handle_set_status(message)
+        token   = message['ext']['user_token']
+        user_id = message['channel'].partition('/users/').last
+        status  = message['data'] && message['data']['status']
+
+        if invalid_user_channel?(user_id)
+          message['error'] = 'The only accepted channel_name is users/:user_id'
+          return message
+        end
+
+        unless status && VALID_STATUSES.include?(status)
+          message['error'] = 'Invalid Status'
+          return message
+        end
+
+        unless colossus.verifier.verify_token(token, user_id)
+          message['error'] = 'Invalid Token'
+          return message
+        end
+
+        colossus.set(user_id, message['clientId'], status)
+
+        message
+      end
+
+      def invalid_user_channel?(user_id)
+        user_id.empty? || user_id.include?('*') || user_id.include?('/')
+      end
+    end
+  end
+end

data/lib/colossus/verifier.rb

@@ -0,0 +1,31 @@
+class Colossus
+  # Implements the verification logic based on SHA1 in order
+  # to avoid timing attacks. (cf Faye doc)
+  class Verifier
+    attr_reader :sha1, :secret, :writer_token
+
+    def initialize(secret = Colossus.config.secret_key,
+                   writer_token = Colossus.config.writer_token)
+      @sha1         = OpenSSL::Digest.new('sha1')
+      @secret       = secret
+      @writer_token = writer_token
+    end
+
+    def verify_token(token_given, user_id)
+      expected_token = generate_user_token(user_id)
+      expected_hash  = Digest::SHA1.hexdigest(expected_token)
+      actual_hash    = Digest::SHA1.hexdigest(token_given)
+      expected_hash == actual_hash
+    end
+
+    def verify_writer_token(token_given)
+      expected_hash  = Digest::SHA1.hexdigest(writer_token)
+      actual_hash    = Digest::SHA1.hexdigest(token_given)
+      expected_hash == actual_hash
+    end
+
+    def generate_user_token(user_id)
+       OpenSSL::HMAC.hexdigest(sha1, secret, user_id)
+    end
+  end
+end

data/lib/colossus/version.rb

@@ -0,0 +1,4 @@
+# The Version
+class Colossus
+  VERSION = '0.0.1'
+end

data/lib/colossus/writer_client.rb

@@ -0,0 +1,62 @@
+class Colossus
+  class WriterClient
+    attr_reader :url, :writer_token, :time_out
+
+    def initialize(url, writer_token, time_out = 2)
+      @url          = url
+      @writer_token = writer_token
+      @time_out     = time_out
+    end
+
+    def get_presences(optional_user_ids = nil)
+      user_ids = Array(optional_user_ids) if optional_user_ids
+      unique_token = generate_unique_token
+      EM.synchrony do
+        EM::Synchrony.add_timer(time_out) { raise "Presence request timed out" }
+        EM::Synchrony.sync(faye_client.subscribe("/presences/response/#{unique_token}") { |message| return message['statuses'] })
+        EM::Synchrony.sync(faye_client.publish("/presences/request/#{unique_token}", user_ids))
+      end
+    end
+
+    def push_message(user_ids, message)
+      user_ids = Array(user_ids)
+      EM.synchrony do
+        user_ids.each do |user_id|
+          EM::Synchrony.sync(faye_client.publish("/users/#{user_id}", message))
+        end
+        EM.stop
+      end
+    end
+
+    private
+
+    def faye_client
+      faye_client  = ::Faye::Client.new(url)
+      faye_client.add_extension(FayeExtension.new(writer_token))
+      faye_client
+    end
+
+    def generate_unique_token
+      SecureRandom.hex(8)
+    end
+
+    class FayeExtension
+      attr_reader :token
+
+      def initialize(token)
+        @token = token
+      end
+
+      def incoming(message, callback)
+        callback.call(message)
+      end
+
+      def outgoing(message, callback)
+        message['ext'] ||= {}
+        message['ext']['writer_token'] = 'WRITER_TOKEN'
+
+        callback.call(message)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: colossus
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- antoinelyset
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faye
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Colossus is a Push and Presence pure Ruby server. It uses Faye internally.
+email:
+- antoinelyset+github@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/colossus.rb
+- lib/colossus/configuration.rb
+- lib/colossus/engines/memory/client_session.rb
+- lib/colossus/engines/memory/client_session_store.rb
+- lib/colossus/engines/memory/memory.rb
+- lib/colossus/faye/extension.rb
+- lib/colossus/verifier.rb
+- lib/colossus/version.rb
+- lib/colossus/writer_client.rb
+homepage: https://github.com/antoinelyset/colossus
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Colossus, Web Push & Presence made easy.
+test_files: []
+has_rdoc: