rcomet 0.0.2

data/lib/rcomet/client.rb

@@ -0,0 +1,188 @@
+require 'net/http'
+require 'uri'
+require 'rubygems'
+require 'json'
+require 'rcomet'
+require 'rcomet/channel'
+
+module RComet
+  class Client    
+    def initialize( uri_or_string )
+      @uri = uri_or_string
+      @uri = URI.parse(@uri) if @uri.class == String
+      @clientId = nil
+      # @interval = nil
+      @connection = nil
+      @subscriptions = {}
+    end
+    
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * clientId                           * successful
+    #                * connectionType                     * clientId
+    # MAY include:   * ext                 MAY include:   * error
+    #                * id                                 * advice
+    #                                                     * ext
+    #                                                     * id
+    #                                                     * timestamp
+    def connect
+      @connection.kill unless @connection.nil?
+      @connection = Thread.new {
+        faild = false
+        while true
+          id = RComet.random(32)
+          message = {
+            "channel" => RComet::Channel::CONNECT,
+            "clientId" => @clientId,
+            "connectionType" => "long-polling",
+            "id" => id
+          }
+          r = send( message )
+            
+          if r[0]["id"] == id and r[0]["successful"] == true
+            @subscriptions[r[1]["channel"]].call( r[1]["data"])
+          elsif r[0]["successful"] == false
+            faild = true
+            break
+          end
+        end
+        
+        if faild
+          handshake()
+          connect()
+        end
+      }
+    end
+    
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * clientId                           * successful
+    # MAY include:   * ext                                * clientId
+    #                * id                  MAY include:   * error
+    #                                                     * ext
+    #                                                     * id
+    def disconnect
+      unless @connection.nil?
+        @connection.kill 
+        message = {
+          "channel" => RComet::Channel::DISCONNECT,
+          "clientId" => @clientId,
+          "id" => RComet.random(32)
+        }
+        r = send( message )
+        ## TODO : Check response
+      end
+    end
+    
+    # Request
+    # MUST include:  * channel
+    #                * version
+    #                * supportedConnectionTypes
+    # MAY include:   * minimumVersion
+    #                * ext
+    #                * id
+    # 
+    # Success Response                             Failed Response
+    # MUST include:  * channel                     MUST include:  * channel
+    #                * version                                    * successful
+    #                * supportedConnectionTypes                   * error
+    #                * clientId                    MAY include:   * supportedConnectionTypes
+    #                * successful                                 * advice
+    # MAY include:   * minimumVersion                             * version
+    #                * advice                                     * minimumVersion
+    #                * ext                                        * ext
+    #                * id                                         * id
+    #                * authSuccessful
+    def handshake
+      id = RComet.random(32)
+      message = {
+        "channel" => RComet::Channel::HANDSHAKE,
+        "version" => RComet::BAYEUX_VERSION,
+        "supportedConnectionTypes" => [ "long-polling", "callback-polling" ],
+        "id" => id
+      }
+      
+      response = send( message )[0]
+      if response["successful"] and response["id"] == id
+        @clientId = response["clientId"]
+        # @interval = response["advice"]["interval"]
+      else
+        raise
+      end
+    end
+    
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * data                               * successful
+    # MAY include:   * clientId            MAY include:   * id
+    #                * id                                 * error
+    #                * ext                                * ext
+    def publish( channel, data )
+      message = {
+        "channel" => channel,
+        "data" => data, 
+        "clientId" => @clientId,
+        "id" => RComet.random(32)
+      }
+      r = send(message)[0]
+      ## TODO : Check response
+    end
+    
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * clientId                           * successful
+    #                * subscription                       * clientId
+    # MAY include:   * ext                                * subscription
+    #                * id                  MAY include:   * error
+    #                                                     * advice
+    #                                                     * ext
+    #                                                     * id
+    #                                                     * timestamp
+    def subscribe( channel, &block )
+      @subscriptions[channel] = block if block_given?
+
+      message = {
+        "channel" => RComet::Channel::SUBSCRIBE,
+        "clientId" => @clientId,
+        "subscription" => channel,
+        "id" => RComet.random(32)
+      }
+      
+      r = send(message)
+      ## TODO : Check response
+    end
+    
+    # Request                              Response
+    # MUST include:  * channel             MUST include:  * channel
+    #                * clientId                           * successful
+    #                * subscription                       * clientId
+    # MAY include:   * ext                                * subscription
+    #                * id                  MAY include:   * error
+    #                                                     * advice
+    #                                                     * ext
+    #                                                     * id
+    #                                                     * timestamp
+    def unsubscribe( channels )
+      channels = [channels] unless channels.class == Array
+      channels.each do |c|
+        @subscriptions.delete(c)
+      end
+      message = {
+        "channel" => RComet::Channel::UNSUBSCRIBE,
+        "clientId" => @clientId,
+        "subscription" => channels,
+        "id" => RComet.random(32)
+      }
+      
+      r = send(message)
+      ## TODO : Check response
+    end
+    
+    private
+    def send( message )
+      res = Net::HTTP.post_form( @uri, { "message" => [message].to_json } )
+      return JSON.parse( res.body )
+    end
+    
+  end
+end

