socky 0.0.8 → 0.0.9

data/CHANGELOG.textile

@@ -1,5 +1,18 @@
 h1. Changelog
 
+h2. 0.0.9 / 2010-06-20
+
+*IMPORTANT! This version will not work with plugin version lower than 0.0.9*
+
+* new features:
+** support for next version of em-websocket debug options(based on mloughran branch)
+** support for websocket draft 76
+** support for wss/SSL connections
+** socky can now be started in 'daemon' mode
+** socky now sending all messages in JSON format
+* bugfixes:
+** socky will no longer crash when when request query is invalid - i.e. chrome 6.0.*(with websocket draft76) and em-websocket 0.0.6
+
 h2. 0.0.8 / 2010-06-06
 
 * new features:

data/Rakefile

@@ -17,7 +17,7 @@ begin
     gemspec.email = "b.potocki@imanel.org"
     gemspec.homepage = "http://github.com/imanel/socky_gem"
     gemspec.authors = ["Bernard Potocki"]
-    gemspec.add_dependency('em-websocket', '>= 0.0.6')
+    gemspec.add_dependency('em-websocket', '>= 0.1.2')
     gemspec.add_dependency('em-http-request')
     gemspec.files.exclude ".gitignore"
   end

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.9

data/lib/em-websocket_hacks.rb

@@ -1,4 +1,10 @@
-EventMachine::WebSocket::Connection.class_eval do
+if defined?(EventMachine::WebSocket::Debugger)
+  klass = EventMachine::WebSocket::Debugger
+else
+  klass = EventMachine::WebSocket::Connection
+end
+
+klass.class_eval do
 
   def debug(*data)
     if @debug

data/lib/socky.rb

@@ -34,7 +34,11 @@ module Socky
     end
 
     def log_path
-      options[:log_path] || File.join(%w( / var run socky.log ))
+      options[:log_path] || nil
+    end
+
+    def pid_path
+      options[:pid_path] || File.join(%w( / var run socky.pid ))
     end
 
     def config_path

data/lib/socky/connection.rb

@@ -1,3 +1,4 @@
+require 'json'
 require 'socky/connection/authentication'
 require 'socky/connection/finders'
 
@@ -19,20 +20,24 @@ module Socky
       @socket = socket
     end
 
+    def query
+      socket.request["Query"] || {}
+    end
+
     def admin
-      ["true","1"].include?(socket.request["Query"]["admin"])
+      ["true","1"].include?(query["admin"])
     end
 
     def client
-      socket.request["Query"]["client_id"]
+      query["client_id"]
     end
 
     def secret
-      socket.request["Query"]["client_secret"]
+      query["client_secret"]
     end
 
     def channels
-      @channels ||= socket.request["Query"]["channels"].to_s.split(",").collect(&:strip).reject(&:empty?)
+      @channels ||= query["channels"].to_s.split(",").collect(&:strip).reject(&:empty?)
     end
 
     def subscribe
@@ -46,7 +51,7 @@ module Socky
     end
 
     def process_message(msg)
-      if admin
+      if admin && authenticated?
         Socky::Message.process(self, msg)
       else
         self.send_message "You are not authorized to post messages"
@@ -54,8 +59,12 @@ module Socky
     end
 
     def send_message(msg)
-      debug [self.name, "sending message", msg.inspect]
-      socket.send msg
+      send_data({:type => :message, :body => msg})
+    end
+
+    def send_data(data)
+      debug [self.name, "sending data", data.inspect]
+      socket.send data.to_json
     end
 
     def disconnect

data/lib/socky/connection/authentication.rb

@@ -13,7 +13,7 @@ module Socky
             debug [self.name, "authentication failed"]
             disconnect
           end
-        end unless authenticated?
+        end unless admin || authenticated?
       end
 
       def unsubscribe_request
@@ -28,7 +28,7 @@ module Socky
       end
 
       def authenticate_as_admin
-        admin
+        options[:secret].nil? || secret == options[:secret]
       end
 
       def authenticate_as_user

data/lib/socky/message.rb

