vines 0.1.0 → 0.1.1

data/README

@@ -19,7 +19,7 @@ database. SSL encryption is mandatory on all client and server connections.
 * bcrypt-ruby >= 2.1.4
 * eventmachine >= 1.0.0
 * nokogiri >= 1.4.4
-* ruby >= 1.9.1
+* ruby >= 1.9.2
 
 == Ubuntu setup
 $ sudo apt-get install build-essential ruby1.9.1 ruby1.9.1-dev libxml2-dev libxslt-dev

data/Rakefile

@@ -31,20 +31,30 @@ all client and server connections."
   s.add_dependency 'em-http-request', '>= 1.0.0.beta.3'
   s.add_dependency "em-redis", "~> 0.3"
   s.add_dependency "eventmachine", ">= 1.0.0.beta.3"
+  s.add_dependency "http_parser.rb", "~> 0.5"
   s.add_dependency "net-ldap", "~> 0.2"
   s.add_dependency "nokogiri", "~> 1.4"
-  s.add_dependency "thin", "~> 1.2"
 
+  s.add_development_dependency "minitest"
   s.add_development_dependency "rake"
   s.add_development_dependency "sqlite3"
 
-  s.required_ruby_version = '>= 1.9.1'
+  s.required_ruby_version = '>= 1.9.2'
 end
 
 Rake::GemPackageTask.new(spec) do |pkg| 
   pkg.need_tar = true
 end
 
+module Rake
+  class TestTask
+    # use our custom test loader
+    def rake_loader
+      'test/rake_test_loader.rb'
+    end
+  end
+end
+
 Rake::TestTask.new(:test) do |test|
   test.libs << 'test'
   test.libs << 'test/storage'

data/conf/config.rb

@@ -69,6 +69,7 @@ Vines::Config.configure do
   # the XMPP server.
   http '0.0.0.0', 5280 do
     max_stanza_size 131072
+    max_resources_per_account 5
   end
 
   # Configure the XEP-0114 external component port. Add entries for each

data/lib/vines/config.rb

@@ -167,6 +167,14 @@ module Vines
         @stream = Vines::Stream::Http
         super(config, host, port, &block)
       end
+
+      def max_resources_per_account(max=nil)
+        if max
+          @settings[:max_resources_per_account] = max
+        else
+          @settings[:max_resources_per_account]
+        end
+      end
     end
 
     class ComponentPort < Port

data/lib/vines/contact.rb

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

data/lib/vines/error.rb

@@ -98,7 +98,7 @@ module Vines
   module StreamErrors
     class BadFormat < StreamError; end
     class BadNamespacePrefix < StreamError; end
-    class Confict < StreamError; end
+    class Conflict < StreamError; end
     class ConnectionTimeout < StreamError; end
     class HostGone < StreamError; end
     class HostUnknown < StreamError; end

data/lib/vines/router.rb

@@ -8,9 +8,16 @@ module Vines
   class Router
     ROUTABLE_STANZAS = %w[message iq presence].freeze
 
+    STREAM_TYPES = [:client, :server, :component].freeze
+    STREAM_TYPES.each do |name|
+      define_method "#{name}s" do
+        @streams[name]
+      end
+    end
+
     @@instance = nil
     def self.instance
-      @@instance ||= Router.new
+      @@instance ||= self.new
     end
 
     def initialize
@@ -19,23 +26,12 @@ module Vines
       @pending = Hash.new {|h,k| h[k] = [] }
     end
 
-    %w[Client Server Component].each do |klass|
-      name = klass.split(/(?=[A-Z])/).join('_').downcase
-      define_method(name + 's') do
-        @streams["Vines::Stream::#{klass}"]
-      end
-    end
-
-    def http_states
-      @streams["Vines::Stream::Http::HttpState"]
-    end
-
     # Returns streams for all connected resources for this JID. A
     # resource is considered connected after it has completed authentication
     # and resource binding.
     def connected_resources(jid)
       jid = JID.new(jid)
-      (clients + http_states).select do |stream|
+      clients.select do |stream|
         stream.connected? && jid == (jid.bare? ? stream.user.jid.bare : stream.user.jid)
       end
     end
@@ -45,7 +41,7 @@ module Vines
     # This method accepts a single JID or a list of JIDs.
     def available_resources(*jid)
       ids = jid.flatten.map {|jid| JID.new(jid).bare }
-      (clients + http_states).select do |stream|
+      clients.select do |stream|
         stream.available? && ids.include?(stream.user.jid.bare)
       end
     end
@@ -55,20 +51,24 @@ module Vines
     # This method accepts a single JID or a list of JIDs.
     def interested_resources(*jid)
       ids = jid.flatten.map {|jid| JID.new(jid).bare }