data/lib/rcomet/core_ext.rb

@@ -0,0 +1,5 @@
+class Hash #:nodoc:
+  def <<( h )
+    self.merge!( h )
+  end
+end

data/lib/rcomet/rack_adapter.rb

@@ -0,0 +1,289 @@
+# The Rack::Adapter class allow you to use RComet as a Rack middleware
+#
+# Example :
+#
+#   map '/comet' do
+#     run RComet::RackAdapter :mount => "/comet" do
+#       # ...
+#     end
+#   end
+#
+require 'rack'
+require 'json'
+
+require 'rcomet'
+require 'rcomet/core_ext'
+require 'rcomet/server'
+require 'rcomet/channel'
+require 'rcomet/user'
+
+module RComet
+  class RackAdapter #:nodoc:
+    def initialize(app = nil, options = nil, &block)
+      @app      = app if app.respond_to?(:call)
+      @options  = [app, options].grep(Hash).first
+      @channels = RComet::ChannelSet.new
+      @users    = Hash.new
+      @timeout  = nil
+      
+      instance_eval(&block) if block
+      return @app  
+    end
+    
+    def call(env)
+      request = Rack::Request.new(env)
+      
+      if request.params.empty?
+        [404, {'Content-Type' => 'text/html'}, ""]
+      else
+        messages = JSON.parse(request.params['message'])
+        jsonp    = request.params['jsonp'] || JSONP_CALLBACK
+        get      = request.get?
+
+        process( jsonp, messages, get )
+      end
+    end
+    
+    def channel
+      @channels
+    end
+    
+    def timeout( &block )
+      @handler = block if block_given?
+      @handler
+    end
+    
+    def process( jsonp, messages, get )
+      replies = []
+      messages.each do |message|
+        reply = nil
+        case message['channel'] 
+          when RComet::Channel::HANDSHAKE
+            reply = handshake( message )
+          when RComet::Channel::CONNECT
+            reply = connect( message )
+          when RComet::Channel::DISCONNECT
+            reply = disconnect( message )
+          when RComet::Channel::SUBSCRIBE
+            reply = subscribe( message )
+          when RComet::Channel::UNSUBSCRIBE
+            reply = unsubscribe( message )
+          else
+            reply = handle( message )
+        end
+        if reply.class == Array
+          replies.concat( reply )
+        else
+          replies << reply
+        end
+      end
+      
+      response = JSON.generate(replies)
+      type = {'Content-Type' => 'text/json'}
+      if get
+        response = "#{jsonp}(#{response});"
+        type = {'Content-Type' => 'text/javascript'}
+      end
+      
+      [200, type, [response]]
+    end
+    
+    def handshake( message )
+      begin
+        user = User.new(self)
+      end while @users.has_key?(user.id)
+      @users[user.id] = user
+      
+      response = {
+        'channel'                   => RComet::Channel::HANDSHAKE,
+        'version'                   => RComet::BAYEUX_VERSION,
+        'minimumVersion'            => RComet::BAYEUX_VERSION,
+        'supportedConnectionTypes'  => ['long-polling','callback-polling'],
+        'clientId'                  => user.id,
+        'successful'                => true
+      }
+      response << { 'id' => message['id'] } if message.has_key?('id')
+      
+      return response
+    end
+    
+    def connect( message )
+      # Initialize response
+      response = { 
+        'channel' => RComet::Channel::CONNECT,
+        'clientId' => message['clientId']
+      }
+      response << { 'id' => message['id'] } if message.has_key?('id')
+
+      # Get user for clientId
+      user = @users[message['clientId']]
+      if user
+        # Ok, connect user
+        user.connected = true
+        time = Time.new
+        response << {
+          'successful'  => true,
+          'timestamp'   =>"#{time.hour}:#{time.min}:#{time.sec} #{time.year}"
+        }
+        
+        if user.has_channel?
+          response = user.wait( response )
+        end
+        user.connected = false
+      else
+        # User does not exist!
+        response << {
+          'successful'  => false,
+          'error'       => "402:#{message['clientId']}:Unknown Client ID"
+        }
+      end
+      
+      return response
+    end
+    
+    def disconnect( message )
+      # Initialize response message
+      response = {
+        'channel'     => RComet::Channel::DISCONNECT,
+        'clientId'    => message['clientId']
+      }
+      response << { 'id' => message['id'] } if message.has_key?('id')
+      
+      # Get user for clientId
+      user = @users[message['clientId']]
+      if user
+        # Ok, disconnect user
+        user.connected = false
+        @users.delete( message['clientId'] )
+        
+        # Complete reponse
+        response << {
+          'successful'  => true
+        }
+      else
+        # User does nit exist!
+        response << {
+          'successful'  => false,
+          'error'       => "402:#{message['clientId']}:Unknown Client ID"
+        }
+      end
+      
+      return response
+    end
+    
+    def subscribe( message )
+      response = {
+        'channel'     => RComet::Channel::SUBSCRIBE,
+        'clientId'    => message['clientId']
+      }
+      response << { 'id' => message['id'] } if message.has_key?('id')
+      
+      # Get user for clientId
+      user = @users[message['clientId']]
+      if user
+        # Get channel
+        channel = @channels[message['subscription']]
+        if channel
+          user.subscribe( channel )
+          response << {
+            'successful'    => true,
+            'subscription'  => message['subscription']
+          }
+          
+          unless channel.data.nil?
+            response = [response]
+            response << { 
+              'channel'   => message['subscription'],
+              'id'        => (message['id'].to_i+1).to_s,
+              'data'      => channel.data
+            }
+          end
+        else
+          #Channel doesn't exist
+          response << {
+            'successful'    => false,
+            'subscription'  => message['subscription'],
+            'error'         => "404:#{message['subscription']}:Unknown Channel"
+          }
+        end
+      else
+        response << {
+          'successful'  => false,
+          'error'       => "402:#{message['clientId']}:Unknown Client ID"
+        }
+      end
+
+      return response
+    end
+    
+    def unsubscribe( message )
+      # Initialize response
+      response = {
+        'channel'     => RComet::Channel::UNSUBSCRIBE,
+        'clientId'    => message['clientId']
+      }
+      response << { 'id' => message['id'] } if message.has_key?('id')
+
+      # Get user for clientId
+      user = @users[message['clientId']]
+      if user
+        # Get channel
+        channel = @channels[message['subscription']]
+        if channel
+          user.unsubscribe( channel )
+          response << {
+            'successful'    => true,
+            'subscription'  => message['subscription']
+          }
+        else
+          #Channel doesn't exist
+          response << {
+            'successful'    => false,
+            'subscription'  => message['subscription'],
+            'error'         => "404:#{message['subscription']}:Unknown Channel"
+          }
+        end
+      else
+        response << {
+          'successful'  => false,
+          'error'       => "402:#{message['clientId']}:Unknown Client ID"
+        }
+      end
+      
+      return response
+    end
+    
+    def handle( message )
+      # Initialize response
+      response = { 
+        'channel' => message['channel']
+      }
+      response << { 'id' => message['id'] } if message.has_key?('id')
+
+      c = channel[message['channel']]
+      if c.nil?
+        response << {
+          'successful'  => false,
+          'error'       => "404:#{message['channel']}:Unknown Channel"
+        }
+      else
+        response << {
+          'successful'  => true
+        }
+      end
+            
+      Thread.new do
+        unless c.nil?
+          if c.handler.nil?
+            c.data( message['data'] )
+          else
+            c.handler.call( message )
+          end
+        end
+        return
+      end
+      
+      return response      
+    end    
+  end
+end

