socky-server 0.4.0

data/lib/socky/connection/finders.rb

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,79 @@
+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

data/lib/socky/options/parser.rb

@@ -0,0 +1,93 @@
+require 'optparse'
+
+module Socky
+  class Options
+    # STDIN options parser - used by Socky::Options
+    class Parser
+
+      class << self
+        # parse options(usually from STDIN)
+        # see source code for available options
+        # @param [Array] argv options for parser
+        # @return [Hash] parsed options from array
+        def parse(argv)
+          result = {}
+          opts = OptionParser.new do |opts|
+            opts.summary_width = 25
+            opts.banner = "Usage: socky [options]\n"
+
+            opts.separator ""
+            opts.separator "Configuration:"
+
+            opts.on("-g", "--generate FILE", String, "Generate config file") do |path|
+              result[:config_path] = File.expand_path(path) if path
+              Config.generate(result[:config_path])
+            end
+
+            opts.on("-c", "--config FILE", String, "Path to configuration file.", "(default: #{Socky.config_path})") do |path|
+              result[:config_path] = File.expand_path(path)
+            end
+
+            opts.separator ""; opts.separator "Network:"
+
+            opts.on("-p", "--port PORT", Integer, "Specify port", "(default: 8080)") do |port|
+              result[:port] = port
+            end
+
+            opts.on("-s", "--secure", "Run in wss/ssl mode") do
+              result[:secure] = true
+            end
+
+            opts.separator ""; opts.separator "Daemonization:"
+
+            opts.on("-d", "--daemon", "Daemonize mode") do
+              result[:daemonize] = true
+            end
+
+            opts.on("-P", "--pid FILE", String, "Path to PID file when using -d option") do |path|
+              result[:pid_path] = File.expand_path(path)
+            end
+
+            opts.on("-k", "--kill", "Kill daemon from specified pid file path") do
+              result[:kill] = true
+            end
+
+            opts.separator ""; opts.separator "Logging:"
+
+            opts.on("-l", "--log FILE", String, "Path to print debugging information.", "(Print to STDOUT if empty)") do |path|
+              result[:log_path] = File.expand_path(path)
+            end
+
+            opts.on("--debug", "Run in debug mode") do
+              result[:debug] = true
+            end
+
+            opts.on("--deep-debug", "Run in debug mode that is even more verbose") do
+              result[:debug] = true
+              result[:deep_debug] = true
+            end
+
+            opts.separator ""; opts.separator "Miscellaneous:"
+
+            opts.on_tail("-?", "--help", "Display this usage information.") do
+              puts "#{opts}\n"
+              exit
+            end
+
+            opts.on_tail("-v", "--version", "Display version") do
+              puts "Socky #{VERSION}"
+              exit
+            end
+          end
+          opts.parse!(argv)
+          result
+        rescue OptionParser::InvalidOption => error
+          puts "#{opts}\n"
+          puts error.message
+          exit
+        end
+      end
+
+    end
+  end
+end