@@ -16,7 +16,7 @@ module Socky
         message.process
       rescue SockyError => error
         error connection.name, error
-        connection.send_message(error.message.to_json)
+        connection.send_message(error.message)
       end
     end
 
@@ -28,16 +28,6 @@ module Socky
     def process
       debug [self.name, "processing", params.inspect]
 
-      verify_secret!
-
-      execute
-    end
-
-    def verify_secret!
-      raise(UnauthorisedQuery, "invalid secret") unless options[:secret].nil? || options[:secret] == params[:secret]
-    end
-
-    def execute
       case params[:command].to_sym
         when :broadcast then broadcast
         when :query then query
@@ -93,7 +83,7 @@ module Socky
     end
 
     def respond(message)
-      creator.send_message(message.to_json)
+      creator.send_message(message)
     end
 
   end

data/lib/socky/misc.rb

@@ -21,6 +21,10 @@ module Socky
       Socky.log_path
     end
 
+    def pid_path
+      Socky.pid_path
+    end
+
     def config_path
       Socky.config_path
     end

data/lib/socky/options.rb

@@ -12,11 +12,12 @@ module Socky
           :port => 8080,
           :debug => false,
           :deep_debug => false,
+          :secure => false,
           :log_path => log_path
         }
 
         parsed_options = Parser.parse(argv)
-        config_options = Config.read(parsed_options[:config_path] || config_path)
+        config_options = Config.read(parsed_options[:config_path] || config_path, :kill => parsed_options[:kill])
 
         self.options.merge!(config_options)
         self.options.merge!(parsed_options)

data/lib/socky/options/config.rb

@@ -21,14 +21,18 @@ module Socky
       end
 
       class << self
-        def read(path)
+        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
-          puts error.message
-          exit
+          if args[:kill]
+            return {}
+          else
+            puts error.message
+            exit
+          end
         end
 
         def generate(path)
@@ -51,7 +55,12 @@ module Socky
 
 :secret: my_secret_key
 
+:secure: false
+
 # :timeout: 3
+
+# :log_path: /var/log/socky.log
+# :pid_path: /var/run/socky.pid
 EOF
       end
 

data/lib/socky/options/parser.rb

@@ -29,9 +29,27 @@ module Socky
               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.", "(default: #{Socky.log_path})") do |path|
+            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
 

data/lib/socky/runner.rb

@@ -5,7 +5,14 @@ module Socky
     class << self
       def run(argv = ARGV)
         server = self.new(argv)
-        server.start
+
+        if options[:kill]
+          server.kill_pid
+        elsif options[:daemonize]
+          server.daemonize
+        else
+          server.start
+        end
       end
     end
 
@@ -21,8 +28,8 @@ module Socky
         trap("TERM") { stop }
         trap("INT")  { stop }
 
-        EventMachine::start_server("0.0.0.0", options[:port],
-            EventMachine::WebSocket::Connection, :debug => options[:deep_debug]) do |ws|
+        EventMachine::start_server("0.0.0.0", options[:port], EventMachine::WebSocket::Connection,
+            :debug => options[:deep_debug], :secure => options[:secure]) do |ws|
 
           connection = Socky::Connection.new(ws)
           ws.onopen    { connection.subscribe }
@@ -40,5 +47,38 @@ module Socky
       EventMachine.stop
     end
 
+    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
+
+    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
+
+    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
   end
 end

data/spec/files/default.yml

@@ -5,3 +5,5 @@
 :unsubscribe_url: http://localhost:3000/socky/unsubscribe
 
 :secret: my_secret_key
+
+:secure: false

data/spec/socky/connection/authentication_spec.rb

@@ -5,6 +5,9 @@ describe Socky::Connection::Authentication do
   
   context "instance" do
     context "#subscribe_request" do
+      before(:each) do
+        stub!(:admin).and_return(false)
+      end
       it "should not call #send_subscribe_request if already authenticated" do
         stub!(:authenticated?).and_return(true)
         should_not_receive(:send_subscribe_request)
@@ -29,7 +32,6 @@ describe Socky::Connection::Authentication do
         authenticated_by_url?.should be_true
       end
       it "should disconnect if #send_subscribe_request block is false" do
-        stub!(:admin).and_return(false)
         stub!(:send_subscribe_request).and_yield(false)
         should_receive(:disconnect)
         subscribe_request
@@ -75,14 +77,21 @@ describe Socky::Connection::Authentication do
       end
     end
     context "#authenticate_as_admin" do
-      it "should return true if admin" do
-        stub!(:admin).and_return(true)
+      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 not admin" do
-        stub!(:admin).and_return(false)
+      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?)

