vines 0.1.0 → 0.1.1

data/lib/vines/stream/http/request.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class Request
+        attr_reader :rid, :stream
+
+        def initialize(stream, rid, content_type)
+          @stream, @rid, @content = stream, rid, content_type
+          @received = Time.now
+        end
+
+        # Return the number of seconds since this request was received.
+        def age
+          Time.now - @received
+        end
+
+        # Send an HTTP 200 OK response wrapping the XMPP node content back
+        # to the client.
+        def reply(node)
+          body = node.to_s
+          header = [
+            "HTTP/1.1 200 OK",
+            "Content-Type: #{@content}",
+            "Content-Length: #{body.bytesize}"
+          ].join("\r\n")
+          @stream.stream_write([header, body].join("\r\n\r\n"))
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/http/session.rb

@@ -0,0 +1,116 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class Session < Client::Session
+        include Nokogiri::XML
+
+        attr_accessor :content_type, :hold, :inactivity, :wait
+
+        CONTENT_TYPE = 'text/xml; charset=utf-8'.freeze
+
+        def initialize(stream)
+          super
+          @state = Http::Start.new(stream)
+          @inactivity, @wait, @hold = 20, 60, 1
+          @replied = Time.now
+          @requests, @responses = [], []
+          @content_type = CONTENT_TYPE
+        end
+
+        def close
+          Sessions.delete(@id)
+          router.delete(self)
+          @requests.each {|req| req.stream.close_connection }
+          @requests.clear
+          @responses.clear
+          @state = Client::Closed.new(nil)
+          @unbound = true
+          @available = false
+          broadcast_unavailable
+        end
+
+        def ready?
+          @state.class == Http::Ready
+        end
+
+        def requests
+          @requests.clone
+        end
+
+        def expired?
+          respond_to_expired_requests
+          @requests.empty? && (Time.now - @replied > @inactivity)
+        end
+
+        # Resume this session from its most recent state with a new client
+        # stream and incoming node.
+        def resume(stream, node)
+          stream.session.requests.each do |req|
+            request(req)
+          end
+          stream.session = self
+          @state.stream = stream
+          @state.node(node)
+        end
+
+        def request(request)
+          if @responses.any?
+            request.reply(wrap_body(@responses.join))
+            @replied = Time.now
+            @responses.clear
+          else
+            while @requests.size >= @hold
+              @requests.shift.reply(wrap_body(''))
+              @replied = Time.now
+            end
+            @requests << request
+          end
+        end
+
+        # Send an HTTP 200 OK response wrapping the XMPP node content back
+        # to the client.
+        def reply(node)
+          @requests.shift.reply(node)
+          @replied = Time.now
+        end
+
+        # Write the XMPP node to the client stream after wrapping it in a BOSH
+        # body tag. If there's a waiting request, the node is written
+        # immediately. If not, it's queued until the next request arrives.
+        def write(node)
+          if request = @requests.shift
+            request.reply(wrap_body(node))
+            @replied = Time.now
+          else
+            @responses << node.to_s
+          end
+        end
+
+        def unbind!(stream)
+          @requests.reject! {|req| req.stream == stream }
+        end
+
+        private
+
+        def respond_to_expired_requests
+          expired = @requests.select {|req| req.age > @wait }
+          expired.each do |request|
+            request.reply(wrap_body(''))
+            @requests.delete(request)
+            @replied = Time.now
+          end
+        end
+
+        def wrap_body(data)
+          doc = Document.new
+          doc.create_element('body') do |node|
+            node.add_namespace(nil, NAMESPACES[:http_bind])
+            node.inner_html = data.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/http/sessions.rb

