socky-server 0.4.1 → 0.5.0.beta1

data/lib/socky/server/channel/private.rb

@@ -0,0 +1,44 @@
+module Socky
+  module Server
+    class Channel
+      class Private < Public
+                
+        protected
+        
+        def check_auth(connection, message)
+          return false unless message.auth.is_a?(String) && message.auth.length > 1
+          
+          hash = self.hash_from_message(connection, message)
+          begin
+            auth = Socky::Authenticator.new(hash, :allow_changing_rights => true, :secret => self.application.secret)
+            auth.salt = message.auth.split(':',2)[0]
+            auth = auth.result
+          rescue ArgumentError => e
+            auth = nil
+          end
+          
+          return false unless auth.is_a?(Hash)
+          
+          auth['auth'] == message.auth
+        end
+        
+        def hash_from_message(connection, message)
+          hash = {
+            'connection_id' => connection.id,
+            'channel' => message.channel
+          }
+          hash.merge!( rights(message) )
+          hash
+        end
+        
+        def rights(message)
+          r = super
+          r.merge!( 'read' => !!message.read ) unless message.read.nil?
+          r.merge!( 'write' => !!message.write ) unless message.write.nil?
+          r
+        end
+
+      end
+    end
+  end
+end

data/lib/socky/server/channel/public.rb