-      (clients + http_states).select do |stream|
+      clients.select do |stream|
         stream.interested? && ids.include?(stream.user.jid.bare)
       end
     end
 
-    # Add the connection to the routing table.
+    # Add the connection to the routing table. The connection must return
+    # :client, :server, or :component from its +stream_type+ method so the
+    # router can properly route stanzas to the stream.
     def <<(connection)
+      type = stream_type(connection)
       @config ||= connection.config
-      @streams[connection.class.to_s] << connection
+      @streams[type] << connection
     end
 
     # Remove the connection from the routing table.
     def delete(connection)
-      @streams[connection.class.to_s].delete(connection)
+      type = stream_type(connection)
+      @streams[type].delete(connection)
     end
 
     # Send the stanza to the appropriate remote server-to-server stream
@@ -121,5 +121,13 @@ module Vines
         stream.ready? && stream.remote_domain == domain
       end
     end
+
+    def stream_type(connection)
+      connection.stream_type.tap do |type|
+        unless STREAM_TYPES.include?(type)
+          raise ArgumentError, "unexpected stream type: #{type}"
+        end
+      end
+    end
   end
 end

data/lib/vines/stanza/presence.rb

@@ -40,7 +40,9 @@ module Vines
         else
           stream.user.subscribed_from?(to) ? router.available_resources(to) : []
         end
-        broadcast(recipients + router.available_resources(stream.user.jid))
+
+        broadcast(recipients)
+        broadcast(router.available_resources(stream.user.jid))
 
         if initial
           stream.available_subscribed_to_resources.each do |recipient|

data/lib/vines/stanza.rb

@@ -5,6 +5,7 @@ module Vines
     include Nokogiri::XML
 
     attr_reader :stream
+
     MESSAGE = 'message'.freeze
     @@types = {}
 
@@ -24,8 +25,14 @@ module Vines
       @node, @stream = node, stream
     end
 
+    # Send the stanza to all recipients, stamping it with from and
+    # to addresses first.
     def broadcast(recipients)
-      stream.broadcast(@node, recipients)
+      @node['from'] = stream.user.jid.to_s
+      recipients.each do |recipient|
+        @node['to'] = recipient.user.jid.to_s
+        recipient.write(@node)
+      end
     end
 
     def local?

data/lib/vines/stream/client/bind.rb

@@ -25,13 +25,21 @@ module Vines
               bind << doc.create_element('jid', stream.user.jid.to_s)
             end
           end
+
           stream.write(result)
-          stream.write('<stream:features/>')
+          send_empty_features
           advance
         end
 
         private
 
+        # Write the final <stream:features/> element to the stream, indicating
+        # stream negotiation is complete and the client is cleared to send
+        # stanzas.
+        def send_empty_features
+          stream.write('<stream:features/>')
+        end
+
         def bind?(node)
           node.name == 'iq' && node['type'] == 'set' && node.xpath('ns:bind', 'ns' => NS).any?
         end

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