data/spec/socky/connection_spec.rb

@@ -37,6 +37,10 @@ describe Socky::Connection do
           @connection.admin.should be_false
         end
       end
+      it "should return false if socket request data is nil" do
+        @connection.socket.request["Query"] = nil
+        @connection.admin.should be_false
+      end
     end
     it "#client should return client_id from socket request data" do
       @connection.socket.request["Query"]["client_id"] = "abstract"
@@ -92,11 +96,15 @@ describe Socky::Connection do
         @connection.process_message("abstract")
       end
     end
-    it "#send_message should send message by socket" do
-      @connection.socket.stub!(:send)
-      @connection.socket.should_receive(:send).with("abstract")
+    it "#send_message should call #send_data with hashed form of message" do
+      @connection.should_receive(:send_data).with({:type => :message, :body => "abstract"})
       @connection.send_message("abstract")
     end
+    it "#send_data should send message by socket in json format" do
+      @connection.socket.stub!(:send)
+      @connection.socket.should_receive(:send).with({:test => "abstract"}.to_json)
+      @connection.send_data({:test => "abstract"})
+    end
     it "#disconnect should close connection after writing" do
       @connection.socket.stub!(:close_connection_after_writing)
       @connection.socket.should_receive(:close_connection_after_writing)

data/spec/socky/message_spec.rb

@@ -47,61 +47,31 @@ describe Socky::Message do
   context "instance" do
     before(:each) { @message = described_class.new(@connection, {}.to_json) }
     context "#process" do
-      before(:each) do
-        @message.stub!(:verify_secret!)
-        @message.stub!(:execute)
-      end
-      it "should verify secret" do
-        @message.should_receive(:verify_secret!)
-        @message.process
-      end
-      it "should execute" do
-        @message.should_receive(:execute)
-        @message.process
-      end
-    end
-    context "#verify_secret!" do
-      it "should not raise error if socky option :secret is nil" do
-        Socky.stub!(:options).and_return({:secret => nil})
-        lambda{ @message.verify_secret! }.should_not raise_error Socky::SockyError
-      end
-      it "should raise error if socky options :secret is not nil but message secret have different value" do
-        Socky.stub!(:options).and_return({:secret => "test"})
-        @message.stub!(:options).and_return({:secret => "another"})
-        lambda{ @message.verify_secret! }.should raise_error Socky::SockyError
-      end
-      it "should not raise error if socky options :secret is not nil and message secret have the some value" do
-        Socky.stub!(:options).and_return({:secret => "test"})
-        @message.stub!(:params).and_return({:secret => "test"})
-        lambda{ @message.verify_secret! }.should_not raise_error Socky::SockyError
-      end
-    end
-    context "#execute" do
       it "should call #broadcast if message command is :broadcast" do
         @message.stub!(:params).and_return({:command => :broadcast})
         @message.stub!(:broadcast)
         @message.should_receive(:broadcast)
-        @message.execute
+        @message.process
       end
       it "should not distinguish between string and symbol in command" do
         @message.stub!(:params).and_return({:command => 'broadcast'})
         @message.stub!(:broadcast)
         @message.should_receive(:broadcast)
-        @message.execute
+        @message.process
       end
       it "should call #query if message command is :query" do
         @message.stub!(:params).and_return({:command => :query})
         @message.stub!(:query)
         @message.should_receive(:query)
-        @message.execute
+        @message.process
       end
       it "should raise error if message command is nil" do
         @message.stub!(:params).and_return({:command => nil})