@@ -0,0 +1,43 @@
+module Socky
+  module Server
+    class Channel
+      class Public < Base
+      
+        def subscribe(connection, message)
+          if self.check_auth(connection, message)
+            self.subscribe_successful(connection, message)
+          else
+            self.subscribe_failed(connection)
+          end
+        end
+        
+        def unsubscribe(connection, message)
+          if self.connected?(connection)
+            unsubscribe_successful(connection)
+          else
+            unsubscribe_failed(connection)
+          end
+        end
+        
+        protected
+        
+        def connected?(connection)
+          !!self.subscribers[connection.id]
+        end
+        
+        def check_auth(connection, message)
+          true
+        end
+        
+        def rights(message)
+          {
+            'read' =>  true,
+            'write' => false,
+            'hide' =>  false
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/socky/server/channel/stub.rb

@@ -0,0 +1,17 @@
+module Socky
+  module Server
+    class Channel
+      class Stub < Base
+      
+        def subscribe(connection, message)
+          self.subscribe_failed(connection)
+        end
+      
+        def unsubscribe(connection, message)
+          self.unsubscribe_failed(connection)
+        end
+
+      end
+    end
+  end
+end

data/lib/socky/server/config.rb

@@ -0,0 +1,52 @@
+require 'yaml'
+
+module Socky
+  module Server
+    class Config
+      
+      # Each config key calls corresponding method with value as param
+      def initialize(config = {})
+        return unless config.is_a?(Hash)
+        
+        # Config file should be readed first
+        file = config.delete(:config_file)
+        self.config_file(file) unless file.nil?
+        
+        config.each { |key, value| self.send(key, value) if self.respond_to?(key) }
+      end
+      
+      # Enable or disable debug
+      def debug(arg)
+        Logger.enabled = !!arg
+      end
+      
+      # List of applications if Hash form where key is app name
+      # and value is app secret.
+      # @example valid hash
+      #   { 'my_app_name' => 'my_secret' }
+      def applications(arg)
+        raise ArgumentError, 'expected Hash' unless arg.is_a?(Hash)
+        
+        arg.each do |app_name, app_secret|
+          Socky::Server::Application.new(app_name.to_s, app_secret.to_s)
+        end
+      end
+      
+      # Reads config file
+      # This should be evaluated before other methods to prevent
+      # overriding settings by config ones(config should have lower priority)
+      def config_file(path)
+        raise ArgumentError, 'expected String' unless path.is_a?(String)
+        raise ArgumentError, "config file not found: #{path}" unless File.exists?(path)
+        
+        begin
+          config = YAML.load_file(path)
+        rescue Exception
+          raise ArgumentError, 'invalid config file'
+        end
+        
+        Config.new(config)
+      end
+    end
+  end
+end

data/lib/socky/server/connection.rb

@@ -0,0 +1,66 @@
+module Socky
+  module Server
+    class Connection
+      include Misc
+    
+      attr_accessor :id, :application
+    
+      # initialize new connection
+      # @param [Socky::Server::WebSocket] socket websocket connection
+      # @param [String] app_name connection application name
+      def initialize(socket, app_name)
+        @socket = socket
+        @application = Application.find(app_name)
+      
+        unless @application.nil?
+          @id = self.generate_id
+          @application.add_connection(self)
+        end
+      
+        self.send_data(initialization_status)
+        @socket.close_websocket if @application.nil?
+      end
+    
+      # return info about connection initialization
+      # if successfull then it will return hash with connection id
+      # otherwise it will return reson why connecton has failed
+      def initialization_status
+        if @application && @id
+          { 'event' => 'socky:connection:established', 'connection_id' => @id }
+        else
+          { 'event' => 'socky:connection:error', 'reason' => 'refused' }
+        end
+      end
+    
+      # list of channels connection is subscribed to
+      def channels
+        @channels ||= {}
+      end
+    
+      # send data to connection
+      # @param [String] data data to send
+      def send_data(data)
+        @socket.send_data(data)
+      end
+    
+      # remove connection from application
+      def destroy
+        log('connection closing', @id)
+        if @application
+          @application.remove_connection(self)
+          @application = nil
+        end
+        self.channels.values.each do |channel|
+          channel.remove_subscriber(self)
+        end
+      end
+    
+      # generate new id
+      # @return [String] connection id
+      def generate_id
+        @id = Time.now.to_f.to_s.gsub('.', '')
+      end
+    
+    end
+  end
+end

data/lib/socky/server/http.rb

@@ -0,0 +1,95 @@
+module Socky
+  module Server
+    class HTTP
+      include Misc
+      
+      class ConnectionError < RuntimeError; attr_accessor :status; end
+      
+      DEFAULT_OPTIONS = {
+        :debug => false,
+        :timestamp_deviation => 10
+      }
+      
+      def initialize(options = {})
+        @options = DEFAULT_OPTIONS.merge(options)
+        Config.new(@options)
+      end
+      
+      def call(env)
+        request = Rack::Request.new(env.merge('CONTENT_TYPE' => nil))
+        @params = request.params
+        log("received", @params)
+        
+        @app_name = request.path.split('/').last
+        
+        check_app
+        check_channel
+        
+        check_timestamp
+        check_auth
+        
+        channel = Channel.find_or_create(@app_name, @params['channel'])
+        channel.deliver(nil, Message.new(nil, @params))
+        
+        [202, {}, ['Event sent']]
+      rescue ConnectionError => e
+        [ e.status, {}, [e.message] ]
+      rescue Exception
+        [ 500, {}, ['Unknown error'] ]
+      end
+      
+      private
+      
+      def app
+        @app ||= Application.find(@app_name)
+      end
+      
+      def check_app
+        error = ConnectionError.new 'Application not found'
+        error.status = 404
+        
+        raise error if app.nil?
+      end
+      
+      def check_channel
+        error = ConnectionError.new 'No channel provided'
+        error.status = 400
+        
+        raise error unless @params['channel']
+      end
+      
+      def check_timestamp
+        error = ConnectionError.new 'Invalid timestamp'
+        error.status = 401
+        
+        timestamp = @params['timestamp'].to_i
+        current_time = Time.now.to_i
+        min_time = current_time - (@options[:timestamp_deviation] * 60)
+        max_time = current_time + (@options[:timestamp_deviation] * 60)
+        
+        raise error unless timestamp > min_time && timestamp < max_time
+      end
+      
+      def check_auth
+        error = ConnectionError.new 'Invalid auth token'
+        error.status = 401
+        
+        auth = @params['auth']
+        authenticator = Authenticator.new({
+          :connection_id => @params['timestamp'],
+          :channel => @params['channel'],
+          :event => @params['event'],
+          :data => @params['data']
+        }, {
+          :secret => app.secret,
+          :method => :http
+        })
+        authenticator.salt = @params['auth'].split(':',2)[0]
+        result = authenticator.result
+        
+        raise error unless result.is_a?(Hash) && result['auth'] == auth
+      end
+      
+    end
+  end
+end

data/lib/socky/server/logger.rb

@@ -0,0 +1,24 @@
+module Socky
+  module Server
+    module Logger    
+      class << self
+      
+        def enabled?
+          @enabled ||= false
+        end
+    
+        def enabled=(val)
+          @enabled = val
+        end
+    
+        def log(*args)
+          if Socky::Server::Logger.enabled?
+            msg = ['Socky'] + args
+            puts msg.join(' : ')
+          end
+        end
+      
+      end
+    end
+  end
+end

data/lib/socky/server/message.rb

@@ -0,0 +1,35 @@
+module Socky
+  module Server
+    class Message
+      include Misc
+    
+      def initialize(connection, data)
+        @connection = connection
+        @data = data.is_a?(Hash) ? data : JSON.parse(data) rescue nil
+        @data ||= {}
+      end
+    
+      def dispath
+        case self.event
+          when 'socky:subscribe' then Channel.find_or_create(@connection.application.name, self.channel).subscribe(@connection, self)
+          when 'socky:unsubscribe' then Channel.find_or_create(@connection.application.name, self.channel).unsubscribe(@connection, self)
+        else
+          unless self.event.match(/\Asocky:/)
+            Channel.find_or_create(@connection.application.name, self.channel).deliver(@connection, self)
+          end
+        end
+      end
+    
+      # Data from @data part:
+    
+      def event; @data['event'].to_s; end
+      def channel; @data['channel'].to_s; end
+      def user_data; @data['data']; end
+      def auth; @data['auth']; end
+      def read; @data['read']; end
+      def write; @data['write']; end
+      def hide; @data['hide']; end
+    
+    end
+  end
+end

data/lib/socky/server/misc.rb

@@ -0,0 +1,18 @@
+module Socky
+  module Server
+    module Misc
+    
+      # extend including class by itself
+      def self.included(base)
+        base.extend Socky::Server::Misc
+      end
+    
+      # log message
+      # @param [Array] args data for logging
+      def log(*args)
+        Logger.log *args
+      end
+    
+    end
+  end
+end

data/lib/socky/server/version.rb

@@ -0,0 +1,5 @@
+module Socky
+  module Server
+    VERSION = '0.5.0.beta1'
+  end
+end

data/lib/socky/server/websocket.rb

@@ -0,0 +1,43 @@
+module Socky
+  module Server
+    class WebSocket < ::Rack::WebSocket::Application
+      include Misc
+
+      DEFAULT_OPTIONS = {
+        :debug => false
+      }
+      
+      attr_reader :connection
+    
+      def initialize(*args)
+        super
+        
+        Config.new(@options)
+      end
+    
+      # Called when connection is opened
+      def on_open(env)
+        app_name = env['PATH_INFO'].split('/').last
+        @connection = Connection.new(self, app_name)
+      end
+    
+      # Called when message is received
+      def on_message(env, msg)
+        log("received", msg)
+        Message.new(@connection, msg).dispath
+      end
+    
+      # Called when client closes clonnecton
+      def on_close(env)
+        @connection.destroy if @connection
+      end
+    
+      # Send JSON-encoded data instead of clear text
+      def send_data(data)
+        jsonified_data = data.to_json
+        log('sending', jsonified_data)
+        super(jsonified_data)
+      end
+    end
+  end
+end