@@ -0,0 +1,146 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Client
+      # A Session tracks the state of a client stream over its lifetime from
+      # negotiation to processing stanzas to shutdown. By disconnecting the
+      # stream's state from the stream, we can allow multiple TCP connections
+      # to access one logical session (e.g. HTTP streams).
+      class Session
+        include Comparable
+
+        attr_accessor :domain, :last_broadcast_presence, :user
+        attr_reader   :id, :state
+
+        def initialize(stream)
+          @id = Kit.uuid
+          @state = Client::Start.new(stream)
+          @available = false
+          @domain = nil
+          @last_broadcast_presence = nil
+          @requested_roster = false
+          @unbound = false
+          @user = nil
+        end
+
+        def <=>(session)
+          session.is_a?(Session) ? self.id <=> session.id : nil
+        end
+
+        alias :eql? :==
+
+        def hash
+          @id.hash
+        end
+
+        def advance(state)
+          @state = state
+        end
+
+        # Returns true if this client has properly authenticated with
+        # the server.
+        def authenticated?
+          !@user.nil?
+        end
+
+        def available!
+          @available = true
+        end
+
+        # An available resource has sent initial presence and can
+        # receive presence subscription requests.
+        def available?
+          @available && connected?
+        end
+
+        # A connected resource has authenticated and bound a resource
+        # identifier.
+        def connected?
+          !@unbound && authenticated? && !@user.jid.bare?
+        end
+
+        # An interested resource has requested its roster and can
+        # receive roster pushes.
+        def interested?
+          @requested_roster && connected?
+        end
+
+        def ready?
+          @state.class == Client::Ready
+        end
+
+        def requested_roster!
+          @requested_roster = true
+        end
+
+        def stream_type
+          :client
+        end
+
+        # Called by the stream when its disconnected from the client. The stream
+        # passes itself to this method in case multiple streams are accessing this
+        # session.
+        def unbind!(stream)
+          @unbound = true
+          @available = false
+          broadcast_unavailable
+        end
+
+        # Returns streams for available resources to which this user
+        # has successfully subscribed.
+        def available_subscribed_to_resources
+          subscribed = @user.subscribed_to_contacts.map {|c| c.jid }
+          router.available_resources(subscribed)
+        end
+
+        # Returns streams for available resources that are subscribed
+        # to this user's presence updates.
+        def available_subscribers
+          subscribed = @user.subscribed_from_contacts.map {|c| c.jid }
+          router.available_resources(subscribed)
+        end
+
+        # Returns contacts hosted at remote servers that are subscribed
+        # to this user's presence updates.
+        def remote_subscribers(to=nil)
+          jid = (to.nil? || to.empty?) ? nil : JID.new(to).bare
+          @user.subscribed_from_contacts.reject do |c|
+            router.local_jid?(c.jid) || (jid && c.jid.bare != jid)
+          end
+        end
+
+        private
+
+        def broadcast_unavailable
+          return unless authenticated?
+
+          doc = Nokogiri::XML::Document.new
+          el = doc.create_element('presence',
+            'from' => @user.jid.to_s,
+            'type' => 'unavailable')
+
+          broadcast(el, available_subscribers)
+          broadcast(el, router.available_resources(@user.jid))
+
+          remote_subscribers.each do |contact|
+            node = el.clone
+            node['to'] = contact.jid.bare.to_s
+            router.route(node) rescue nil # ignore RemoteServerNotFound
+          end
+        end
+
+        def broadcast(stanza, recipients)
+          recipients.each do |recipient|
+            stanza['to'] = recipient.user.jid.to_s
+            recipient.write(stanza)
+          end
+        end
+
+        def router
+          Router.instance
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/client.rb

@@ -6,22 +6,27 @@ module Vines
     # Implements the XMPP protocol for client-to-server (c2s) streams. This
     # serves connected streams using the jabber:client namespace.
     class Client < Stream
-      attr_reader :config, :domain
-      attr_accessor :last_broadcast_presence
+      attr_reader :config
 
       def initialize(config)
         @config = config
-        @domain = nil
-        @requested_roster = false
-        @available = false
-        @unbound = false
-        @last_broadcast_presence = nil
-        @state = Start.new(self)
+        @session = Client::Session.new(self)
+      end
+
+      # Delegate behavior to the session that's storing our stream state.
+      def method_missing(name, *args)
+        @session.send(name, *args)
+      end
+
+      %w[advance domain state user user=].each do |name|
+        define_method name do |*args|
+          @session.send(name, *args)
+        end
       end
 
       def ssl_handshake_completed
         if get_peer_cert
-          close_connection unless cert_domain_matches?(@domain)
+          close_connection unless cert_domain_matches?(@session.domain)
         end
       end
 
@@ -34,80 +39,16 @@ module Vines
       end
 
       def unbind
-        @unbound = true
-        @available = false
-        if authenticated?
-          doc = Nokogiri::XML::Document.new
-          el = doc.create_element('presence', 'type' => 'unavailable')
-          Stanza::Presence::Unavailable.new(el, self).outbound_broadcast_presence
-        end
+        @session.unbind!(self)
         super
       end
 
-      # Returns true if this client has properly authenticated with
-      # the server.
-      def authenticated?
-        !@user.nil?
-      end
-
-      # A connected resource has authenticated and bound a resource
-      # identifier.
-      def connected?
-        !@unbound && authenticated? && !@user.jid.bare?
-      end
-
-      # An available resource has sent initial presence and can
-      # receive presence subscription requests.
-      def available?
-        @available && connected?
-      end
-
-      # An interested resource has requested its roster and can
-      # receive roster pushes.
-      def interested?
-        @requested_roster && connected?
-      end
-
-      def available!
-        @available = true
-      end
-
-      def requested_roster!
-        @requested_roster = true
-      end
-
-      # Returns streams for available resources to which this user
-      # has successfully subscribed.
-      def available_subscribed_to_resources
-        subscribed = @user.subscribed_to_contacts.map {|c| c.jid }
-        router.available_resources(subscribed)
-      end
-
-      # Returns streams for available resources that are subscribed
-      # to this user's presence updates.
-      def available_subscribers
-        subscribed = @user.subscribed_from_contacts.map {|c| c.jid }
-        router.available_resources(subscribed)
-      end
-
-      # Returns contacts hosted at remote servers that are subscribed
-      # to this user's presence updates.
-      def remote_subscribers(to=nil)
-        jid = (to.nil? || to.empty?) ? nil : JID.new(to).bare
-        @user.subscribed_from_contacts.reject do |c|
-          router.local_jid?(c.jid) || (jid && c.jid.bare != jid)
-        end
-      end
-
-      def ready?
-        @state.class == Client::Ready
-      end
-
       def start(node)