-        lambda {@message.execute}.should raise_error Socky::SockyError
+        lambda {@message.process}.should raise_error Socky::SockyError
       end
       it "should raise error if message command is neither :broadcast nor :query" do
         @message.stub!(:params).and_return({:command => "invalid"})
-        lambda {@message.execute}.should raise_error Socky::SockyError
+        lambda {@message.process}.should raise_error Socky::SockyError
       end
     end
     context "#broadcast" do
@@ -250,10 +220,6 @@ describe Socky::Message do
         @connection.should_receive(:send_message)
         @message.respond({:test => true})
       end
-      it "should convert message to json" do
-        @connection.should_receive(:send_message).with({:test => true}.to_json)
-        @message.respond({:test => true})
-      end
     end
 
   end

data/spec/socky/options/config_spec.rb

@@ -18,6 +18,10 @@ describe Socky::Options::Config do
         described_class.should_receive(:puts).with("Provided config file is invalid.")
         lambda { described_class.read(FILES_DIR + "/invalid.yml") }.should raise_error SystemExit
       end
+      it "should not raise error if :kill option is provided" do
+        described_class.should_not_receive(:puts).with("Provided config file is invalid.")
+        lambda { described_class.read(FILES_DIR + "/invalid.yml", :kill => true) }.should_not raise_error SystemExit
+      end
       it "should return valid options if file is valid" do
         lambda { described_class.read(FILES_DIR + "/default.yml") }.should_not raise_error SystemExit
         described_class.read(FILES_DIR + "/default.yml").should eql(default_options)
@@ -55,13 +59,16 @@ describe Socky::Options::Config do
       end
     end
   end
-end
-
-def default_options
-  { :port => 8080,
-    :debug => false,
-    :subscribe_url => "http://localhost:3000/socky/subscribe",
-    :unsubscribe_url => "http://localhost:3000/socky/unsubscribe",
-    :secret => "my_secret_key"
-  }
+  
+  def default_options
+    {
+      :port => 8080,
+      :debug => false,
+      :subscribe_url => "http://localhost:3000/socky/subscribe",
+      :unsubscribe_url => "http://localhost:3000/socky/unsubscribe",
+      :secret => "my_secret_key",
+      :secure => false
+    }
+  end
+  
 end

data/spec/socky/options/parser_spec.rb

@@ -28,7 +28,24 @@ describe Socky::Options::Parser do
         end
       end
       it "on -p or --port should set port" do
-        described_class.parse(["-p","222"]).should eql({:port => 222})
+        ["-p","--port"].each do |function|
+          described_class.parse([function,"222"]).should eql({:port => 222})
+        end
+      end
+      it "on -s or --secure should set secure mode on" do
+        ["-s","--secure"].each do |function|
+          described_class.parse([function]).should eql({:secure => true})
+        end
+      end
+      it "on -P or --pid should set pid_path to provided path" do
+        ["-P","--pid"].each do |function|
+          described_class.parse([function,"/tmp/socky.pid"]).should eql({:pid_path => "/tmp/socky.pid"})
+        end
+      end
+      it "on -d or --daemon should set daemon mode on" do
+        ["-d","--daemon"].each do |function|
+          described_class.parse([function]).should eql({:daemonize => true})
+        end
       end
       it "on -l or --log should set log_path to provided path" do
         ["-l","--log"].each do |function|

data/spec/socky/options_spec.rb

@@ -20,46 +20,41 @@ describe Socky::Options do
         Socky::Options.prepare([:a,:b,:c])
       end
       it "should call read_config with patch" do
-        Socky::Options::Config.should_receive(:read).with("/var/run/socky.yml")
+        Socky::Options::Config.should_receive(:read).with("/var/run/socky.yml", :kill => nil)
         Socky::Options.prepare([])
       end
       it "should set Socky options to default hash when parse_options and read_config don't do anything" do
         Socky::Options.prepare([])
-        Socky.options.should eql({:port=>8080,
-                                  :log_path=>"/var/run/socky.log",
-                                  :debug=>false,
-                                  :deep_debug=>false,
-                                  :config_path=>"/var/run/socky.yml"})
+        Socky.options.should eql(default_options)
       end
       it "should value parse_options over default values" do
         Socky::Options::Parser.stub!(:parse).and_return(:log_path => "parsed")
         Socky::Options.prepare([])