data/lib/rcomet/server.rb

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rcomet/rack_adapter'
+require 'logger'
+
+module RComet
+  class Server
+    # Create a new Comet server
+    def initialize( options = {}, &block )
+      @conf = {
+        :host => "0.0.0.0",
+        :port => 8990,
+        :mount => "/comet",
+        :log => $stdout,
+        :server => :webrick
+      }.merge( options )
+      
+      if block_given?
+        @comet = RComet::RackAdapter.new( &block )
+      else
+        @comet = RComet::RackAdapter.new( )
+      end
+    end
+    
+    # Start the Comet server
+    def start
+      route = { @conf[:mount] => @comet }
+      app = Rack::URLMap.new(route)
+      app = Rack::ContentLength.new(app)
+      app = Rack::CommonLogger.new(app, Logger.new(@conf[:log]))
+      
+      @main_loop = Thread.new do
+        case @conf[:server].to_sym
+        when :mongrel
+          puts "** Starting Mongrel on #{@conf[:host]}:#{@conf[:port]}"
+          @server = Rack::Handler::Mongrel.run( app, {:Port => @conf[:port], :Host => @conf[:host]} )
+        when :webrick
+          puts "** Starting WEBrick on #{@conf[:host]}:#{@conf[:port]}"
+          @server = Rack::Handler::WEBrick.run( app, {:Port => @conf[:port], :BindAddress => @conf[:host]} )
+        when :thin
+          puts "** Starting Thin on #{@conf[:host]}:#{@conf[:port]}"
+          @server = Rack::Handler::Thin.run( app, {:Port => @conf[:port], :Host => @conf[:host]} )
+        end
+        
+        puts "Thread end !"
+        exit
+      end
+      
+      at_exit {
+        puts "Quitting..."
+      }
+    end
+    
+    def method_missing(method_name, *args, &block) #:nodoc:
+      @comet.send(method_name,*args, &block)
+    end
+  end
+end

