vines 0.3.2 → 0.4.0

data/lib/vines/config.rb

@@ -9,7 +9,7 @@ module Vines
   class Config
     LOG_LEVELS = %w[debug info warn error fatal].freeze
 
-    attr_reader :vhosts
+    attr_reader :router, :vhosts
 
     @@instance = nil
     def self.configure(&block)
@@ -21,7 +21,9 @@ module Vines
     end
 
     def initialize(&block)
-      @vhosts, @ports = {}, {}
+      @vhosts, @ports, @cluster = {}, {}, nil
+      @null = Storage::Null.new
+      @router = Router.new(self)
       instance_eval(&block)
       raise "must define at least one virtual host" if @vhosts.empty?
     end
@@ -31,7 +33,7 @@ module Vines
       dupes = names.uniq.size != names.size || (@vhosts.keys & names).any?
       raise "one host definition per domain allowed" if dupes
       names.each do |name|
-        @vhosts[name] = Host.new(name, &block)
+        @vhosts[name] = Host.new(self, name, &block)
       end
     end
 
@@ -45,6 +47,12 @@ module Vines
       end
     end
 
+    def cluster(&block)
+      return @cluster unless block
+      raise "one cluster definition allowed" if @cluster
+      @cluster = Cluster.new(self, &block)
+    end
+
     def log(level)
       const = Logger.const_get(level.to_s.upcase) rescue nil
       unless LOG_LEVELS.include?(level.to_s) && const
@@ -59,10 +67,30 @@ module Vines
 
     # Return true if the domain is virtual hosted by this server.
     def vhost?(domain)
-      @vhosts.key?(domain)
+      @vhosts.key?(domain.to_s)
+    end
+
+    # Returns the storage system for the domain or a Storage::Null instance if
+    # the domain is not hosted at this server.
+    def storage(domain)
+      host = @vhosts[domain.to_s]
+      host ? host.storage : @null
+    end
+
+    # Returns the PubSub system for the domain or nil if pubsub is not enabled
+    # for this domain.
+    def pubsub(domain)
+      host = @vhosts.values.find {|host| host.pubsub?(domain) }
+      host.pubsubs[domain.to_s] if host
+    end
+
+    # Return true if the domain is a pubsub service hosted at a virtual host
+    # at this server.
+    def pubsub?(domain)
+      @vhosts.values.any? {|host| host.pubsub?(domain) }
     end
 
-    # Return true if all JID's belong to components hosted by this server.
+    # Return true if all JIDs belong to components hosted by this server.
     def component?(*jids)
       !jids.flatten.index do |jid|
         !component_password(JID.new(jid).domain)
@@ -75,7 +103,7 @@ module Vines
       host.password(domain) if host
     end
 
-    # Return true if all of the JID's are hosted by this server.
+    # Return true if all of the JIDs are hosted by this server.
     def local_jid?(*jids)
       !jids.flatten.index do |jid|
         !vhost?(JID.new(jid).domain)
@@ -84,13 +112,20 @@ module Vines
 
     # Return true if private XML fragment storage is enabled for this domain.
     def private_storage?(domain)
-      @vhosts[domain].private_storage?
+      host = @vhosts[domain.to_s]
+      host.private_storage? if host
     end
 
     # Returns true if server-to-server connections are allowed with the
     # given domain.
     def s2s?(domain)
-      @ports[:server] && @ports[:server].hosts.include?(domain)
+      @ports[:server] && @ports[:server].hosts.include?(domain.to_s)
+    end
+
+    # Return true if the server is a member of a cluster, serving the same
+    # domains from different machines.
+    def cluster?
+      !!@cluster
     end
 
     # Retrieve the Port subclass with this name:
@@ -99,16 +134,16 @@ module Vines
       @ports[name] or raise ArgumentError.new("no port named #{name}")
     end
 
-    # Return true if the two JID's are allowed to send messages to each other.
+    # Return true if the two JIDs are allowed to send messages to each other.
     # Both domains must have enabled cross_domain_messages in their config files.
     def allowed?(to, from)
       to, from = JID.new(to), JID.new(from)
       return false                      if to.empty? || from.empty?
       return true                       if to.domain == from.domain # same domain always allowed
       return cross_domain?(to, from)    if local_jid?(to, from)     # both virtual hosted here
