socky-server 0.4.0

data/CHANGELOG.textile

@@ -0,0 +1,95 @@
+h1. Changelog
+
+h2. 0.4.0 / 2010-10-27
+
+* new features:
+** rename project to 'socky-server-ruby' for future compatibility
+* bugfixes:
+** use fund_all in finders instead of collect in finders
+
+h2. 0.2.1 / 2010-10-09
+
+* new features:
+** default config should have subscribe url's commented out for starting users
+* bugfixes:
+** show sent messages in true form instead of "inspect" one
+
+h2. 0.2.0 / 2010-10-03
+
+* new features:
+** inline documentation
+* bugfixes:
+** send authentication after finishing handshake
+** tests less using stubs and more real cases
+** fix some tests
+
+h2. 0.1.3 / 2010-09-23
+
+* new features:
+** none
+* bugfixes:
+** fix query :show_connections in ruby 1.9
+** fix user authentication when url subscribe/unsubscribe is disabled
+
+h2. 0.1.2 / 2010-09-21
+
+* new features:
+** none
+* bugfixes:
+** fix routes to spec_helper in ruby 1.9.2
+** ruby 1.9 will no longer raise errors on String to_a call
+
+h2. 0.1.1 / 2010-08-25
+
+* new features:
+** socky has now support for signed certificates by :tls_options config option
+* bugfixes:
+** none
+
+h2. 0.1.0 / 2010-08-03
+
+*IMPORTANT! This version will not work with plugin version lower than 0.1.0*
+
+* new features:
+** server now send authentication status
+** new syntax
+** option to exclude clients/channels
+* bugfixes:
+** none
+
+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:
+** full rspec suite
+** allow admin param to be both "1" and "true"
+* bugfixes:
+** proper configuration options parsing order
+** rescue from invalid config file
+** rescue from invalid args
+** symbolize_keys will no longer raise error if argument is not hash
+** modules will no longer depend on parent class
+** message will no longer raise exeption is JSON is invalid
+
+h2. 0.0.7 / 2010-05-25
+
+* new features:
+** user authentication is now async
+* bugfixes:
+** server will no longer fail when starting from source instead of gem
+
+h2. 0.0.6 / 2010-05-24
+
+* initial release

data/README.md

