socky-server 0.4.0

data/lib/socky/runner.rb

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

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

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

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

data/spec/socky/connection/authentication_spec.rb

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

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