-      return check_components(to, from) if component?(to, from)     # component to component
-      return check_component(to, from)  if component?(to)           # to component
-      return check_component(from, to)  if component?(from)         # from component
+      return check_subdomains(to, from) if subdomain?(to, from)     # component/pubsub to component/pubsub
+      return check_subdomain(to, from)  if subdomain?(to)           # to component/pubsub
+      return check_subdomain(from, to)  if subdomain?(from)         # from component/pubsub
       return cross_domain?(to)          if local_jid?(to)           # from is remote
       return cross_domain?(from)        if local_jid?(from)         # to is remote
       return false
@@ -116,25 +151,44 @@ module Vines
 
     private
 
-    def check_components(to, from)
-      comp1, comp2 = strip_domain(to), strip_domain(from)
-      (comp1 == comp2) || cross_domain?(comp1, comp2)
+    # Return true if all of the JIDs are some kind of subdomain resource hosted
+    # here (either a component or a pubsub domain).
+    def subdomain?(*jids)
+      !jids.flatten.index do |jid|
+        !component?(jid) && !pubsub?(jid)
+      end
+    end
+
+    # Return true if the third-level subdomain JIDs (components and pubsubs)
+    # are allowed to communicate with each other. For example, a
+    # tea.wonderland.lit component should be allowed to send messages to
+    # pubsub.wonderland.lit because they share the second-level wonderland.lit
+    # domain.
+    def check_subdomains(to, from)
+      sub1, sub2 = strip_domain(to), strip_domain(from)
+      (sub1 == sub2) || cross_domain?(sub1, sub2)
     end
 
-    def check_component(component_jid, jid)
-      comp = strip_domain(component_jid)
+    # Return true if the third-level subdomain JID (component or pubsub) is
+    # allowed to communicate with the other JID. For example,
+    # pubsub.wonderland.lit should be allowed to send messages to
+    # alice@wonderland.lit because they share the second-level wonderland.lit
+    # domain.
+    def check_subdomain(subdomain, jid)
+      comp = strip_domain(subdomain)
       return true if comp.domain == jid.domain
       local_jid?(jid) ? cross_domain?(comp, jid) : cross_domain?(comp)
     end
 
-    # Return the JID's domain with the first subdomain stripped off. For example,
-    # alice@tea.wonderland.lit returns wonderland.lit.
+    # Return the third-level JID's domain with the first subdomain stripped off
+    # to create a second-level domain. For example, alice@tea.wonderland.lit
+    # returns wonderland.lit.
     def strip_domain(jid)
       domain = jid.domain.split('.').drop(1).join('.')
       JID.new(domain)
     end
 
-    # Return true if all JID's are allowed to exchange cross domain messages.
+    # Return true if all JIDs are allowed to exchange cross domain messages.
     def cross_domain?(*jids)
       !jids.flatten.index do |jid|
         !@vhosts[jid.domain].cross_domain_messages?

data/lib/vines/jid.rb

@@ -30,14 +30,28 @@ module Vines
       validate
     end
 
+    # Strip the resource part from this JID and return it as a new
+    # JID object. The new JID contains only the optional node part
+    # and the required domain part from the original. This JID remains
+    # unchanged.
     def bare
       JID.new(@node, @domain)
     end
 
+    # Return true if this is a bare JID without a resource part.
     def bare?
       @resource.nil?
     end
 
+    # Return true if this is a domain-only JID without a node or resource part.
+    def domain?
+      !empty? && to_s == @domain
+    end
+
+    # Return true if this JID is equal to the empty string ''. That is, it's
+    # missing the node, domain, and resource parts that form a valid JID. It
+    # makes for easier error handling to be able to create JID objects from
+    # strings and then check if they're empty rather than nil.
     def empty?
       to_s == ''
     end

data/lib/vines/router.rb

@@ -4,72 +4,74 @@ module Vines
   # The router tracks all stream connections to the server for all clients,
   # servers, and components. It sends stanzas to the correct stream based on
   # the 'to' attribute. Router is a singleton, shared by all streams, that must
-  # be accessed with +Router.instance+, not +Router.new+.
+  # be accessed with +Config#router+.
   class Router
+    EMPTY = [].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 ||= self.new
-    end
-
-    def initialize
-      @config = nil
-      @streams = Hash.new {|h,k| h[k] = [] }
+    def initialize(config)
+      @config = config
+      @clients, @servers, @components = {}, [], []
       @pending = Hash.new {|h,k| h[k] = [] }
     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, from)