@@ -0,0 +1,65 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      # Sessions is a cache of Http::Session objects for transient HTTP
+      # connections. The cache is monitored for expired client connections.
+      class Sessions
+        include Vines::Log
+
+        @@instance = nil
+        def self.instance
+          @@instance ||= self.new
+        end
+
+        def self.[](sid)
+          instance[sid]
+        end
+
+        def self.[]=(sid, session)
+          instance[sid] = session
+        end
+
+        def self.delete(sid)
+          instance.delete(sid)
+        end
+
+        def initialize
+          @sessions = {}
+          start_timer
+        end
+
+        def []=(sid, session)
+          @sessions[sid] = session
+        end
+
+        def [](sid)
+          @sessions[sid]
+        end
+
+        def delete(sid)
+          @sessions.delete(sid)
+        end
+
+        private
+
+        # Check for expired clients to cleanup every second.
+        def start_timer
+          @timer ||= EventMachine::PeriodicTimer.new(1) { cleanup }
+        end
+
+        # Remove cached information for all expired connections. An expired
+        # HTTP client is one that has no queued requests and has had no activity
+        # for over 20 seconds.
+        def cleanup
+          @sessions.each_value do |session|
+            session.close if session.expired?
+          end
+        rescue Exception => e
+          log.error("Expired session cleanup failed: #{e}")
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/http/start.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class Start < State
+        def initialize(stream, success=Auth)
+          super
+        end
+
+        def node(node)
+          raise StreamErrors::NotAuthorized unless body?(node)
+          if session = Sessions[node['sid']]
+            session.resume(stream, node)
+          else
+            stream.start(node)
+            advance
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/http.rb

@@ -3,108 +3,150 @@
 module Vines
   class Stream
     class Http < Client
-      include Thin
-      include Vines::Log
-
-      attr_accessor :last_broadcast_presence, :last_activity
+      attr_accessor :session
 
       def initialize(config)
-        @config = config
-        @domain = nil
-        @requested_roster = false
-        @available = false
-        @unbound = false
-        @last_broadcast_presence = nil
-        @request = Thin::Request.new
-        @@http_states ||= HttpStates.new
-        @state = Auth.new(self)
+        super
+        @session = Http::Session.new(self)
+      end
+
+      def post_init
+        super
+        router.delete(self)
+        @parser = ::Http::Parser.new.tap do |p|
+          body = ''
+          p.on_body = proc {|data| body << data }
+          p.on_message_complete = proc {
+            process_request(body)
+            body = ''
+          }
+        end
+      end
+
+      # Return true if this session ID matches the stream's session ID. Clients
+      # are only allowed one session per stream so they must send the same
+      # session ID on each request.
+      def valid_session?(sid)
+        @session.id == sid
       end
 
-      def user
-        @http_state.user
+      def max_stanza_size
+        @config[:http].max_stanza_size
       end
 
-      def user=(user)
-        @http_state.user = user
+      def max_resources_per_account
+        @config[:http].max_resources_per_account
       end
 
-      def receive_data(data)
-        #TODO: make sure we add max stanza size enforcement
-        if @request.parse(data)
-          process_http_request(@request)
-          @request = Thin::Request.new
+      def process_request(body)
+        # proxy server ping
+        if body.empty?
+          req = Request.new(self, nil, 'text/plain')
+          req.reply('online')
+          close_connection_after_writing
+        else
+          body = Nokogiri::XML(body).root
+          req = Request.new(self, body['rid'], @session.content_type)
+          @session.request(req)
+          @nodes.push(body)
         end
-      rescue InvalidRequest => e
-        error(StreamErrors::NotWellFormed.new)
       end
 
+      # Alias the Stream#write method before overriding it so we can call
+      # it later from a Session instance.
+      alias :stream_write :write
+
+      # Override Stream#write to queue stanzas rather than immediately writing
+      # to the stream. Stanza responses must be paired with a queued request.
       def write(data)
-        @http_state.write(data)
+        @session.write(data)
+      end
+
+      # Return an array of Node objects inside the body element.
+      # TODO This parses the XML again just to strip namespaces. Figure out
+      # Nokogiri namespace handling instead.
+      def parse_body(body)
+        body.namespace = nil
+        body.elements.map do |node|
+          Nokogiri::XML(node.to_s.sub(' xmlns="jabber:client"', '')).root
+        end
       end
 
