rocket-server 0.0.1

data/.gitignore

@@ -0,0 +1,22 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+*.rdb

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Araneo Ltd.
+
+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,60 @@
+# -*- ruby -*-
+
+$:.unshift(File.expand_path('../lib', __FILE__))
+$:.unshift(File.expand_path('../../rocket/lib', __FILE__))
+
+require 'rspec/core/rake_task'
+require 'rake/rdoctask'
+require 'rocket/server/version'
+
+SUMMARY = %Q{Fast and extensible web socket server built upon em-websockets.}
+DESCRIPTION = %Q{
+This is a fast web socket server built on awesome EventMachine with em-websockets help. 
+It provides easy to use, event-oriented middleware for your web-socket powered applications.    
+}
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.version = Rocket::Server.version
+    gem.name = "rocket-server"
+    gem.email = "chris@nu7hat.ch"
+    gem.homepage = "http://github.com/araneo/rocket"
+    gem.authors = ["Araneo", "Chris Kowalik"]
+    gem.summary = SUMMARY
+    gem.description = DESCRIPTION
+    #gem.add_dependency "rocket", "0.0.1"
+    gem.add_dependency "optitron", "~> 0.2"
+    gem.add_dependency "json", "~> 1.4"
+    gem.add_dependency "eventmachine", ">= 0.12"
+    gem.add_dependency "em-websocket", ">= 0.1.4"
+    gem.add_dependency "logging", "~> 1.4"
+    gem.add_dependency "daemons", "~> 1.1"
+    gem.add_dependency "konfigurator", ">= 0.1.1"
+    gem.add_development_dependency "rspec", "~> 2.0"
+    gem.add_development_dependency "mocha", "~> 0.9"
+  end
+  Jeweler::GemcutterTasks.new
+rescue
+  puts 'Jeweler is not available here'
+end
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rspec_opts = %q[-I../rocket/lib -Ilib -c -b]
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rcov = true
+  t.rspec_opts = %q[-I../rocket/lib -Ilib -c -b]
+  t.rcov_opts = %q[-I../rocket/lib -Ilib -T -x "spec"]
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.title = "Rocket server #{Rocket::Server.version}"
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :spec

data/bin/rocket-server

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+trap("TERM") { exit(0) }
+trap("INT")  { exit(0) }
+
+begin
+  require "rocket-server"
+rescue LoadError
+  require "rubygems"
+  require "rocket-server"
+end
+
+Rocket::Server::CLI.dispatch(ARGV)

data/etc/testing.yml

@@ -0,0 +1,38 @@
+# On which host and port server should listen for connections. 
+host: localhost
+port: 9772
+
+# Run applicaiton in secured mode (wss).
+#secure: true
+secure: false
+
+# Specify prefered verbosity level.
+#verbose: true # Increase verbosity
+#quiet: true # Decrease verbosity
+verbose: true
+
+# Run web sockets server in debug mode.
+#debug: true
+debug: true
+
+# Run daemonized instance of Rocket server.
+#daemon: true
+daemon: false
+
+# Specify path to server process' PID file. This option works only
+# when server is daemonized.  
+#pid: /var/run/rocket.pid
+
+# Specify path to server's output log. 
+#log: /var/log/rocket.log
+
+# SSL certificates configuration.
+#tls_options:
+#  private_key_file: /home/ssl/private.key
+#  cert_chain_file: /home/ssl/certificate
+
+# Here you can specify all static apps allowed to run on this server. 
+# Apps are kind of namespaces with separated authentication.
+apps:
+  test_app: 
+    secret: secretkey

data/lib/rocket-server.rb

@@ -0,0 +1,2 @@
+require 'rocket'
+require 'rocket/server'

data/lib/rocket/server.rb

@@ -0,0 +1,87 @@
+require "konfigurator"
+require 'eventmachine'
+require 'em-websocket'
+require 'logging'
+require 'fileutils'
+require 'json'
+require 'yaml'
+
+module Rocket
+  module Server
+  
+    autoload :Helpers,    "rocket/server/helpers"
+    autoload :CLI,        "rocket/server/cli"
+    autoload :Runner,     "rocket/server/runner"
+    autoload :Connection, "rocket/server/connection"
+    autoload :Channel,    "rocket/server/channel"
+    autoload :Session,    "rocket/server/session"
+    autoload :App,        "rocket/server/app"
+    autoload :Misc,       "rocket/server/misc"
+
+    include Konfigurator::Simple
+
+    # Default configuration
+    set :host, "localhost"
+    set :port, 9772
+    disable :debug
+    disable :secure
+    disable :verbose
+    disable :quiet
+    disable :daemon
+    set :pid, nil
+    set :log, nil
+    set :tls_options, {}
+    set :apps, []
+    set :plugins, []
+    
+    class << self
+    
+      def apps
+        @apps ||= settings[:apps] || {}
+      end
+    
+      def logger
+        @logger ||= default_logger
+      end
+      
+      def logger=(logger)
+        @logger = logger
+      end
+      
+      def load_settings_with_setup(file, local_settings={})
+        load_settings_without_setup(file, false)
+        settings.merge!(local_settings)
+        configure_logger
+        require_plugins
+        true
+      rescue => ex
+        puts ex.to_s
+        exit 1
+      end
+      alias_method :load_settings_without_setup, :load_settings
+      alias_method :load_settings, :load_settings_with_setup
+      
+      def require_plugins
+        plugins.to_a.each {|plugin| require plugin }
+      end
+      
+      def configure_logger
+        logger.add_appenders(Logging.appenders.file(settings[:log])) if log
+        logger.level = :debug if verbose
+        logger.level = :error if !verbose and quiet
+        true
+      end
+      
+      def default_logger
+        logger = Logging.logger["Rocket"]
+        logger.add_appenders(Logging.appenders.stdout)
+        logger.level = :info
+        logger
+      end
+      
+    end # << self
+  end # Server
+end # Rocket
+
+require 'rocket/server/version'
+

