socky 0.2.1 → 0.4.0

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

data/spec/files/default.yml

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

data/spec/files/invalid.yml

@@ -1 +0,0 @@
-invalid data

data/spec/socky/connection/authentication_spec.rb

@@ -1,183 +0,0 @@
-require 'spec_helper'
-
-describe Socky::Connection::Authentication do
-  include Socky::Connection::Authentication
-  
-  context "instance" do
-    context "#subscribe_request" do
-      before(:each) do
-        stub!(:admin).and_return(false)
-        stub!(:send_data)
-      end
-      it "should not call #send_subscribe_request if already authenticated" do
-        stub!(:authenticated?).and_return(true)
-        should_not_receive(:send_subscribe_request)
-        subscribe_request
-      end
-      it "should call #send_subscribe_request if unauthenticated" do
-        stub!(:authenticated?).and_return(false)
-        should_receive(:send_subscribe_request)
-        subscribe_request
-      end
-      it "should add self to connection list if #send_subscribe_request block is true" do
-        EM.run do
-          stub!(:authenticated?).and_return(false)
-          stub!(:send_subscribe_request).and_yield(true)
-          should_receive(:add_to_pool)
-          subscribe_request
-          EM.stop
-        end
-      end
-      it "should be authenticated by url if #send_subscribe_request block is true" do
-        EM.run do
-          stub!(:authenticated?).and_return(false)
-          stub!(:send_subscribe_request).and_yield(true)
-          stub!(:add_to_pool)
-          subscribe_request
-          authenticated_by_url?.should be_true
-          EM.stop
-        end
-      end
-      it "should disconnect if #send_subscribe_request block is false" do
-        EM.run do
-          stub!(:send_subscribe_request).and_yield(false)
-          should_receive(:disconnect)
-          subscribe_request
-          EM.add_timer(0.1) do
-            EM.stop
-          end
-        end
-      end
-    end
-    context "#unsubscribe_request" do
-      it "should remove self from connection list if authenticated" do
-        stub!(:admin).and_return(false)
-        stub!(:authenticated?).and_return(true)
-        should_receive(:remove_from_pool)
-        unsubscribe_request
-      end
-      it "should send unsubscribe request if authenticated but not admin" do
-        stub!(:admin).and_return(false)
-        stub!(:authenticated?).and_return(true)
-        stub!(:remove_from_pool)
-        should_receive(:send_unsubscribe_request)
-        unsubscribe_request
-      end
-      it "should not send unsubscribe request if authenticated and admin" do
-        stub!(:admin).and_return(true)
-        stub!(:authenticated?).and_return(true)
-        stub!(:remove_from_pool)
-        should_not_receive(:send_unsubscribe_request)
-        unsubscribe_request
-      end
-      it "should not send unsubscribe request if unauthenticated" do
-        stub!(:authenticated?).and_return(false)
-        should_not_receive(:send_unsubscribe_request)
-        unsubscribe_request
-      end
-    end
-    context "#authenticated?" do
-      it "should authenticate as admin if admin" do
-        stub!(:admin).and_return(true)
-        should_receive(:authenticate_as_admin)
-        authenticated?
-      end
-      it "should authenticate as user if not admin" do
-        stub!(:admin).and_return(false)
-        should_receive(:authenticate_as_user)
-        authenticated?
-      end
-    end
-    context "#authenticate_as_admin" do
-      it "should return true if client secret is equal server secret" do
-        stub!(:secret).and_return("test")
-        Socky.stub!(:options).and_return({:secret => "test"})
-        authenticate_as_admin.should be_true
-      end
-      it "should return false if client secret is not equal server secret" do
-        stub!(:secret).and_return("abstract")
-        Socky.stub!(:options).and_return({:secret => "test"})
-        authenticate_as_admin.should be_false
-      end
-      it "should return true if server secret is nil" do
-        stub!(:secret).and_return("abstract")
-        Socky.stub!(:options).and_return({:secret => nil})
-        authenticate_as_admin.should be_true
-      end
-    end
-    it "#authenticate_as_user should call #authenticated_by_url?" do
-      should_receive(:authenticated_by_url?)
-      authenticate_as_user
-    end
-    it "#authenticated_by_url? should return current status" do
-      instance_variable_set('@authenticated_by_url',true)
-      authenticated_by_url?.should be_true
-      instance_variable_set('@authenticated_by_url',false)
-      authenticated_by_url?.should be_false
-    end
-    context "#send_subscribe_request" do
-      it "should build params for request if socky option subscribe_url is not nil" do
-        Socky.stub!(:options).and_return({:subscribe_url => "any"})
-        should_receive(:params_for_request)
-        send_subscribe_request
-      end
-      it "should call Socky::NetRequest#post if socky option subscribe_url is not nil" do
-        Socky.stub!(:options).and_return({:subscribe_url => "any"})
-        stub!(:params_for_request)
-        Socky::NetRequest.should_receive(:post)
-        send_subscribe_request
-      end
-      it "should not call Socky::NetRequest#post if socky option subscribe_url is nil" do
-        Socky.stub!(:options).and_return({:subscribe_url => nil})
-        Socky::NetRequest.should_not_receive(:post)
-        send_subscribe_request{}
-      end
-    end
-    context "#send_unsubscribe_request" do
-      it "should build params for request if socky option unsubscribe_url is not nil" do
-        Socky.stub!(:options).and_return({:unsubscribe_url => "any"})
-        should_receive(:params_for_request)
-        send_unsubscribe_request{}
-      end
-      it "should call Socky::NetRequest#post if socky option unsubscribe_url is not nil" do
-        Socky.stub!(:options).and_return({:unsubscribe_url => "any"})
-        stub!(:params_for_request)
-        Socky::NetRequest.should_receive(:post)
-        send_unsubscribe_request{}
-      end
-      it "should not call Socky::NetRequest#post if socky option unsubscribe_url is nil" do
-        Socky.stub!(:options).and_return({:unsubscribe_url => nil})
-        Socky::NetRequest.should_not_receive(:post)
-        send_unsubscribe_request{}
-      end
-    end
-    context "#params_for_request" do
-      before(:each) do
-        stub!(:client)
-        stub!(:secret)
-        stub!(:channels).and_return([])
-      end
-      it "should return empty hash if none of (client,secret,channels) are set" do
-        params_for_request.should eql({})
-      end
-      it "should return client as client_id if set" do
-        stub!(:client).and_return("some client")
-        params_for_request.should eql({:client_id => "some client"})
-      end
-      it "should return secret as client_secret if set" do
-        stub!(:secret).and_return("some secret")
-        params_for_request.should eql({:client_secret => "some secret"})
-      end
-      it "should return channels if not empty" do
-        stub!(:channels).and_return(["some channel"])
-        params_for_request.should eql({:channels => ["some channel"]})
-      end
-      it "should return client, secret and channels as hash if all are set" do
-        stub!(:client).and_return("some client")
-        stub!(:secret).and_return("some secret")
-        stub!(:channels).and_return(["some channel"])
-        params_for_request.should eql({:client_id => "some client", :client_secret => "some secret", :channels => ["some channel"]})
-      end
-    end
-  end
-end

