socky-server 0.4.1 → 0.5.0.beta1

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

data/lib/socky/options/parser.rb

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

data/lib/socky/runner.rb

@@ -1,95 +0,0 @@
-module Socky
-  # default runner class - creates server and runs it
-  class Runner
-    include Socky::Misc
-
-    class << self
-      # create new eventmachine server
-      def run(argv = ARGV)
-        server = self.new(argv)
-
-        if options[:kill]
-          server.kill_pid
-        elsif options[:daemonize]
-          server.daemonize
-        else
-          server.start
-        end
-      end
-    end
-
-    # set server-wide options from args
-    def initialize(argv = ARGV)
-      Options.prepare(argv)
-    end
-
-    # start eventmachine server
-    # require options to be parsed earlier
-    def start
-      EventMachine.epoll
-
-      EventMachine.run do
-
-        trap("TERM") { stop }
-        trap("INT")  { stop }
-
-        EventMachine::start_server("0.0.0.0", options[:port], EventMachine::WebSocket::Connection,
-            :debug => options[:deep_debug], :secure => options[:secure], :tls_options => options[:tls_options]) do |ws|
-
-          connection = Socky::Connection.new(ws)
-          ws.onopen    { connection.subscribe }
-          ws.onmessage { |msg| connection.process_message(msg) }
-          ws.onclose   { connection.unsubscribe }
-
-        end
-
-        info ["Server started"]
-      end
-    end
-
-    # stop eventmachine server
-    def stop
-      info ["Server stopping"]
-      EventMachine.stop
-    end
-
-    # run server in daemon mode
-    def daemonize
-      fork do
-        Process.setsid
-        exit if fork
-        store_pid(Process.pid)
-        # Dir.chdir "/" # Mucks up logs
-        File.umask 0000
-        STDIN.reopen "/dev/null"
-        STDOUT.reopen "/dev/null", "a"
-        STDERR.reopen STDOUT
-        start
-      end
-    end
-
-    # kill daemonized server according to pid file in pid_path
-    def kill_pid
-      begin
-        pid = IO.read(pid_path).chomp.to_i
-        FileUtils.rm pid_path
-        Process.kill(9, pid)
-        puts "killed PID: #{pid}"
-      rescue => e
-        puts e
-      end
-      exit
-    end
-
-    private
-    
-    def store_pid(pid)
-     FileUtils.mkdir_p(File.dirname(pid_path))
-     File.open(pid_path, 'w'){|f| f.write("#{pid}\n")}
-    rescue => e
-      puts e
-      exit
-    end
-
-  end
-end

data/spec/em-websocket_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe EM::WebSocket::Connection do
-
-  it "should not receive debug message if :debug option is false" do
-    EM.run do
-      Socky.logger.should_not_receive(:debug)
-      EM.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('ws://127.0.0.1:9999/').get(:timeout => 0)
-        http.errback  { http.close_connection }
-        http.callback { http.close_connection }
-      end
-
-      EM::WebSocket.start(:host => "127.0.0.1", :port => 9999, :debug => false) do |ws|
-        ws.onclose { EM.stop }
-      end
-    end
-  end
-
-  it "should use Socky.logger.debug instead of pp when instance call #debug" do
-    EM.run do
-      Socky.logger.should_receive(:debug).with("Socket initialize")
-      Socky.logger.should_receive(:debug).with(anything()).at_least(:once)
-      EM.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('ws://127.0.0.1:9999/').get(:timeout => 0)
-        http.errback  { http.close_connection }
-        http.callback { http.close_connection }
-      end
-
-      EM::WebSocket.start(:host => "127.0.0.1", :port => 9999, :debug => true) do |ws|
-        ws.onclose { EM.stop }
-      end
-    end
-  end
-
-end