@@ -0,0 +1,30 @@
+Socky - server in Ruby
+===========
+
+Socky is push server for Ruby based on WebSockets. It allows you to break border between your application and client browser by letting the server initialize a connection and push data to the client.
+
+## Getting Started
+
+- [Install](http://github.com/socky/socky-server-ruby/wiki/install) the gem
+- Read up about its [Usage](http://github.com/socky/socky-server-ruby/wiki/usage) and [Configuration](http://github.com/socky/socky-server-ruby/wiki/configuration)
+- Try [Example Application](http://github.com/socky/socky-example) or [demo page](http://sockydemo.imanel.org)
+- Fork and Contribute your own modifications
+- See [sites using socky](http://github.com/socky/socky-server-ruby/wiki/sites)
+- Discuss on [google group](http://groups.google.com/group/socky-framework)
+
+## Runtime Dependencies
+
+- EM-WebSocket: Backend for WebSocket server
+- EM-HTTP-Client: Sending authorize requests
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2010 Bernard Potocki 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rake'
+require 'rake/clean'
+CLEAN.include %w(**/*.{log,rbc})
+
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "socky-server"
+    gemspec.summary = "Socky is a WebSocket server and client for Ruby"
+    gemspec.description = "Socky is a WebSocket server and client for Ruby"
+    gemspec.email = "bernard.potocki@imanel.org"
+    gemspec.homepage = "http://imanel.org/projects/socky"
+    gemspec.authors = ["Bernard Potocki"]
+    gemspec.add_dependency 'em-websocket', '>= 0.1.4'
+    gemspec.add_dependency 'em-http-request'
+    gemspec.add_dependency 'json'
+    gemspec.add_development_dependency 'rspec', '~> 2.0'
+    gemspec.add_development_dependency 'rack'
+    gemspec.add_development_dependency 'mongrel'
+    gemspec.files.exclude ".gitignore"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.4.0

data/bin/socky

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require File.join(File.dirname(File.expand_path(__FILE__)), '..', 'lib', 'socky')
+Socky::Runner.run

data/lib/em-websocket_hacks.rb

@@ -0,0 +1,15 @@
+if defined?(EventMachine::WebSocket::Debugger)
+  klass = EventMachine::WebSocket::Debugger
+else
+  klass = EventMachine::WebSocket::Connection
+end
+
+klass.class_eval do
+
+  def debug(*data)
+    if @debug
+      Socky.logger.debug "Socket " + data.flatten.collect{|line| line.to_s.gsub("\r\n","\n").gsub("\n","\\n")}.join(" ")
+    end
+  end
+
+end

data/lib/socky.rb

@@ -0,0 +1,75 @@
+require 'rubygems'
+require 'logger'
+require 'fileutils'
+require 'em-websocket'
+$:.unshift(File.dirname(__FILE__))
+require 'em-websocket_hacks'
+
+# Socky is a WebSocket server and client for Ruby on Rails 
+# @author Bernard "Imanel" Potocki
+# @see http://github.com/imanel/socky_gem main repository
+module Socky
+
+  class SockyError < StandardError; end #:nodoc:
+
+  # server version
+  VERSION = File.read(File.dirname(__FILE__) + '/../VERSION').strip
+
+  class << self
+    # read server-wide options
+    def options
+      @options ||= {}
+    end
+
+    # write server-wide options
+    def options=(val)
+      @options = val
+    end
+
+    # access or initialize logger
+    # default logger writes to STDOUT
+    def logger
+      return @logger if defined?(@logger) && !@logger.nil?
+      path = log_path
+      FileUtils.mkdir_p(File.dirname(path))
+      prepare_logger(path)
+    rescue
+      prepare_logger(STDOUT)
+    end
+
+    # overwrite default logger
+    def logger=(logger)
+      @logger = logger
+    end
+
+    # default log path
+    def log_path
+      options[:log_path] || nil
+    end
+
+    # default pid path
+    def pid_path
+      options[:pid_path] || File.join(%w( / var run socky.pid ))
+    end
+
+    # default config path
+    def config_path
+      options[:config_path] || File.join(%w( / var run socky.yml ))
+    end
+
+    private
+
+    def prepare_logger(output)
+      @logger = Logger.new(output)
+      @logger.level = Logger::INFO unless options[:debug]
+      @logger
+    end
+  end
+end
+
+require 'socky/misc'
+require 'socky/options'
+require 'socky/runner'
+require 'socky/connection'
+require 'socky/net_request'
+require 'socky/message'

data/lib/socky/connection.rb

@@ -0,0 +1,137 @@
+require 'json'
+require 'socky/connection/authentication'
+require 'socky/connection/finders'
+
+module Socky
+  # every connection to server creates one instance of Connection
+  class Connection
+    include Socky::Misc
+    include Socky::Connection::Authentication
+    extend Socky::Connection::Finders
+
+    # reference to connection socket
+    attr_reader :socket
+
+    class << self
+      # list of all connections in pool
+      # @return [Array] list of connections
+      def connections
+        @connections ||= []
+      end
+    end
+    
+    # initialize new connection
+    # @param [WebSocket] socket valid connection socket
+    def initialize(socket)
+      @socket = socket
+    end
+
+    # read query data from socket request
+    # @return [Hash] hash of query data
+    def query
+      socket.request["Query"] || {}
+    end
+
+    # return if user appear to be admin
+    # this one should not be base to imply that user actually is
+    # admin - later authentication is needed
+    # @return [Boolean] is user claim to be admin?
+    def admin
+      ["true","1"].include?(query["admin"])
+    end
+
+    # client individual id - multiple connection can be organized
+    # by client id and later accessed at once
+    # @return [String] client id(might be nil)
+    def client
+      query["client_id"]
+    end
+
+    # client individual secret - used to check if user is admin
+    # and to sending authentication data to server(by subscribe_url)
+    # @return [String] client secret(might be nil)
+    def secret
+      query["client_secret"]
+    end
+
+    # client channel list - one client can have multiple channels
+    # every client have at last channel - if no channels are provided
+    # at default then user is assigned to nil channel
+    # @return [Array] list of client channels
+    def channels
+      @channels ||= query["channels"].to_s.split(",").collect(&:strip).reject(&:empty?)
+      @channels[0] ||= nil # Every user should have at last one channel
+      @channels
+    end
+
+    # check if client is valid and add him to pool or disconnect
+    def subscribe
+      debug [self.name, "incoming"]
+      subscribe_request
+    end
+
+    # remove client from pool and disconnect
+    def unsubscribe
+      debug [self.name, "terminated"]
+      unsubscribe_request
+    end
+
+    # check if client can send messages and process it
+    # @see Socky::Message.process
+    # @param [String] msg message to send in json format
+    def process_message(msg)
+      if admin && authenticated?
+        Socky::Message.process(self, msg)
+      else
+        self.send_message "You are not authorized to post messages"
+      end
+    end
+
+    # send message to client
+    # @param [Object] msg data to send(will be converted to json using to_json method)
+    def send_message(msg)
+      send_data({:type => :message, :body => msg})
+    end
+
+    # disconnect connection
+    def disconnect
+      socket.close_connection_after_writing
+    end
+
+    # convert connection to json(used in show_connection query)
+    # @param [Any] args it is required by different versions of ruby
+    # @return [JSon] id, client_id and channel list data
+    def to_json(*args)
+      {
+        :id => self.object_id,
+        :client_id => self.client,
+        :channels => self.channels.reject{|channel| channel.nil?}
+      }.to_json
+    end
+
+    private
+
+    def send_data(data)
+      json_data = data.to_json
+      debug [self.name, "sending data", json_data]
+      socket.send json_data
+    end
+
+    def connection_pool
+      self.class.connections
+    end
+
+    def in_connection_pool?
+      connection_pool.include?(self)
+    end
+
+    def add_to_pool
+      connection_pool << self unless self.admin || in_connection_pool?
+    end
+
+    def remove_from_pool
+      connection_pool.delete(self)
+    end
+
+  end
+end

data/lib/socky/connection/authentication.rb

@@ -0,0 +1,99 @@
+module Socky
+  class Connection
+    # authentication module - included in Socky::Connection
+    module Authentication
+      include Socky::Misc
+
+      # check if user is valid and then send him authentication data and add to pool
+      # if not then user is given failure response(so client javascript
+      # will know that is should not reconnect again) and then is disconnected
+      # admin user is automaticaly authenticated but isn't added to pool
+      # he will be authenticated when he will try to send message
+      # thanks to that admin don't need to wait for authentication confirmation
+      # on every connection so it will fasten things for him
+      def subscribe_request
+        send_subscribe_request do |response|
+          if response
+            debug [self.name, "authentication successed"]
+            add_to_pool
+            EventMachine.add_timer(0.1) do
+              send_authentication("success")
+            end
+            @authenticated_by_url = true
+          else
+            debug [self.name, "authentication failed"]
+            EventMachine.add_timer(0.1) do
+              send_authentication("failure")
+              disconnect
+            end
+          end
+        end unless admin || authenticated?
+      end
+
+      # if user is authenticated then he is removed from pool and 
+      # unsubscribe notification is sent to server unless he is admin
+      # if user is not authenticated then nothing will happen
+      def unsubscribe_request
+        if authenticated?
+          remove_from_pool
+          send_unsubscribe_request{} unless admin
+        end
+      end
+
+      # if user is admin then his secred is compared with server secred
+      # in user isn't admin then it checks if user is authenticated by
+      # server request(defaults to true if subscribe_url is nil)
+      def authenticated?
+        @authenticated ||= (admin ? authenticate_as_admin : authenticate_as_user)
+      end
+
+      private
+
+      def send_authentication(msg)
+        send_data({:type => :authentication, :body => msg})
+      end
+
+      def authenticate_as_admin
+        options[:secret].nil? || secret == options[:secret]
+      end
+
+      def authenticate_as_user
+        authenticated_by_url?
+      end
+
+      def authenticated_by_url?
+        @authenticated_by_url
+      end
+
+      def send_subscribe_request(&block)
+        subscribe_url = options[:subscribe_url]
+        if subscribe_url
+          debug [self.name, "sending subscribe request to", subscribe_url]
+          Socky::NetRequest.post(subscribe_url, params_for_request, &block)
+          true
+        else
+          yield true
+        end
+      end
+
+      def send_unsubscribe_request(&block)
+        unsubscribe_url = options[:unsubscribe_url]
+        if unsubscribe_url
+          debug [self.name, "sending unsubscribe request to", unsubscribe_url]
+          Socky::NetRequest.post(unsubscribe_url, params_for_request, &block)
+        else
+          yield true
+        end
+      end
+
+      def params_for_request
+        {
+          :client_id => client,
+          :client_secret => secret,
+          :channels => channels
+        }.reject{|key,value| value.nil? || value.empty?}
+      end
+
+    end
+  end
+end