-      def setup_new_client(rid, domain)
-        sid = Kit.uuid
-        log.info("Setting up a new client SID: #{sid} for RID: #{rid}.")
-        @http_state = HttpState.new(self, sid, rid, domain)
-        @@http_states[sid] = @http_state
+      def start(node)
+        domain, type, hold, wait, rid = %w[to content hold wait rid].map {|a| (node[a] || '').strip }
+        version = node.attribute_with_ns('version', NAMESPACES[:bosh]).value rescue nil
+
+        @session.inactivity = 20
+        @session.domain = domain
+        @session.content_type = type unless type.empty?
+        @session.hold = hold.to_i unless hold.empty?
+        @session.wait = wait.to_i unless wait.empty?
+
+        raise StreamErrors::UndefinedCondition.new('rid required') if rid.empty?
+        raise StreamErrors::UnsupportedVersion unless version == '1.0'
+        raise StreamErrors::HostUnknown unless @config.vhost?(domain)
+        raise StreamErrors::InvalidNamespace unless node.namespaces['xmlns'] == NAMESPACES[:http_bind]
+
+        Sessions[@session.id] = @session
+        router << @session
+        send_stream_header
       end
 
-      def unbind
-        #router.delete(@http_state)
-        log.info("HTTP Stream disconnected:\tfrom=#{@remote_addr}\tto=#{@local_addr}")
-        log.info("Streams connected: #{router.size}")
+      def terminate
+        doc = Nokogiri::XML::Document.new
+        node = doc.create_element('body',
+          'type'  => 'terminate',
+          'xmlns' => NAMESPACES[:http_bind])
+        @session.reply(node)
+        close_stream
       end
 
-      def process_http_request(request)
-        if request.body.string.empty?
-          #Respond to proxy servers' status pings
-          log.info("A status request has been received.")
-          send_data("Online")
-          close_connection_after_writing
-          return
-        end
-        body = Nokogiri::XML(request.body.string).root
-        body.namespace = nil
-        #TODO: Confirm this is a valid body stanza.
-        # If it isn't a body, return proxy ping result
-
-        if body['sid']
-          @http_state = @@http_states[body['sid']]
-          unless @http_state
-            log.info("Client was not found #{body['sid']}")
-            send_bosh_error
-            return
-          end
-          @domain = @http_state.domain
-          @user = @http_state.user
-          @http_state.request(body['rid'])
-          if body['restart']
-            @http_state.handle_restart
-            router << @http_state
-            @state = Bind.new(self)
-          end
+      private
 
-          body.elements.each do |node|
-            @nodes.push(Nokogiri::XML(node.to_s.sub(' xmlns="jabber:client"', '')).root)
+      def send_stream_header
+        doc = Nokogiri::XML::Document.new
+        node = doc.create_element('body',
+          'charsets'     => 'UTF-8',
+          'from'         => @session.domain, 
+          'hold'         => @session.hold,
+          'inactivity'   => @session.inactivity,
+          'polling'      => '5',
+          'requests'     => '2',
+          'sid'          => @session.id,
+          'ver'          => '1.6',
+          'wait'         => @session.wait,
+          'xmpp:version' => '1.0',
+          'xmlns'        => NAMESPACES[:http_bind],
+          'xmlns:xmpp'   => NAMESPACES[:bosh],
+          'xmlns:stream' => NAMESPACES[:stream])
+
+        node << doc.create_element('stream:features') do |el|
+          el << doc.create_element('mechanisms') do |mechanisms|
+            mechanisms.default_namespace = NAMESPACES[:sasl]
+            mechanisms << doc.create_element('mechanism', 'PLAIN')
           end
-        else
-          self.setup_new_client(body['rid'], body['to'])
         end