-        Socky.options.should eql({:port=>8080,
-                                  :log_path=>"parsed",
-                                  :debug=>false,
-                                  :deep_debug=>false,
-                                  :config_path=>"/var/run/socky.yml"})
+        Socky.options.should eql(default_options.merge(:log_path=>"parsed"))
       end
       it "should value read_config over default values" do
         Socky::Options::Config.stub!(:read).and_return(:log_path => "from config")
         Socky::Options.prepare([])
-        Socky.options.should eql({:port=>8080,
-                                  :log_path=>"from config",
-                                  :debug=>false,
-                                  :deep_debug=>false,
-                                  :config_path=>"/var/run/socky.yml"})
+        Socky.options.should eql(default_options.merge(:log_path=>"from config"))
       end
       it "should value parse_options over read_config" do
         Socky::Options::Config.stub!(:read).and_return(:log_path => "from config")
         Socky::Options::Parser.stub!(:parse).and_return(:log_path => "parsed")
         Socky::Options.prepare([])
-        Socky.options.should eql({:port=>8080,
-                                  :log_path=>"parsed",
-                                  :debug=>false,
-                                  :deep_debug=>false,
-                                  :config_path=>"/var/run/socky.yml"})
+        Socky.options.should eql(default_options.merge(:log_path=>"parsed"))
       end
     end
   end
+  
+  def default_options
+    {
+      :port => 8080,
+      :log_path => nil,
+      :debug => false,
+      :deep_debug => false,
+      :secure => false,
+      :config_path => "/var/run/socky.yml"
+    }
+  end
 
 end

data/spec/socky/runner_spec.rb

@@ -12,10 +12,21 @@ describe Socky::Runner do
         described_class.should_receive(:new).with("some args")
         described_class.run("some args")
       end
-      it "should call #start on new instance of self" do
+      it "should call #start on new instance of self if daemonize option is false" do
+        Socky.stub(:options).and_return({:daemonize => false})
         @server.should_receive(:start)
         described_class.run
       end
+      it "should call #daemonize on new instance of self if daemonize option is true" do
+        Socky.stub(:options).and_return({:daemonize => true})
+        @server.should_receive(:daemonize)
+        described_class.run
+      end
+      it "should call #kill_pid on new instance of self if kill option is true" do
+        Socky.stub(:options).and_return({:kill => true})
+        @server.should_receive(:kill_pid)
+        described_class.run
+      end
     end
     context "#new" do
       it "should prepare options from args" do

data/spec/socky_spec.rb

@@ -50,9 +50,8 @@ describe Socky do
         Socky.logger = nil
       end
     end
-    it "should have default log path" do
-      Socky.log_path.should_not be_nil
-      Socky.log_path.should eql("/var/run/socky.log")
+    it "should not have default log path" do
+      Socky.log_path.should be_nil
     end
     it "should be able to change log path by settion log_path option" do
       Socky.stub!(:options).and_return({:log_path => "abstract"})
@@ -68,6 +67,14 @@ describe Socky do
         Socky.options = {}
       end
     end
+    it "should have default pid path" do
+      Socky.pid_path.should_not be_nil
+      Socky.pid_path.should eql("/var/run/socky.pid")
+    end
+    it "should be able to change pid path by settion pid_path option" do
+      Socky.stub!(:options).and_return({:pid_path => "abstract"})
+      Socky.pid_path.should eql("abstract")
+    end
     it "should have default config path" do
       Socky.config_path.should_not be_nil
       Socky.config_path.should eql("/var/run/socky.yml")

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 8
-  version: 0.0.8
+  - 9
+  version: 0.0.9
 platform: ruby
 authors: 
 - Bernard Potocki
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-06 00:00:00 +02:00
+date: 2010-06-20 00:00:00 +02:00
 default_executable: socky
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,9 +26,9 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 0
-        - 6
-        version: 0.0.6
+        - 1
+        - 2
+        version: 0.1.2
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency