socky-server 0.4.1 → 0.5.0.beta1

data/bin/socky

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require File.join(File.dirname(File.expand_path(__FILE__)), '..', 'lib', 'socky')
-Socky::Runner.run

data/lib/em-websocket_hacks.rb

@@ -1,15 +0,0 @@
-if defined?(EventMachine::WebSocket::Debugger)
-  klass = EventMachine::WebSocket::Debugger
-else
-  klass = EventMachine::WebSocket::Connection
-end
-
-klass.class_eval do
-
-  def debug(*data)
-    if @debug
-      Socky.logger.debug "Socket " + data.flatten.collect{|line| line.to_s.gsub("\r\n","\n").gsub("\n","\\n")}.join(" ")
-    end
-  end
-
-end

data/lib/socky.rb

@@ -1,75 +0,0 @@
-require 'rubygems'
-require 'logger'
-require 'fileutils'
-require 'em-websocket'
-$:.unshift(File.dirname(__FILE__))
-require 'em-websocket_hacks'
-
-# Socky is a WebSocket server and client for Ruby on Rails 
-# @author Bernard "Imanel" Potocki
-# @see http://github.com/imanel/socky_gem main repository
-module Socky
-
-  class SockyError < StandardError; end #:nodoc:
-
-  # server version
-  VERSION = '0.4.1'
-
-  class << self
-    # read server-wide options
-    def options
-      @options ||= {}
-    end
-
-    # write server-wide options
-    def options=(val)
-      @options = val
-    end
-
-    # access or initialize logger
-    # default logger writes to STDOUT
-    def logger
-      return @logger if defined?(@logger) && !@logger.nil?
-      path = log_path
-      FileUtils.mkdir_p(File.dirname(path))
-      prepare_logger(path)
-    rescue
-      prepare_logger(STDOUT)
-    end
-
-    # overwrite default logger
-    def logger=(logger)
-      @logger = logger
-    end
-
-    # default log path
-    def log_path
-      options[:log_path] || nil
-    end
-
-    # default pid path
-    def pid_path
-      options[:pid_path] || File.join(%w( / var run socky.pid ))
-    end
-
-    # default config path
-    def config_path
-      options[:config_path] || File.join(%w( / var run socky.yml ))
-    end
-
-    private
-
-    def prepare_logger(output)
-      @logger = Logger.new(output)
-      @logger.level = Logger::INFO unless options[:debug]
-      @logger
-    end
-  end
-end
-
-require 'socky/misc'
-require 'socky/options'
-require 'socky/runner'
-require 'socky/connection'
-require 'socky/net_request'
-require 'socky/message'

data/lib/socky/connection.rb

@@ -1,137 +0,0 @@
-require 'json'
-require 'socky/connection/authentication'
-require 'socky/connection/finders'
-
-module Socky
-  # every connection to server creates one instance of Connection
-  class Connection
-    include Socky::Misc
-    include Socky::Connection::Authentication
-    extend Socky::Connection::Finders
-
-    # reference to connection socket
-    attr_reader :socket
-
-    class << self
-      # list of all connections in pool
-      # @return [Array] list of connections
-      def connections
-        @connections ||= []
-      end
-    end
-    
-    # initialize new connection
-    # @param [WebSocket] socket valid connection socket
-    def initialize(socket)
-      @socket = socket
-    end
-
-    # read query data from socket request
-    # @return [Hash] hash of query data
-    def query
-      socket.request["query"] || {}
-    end
-
-    # return if user appear to be admin
-    # this one should not be base to imply that user actually is
-    # admin - later authentication is needed
-    # @return [Boolean] is user claim to be admin?
-    def admin
-      ["true","1"].include?(query["admin"])
-    end
-
-    # client individual id - multiple connection can be organized
-    # by client id and later accessed at once
-    # @return [String] client id(might be nil)
-    def client
-      query["client_id"]
-    end
-
-    # client individual secret - used to check if user is admin
-    # and to sending authentication data to server(by subscribe_url)
-    # @return [String] client secret(might be nil)
-    def secret
-      query["client_secret"]
-    end
-
-    # client channel list - one client can have multiple channels
-    # every client have at last channel - if no channels are provided
-    # at default then user is assigned to nil channel
-    # @return [Array] list of client channels
-    def channels
-      @channels ||= query["channels"].to_s.split(",").collect(&:strip).reject(&:empty?)
-      @channels[0] ||= nil # Every user should have at last one channel
-      @channels
-    end
-
-    # check if client is valid and add him to pool or disconnect
-    def subscribe
-      debug [self.name, "incoming"]
-      subscribe_request
-    end
-
-    # remove client from pool and disconnect
-    def unsubscribe
-      debug [self.name, "terminated"]
-      unsubscribe_request
-    end
-
-    # check if client can send messages and process it
-    # @see Socky::Message.process
-    # @param [String] msg message to send in json format
-    def process_message(msg)
-      if admin && authenticated?
-        Socky::Message.process(self, msg)
-      else
-        self.send_message "You are not authorized to post messages"
-      end
-    end
-
-    # send message to client
-    # @param [Object] msg data to send(will be converted to json using to_json method)
-    def send_message(msg)
-      send_data({:type => :message, :body => msg})
-    end
-
-    # disconnect connection
-    def disconnect
-      socket.close_connection_after_writing
-    end
-
-    # convert connection to json(used in show_connection query)
-    # @param [Any] args it is required by different versions of ruby
-    # @return [JSon] id, client_id and channel list data
-    def to_json(*args)
-      {
-        :id => self.object_id,
-        :client_id => self.client,
-        :channels => self.channels.reject{|channel| channel.nil?}
-      }.to_json
-    end
-
-    private
-
-    def send_data(data)
-      json_data = data.to_json
-      debug [self.name, "sending data", json_data]
-      socket.send json_data
-    end
-
-    def connection_pool
-      self.class.connections
-    end
-
-    def in_connection_pool?
-      connection_pool.include?(self)
-    end
-
-    def add_to_pool
-      connection_pool << self unless self.admin || in_connection_pool?
-    end
-
-    def remove_from_pool
-      connection_pool.delete(self)
-    end
-
-  end
-end