+    # 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, from, proxies=true)
       jid, from = JID.new(jid), JID.new(from)
-      clients.select do |stream|
-        stream.connected? &&
-          jid == (jid.bare? ? stream.user.jid.bare : stream.user.jid) &&
-          @config.allowed?(jid, from)
-      end
+      return [] unless @config.allowed?(jid, from)
+
+      local = @clients[jid.bare] || EMPTY
+      local = local.select {|stream| stream.user.jid == jid } unless jid.bare?
+      remote = proxies ? proxies(jid) : EMPTY
+      [local, remote].flatten
     end
 
-    # Returns streams for all available resources for this JID. A
-    # resource is marked available after it sends initial presence.
-    # This method accepts a single JID or a list of JIDs.
+    # Returns streams for all available resources for this JID. A resource is
+    # marked available after it sends initial presence.
     def available_resources(*jids, from)
-      jids = filter_allowed(jids, from)
-      clients.select do |stream|
-        stream.available? && jids.include?(stream.user.jid.bare)
+      clients(jids, from) do |stream|
+        stream.available?
       end
     end
 
-    # Returns streams for all interested resources for this JID. A
-    # resource is marked interested after it requests the roster.
-    # This method accepts a single JID or a list of JIDs.
+    # Returns streams for all interested resources for this JID. A resource is
+    # marked interested after it requests the roster.
     def interested_resources(*jids, from)
-      jids = filter_allowed(jids, from)
-      clients.select do |stream|
-        stream.interested? && jids.include?(stream.user.jid.bare)
+      clients(jids, from) do |stream|
+        stream.interested?
       end
     end
 
     # 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[type] << connection
+    def <<(stream)
+      case stream_type(stream)
+      when :client then
+        return unless stream.connected?
+        jid = stream.user.jid.bare
+        @clients[jid] ||= []
+        @clients[jid] << stream
+      when :server then @servers << stream
+      when :component then @components << stream
+      end
     end
 
     # Remove the connection from the routing table.
-    def delete(connection)
-      type = stream_type(connection)
-      @streams[type].delete(connection)
+    def delete(stream)
+      case stream_type(stream)
+      when :client then
+        return unless stream.connected?
+        jid = stream.user.jid.bare
+        streams = @clients[jid] || []
+        streams.delete(stream)
+        @clients.delete(jid) if streams.empty?
+      when :server then @servers.delete(stream)
+      when :component then @components.delete(stream)
+      end
     end
 
     # Send the stanza to the appropriate remote server-to-server stream
@@ -96,7 +98,8 @@ module Vines
 
     # Returns the total number of streams connected to the server.
     def size
-      @streams.values.inject(0) {|sum, arr| sum + arr.size }
+      clients = @clients.values.inject(0) {|sum, arr| sum + arr.size }
+      clients + @servers.size + @components.size
     end
 
     private
@@ -124,16 +127,27 @@ module Vines
       end
     end
 
-    # Return the bare JID's from the list that are allowed to talk to
-    # the +from+ JID. Store them in a Hash for fast +include?+ checks.
+    # Return the client streams to which the from address is allowed to
+    # contact. Apply the filter block to each stream to narrow the results
+    # before returning the streams.
+    def clients(jids, from, &filter)
+      jids = filter_allowed(jids, from)
+      local = @clients.values_at(*jids).compact.flatten.select(&filter)
+      proxies = proxies(*jids).select(&filter)
+      [local, proxies].flatten
+    end
+
+    # Return the bare JIDs from the list that are allowed to talk to
+    # the +from+ JID.
     def filter_allowed(jids, from)
       from = JID.new(from)
-      {}.tap do |ids|
-        jids.flatten.each do |jid|
-          jid = JID.new(jid).bare
-          ids[jid] = nil if @config.allowed?(jid, from)
-        end
-      end
+      jids.flatten.map {|jid| JID.new(jid).bare }
+        .select {|jid| @config.allowed?(jid, from) }
+    end
+
+    def proxies(*jids)
+      return EMPTY unless @config.cluster?
+      @config.cluster.remote_sessions(*jids)
     end
 
     def connection_to(to, from)
@@ -141,17 +155,17 @@ module Vines
     end
 
     def component_stream(to)
-      components.find do |stream|
+      @components.select do |stream|
         stream.ready? && stream.remote_domain == to.domain
-      end
+      end.sample
     end
 
     def server_stream(to, from)
-      servers.find do |stream|
+      @servers.select do |stream|
         stream.ready? &&
           stream.remote_domain == to.domain &&
             stream.domain == from.domain
-      end
+      end.sample
     end
 
     def stream_type(connection)

data/lib/vines/stanza/iq/disco_info.rb

@@ -9,23 +9,36 @@ module Vines
         register "/iq[@id and @type='get']/ns:query", 'ns' => NS
 
         def process
-          return if route_iq
+          return if route_iq || !allowed?
           result = to_result.tap do |el|
             el << el.document.create_element('query') do |query|
               query.default_namespace = NS
-              query << el.document.create_element('identity', 'category' => 'server', 'type' => 'im')
-              query << el.document.create_element('feature', 'var' => NAMESPACES[:disco_info])
-              query << el.document.create_element('feature', 'var' => NAMESPACES[:disco_items])
-              query << el.document.create_element('feature', 'var' => NAMESPACES[:ping])
-              query << el.document.create_element('feature', 'var' => NAMESPACES[:vcard])
-              query << el.document.create_element('feature', 'var' => NAMESPACES[:version])
-              if stream.config.private_storage?(stream.domain)
-                query << el.document.create_element('feature', 'var' => NAMESPACES[:storage])
+              if to_pubsub_domain?
+                identity(query, 'pubsub', 'service')
+                pubsub = [:pubsub_create, :pubsub_delete, :pubsub_instant, :pubsub_item_ids, :pubsub_publish, :pubsub_subscribe]
+                features(query, :disco_info, :ping, :pubsub, *pubsub)
+              else
+                identity(query, 'server', 'im')
+                features = [:disco_info, :disco_items, :ping, :vcard, :version]
+                features << :storage if stream.config.private_storage?(validate_to || stream.domain)
+                features(query, features)
               end
             end
           end
           stream.write(result)
         end
+
+        private
+
+        def identity(query, category, type)
+          query << query.document.create_element('identity', 'category' => category, 'type' => type)
+        end
+
+        def features(query, *features)
+          features.flatten.each do |feature|
+            query << query.document.create_element('feature', 'var' => NAMESPACES[feature])
+          end
+        end
       end
     end
   end

data/lib/vines/stanza/iq/disco_items.rb

@@ -9,12 +9,15 @@ module Vines
         register "/iq[@id and @type='get']/ns:query", 'ns' => NS
 
         def process
-          return if route_iq
+          return if route_iq || !allowed?
           result = to_result.tap do |el|
             el << el.document.create_element('query') do |query|
               query.default_namespace = NS
-              stream.config.vhosts[stream.domain].components.keys.sort.each do |domain|
-                query << el.document.create_element('item', 'jid' => domain)
+              unless to_pubsub_domain?
+                to = (validate_to || stream.domain).to_s
+                stream.config.vhosts[to].disco_items.each do |domain|
+                  query << el.document.create_element('item', 'jid' => domain)
+                end
               end
             end
           end

data/lib/vines/stanza/iq/ping.rb

@@ -7,7 +7,7 @@ module Vines
         register "/iq[@id and @type='get']/ns:ping", 'ns' => NAMESPACES[:ping]
 
         def process
-          return if route_iq
+          return if route_iq || !allowed?
           stream.write(to_result)
         end
       end

data/lib/vines/stanza/iq/private_storage.rb

@@ -44,14 +44,10 @@ module Vines
         private
 
         def to_result
-          doc = Document.new
-          node = doc.create_element('iq',
-            'from' => stream.user.jid.to_s,
-            'id'   => self['id'],
-            'to'   => stream.user.jid.to_s,
-            'type' => 'result')
-          yield node if block_given?
-          node
+          super.tap do |node|
+            node['from'] = stream.user.jid.to_s
+            yield node if block_given?
+          end
         end
 
         def validate_children_size

data/lib/vines/stanza/iq/roster.rb

@@ -55,7 +55,7 @@ module Vines
 
           contact = stream.user.contact(jid)
           unless contact
-            contact = Contact.new(:jid => jid)
+            contact = Contact.new(jid: jid)
             stream.user.roster << contact
           end
           contact.name = item['name']
@@ -89,9 +89,8 @@ module Vines
           end
 
           send_result_iq