-        @domain, from = %w[to from].map {|a| node[a] }
+        to, from = %w[to from].map {|a| node[a] }
+        @session.domain = to
         send_stream_header(from)
         raise StreamErrors::UnsupportedVersion unless node['version'] == '1.0'
-        raise StreamErrors::HostUnknown unless @config.vhost?(@domain)
+        raise StreamErrors::HostUnknown unless @config.vhost?(@session.domain)
         raise StreamErrors::InvalidNamespace unless node.namespaces['xmlns'] == NAMESPACES[:client]
         raise StreamErrors::InvalidNamespace unless node.namespaces['xmlns:stream'] == NAMESPACES[:stream]
       end
@@ -120,7 +61,7 @@ module Vines
           'xmlns:stream' => NAMESPACES[:stream],
           'xml:lang' => 'en',
           'id' => Kit.uuid,
-          'from' => @domain,
+          'from' => @session.domain,
           'version' => '1.0'
         }
         attrs['to'] = to if to

data/lib/vines/stream/component.rb

@@ -13,7 +13,7 @@ module Vines
         @config = config
         @remote_domain = nil
         @stream_id = Kit.uuid
-        @state = Start.new(self)
+        advance(Start.new(self))
       end
 
       def max_stanza_size
@@ -21,7 +21,11 @@ module Vines
       end
 
       def ready?
-        @state.class == Component::Ready
+        state.class == Component::Ready
+      end
+
+      def stream_type
+        :component
       end
 
       def start(node)

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

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class Auth < Client::Auth
+        def initialize(stream, success=BindRestart)
+          super
+        end
+
+        def node(node)
+          unless body?(node) && node['rid'] && stream.valid_session?(node['sid'])
+            raise StreamErrors::NotAuthorized
+          end
+          nodes = stream.parse_body(node)
+          raise StreamErrors::NotAuthorized unless nodes.size == 1
+          super(nodes.first)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class Bind < Client::Bind
+        FEATURES = %Q{<stream:features xmlns:stream="#{NAMESPACES[:stream]}"/>}.freeze
+
+        def initialize(stream, success=Ready)
+          super
+        end
+
+        def node(node)
+          unless body?(node) && node['rid'] && stream.valid_session?(node['sid'])
+            raise StreamErrors::NotAuthorized
+          end
+          nodes = stream.parse_body(node)
+          raise StreamErrors::NotAuthorized unless nodes.size == 1
+          super(nodes.first)
+        end
+
+        private
+
+        # Override Client::Bind#send_empty_features to properly namespace the
+        # empty features element.
+        def send_empty_features
+          stream.write(FEATURES)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class BindRestart < State
+        def initialize(stream, success=Bind)
+          super
+        end
+
+        def node(node)
+          raise StreamErrors::NotAuthorized unless body?(node) && restart?(node)
+
+          doc = Document.new
+          body = doc.create_element('body') do |el|
+            el.add_namespace(nil, NAMESPACES[:http_bind])
+            el.add_namespace('stream', NAMESPACES[:stream])
+            el << doc.create_element('stream:features') do |features|
+              features << doc.create_element('bind', 'xmlns' => NAMESPACES[:bind])
+            end
+          end
+          stream.reply(body)
+          advance
+        end
+
+        private
+
+        def restart?(node)
+          restart = node.attribute_with_ns('restart', NAMESPACES[:bosh]).value rescue nil
+          domain = node['to'] == stream.domain
+          domain && restart == 'true' && node['rid'] && stream.valid_session?(node['sid'])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class Ready < Client::Ready
+        RID, SID, TYPE, TERMINATE = %w[rid sid type terminate].map {|s| s.freeze }
+
+        def node(node)
+          unless body?(node) && node[RID] && stream.valid_session?(node[SID])
+            raise StreamErrors::NotAuthorized
+          end
+          stream.parse_body(node).each do |child|
+            super(child)
+          end
+          stream.terminate if terminate?(node)
+        end
+
+        def terminate?(node)
+          node[TYPE] == TERMINATE
+        end
+      end
+    end
+  end
+end