data/lib/socky/connection/authentication.rb

@@ -1,99 +0,0 @@
-module Socky
-  class Connection
-    # authentication module - included in Socky::Connection
-    module Authentication
-      include Socky::Misc
-
-      # check if user is valid and then send him authentication data and add to pool
-      # if not then user is given failure response(so client javascript
-      # will know that is should not reconnect again) and then is disconnected
-      # admin user is automaticaly authenticated but isn't added to pool
-      # he will be authenticated when he will try to send message
-      # thanks to that admin don't need to wait for authentication confirmation
-      # on every connection so it will fasten things for him
-      def subscribe_request
-        send_subscribe_request do |response|
-          if response
-            debug [self.name, "authentication successed"]
-            add_to_pool
-            EventMachine.add_timer(0.1) do
-              send_authentication("success")
-            end
-            @authenticated_by_url = true
-          else
-            debug [self.name, "authentication failed"]
-            EventMachine.add_timer(0.1) do
-              send_authentication("failure")
-              disconnect
-            end
-          end
-        end unless admin || authenticated?
-      end
-
-      # if user is authenticated then he is removed from pool and 
-      # unsubscribe notification is sent to server unless he is admin
-      # if user is not authenticated then nothing will happen
-      def unsubscribe_request
-        if authenticated?
-          remove_from_pool
-          send_unsubscribe_request{} unless admin
-        end
-      end
-
-      # if user is admin then his secred is compared with server secred
-      # in user isn't admin then it checks if user is authenticated by
-      # server request(defaults to true if subscribe_url is nil)
-      def authenticated?
-        @authenticated ||= (admin ? authenticate_as_admin : authenticate_as_user)
-      end
-
-      private
-
-      def send_authentication(msg)
-        send_data({:type => :authentication, :body => msg})
-      end
-
-      def authenticate_as_admin
-        options[:secret].nil? || secret == options[:secret]
-      end
-
-      def authenticate_as_user
-        authenticated_by_url?
-      end
-
-      def authenticated_by_url?
-        @authenticated_by_url
-      end
-
-      def send_subscribe_request(&block)
-        subscribe_url = options[:subscribe_url]
-        if subscribe_url
-          debug [self.name, "sending subscribe request to", subscribe_url]
-          Socky::NetRequest.post(subscribe_url, params_for_request, &block)
-          true
-        else
-          yield true
-        end
-      end
-
-      def send_unsubscribe_request(&block)
-        unsubscribe_url = options[:unsubscribe_url]
-        if unsubscribe_url
-          debug [self.name, "sending unsubscribe request to", unsubscribe_url]
-          Socky::NetRequest.post(unsubscribe_url, params_for_request, &block)
-        else
-          yield true
-        end
-      end
-
-      def params_for_request
-        {
-          :client_id => client,
-          :client_secret => secret,
-          :channels => channels
-        }.reject{|key,value| value.nil? || value.empty?}
-      end
-
-    end
-  end
-end

data/lib/socky/connection/finders.rb