data/lib/rocket/server/app.rb

@@ -0,0 +1,44 @@
+module Rocket
+  module Server
+    class App
+    
+      # Raised when specified app doesn't exist. 
+      class NotFoundError < RuntimeError; end
+      
+      class << self
+        # Returns list of all registered apps. 
+        def all
+          Rocket::Server.apps.to_a.map {|id,app| new(app.merge('id' => id)) }
+        end
+        
+        # Returns given app if such is registered.
+        #
+        #   Rocket::Server::App.find("my-test-app-id")     # => #<Rocket::Server::App>
+        #   Rocket::Server::App.find("not-registered-app") # raises Rocket::Server::App::NotFoundError
+        #
+        def find(app_id)
+          if app = Rocket::Server.apps[app_id] 
+            new(app.merge('id' => app_id))
+          else 
+            raise NotFoundError, "Application '#{app_id}' does not exist!"
+          end
+        end
+      end # << self
+      
+      attr_accessor :attributes
+      
+      def initialize(attrs={})
+        @attributes = attrs
+      end
+      
+      def id
+        attributes['id']
+      end
+      
+      def method_missing(meth, *args, &block) # :nodoc:
+        (value = attributes[meth.to_s]) ? value : super(meth, *args, &block)
+      end
+      
+    end # App
+  end # Server
+end # Rocket

data/lib/rocket/server/channel.rb

@@ -0,0 +1,22 @@
+module Rocket
+  module Server
+    class Channel < EM::Channel
+    
+      # Get specfied channel for given app or create it if doesn't exist.
+      #
+      #   Channel["my-app" => "testing-channel"] # => #<Rocket::Channel>
+      #   Channel["my-another-app" => "next-one"]
+      #
+      def self.[](id)
+        app, name = id.to_a.flatten
+        channels[[app, name]] ||= new
+      end
+      
+      # Returns list of registered channels.
+      def self.channels
+        @channels ||= {}
+      end
+      
+    end # Channels
+  end # Server
+end # Rocket

data/lib/rocket/server/cli.rb

@@ -0,0 +1,52 @@
+require "optitron"
+
+module Rocket
+  module Server
+    class CLI < Optitron::CLI
+      
+      include Helpers
+      
+      desc "Show used version of Rocket server"
+      def version
+        puts "Rocket v#{Rocket::Server.version}"
+      end
+      
+      desc "Start Rocket server on given host and port"
+      opt "config",  :short_name => "c", :default => "/etc/rocket/default.yml",    :desc => "Path to configuration file" 
+      opt "host",    :short_name => "h", :default => "localhost",                  :desc => "Specify server host"
+      opt "port",    :short_name => "p", :default => 9772,                         :desc => "Specify server port"
+      opt "plugins", :short_name => "r", :default => [],                           :desc => "Require ruby extensions at runtime"
+      opt "secure",  :short_name => "s", :default => false,                        :desc => "Switch between wss/ws modes"
+      opt "verbose", :short_name => "v", :default => false,                        :desc => "Increase verbosity"
+      opt "quiet",   :short_name => "q", :default => false,                        :desc => "Decrease verbosity"
+      opt "debug",   :short_name => "D", :default => false,                        :desc => "Run server in debug mode"
+      opt "daemon",  :short_name => "d", :default => false,                        :desc => "Run server as a daemon"
+      opt "pid",     :short_name => "P", :default => "/var/run/rocket/server.pid", :desc => "Path to PID file (only when daemonized)"
+      opt "log",     :short_name => "l", :default => nil,                          :desc => "Path to log file"
+      def start
+        Rocket::Server.load_settings(params.delete('config'), symbolize_keys(params))
+        Rocket::Server::Runner.new(Rocket::Server.settings).start!
+      end
+      
+      desc "Stop daemonized instance of Rocket server"
+      opt "config",  :short_name => "c", :default => "/etc/rocket/default.yml",    :desc => "Path to configuration file" 
+      opt "pid",     :short_name => "P", :default => "/var/run/rocket/server.pid", :desc => "Path to PID file (only when daemonized)"
+      def stop
+        Rocket::Server.load_settings(params.delete('config'), symbolize_keys(params))
+        
+        if pid = Rocket::Server::Runner.new(Rocket::Server.settings).kill!
+          puts "Rocket server killed (PID: #{pid})"
+        else
+          puts "No processes were killed!"
+        end
+      end
+      
+      desc "Generate configuration file"
+      def configure(file="rocket.yml")
+        Rocket::Server::Misc.generate_config_file(file)
+        puts "Created Rocket's server configuration: #{file}"
+      end
+      
+    end # CLI
+  end # Server
+end # Rocket