+        @session.reply(node)
       end
 
-      def send_bosh_error
-        body = "<body type='terminate' condition='remote-connection-failed' xmlns='http://jabber.org/protocol/httpbind'/>"
-        header = [
-          "HTTP/1.1 404 OK",
-          "Content-Type: text/xml; charset=utf-8",
-          "Content-Length: #{body.bytesize}"
-        ].join("\r\n")
-
-        send_data([header, body].join("\r\n\r\n"))
+      # Override +Stream#send_stream_error+ to wrap the error XML in a BOSH
+      # terminate body tag.
+      def send_stream_error(e)
+        doc = Nokogiri::XML::Document.new
+        node = doc.create_element('body',
+          'condition'    => 'remote-stream-error',
+          'type'         => 'terminate',
+          'xmlns'        => NAMESPACES[:http_bind],
+          'xmlns:stream' => NAMESPACES[:stream])
+        node.inner_html = e.to_xml
+        @session.reply(node)
       end
 
-      def domain
-        @http_state.domain
+      # Override +Stream#close_stream+ to simply close the connection without
+      # writing a closing stream tag.
+      def close_stream
+        close_connection_after_writing
+        @session.close
       end
     end
   end

data/lib/vines/stream/server.rb

@@ -57,7 +57,8 @@ module Vines
         @srv = options[:srv]
         @callback = options[:callback]
         @outbound = @remote_domain && @domain
-        @state = @outbound ? Outbound::Start.new(self) : Start.new(self)
+        start = @outbound ? Outbound::Start.new(self) : Start.new(self)
+        advance(start)
       end
 
       def post_init
@@ -73,9 +74,13 @@ module Vines
         close_connection unless cert_domain_matches?(@remote_domain)
       end
 
+      def stream_type
+        :server
+      end
+
       def unbind
         super
-        if @outbound && @state.class != Ready
+        if @outbound && !ready?
           Server.connect(@config, @remote_domain, @domain, @srv, @callback)
         end
       end
@@ -92,7 +97,7 @@ module Vines
       end
 
       def ready?
-        @state.class == Server::Ready
+        state.class == Server::Ready
       end
 
       def start(node)

data/lib/vines/stream/state.rb

@@ -9,8 +9,9 @@ module Vines
       include Nokogiri::XML
       include Vines::Log
 
-      attr_reader :stream
+      attr_accessor :stream
 
+      BODY   = 'body'.freeze
       STREAM = 'stream'.freeze
 
       def initialize(stream, success=nil)
@@ -43,6 +44,10 @@ module Vines
         node.name == STREAM && namespace(node) == NAMESPACES[:stream]
       end
 
+      def body?(node)
+        node.name == BODY && namespace(node) == NAMESPACES[:http_bind]
+      end
+
       def namespace(node)
         node.namespace ? node.namespace.href : nil
       end

data/lib/vines/stream.rb

@@ -10,13 +10,12 @@ module Vines
     ERROR = 'error'.freeze
     PAD   = 20
 
+    attr_reader   :domain
     attr_accessor :user
 
     def post_init
       router << self
-      @remote_addr, @local_addr = [get_peername, get_sockname].map do |addr|
-        addr ? Socket.unpack_sockaddr_in(addr)[0, 2].reverse.join(':') : 'unknown'
-      end
+      @remote_addr, @local_addr = addresses
       @user, @closed, @stanza_size = nil, false, 0
       @bucket = TokenBucket.new(100, 10)
       @store = Store.new
@@ -49,20 +48,10 @@ module Vines
       end
     end
 
-    # Send the stanza to all recipients, stamping it with from and
-    # to addresses first.
-    def broadcast(stanza, recipients)
-      stanza['from'] = @user.jid.to_s
-      recipients.each do |recipient|
-        stanza['to'] = recipient.user.jid.to_s
-        recipient.write(stanza)
-      end
-    end
-
     # Returns the storage system for the domain. If no domain is given,
     # the stream's storage mechanism is returned.