-          push_roster_updates(stream.user.jid, Contact.new(
-            :jid => contact.jid,
-            :subscription => 'remove'))
+          push_roster_updates(stream.user.jid,
+            Contact.new(jid: contact.jid, subscription: 'remove'))
 
           if local_jid?(contact.jid)
             send_unavailable(stream.user.jid, contact.jid) if contact.subscribed_from?
@@ -110,14 +109,7 @@ module Vines
           presence = [%w[to unsubscribe], %w[from unsubscribed]].map do |meth, type|
             presence(contact.jid, type) if contact.send("subscribed_#{meth}?")
           end.compact
-
-          if local_jid?(contact.jid)
-            stream.interested_resources(contact.jid).each do |recipient|
-              presence.each {|el| recipient.write(el) }
-            end
-          else
-            presence.each {|el| router.route(el) }
-          end
+          broadcast_to_interested_resources(presence, contact.jid)
         end
 
         def presence(to, type)
@@ -138,8 +130,8 @@ module Vines
         end
 
         def send_result_iq
-          doc = Document.new
-          node = doc.create_element('iq', 'id' => self['id'], 'type' => 'result')
+          node = to_result
+          node.remove_attribute('from')
           stream.write(node)
         end
       end

data/lib/vines/stanza/iq/session.rb

@@ -3,18 +3,13 @@
 module Vines
   class Stanza
     class Iq
-      # Session support is deprecated, but Adium requires it so reply with an
+      # Session support is deprecated, but Adium requires it, so reply with an
       # iq result stanza.
       class Session < Iq
         register "/iq[@id and @type='set']/ns:session", 'ns' => NAMESPACES[:session]
 
         def process
-          doc = Document.new
-          result = doc.create_element('iq',
-            'from' => stream.domain,
-            'id'   => self['id'],
-            'type' => 'result')
-          stream.write(result)
+          stream.write(to_result)
         end
       end
     end

data/lib/vines/stanza/iq/vcard.rb

@@ -9,6 +9,7 @@ module Vines
         register "/iq[@id and @type='get' or @type='set']/ns:vCard", 'ns' => NS
 
         def process
+          return unless allowed?
           if local?
             get? ? vcard_query : vcard_update
           else
@@ -22,7 +23,7 @@ module Vines
         def vcard_query
           to = validate_to
           jid = to ? to.bare : stream.user.jid.bare
-          card = storage.find_vcard(jid)
+          card = storage(jid.domain).find_vcard(jid)
 
           raise StanzaErrors::ItemNotFound.new(self, 'cancel') unless card
 
@@ -45,11 +46,8 @@ module Vines
 
           storage.save_vcard(stream.user.jid, elements.first)
 
-          doc = Document.new
-          result = doc.create_element('iq',
-            'id'   => self['id'],
-            'to'   => stream.user.jid.to_s,
-            'type' => 'result')
+          result = to_result
+          result.remove_attribute('from')
           stream.write(result)
         end
       end

data/lib/vines/stanza/iq/version.rb

@@ -9,7 +9,7 @@ module Vines
         register "/iq[@id and @type='get']/ns:query", 'ns' => NS
 
         def process
-          return if route_iq
+          return if route_iq || to_pubsub_domain? || !allowed?
           result = to_result.tap do |node|
             node << node.document.create_element('query') do |query|
               query.default_namespace = NS

data/lib/vines/stanza/iq.rb

@@ -24,25 +24,23 @@ module Vines
       def to_result
         doc = Document.new
         doc.create_element('iq',
-          'from' => stream.domain,
+          'from' => validate_to || stream.domain,
           'id'   => self['id'],
-          'to'   => stream.user.jid.to_s,
+          'to'   => stream.user.jid,
           'type' => 'result')
       end
 
       private
 
+      # Return false if this IQ stanza is addressed to the server, or a pubsub
+      # service hosted here, and must be handled locally. Return true if the
+      # stanza must not be handled locally and has been routed to the appropriate
+      # component, s2s, or c2s stream.
       def route_iq
         to = validate_to
-        return false if to.nil? || to.to_s == stream.domain
+        return false if to.nil? || stream.config.vhost?(to) || to_pubsub_domain?
         self['from'] = stream.user.jid.to_s
-        if local?
-          stream.available_resources(to).each do |recipient|
-            recipient.write(@node)
-          end
-        else
-          route
-        end
+        local? ? broadcast(stream.connected_resources(to)) : route
         true
       end
     end