data/spec/socky/connection/finders_spec.rb

@@ -1,188 +0,0 @@
-require 'spec_helper'
-
-describe Socky::Connection::Finders do
-  include Socky::Connection::Finders
-  include Socky::Misc
-  
-  context "class" do
-    before(:each) do
-      @connection1 = mock(:connection1, :client => "client1", :channels => [nil])
-      @connection2 = mock(:connection2, :client => "client1", :channels => ["1", "3", "5"])
-      @connection3 = mock(:connection3, :client => "client2", :channels => ["2", "5"])
-      @connection4 = mock(:connection4, :client => "client3", :channels => ["3", "5"])
-      @connections = [@connection1,@connection2,@connection3,@connection4]
-      @connections.collect { |connection| Socky::Connection.connections << connection }
-    end
-    after(:each) do
-      Socky::Connection.connections.clear
-    end
-    
-    it "#find_all should return all connections" do
-      find_all.should eql(@connections)
-    end
-    context "#find" do
-      it "should return all connections if no options specified" do
-        find.should eql(@connections)
-      end
-      context "on :to" do
-        context "if :clients option is specified" do
-          it "should return all connections if :clients is nil" do
-            find(:to => {:clients => nil}).should eql(@connections)
-          end
-          it "should return none connections if :clients is empty" do
-            find(:to => {:clients => []}).should eql([])
-          end
-          it "should return only connections from specified client" do
-            find(:to => {:clients => "client1"}).should eql([@connection1,@connection2])
-          end
-          it "should return only connections from specified clients if array provided" do
-            find(:to => {:clients => ["client1","client2"]}).should eql([@connection1,@connection2,@connection3])
-          end
-        end
-        context "if :channels option is specified" do
-          it "should return all connections if :channels is nil" do
-            find(:to => {:channels => nil}).should eql(@connections)
-          end
-          it "should return none connections if :channels is empty" do
-            find(:to => {:channels => []}).should eql([])
-          end
-          it "should return all connections that include specified channel" do
-            find(:to => {:channels => "3"}).should eql([@connection2,@connection4])
-          end
-          it "should return all connections that include at last one of specified channels" do
-            find(:to => {:channels => ["2","3"]}).should eql([@connection2,@connection3,@connection4])
-          end
-        end
-        context "if both :clients and :channels options are provided" do
-          context "but :channels are nil" do
-            it "should return only connections from specified client" do
-              find(:to => {:channels => nil,:clients => "client1"}).should eql([@connection1,@connection2])
-            end
-            it "should return only connections from specified clients if array provided" do
-              find(:to => {:channels => nil,:clients => ["client1","client2"]}).should eql([@connection1,@connection2,@connection3])
-            end
-          end
-          context "but :channels are empty" do
-            it "should return none connections" do
-              find(:to => {:channels => [],:clients => "client1"}).should eql([])
-            end
-            it "should return none connections if array provided" do
-              find(:to => {:channels => [],:clients => ["client1","client2"]}).should eql([])
-            end
-          end
-          context "but :clients are nil" do
-            it "should return all connections that include specified channel" do
-              find(:to => {:clients => nil,:channels => "3"}).should eql([@connection2,@connection4])
-            end
-            it "should return all connections that include at last one of specified channels" do
-              find(:to => {:clients => nil,:channels => ["2","3"]}).should eql([@connection2,@connection3,@connection4])
-            end
-          end
-          context "but :clients are empty" do
-            it "should return none connections" do
-              find(:to => {:clients => [],:channels => "3"}).should eql([])
-            end
-            it "should return none connections if array provided" do
-              find(:to => {:clients => [],:channels => ["2","3"]}).should eql([])
-            end
-          end
-          it "should return only connections from specified client that include specified channel" do
-            find(:to => {:clients => "client1",:channels => "3"}).should eql([@connection2])
-            find(:to => {:clients => "client1",:channels => "2"}).should eql([])
-          end
-          it "should return only connections from specified client that include one of specified channels" do
-            find(:to => {:clients => "client1",:channels => ["2","3"]}).should eql([@connection2])
-          end
-          it "should return only connections from specified clients that include specified channel" do
-            find(:to => {:clients => ["client1","client2"],:channels => "2"}).should eql([@connection3])
-          end
-          it "should return only connections from specified clients that include at last one of specified channels" do
-            find(:to => {:clients => ["client1","client2"],:channels => ["2","1"]}).should eql([@connection2,@connection3])
-          end
-        end
-      end
-      
-      context "on :except" do
-        context "if :clients option is specified" do
-          it "should return all connections if :clients is nil" do
-            find(:except => {:clients => nil}).should eql(@connections)
-          end
-          it "should return all connections if :clients is empty" do
-            find(:except => {:clients => []}).should eql(@connections)
-          end
-          it "should return all connections except of specified client" do
-            find(:except => {:clients => "client1"}).should eql([@connection3,@connection4])
-          end
-          it "should return all connections except of specified clients if array provided" do
-            find(:except => {:clients => ["client1","client2"]}).should eql([@connection4])
-          end
-        end
-        context "if :channels option is specified" do
-          it "should return all connections if :channels is nil" do
-            find(:except => {:channels => nil}).should eql(@connections)
-          end
-          it "should return all connections if :channels is empty" do
-            find(:except => {:channels => []}).should eql(@connections)
-          end
-          it "should return all connections except of that include all specified channels" do
-            find(:except => {:channels => ["2","5"]}).should eql([@connection1,@connection2,@connection4])
-          end
-        end
-        context "if both :clients and :channels options are provided" do
-          context "but :channels are nil" do
-            it "should return all connections except of specified client" do
-              find(:except => {:channels => nil,:clients => "client1"}).should eql([@connection3,@connection4])
-            end
-            it "should return all connections except of specified clients if array provided" do
-              find(:except => {:channels => nil,:clients => ["client1","client2"]}).should eql([@connection4])
-            end
-          end
-          context "but :channels are empty" do
-            it "should return all connections except of specified client" do
-              find(:except => {:channels => [],:clients => "client1"}).should eql([@connection3,@connection4])
-            end
-            it "should return all connections except of provided clients if array provided" do
-              find(:except => {:channels => [],:clients => ["client1","client2"]}).should eql([@connection4])
-            end
-          end
-          context "but :clients are nil" do
-            it "should return all connections except of that include all of specified channels" do
-              find(:except => {:clients => nil,:channels => ["2","5"]}).should eql([@connection1,@connection2,@connection4])
-            end
-          end
-          context "but :clients are empty" do
-            it "should return all connections except of that include all of specified channels " do
-              find(:except => {:clients => [],:channels => ["2","5"]}).should eql([@connection1,@connection2,@connection4])
-            end
-          end
-          it "should return all connections except of specified client or all specified channels" do
-            find(:except => {:clients => "client2",:channels => "3"}).should eql([@connection1,@connection2,@connection4])
-            find(:except => {:clients => "client2",:channels => ["3","5"]}).should eql([@connection1,@connection2])
-          end
-          it "should return only connections from specified clients that include specified channel" do
-            find(:except => {:clients => ["client1","client2"],:channels => "3"}).should eql([@connection4])
-            find(:except => {:clients => ["client1","client2"],:channels => ["3","5"]}).should eql([])
-          end
-        end
-      end
-    
-      context "on :to and :except" do
-        context "should value 'except' more that 'to'" do
-          it "on :client" do
-            find(:to => {:clients => "client1"},:except => {:clients => "client1"}).should eql([])
-          end
-          it "on :channels" do
-            find(:to => {:channels => "5"},:except => {:channels => "5"}).should eql([])
-          end
-          it "on :client allow and :channels except" do
-            find(:to => {:clients => "client2"},:except => {:channels => ["2","5"]}).should eql([])
-          end
-          it "on :channels allow and :clients except" do
-            find(:to => {:channels => ["5"]},:except => {:clients => "client2"}).should eql([@connection2,@connection4])
-          end
-        end
-      end
-    end
-    
-  end
-end