@@ -1,67 +0,0 @@
-module Socky
-  class Connection
-    # finders module - extends Socky::Connection
-    module Finders
-
-      # Return list of all connections
-      def find_all
-        Socky::Connection.connections
-      end
-
-      # Return filtered list of connections
-      # @param [Hash] opts the options for filters.
-      # @option opts [Hash] :to ({}) return only listed clients/channels. keys supported: clients, channels
-      # @option opts [Hash] :except ({}) return all clients/channels except listed. keys supported: clients, channels
-      # @return [Array] list of connections
-      # @example return all connections
-      #   Socky::Connection.find
-      # @example return no connections
-      #   # empty array as param means "no channels"
-      #   # nil is handles as "ignore param" so all clients/channels will be executed
-      #   Socky::Connection.find(:to => { :clients => [] })
-      #   Socky::Connection.find(:to => { :channels => [] })
-      # @example return connections of users "first" and "second" from channels "some_channel"
-      #   Socky::Connection.find(:to => { :clients => ["first","second"], :channels => "some_channel" })
-      # @example return all connections from channel "some_channel" except of ones belonging to "first"
-      #   Socky::Connection.find(:to => { :channels => "some_channel" }, :except => { :clients => "first" })
-      def find(opts = {})
-        to = symbolize_keys(opts[:to]) || {}
-        exclude = symbolize_keys(opts[:except]) || {}
-
-        connections = find_all
-        connections = filter_by_clients(connections, to[:clients], exclude[:clients])
-        connections = filter_by_channels(connections, to[:channels], exclude[:channels])
-
-        connections
-      end
-
-      private
-
-      def filter_by_clients(connections, included_clients = nil, excluded_clients = nil)
-        # Empty table means "no users" - nil means "all users"
-        return [] if (included_clients.is_a?(Array) && included_clients.empty?)
-
-        included_clients = Array(included_clients)
-        excluded_clients = Array(excluded_clients)
-
-        connections.find_all do |connection|
-          connection if (included_clients.empty? || included_clients.include?(connection.client)) && !excluded_clients.include?(connection.client)
-        end
-      end
-
-      def filter_by_channels(connections, included_channels = nil, excluded_channels = nil)
-        # Empty table means "no channels" - nil means "all channels"
-        return [] if (included_channels.is_a?(Array) && included_channels.empty?)
-
-        included_channels = Array(included_channels)
-        excluded_channels = Array(excluded_channels)
-
-        connections.find_all do |connection|
-          connection if connection.channels.any? do |channel|
-            (included_channels.empty? || included_channels.include?(channel) ) && !excluded_channels.include?(channel)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/socky/message.rb

@@ -1,85 +0,0 @@
-require 'json'
-
-module Socky
-  # every message from admin is stored as instance of Message
-  # and then processed by #process method
-  class Message
-    include Socky::Misc
-
-    class InvalidJSON < Socky::SockyError; end #:nodoc:
-    class UnauthorisedQuery < Socky::SockyError; end #:nodoc:
-    class InvalidQuery < Socky::SockyError; end #:nodoc:
-
-    # message params like command type or message content
-    attr_reader :params
-    # message sender(admin) required when some data are returned
-    attr_reader :creator
-
-    class << self
-      # create new message and process it
-      # @see #process
-      # @param [Connection] connection creator of message
-      # @param [String] message message content
-      def process(connection, message)
-        message = new(connection, message)
-        message.process
-      rescue SockyError => error
-        error connection.name, error
-        connection.send_message(error.message)
-      end
-    end
-
-    # initialize new message
-    # @param [Connection] creator creator of message
-    # @param [String] message valid json containing hash of params
-    # @raise [InvalidJSON] if message is invalid json or don't evaluate to hash
-    def initialize(creator, message)
-      @params = symbolize_keys(JSON.parse(message)) rescue raise(InvalidJSON, "invalid request")
-      @creator = creator
-    end
-
-    # process message - check command('broadcast' or 'query')
-    # and send message to correct connections
-    # 'broadcast' command require 'body' of message and allows 'to' and 'except' hashes for filters
-    # 'query' command require 'type' of query - currently only 'show_connections' is supported
-    # @see Socky::Connection::Finders.find filtering options
-    # @raise [InvalidQuery, 'unknown command'] when 'command' param is invalid
-    # @raise [InvalidQuery, 'unknown query type'] when 'command' is 'queru' but no 'type' is provided
-    def process
-      debug [self.name, "processing", params.inspect]
-
-      case params.delete(:command).to_s
-        when "broadcast" then broadcast
-        when "query" then query
-        else raise(InvalidQuery, "unknown command")
-      end
-    end
-
-    private
-
-    def broadcast
-      connections = Socky::Connection.find(params)
-      send_message(params[:body], connections)
-    end
-
-    def query
-      case params[:type].to_s
-        when "show_connections" then query_show_connections
-        else raise(InvalidQuery, "unknown query type")
-      end
-    end
-
-    def query_show_connections
-      respond Socky::Connection.find_all
-    end
-
-    def respond(message)
-      creator.send_message(message)
-    end
-
-    def send_message(message, connections)
-      connections.each{|connection| connection.send_message message}
-    end
-
-  end
-end