-    def storage(domain=@domain)
-      @config.vhosts[domain]
+    def storage(domain=nil)
+      @config.vhosts[domain || self.domain]
     end
 
     # Reload the user's information into their active connections. Call this
@@ -114,6 +103,8 @@ module Vines
       log.info { "Streams connected: #{router.size}" }
     end
 
+    # Advance the stream's state machine to the new state. XML nodes received
+    # by the stream will be passed to this state's +node+ method.
     def advance(state)
       @state = state
     end
@@ -126,11 +117,11 @@ module Vines
       when SaslError, StanzaError
         write(e.to_xml)
       when StreamError
-        write(e.to_xml)
+        send_stream_error(e)
         close_stream
       else
         log.error(e)
-        write(StreamErrors::InternalServerError.new.to_xml)
+        send_stream_error(StreamErrors::InternalServerError.new)
         close_stream
       end
     end
@@ -141,6 +132,21 @@ module Vines
 
     private
 
+    # Return the remote and local socket addresses used by this connection.
+    def addresses
+      [get_peername, get_sockname].map do |addr|
+        addr ? Socket.unpack_sockaddr_in(addr)[0, 2].reverse.join(':') : 'unknown'
+      end
+    end
+
+    # Write the StreamError's xml to the stream. Subclasses can override
+    # this method with custom error writing behavior.
+    def send_stream_error(e)
+      write(e.to_xml)
+    end
+
+    # Write a closing stream tag to the stream then close the stream. Subclasses
+    # can override this method for custom close behavior.
     def close_stream
       write('</stream:stream>')
       close_connection_after_writing
@@ -170,7 +176,7 @@ module Vines
       if error?(node)
         close_stream
       else
-        @state.node(node)
+        state.node(node)
       end
     rescue Exception => e
       error(e)
@@ -191,8 +197,14 @@ module Vines
         ["#{label} stanza:".ljust(PAD), from, to, node])
     end
 
+    # Returns the current state of the stream's state machine. Provided as a
+    # method so subclasses can override the behavior.
+    def state
+      @state
+    end
+
     def tls_files
-      %w[crt key].map {|ext| File.join(VINES_ROOT, 'conf', 'certs', "#{@domain}.#{ext}") }
+      %w[crt key].map {|ext| File.join(VINES_ROOT, 'conf', 'certs', "#{domain}.#{ext}") }
     end
   end
 end

data/lib/vines/user.rb

@@ -16,12 +16,10 @@ module Vines
     end
 
     def <=>(user)
-      self.jid.to_s <=> user.jid.to_s
+      user.is_a?(User) ? self.jid.to_s <=> user.jid.to_s : nil
     end
 
-    def eql?(user)
-      user.is_a?(User) && self == user
-    end
+    alias :eql? :==
 
     def hash
       jid.to_s.hash

data/lib/vines/version.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
 
 module Vines
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/lib/vines.rb

@@ -52,12 +52,12 @@ end
   em-redis
   eventmachine
   fiber
+  http/parser
   logger
   net/ldap
   nokogiri
   openssl
   socket
-  thin
   uri
   yaml
 
@@ -108,6 +108,7 @@ end
   vines/stream/parser
 
   vines/stream/client
+  vines/stream/client/session
   vines/stream/client/start
   vines/stream/client/tls
   vines/stream/client/auth_restart
@@ -123,9 +124,14 @@ end
   vines/stream/component/ready
 
   vines/stream/http
-  vines/stream/http/http_state
-  vines/stream/http/http_states
-  vines/stream/http/http_request
+  vines/stream/http/session
+  vines/stream/http/sessions
+  vines/stream/http/request
+  vines/stream/http/start
+  vines/stream/http/auth
+  vines/stream/http/bind_restart
+  vines/stream/http/bind
+  vines/stream/http/ready
 
   vines/stream/server
   vines/stream/server/start