data/lib/rocket/server/connection.rb

@@ -0,0 +1,137 @@
+module Rocket
+  module Server
+    class Connection < EM::WebSocket::Connection
+    
+      include Helpers
+      
+      LOG_MESSAGES = {
+        :app_not_found_error   => "#%d : %s",
+        :opening_connection    => "%s #%d : Opening new connection...",
+        :closing_connection    => "%s #%d : Closing connection...",
+        :auth_success          => "%s #%d : Session authenticated successfully!",
+        :auth_error            => "%s #%d : Authentication error! Invalid secret key.",
+        :web_socket_error      => "%s #%d : Web socket error: %s",
+        :invalid_json_error    => "%s #%d : Invalid event's data! This is not valid JSON: %s",
+        :subscribing_channel   => "%s #%d : Subscribing the '%s' channel.",
+        :unsubscribing_channel => "%s #%d : Unsubscribing the '%s' channel.",
+        :trigger_error         => "%s #%d : Invalid event's data! No channel or event name specified in: %s",
+        :access_denied_error   => "%s #%d : Action can't be performed, access denied!",
+        :trigger_success       => "%s #%d : Triggering '%s' on '%s' channel: %s",
+        :subscribe_error       => "%s #%d : Can't start subscription! Invalid data: %s",
+        :unsubscribe_error     => "%s #%d : Can't stop subscription! Invalid data: %s"
+      }
+    
+      # Only connections to path matching this pattern will be accepted.
+      APP_PATH_PATTERN = /^\/app\/([\d\w\-\_]+)/
+      
+      attr_reader :session
+      
+      def initialize(options={})
+        super(options)
+        @onopen = method(:onopen)
+        @onclose = method(:onclose)
+        @onmessage = method(:onmessage)
+        @onerror = method(:onerror)
+        @debug = Rocket::Server.debug
+      end
+      
+      # Starts new session for application specified in request path.
+      def onopen
+        ok = false
+        request["Path"] =~ APP_PATH_PATTERN
+        
+        if @session = Session.new($1) 
+          log_debug(:opening_connection, app_id, signature)
+          
+          if secret = request["Query"]["secret"]
+            if @session.authenticate!(secret)
+              ok = true
+              log_debug(:auth_success, app_id, signature)
+            else
+              log_debug(:auth_error, app_id, signature)
+            end
+          else
+            ok = true
+          end
+        end
+        
+        send({:event => 'rocket:connected', :data => { :session_id => signature }}.to_json) if ok
+        return ok
+      rescue App::NotFoundError => ex
+        log_error(:app_not_found_error, signature, ex.to_s)
+        close_connection
+      end
+      
+      # Closes current session. 
+      def onclose
+        log_debug(:closing_connection, app_id, signature)
+        @session.close and true if session?
+      end
+      
+      # Handler websocket's of runtime errors. 
+      def onerror(reason)
+        log_error(:web_socket_error, app_id, signature, reason)
+      end
+      
+      # Dispatches the received message.
+      def onmessage(message)
+        if session? and data = JSON.parse(message)
+          case data["event"]
+            when "rocket:subscribe"   then subscribe!(data['data'] || {})
+            when "rocket:unsubscribe" then unsubscribe!(data['data'] || {})
+          else
+            trigger!(data)
+          end
+        end
+      rescue JSON::ParserError
+        log_error(:invalid_json_error, app_id, signature, message.inspect)
+      end
+      
+      # Returns true if session is open. 
+      def session?
+        !!@session
+      end
+      
+      # Handles subscription event. 
+      def subscribe!(data)
+        if channel = data["channel"]
+          log_debug(:subscribing_channel, app_id, signature, channel)
+          @session.subscribe(channel, self)
+        else
+          log_error(:subscribe_error, app_id, signature, data.to_json)
+          false
+        end
+      end
+      
+      # Handles unsubscribe event.
+      def unsubscribe!(data)
+        if channel = data["channel"]
+          log_debug(:unsubscribing_channel, app_id, signature, channel)
+          @session.unsubscribe(channel, self)
+        else
+          log_error(:unsubscribe_error, app_id, signature, data.to_json)
+          false
+        end
+      end
+      
+      # Publishes given message. 
+      def trigger!(data)
+        if session? and session.authenticated?
+          channel, event = data.values_at("channel", "event")
+          if channel and event
+            log_debug(:trigger_success, app_id, signature, event, channel, data.inspect)
+            return Channel[session.app_id => channel].push(data.to_json)
+          end
+          log_error(:trigger_error, app_id, signature, data.inspect)
+        else
+          log_error(:access_denied_error, app_id, signature)
+        end
+      end
+      
+      def app_id
+        session? ? session.app_id : "unknown"
+      end
+      
+    end # Connection
+  end # Server
+end # Rocket