data/lib/rcomet/user.rb

@@ -0,0 +1,61 @@
+module RComet
+  class User
+    attr_reader :id
+    attr_accessor :connected
+    
+    # Create a new Comet user
+    def initialize(adapter)
+      @connected = false
+      @id = RComet.random(64)
+      
+      @channels = Hash.new
+      @event_mutex = Mutex.new
+      @messages = []
+      @adapter = adapter
+    end
+    
+    def wait( messages ) #:nodoc:
+      @continue = @messages.empty?
+      @messages << messages
+      while @continue; end
+      
+      messages = @messages.clone
+      @messages = []
+      return messages
+    end
+    
+    def send( message ) #:nodoc:
+      if @connected == false
+        ## ADD TIMEOUT !
+        unless @adapter.timeout.nil?
+          @adapter.timeout.call(self)
+        end
+      end
+      
+      @messages << message
+      @continue = false
+    end
+    
+    # Subscribe to a given channel
+    def subscribe( channel )
+      channel.add_user( self )
+      @channels[channel.path] = channel
+    end
+    
+    # Unsubscribe to a given channel
+    def unsubscribe( channel )
+      c = @channels.delete(channel)
+      c.delete_user(self) if c
+    end
+    
+    def unsubscribe_all( )
+      @channels.each do |c|
+        unsubscribe(c)
+      end
+    end
+    
+    def has_channel? #:nodoc:
+      return( not @channels.empty? )
+    end
+  end
+end

data/lib/rcomet.rb

@@ -0,0 +1,15 @@
+module RComet
+  VERSION = '0.0.2'
+  
+  BAYEUX_VERSION   = '1.0'
+  JSONP_CALLBACK   = 'jsonpcallback'
+  CONNECTION_TYPES = %w[long-polling callback-polling]
+  
+  def self.random(size) #:nodoc:
+    id = ''
+    size.times do |i|
+      id << ?A+rand(50)
+    end
+    return id
+  end
+end