socky-server 0.4.1 → 0.5.0.beta1

data/.gitignore

@@ -1,6 +1,2 @@
 pkg/
-tmp/
-*.gem
-
-spec/files/socky.log
 Gemfile.lock

data/.travis.yml

@@ -0,0 +1,6 @@
+script: "bundle exec rake spec"
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ree
+  - rbx

data/CHANGELOG.md

@@ -1,11 +1,17 @@
 # Changelog
 
-## 0.4.1 / 2011-05-12
+## 0.5.0.beta1 / 2011-08-01
 
-- new features:
-  - none
-- bugfixes:
-  - restore compatibility with em-websocket 0.3.x
+Socky was rewritten from scratch. From this version it's Rack application and is based on
+open protocol, and have a lot of new features. Some of them:
+
+- Rack app - you can run both Socky and your web-application in the same process!
+- New, standarized communication protocol(it will be easy to implement Socky in other languages)
+- New user authentication process - much faster and more secure
+- Allow users to dynamicly subscribe/unsubscribe from channels
+- New events system - easier to learn and much more powerfull
+
+And many more - please check [Socky website](http://socky.org) for more or check specific Socky elements at [Github](http://github.com/socky).
 
 ## 0.4.0 / 2010-10-27
 

data/Gemfile

@@ -1,3 +1,5 @@
 source "http://rubygems.org"
 
 gemspec
+
+gem 'rake'

data/README.md

@@ -1,102 +1,81 @@
-Socky - server in Ruby
-===========
+# Socky - server in Ruby [![](http://travis-ci.org/socky/socky-server-ruby.png)](http://travis-ci.org/socky/socky-server-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.
+## Installation
 
-## Example
+    $ gem install socky-server --pre
 
-You can try [live example](http://sockydemo.imanel.org) or view its [source code](http://github.com/socky/socky-example)
-
-Also important information can be found on our [google group](http://groups.google.com/group/socky-users).
-
-## Install
-
-The best way to install Socky server is via RubyGems:
-
-    gem install socky-server
-
-Socky ruby server requires the gems em-websocket and em-http-request. These are automatically installed by the gem install command.
-
-Alternative method is to clone repo and run it manually:
+## Usage
 
-    git clone git://github.com/socky/socky-server-ruby.git
-    cd socky-server-ruby
-    ./bin/socky
+Socky server provides two Rack middlewares - WebSocket and HTTP. Each one of them can be used separately, but they can be also used in one process. Example Rackup file could look like that:
 
-You can also build it after clonning(this will require Jeweler gem)
+    require 'socky/server'
+    
+    map '/websocket' do
+      run Socky::Server::WebSocket.new
+    end
+    
+    map '/http' do
+      run Socky::Server::HTTP.new
+    end
 
-    rake gemspec
-    rake build
+## Configuration
 
-## Runtime Dependencies
+Both middlewares accept options as hash. Currently available options are:
 
-- EM-WebSocket: Backend for WebSocket server
-- EM-HTTP-Client: Sending authorize requests
+### :applications [Hash]
 
-## Usage
+Hash of supported applications. Each key is application name, each value is application secret. You can use as much applications as you want - each of them will have separate application address created by mixing hostname, middleware address and applicatio name. So i.e. for app "my_app" WebSocket application uri will be:
 
-After installing gem you will have binary available:
+    http://example.org/websocket/my_app
 
-    socky [OPTIONS]
+### :debug [Boolean]
 
-First of all you will need to generate config file:
+Should application log output? Default Rack logger will be used, so demonized server will log to file. Please note that for HTTP middlewere Rack::CommonLogger will be more reliable that debug mode.
 
-    socky -g config.yml
+### :config [String]
 
-After that you can tweak this file, or just run server with default values:
+Path to YAML config file. Config file should contain hash with exactly the same syntax like normal options.
 
-    socky -c config.yml
-
-## Configuration
+## Example configuration
 
-The following is a list of the currently supported configuration options. These can all be specified by creating a config file. There are also flags for the `socky` executable which are described below next to their respective configuration options.
+Create file 'config.ru':
 
-### Configuration Settings
+    require 'socky/server'
 
-| *Setting*       | *Config*                 | *Flag*                  | *Description* |
-| --------------- | ------------------------ | ----------------------- | ------------- |
-| Generate config |                          | `-g, --generate [path]` | Generate default config file
-| Read config     |                          | `-c, --config [path]`   | Path to configuration file
-| Port            | `port: [integer]`        | `-p, --port PORT`       | Set the port for server to listen
-| Secure          | `secure: [boolean]`      | `-s, --secure`          | Set wss/SSL model on
-| TLS Options     | `tls_options: [hash]`    |                         | Paths to private key file and certificate chain file for secure connection
-| Daemon          | `daemon: [boolean]`      | `-d, --daemon`          | Run in daemon(background) mode
-| Pid path        | `pid_path: [path]`       | `-P, --pid`             | Path to store pid path
-| Kill            |                          | `-k, --kill`            | Kill daemonized server described by file in pid path
-| Use log         | `log_path: [path]`       | `-l, --log [path]`      | Path to print debugging information
-| Debug           | `debug: [boolean]`       | `--debug`               | Run in debug mode
-| Deep debug      | `deep_debug: [boolean]`  | `--deep-debug`          | Run in debug mode that is even more verbose
-| Subscribe URL   | `subscribe_url: [url]`   |                         | Url to with send authentication request
-| Unsubscribe URL | `unsubscribe_url: [url]` |                         | Url to with send logout request
-| Timeout         | `timeout: [integer]`     |                         | Time after with authentication request will timeout
-| Secret          | `secret: [string]`       |                         | Key that will be used by to authorize as admin user
+    options = {
+      :debug => true,
+      :applications => {
+        :my_app => 'my_secret',
+        :other_app => 'other_secret'
+      }
+    }
 
-### Default Configuration
+    map '/websocket' do
+      run Socky::Server::WebSocket.new options
+    end
 
-    :port: 8080
-    :debug: false
+    map '/http' do
+      use Rack::CommonLogger
+      run Socky::Server::HTTP.new options
+    end
 
-    :subscribe_url: http://localhost:3000/socky/subscribe
-    :unsubscribe_url: http://localhost:3000/socky/unsubscribe
+Run file using Thin:
 
-    :secret: my_secret_key
+    $ thin -R config.ru -p3001 start
 
-    :secure: false
+## Setting other options
 
-    # :timeout: 3
+Options like demonizing, logging to file, SSL support and others should be supported by Rack server like Thin. Socky Server is utilizing all of them so we will not describe them here.
 
-    # :log_path: /var/log/socky.log
-    # :pid_path: /var/run/socky.pid
+## Which Rack servers are currently supported?
 
-    # :tls_options:
-    #   :private_key_file: /private/key
-    #   :cert_chain_file: /ssl/certificate
+All that are supported by [websocket-rack](http://github.com/imanel/websocket-rack). At the time of writing only Thin was supported, but it should change in near future.
 
 ## License
 
 (The MIT License)
 
-Copyright (c) 2010 Bernard Potocki
+Copyright (c) 2011 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:
 

data/Rakefile

@@ -1,13 +1,11 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
-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|
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["-c", "-f progress"]
+  t.pattern = 'spec/**/*_spec.rb'
 end
+
+task :default => :spec

data/config.ru

@@ -0,0 +1,19 @@
+# Start with:
+# $ thin -R socky.ru start
+current_dir = File.expand_path(File.dirname(__FILE__))
+require current_dir + '/lib/socky/server'
+
+options = {
+  :config_file => current_dir + '/example/config.yml',
+  :debug => true
+}
+
+map '/websocket' do
+  run Socky::Server::WebSocket.new options
+end
+
+map '/http' do
+  use Rack::CommonLogger
+  
+  run Socky::Server::HTTP.new options
+end

data/example/config.yml

@@ -0,0 +1,4 @@
+debug: false
+
+applications:
+  my_app: my_secret

data/lib/socky/server.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'json'
+require 'rack/websocket'
+require 'socky/authenticator'
+
+# Socky is a WebSocket server and client for Ruby
+# @author Bernard "Imanel" Potocki
+# @see http://github.com/socky/socky-server-ruby main repository
+module Socky
+  module Server
+    ROOT = File.expand_path(File.dirname(__FILE__))
+  
+    autoload :Application, "#{ROOT}/server/application"
+    autoload :Channel,     "#{ROOT}/server/channel"
+    autoload :Config,      "#{ROOT}/server/config"
+    autoload :Connection,  "#{ROOT}/server/connection"
+    autoload :HTTP,        "#{ROOT}/server/http"
+    autoload :Logger,      "#{ROOT}/server/logger"
+    autoload :Message,     "#{ROOT}/server/message"
+    autoload :Misc,        "#{ROOT}/server/misc"
+    autoload :WebSocket,   "#{ROOT}/server/websocket"
+  end
+end

data/lib/socky/server/application.rb

@@ -0,0 +1,51 @@
+module Socky
+  module Server
+    class Application
+    
+      attr_accessor :name, :secret
+    
+      class << self
+        # list of all known applications
+        # @return [Hash] list of applications
+        def list
+          @list ||= {}
+        end
+      
+        # find application by name
+        # @param [String] name name of application
+        # @return [Application] found application or nil
+        def find(name)
+          list[name]
+        end
+      end
+    
+      # initialize new application
+      # @param [String] name application name
+      # @param [String] secret application secret key
+      def initialize(name, secret)
+        @name = name
+        @secret = secret
+        self.class.list[name] ||= self
+      end
+    
+      # list of all connections for this application
+      # @return [Hash] hash of all connections
+      def connections
+        @connections ||= {}
+      end
+    
+      # add new connection to application
+      # @param [Connection] connection connetion to add
+      def add_connection(connection)
+        self.connections[connection.id] = connection
+      end
+    
+      # remove connection from application
+      # @param [Connection] connection connection to remove
+      def remove_connection(connection)
+        self.connections.delete(connection.id)
+      end
+    
+    end
+  end
+end

data/lib/socky/server/channel.rb

@@ -0,0 +1,30 @@
+module Socky
+  module Server
+    class Channel
+      ROOT = File.expand_path(File.dirname(__FILE__))
+
+      autoload :Base,     "#{ROOT}/channel/base"
+      autoload :Presence, "#{ROOT}/channel/presence"
+      autoload :Private,  "#{ROOT}/channel/private"
+      autoload :Public,   "#{ROOT}/channel/public"
+      autoload :Stub,     "#{ROOT}/channel/stub"
+    
+      # Find or create by application and channel by name
+      # @param [String] application_name name of application
+      # @param [String] channel_name name of channel
+      # @return [Channel::Base] channel instance
+      def self.find_or_create(application_name, channel_name)
+        return Stub.new(application_name, channel_name) unless (1..30).include?(channel_name.size)
+      
+        channel_type = case channel_name.match(/\A\w+/).to_s
+          when 'private' then Private
+          when 'presence' then Presence
+          else Public
+        end
+        
+        channel_type.find_or_create(application_name, channel_name)
+      end
+    
+    end
+  end
+end

data/lib/socky/server/channel/base.rb

@@ -0,0 +1,80 @@
+module Socky
+  module Server
+    class Channel
+      class Base
+      
+        attr_accessor :application, :name
+      
+        class << self
+          # List of all already registered channels of current type
+          # namespaces by application name
+          def list
+            @list ||= Hash.new{ |hash, key| hash[key] = Hash.new }
+          end
+        
+          # Find channel or create new
+          # @param [String] application_name name of application
+          # @param [String] channel_name name for channel
+          # @return [Base] channel instance
+          def find_or_create(application_name, channel_name)
+            self.list[application_name][channel_name] ||= self.new(application_name, channel_name)
+          end
+        end
+      
+        # Initialize new channel
+        # @param [String] application_name name of application
+        # @param [String] channel_name name for channel
+        def initialize(application_name, channel_name)
+          @application = Application.find(application_name)
+          @name = channel_name
+        end
+      
+        def subscribers
+          @subscribers ||= {}
+        end
+        
+        def send_data(data, except = nil)
+          self.subscribers.each do |subscriber_id, subscriber|
+            subscriber['connection'].send_data(data) unless subscriber_id == except || !subscriber['read']
+          end
+        end
+        
+        def add_subscriber(connection, message, subscriber_data = nil)
+          self.subscribers[connection.id] = { 'connection' => connection, 'data' => subscriber_data }.merge( rights(message) )
+          connection.channels[self.name] = self
+        end
+      
+        def remove_subscriber(connection)
+          self.subscribers.delete(connection.id)
+          connection.channels.delete(self.name)
+        end
+        
+        def deliver(connection, message)
+          return unless connection.nil? || (subscribers[connection.id] && subscribers[connection.id]['write'])
+          send_data({ 'event' => message.event, 'channel' => self.name, 'data' => message.user_data })
+        end
+        
+        protected
+      
+        def subscribe_successful(connection, message)
+          self.add_subscriber(connection, message)
+          connection.send_data('event' => 'socky:subscribe:success', 'channel' => self.name)
+        end
+      
+        def subscribe_failed(connection)
+          connection.send_data('event' => 'socky:subscribe:failure', 'channel' => self.name)
+        end
+      
+        def unsubscribe_successful(connection)
+          self.remove_subscriber(connection)
+          connection.send_data('event' => 'socky:unsubscribe:success', 'channel' => self.name)
+        end
+      
+        def unsubscribe_failed(connection)
+          connection.send_data('event' => 'socky:unsubscribe:failure', 'channel' => self.name)
+        end
+
+      end
+    end
+  end
+end

data/lib/socky/server/channel/presence.rb

@@ -0,0 +1,49 @@
+module Socky
+  module Server
+    class Channel
+      class Presence < Private
+        
+        def add_subscriber(connection, message, subscriber_data = nil)
+          self.send_data({ 'event' => 'socky:member:added', 'connection_id' => connection.id, 'channel' => self.name, 'data' => subscriber_data }, connection.id) unless rights(message)['hide']
+          super
+        end
+      
+        def remove_subscriber(connection)
+          self.send_data({ 'event' => 'socky:member:removed', 'connection_id' => connection.id, 'channel' => self.name }, connection.id)
+          super
+        end
+        
+        protected
+        
+        def subscribe_successful(connection, message)
+          user_data = JSON.parse(message.user_data) rescue nil
+          user_data = {} unless user_data.is_a?(Hash)
+          
+          self.add_subscriber(connection, message, user_data)
+          connection.send_data('event' => 'socky:subscribe:success', 'channel' => self.name, 'members' => member_list(connection))
+        end
+        
+        def member_list(connection)
+          list = []
+          self.subscribers.each do |connection_id, member|
+            list << { 'connection_id' => connection_id, 'data' => member['data'] } unless connection_id == connection.id
+          end
+          list
+        end
+                
+        def hash_from_message(connection, message)
+          hash = super
+          hash.merge!('data' => message.user_data)
+          hash
+        end
+        
+        def rights(message)
+          r = super
+          r.merge!( 'hide' => !!message.hide ) unless message.hide.nil?
+          r
+        end
+
+      end
+    end
+  end
+end