socky 0.2.1 → 0.4.0

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.collect do |connection|
-          connection if (included_clients.empty? || included_clients.include?(connection.client)) && !excluded_clients.include?(connection.client)
-        end.compact
-      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.collect do |connection|
-          connection if connection.channels.any? do |channel|
-            (included_channels.empty? || included_channels.include?(channel) ) && !excluded_channels.include?(channel)
-          end
-        end.compact
-      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

data/lib/socky/misc.rb

@@ -1,74 +0,0 @@
-module Socky
-  # common methods for all other classes
-  module Misc
-
-    # extend including class by itself
-    def self.included(base)
-      base.extend Socky::Misc
-    end
-
-    # return server-wide options
-    # @see Socky.options
-    def options
-      Socky.options
-    end
-
-    # write server-wide options
-    def options=(ob)
-      Socky.options = ob
-    end
-
-    # return name of current object
-    # @example when included in connection
-    #   @connection.name #=> "Connection(2149785820)"
-    def name
-      "#{self.class.to_s.split("::").last}(#{self.object_id})"
-    end
-
-    # return log path
-    def log_path
-      Socky.log_path
-    end
-
-    # return pid path
-    def pid_path
-      Socky.pid_path
-    end
-
-    # return config path
-    def config_path
-      Socky.config_path
-    end
-
-    # log message at info level
-    # @param [Array] args data for logging
-    def info(args)
-      Socky.logger.info args.join(" ")
-    end
-
-    # log message at debug level
-    # @param [Array] args data for logging
-    def debug(args)
-      Socky.logger.debug args.join(" ")
-    end
-
-    # log message at error level
-    # @param [String] name object name with raised error
-    # @param [Error] error error instance that was raised
-    def error(name, error)
-      debug [name, "raised:", error.class, error.message]
-    end
-
-    # convert keys of hash to symbol
-    # @param [Hash] hash hash to symbolize
-    # @return [Hash] with symbolized keys
-    # @return [Object] if hash isn't instance of Hash
-    def symbolize_keys(hash)
-      return hash unless hash.is_a?(Hash)
-      hash.inject({}) do |options, (key, value)|
-        options[(key.to_sym if key.respond_to?(:to_sym)) || key] = value
-        options
-      end
-    end
-  end
-end

data/lib/socky/net_request.rb

@@ -1,27 +0,0 @@
-require 'em-http'
-
-module Socky
-  # this class provide unobtrusive http request methods
-  class NetRequest
-    include Socky::Misc
-
-    class << self
-
-      # send unobtrusive http POST request to gived address and return status of request as block response
-      # @param [String] url address to send request in format 'http://address[:port]/[path]'
-      # @param [Hash] params params for request(will be attached in post message)
-      # @yield [Boolean] called after request is finished - if response status is 200 then it's true, else false
-      def post(url, params = {}, &block)
-        http = EventMachine::HttpRequest.new(url).post :body => params, :timeout => options[:timeout] || 3
-        http.errback  { yield false }
-        http.callback { yield http.response_header.status == 200 }
-        true
-      rescue => error
-        error "Bad request", error
-        false
-      end
-
-    end
-
-  end
-end

data/lib/socky/options.rb

@@ -1,39 +0,0 @@
-require 'socky/options/config'
-require 'socky/options/parser'
-
-module Socky
-  # options parser - reads options from STDIN and config file and set Socky.options
-  class Options
-    include Socky::Misc
-
-    class << self
-      # prepare server-wide options from config and parser
-      # @param [Array] argv arguments that will be provided to parser
-      # @see default_options default options
-      # @see Config.read merged with default options
-      # @see Parser.parse merges with default options after config
-      def prepare(argv)
-        self.options = default_options
-
-        parsed_options = Parser.parse(argv)
-        config_options = Config.read(parsed_options[:config_path] || config_path, :kill => parsed_options[:kill])
-
-        self.options.merge!(config_options)
-        self.options.merge!(parsed_options)
-      end
-      
-      # default options for server
-      def default_options
-        {
-          :config_path => config_path,
-          :port => 8080,
-          :debug => false,
-          :deep_debug => false,
-          :secure => false,
-          :log_path => log_path
-        }
-      end
-    end
-
-  end
-end

data/lib/socky/options/config.rb

@@ -1,79 +0,0 @@
-require 'yaml'
-require 'erb'
-
-module Socky
-  class Options
-    # config parser class - used by Socky::Options
-    class Config
-
-      class NoConfigFile < Socky::SockyError; end #:nodoc:
-      class InvalidConfig < Socky::SockyError; end #:nodoc:
-      class AlreadyExists < Socky::SockyError; end #:nodoc:
-      class ConfigUnavailable < Socky::SockyError; end #:nodoc:
-      class SuccessfullyCreated < Socky::SockyError; end #:nodoc:
-
-      class << self
-        # read config file or exits if file don't exists or is invalid
-        # @param [String] path path to valid yaml file
-        # @param [Hash] args args to rescue eventual problems
-        # @option args [Any] kill (nil) if not nil then empty hash will be returned if config file isn't found
-        # @return [Hash] parsed config options
-        # @raise [NoConfigFile] if file doesn't exists
-        # @raise [InvalidConfig] if file isn't valid yaml
-        def read(path, args = {})
-          raise(NoConfigFile, "You must generate a config file (socky -g filename.yml)") unless File.exists?(path)
-          result = YAML::load(ERB.new(IO.read(path)).result)
-          raise(InvalidConfig, "Provided config file is invalid.") unless result.is_a?(Hash)
-          result
-        rescue SockyError => error
-          if args[:kill]
-            return {}
-          else
-            puts error.message
-            exit
-          end
-        end
-
-        # generate default config file
-        # @see DEFAULT_CONFIG_FILE
-        # @param [String] path path to file that will be created
-        # @raise [AlreadyExists] if file exists(you must delete it manually)
-        # @raise [ConfigUnavailable] if file cannot be created(wrong privilages?)
-        # @raise [SuccessfullyCreated] if file is successfully created
-        def generate(path)
-          raise(AlreadyExists, "Config file already exists. You must remove it before generating a new one.") if File.exists?(path)
-          File.open(path, 'w+') do |file|
-            file.write DEFAULT_CONFIG_FILE
-          end rescue raise(ConfigUnavailable, "Config file is unavailable - please choose another.")
-          raise(SuccessfullyCreated, "Config file generated at #{path}")
-        rescue SockyError => error
-          puts error.message
-          exit
-        end
-
-        # default config file content
-        DEFAULT_CONFIG_FILE= <<-EOF
-:port: 8080
-:debug: false
-
-# :subscribe_url: http://localhost:3000/socky/subscribe
-# :unsubscribe_url: http://localhost:3000/socky/unsubscribe
-
-:secret: my_secret_key
-
-:secure: false
-
-# :timeout: 3
-
-# :log_path: /var/log/socky.log
-# :pid_path: /var/run/socky.pid
-
-# :tls_options:
-#   :private_key_file: /private/key
-#   :cert_chain_file: /ssl/certificate
-EOF
-      end
-
-    end
-  end
-end