vines 0.3.2 → 0.4.0

data/lib/vines/stanza/presence/subscribe.rb

@@ -7,29 +7,21 @@ module Vines
         register "/presence[@type='subscribe']"
 
         def process
+          stamp_from
           inbound? ? process_inbound : process_outbound
         end
 
         def process_outbound
-          self['from'] = stream.user.jid.bare.to_s
           to = stamp_to
-
           stream.user.request_subscription(to)
           storage.save_user(stream.user)
           stream.update_user_streams(stream.user)
-
           local? ? process_inbound : route
-
-          contact = stream.user.contact(to)
-          stream.interested_resources(stream.user.jid).each do |recipient|
-            contact.send_roster_push(recipient)
-          end
+          send_roster_push(to)
         end
 
         def process_inbound
-          self['from'] = stream.user.jid.bare.to_s
           to = stamp_to
-
           contact = storage(to.domain).find_user(to)
           if contact.nil?
             auto_reply_to_subscription_request(to, 'unsubscribed')
@@ -40,7 +32,7 @@ module Vines
             if recipients.empty?
               # TODO store subscription request per RFC 6121 3.1.3 #4
             else
-              recipients.each {|stream| stream.write(@node) }
+              broadcast_to_available_resources([@node], to)
             end
           end
         end

data/lib/vines/stanza/presence/subscribed.rb

@@ -7,56 +7,43 @@ module Vines
         register "/presence[@type='subscribed']"
 
         def process
+          stamp_from
           inbound? ? process_inbound : process_outbound
         end
 
         def process_outbound
-          self['from'] = stream.user.jid.bare.to_s
           to = stamp_to
-
           stream.user.add_subscription_from(to)
           storage.save_user(stream.user)
           stream.update_user_streams(stream.user)
-
           local? ? process_inbound : route
-
-          contact = stream.user.contact(to)
-          stream.interested_resources(stream.user.jid).each do |recipient|
-            contact.send_roster_push(recipient)
-          end
-
-          presences = stream.available_resources(stream.user.jid).map do |c|
-            c.last_broadcast_presence.clone.tap do |node|
-              node['from'] = c.user.jid.to_s
-              node['id'] = Kit.uuid
-              node['to'] = to.to_s
-            end
-          end
-
-          if local?
-            stream.available_resources(to).each do |recipient|
-              presences.each {|el| recipient.write(el) }
-            end
-          else
-            presences.each {|el| router.route(el) }
-          end
+          send_roster_push(to)
+          send_known_presence(to)
         end
 
         def process_inbound
-          self['from'] = stream.user.jid.bare.to_s
           to = stamp_to
-
           user = storage(to.domain).find_user(to)
           contact = user.contact(stream.user.jid) if user
           return unless contact && contact.can_subscribe?
           contact.subscribe_to
           storage(to.domain).save_user(user)
           stream.update_user_streams(user)
+          broadcast_subscription_change(contact)
+        end
+
+        private
 
-          stream.interested_resources(to).each do |recipient|
-            recipient.write(@node)
-            contact.send_roster_push(recipient)
+        # After approving a contact's subscription to this user's presence,
+        # broadcast this user's most recent presence stanzas to the contact.
+        def send_known_presence(to)
+          stanzas = stream.available_resources(stream.user.jid).map do |stream|
+            stream.last_broadcast_presence.clone.tap do |node|
+              node['from'] = stream.user.jid.to_s
+              node['id'] = Kit.uuid
+            end
           end
+          broadcast_to_available_resources(stanzas, to)
         end
       end
     end

data/lib/vines/stanza/presence/unsubscribe.rb

@@ -7,41 +7,29 @@ module Vines
         register "/presence[@type='unsubscribe']"
 
         def process
+          stamp_from
           inbound? ? process_inbound : process_outbound
         end
 
         def process_outbound
-          self['from'] = stream.user.jid.bare.to_s
           to = stamp_to
-
           return unless stream.user.subscribed_to?(to)
           stream.user.remove_subscription_to(to)
           storage.save_user(stream.user)
           stream.update_user_streams(stream.user)
-
           local? ? process_inbound : route
-
-          contact = stream.user.contact(to)
-          stream.interested_resources(stream.user.jid).each do |recipient|
-            contact.send_roster_push(recipient)
-          end
+          send_roster_push(to)
         end
 
         def process_inbound
-          self['from'] = stream.user.jid.bare.to_s
           to = stamp_to
-
           user = storage(to.domain).find_user(to)
           return unless user && user.subscribed_from?(stream.user.jid)
           contact = user.contact(stream.user.jid)
           contact.unsubscribe_from
           storage(to.domain).save_user(user)
           stream.update_user_streams(user)
-
-          stream.interested_resources(to).each do |recipient|
-            recipient.write(@node)
-            contact.send_roster_push(recipient)
-          end
+          broadcast_subscription_change(contact)
           send_unavailable(to, stream.user.jid.bare)
         end
       end

data/lib/vines/stanza/presence/unsubscribed.rb

@@ -7,43 +7,30 @@ module Vines
         register "/presence[@type='unsubscribed']"
 
         def process
+          stamp_from
           inbound? ? process_inbound : process_outbound
         end
 
         def process_outbound
-          self['from'] = stream.user.jid.bare.to_s
           to = stamp_to
-
           return unless stream.user.subscribed_from?(to)
           send_unavailable(stream.user.jid, to)
-
           stream.user.remove_subscription_from(to)
           storage.save_user(stream.user)
           stream.update_user_streams(stream.user)
-
           local? ? process_inbound : route
-
-          contact = stream.user.contact(to)
-          stream.interested_resources(stream.user.jid).each do |recipient|
-            contact.send_roster_push(recipient)
-          end
+          send_roster_push(to)
         end
 
         def process_inbound
-          self['from'] = stream.user.jid.bare.to_s
           to = stamp_to
-
           user = storage(to.domain).find_user(to)
           return unless user && user.subscribed_to?(stream.user.jid)
           contact = user.contact(stream.user.jid)
           contact.unsubscribe_to
           storage(to.domain).save_user(user)
           stream.update_user_streams(user)
-
-          stream.interested_resources(to).each do |recipient|
-            recipient.write(@node)
-            contact.send_roster_push(recipient)
-          end
+          broadcast_subscription_change(contact)
         end
       end
     end

data/lib/vines/stanza/presence.rb

@@ -96,6 +96,28 @@ module Vines
         stream.write(node)
       end
 
+      # Send the contact's roster item to the current user's interested streams.
+      # Roster pushes are required, following presence subscription updates, to
+      # notify the user's clients of the contact's current state.
+      def send_roster_push(to)
+        contact = stream.user.contact(to)
+        stream.interested_resources(stream.user.jid).each do |recipient|
+          contact.send_roster_push(recipient)
+        end
+      end
+
+      # Notify the current user's interested streams of a contact's subscription
+      # state change as a result of receiving a subscribed, unsubscribe, or
+      # unsubscribed presence stanza.
+      def broadcast_subscription_change(contact)
+        stamp_from
+        stream.interested_resources(stamp_to).each do |recipient|
+          @node['to'] = recipient.user.jid.to_s
+          recipient.write(@node)
+          contact.send_roster_push(recipient)
+        end
+      end
+
       # Validate that the incoming stanza has a 'to' attribute and strip any
       # resource part from it so it's a bare jid. Return the bare JID object
       # that was stamped.
@@ -106,6 +128,14 @@ module Vines
           self['to'] = bare.to_s
         end
       end
+
+      # Presence subscription stanzas must be addressed from the user's bare
+      # JID. Return the user's bare JID object that was stamped.
+      def stamp_from
+        stream.user.jid.bare.tap do |bare|
+          self['from'] = bare.to_s
+        end
+      end
     end
   end
 end

data/lib/vines/stanza/pubsub/create.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class PubSub
+      class Create < PubSub
+        NS = NAMESPACES[:pubsub]
+
+        register "/iq[@id and @type='set']/ns:pubsub/ns:create", 'ns' => NS
+
+        def process
+          return if route_iq || !allowed?
+          validate_to_address
+
+          node = self.xpath('ns:pubsub/ns:create', 'ns' => NS)
+          raise StanzaErrors::BadRequest.new(self, 'modify') if node.size != 1
+          node = node.first
+
+          id = (node['node'] || '').strip
+          id = Kit.uuid if id.empty?
+          raise StanzaErrors::Conflict.new(self, 'cancel') if pubsub.node?(id)
+          pubsub.add_node(id)
+          send_result_iq(id)
+        end
+
+        private
+
+        def send_result_iq(id)
+          el = to_result
+          el << el.document.create_element('pubsub') do |node|
+            node.default_namespace = NS
+            node << el.document.create_element('create', 'node' => id)
+          end
+          stream.write(el)
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/pubsub/delete.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class PubSub
+      class Delete < PubSub
+        NS = NAMESPACES[:pubsub]
+
+        register "/iq[@id and @type='set']/ns:pubsub/ns:delete", 'ns' => NS
+
+        def process
+          return if route_iq || !allowed?
+          validate_to_address
+
+          node = self.xpath('ns:pubsub/ns:delete', 'ns' => NS)
+          raise StanzaErrors::BadRequest.new(self, 'modify') if node.size != 1
+          node = node.first
+
+          id = node['node']
+          raise StanzaErrors::ItemNotFound.new(self, 'cancel') unless pubsub.node?(id)
+
+          pubsub.publish(id, message(id))
+          pubsub.delete_node(id)
+          stream.write(to_result)
+        end
+
+        private
+
+        def message(id)
+          doc = Document.new
+          doc.create_element('message') do |node|
+            node << node.document.create_element('event') do |event|
+              event.default_namespace = NAMESPACES[:pubsub_event]
+              event << node.document.create_element('delete', 'node' => id)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/pubsub/publish.rb

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class PubSub
+      class Publish < PubSub
+        NS = NAMESPACES[:pubsub]
+
+        register "/iq[@id and @type='set']/ns:pubsub/ns:publish", 'ns' => NS
+
+        def process
+          return if route_iq || !allowed?
+          validate_to_address
+
+          node = self.xpath('ns:pubsub/ns:publish', 'ns' => NS)
+          raise StanzaErrors::BadRequest.new(self, 'modify') if node.size != 1
+          node = node.first
+          id = node['node']
+
+          raise StanzaErrors::ItemNotFound.new(self, 'cancel') unless pubsub.node?(id)
+
+          item = node.xpath('ns:item', 'ns' => NS)
+          raise StanzaErrors::BadRequest.new(self, 'modify') unless item.size == 1
+          item = item.first
+          unless item['id']
+            item['id'] = Kit.uuid
+            include_item = true
+          end
+
+          raise StanzaErrors::BadRequest.new(self, 'modify') unless item.elements.size == 1
+          pubsub.publish(id, message(id, item))
+          send_result_iq(id, include_item ? item : nil)
+        end
+
+        private
+
+        def message(node, item)
+          doc = Document.new
+          doc.create_element('message') do |message|
+            message << doc.create_element('event') do |event|
+              event.default_namespace = NAMESPACES[:pubsub_event]
+              event << doc.create_element('items', 'node' => node) do |items|
+                items << doc.create_element('item', 'id' => item['id'], 'publisher' => stream.user.jid.to_s) do |el|
+                  el << item.elements.first
+                end
+              end
+            end
+          end
+        end
+
+        def send_result_iq(node, item)
+          result = to_result
+          if item
+            result << result.document.create_element('pubsub') do |pubsub|
+              pubsub.default_namespace = NS
+              pubsub << result.document.create_element('publish', 'node' => node) do |publish|
+                publish << result.document.create_element('item', 'id' => item['id'])
+              end
+            end
+          end
+          stream.write(result)
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/pubsub/subscribe.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class PubSub
+      class Subscribe < PubSub
+        NS = NAMESPACES[:pubsub]
+
+        register "/iq[@id and @type='set']/ns:pubsub/ns:subscribe", 'ns' => NS
+
+        def process
+          return if route_iq || !allowed?
+          validate_to_address
+
+          node = self.xpath('ns:pubsub/ns:subscribe', 'ns' => NS)
+          raise StanzaErrors::BadRequest.new(self, 'modify') if node.size != 1
+          node = node.first
+          id, jid = node['node'], JID.new(node['jid'])
+
+          raise StanzaErrors::BadRequest.new(self, 'modify') unless stream.user.jid.bare == jid.bare
+          raise StanzaErrors::ItemNotFound.new(self, 'cancel') unless pubsub.node?(id)
+          raise StanzaErrors::PolicyViolation.new(self, 'wait') if pubsub.subscribed?(id, jid)
+
+          pubsub.subscribe(id, jid)
+          send_result_iq(id, jid)
+        end
+
+        private
+
+        def send_result_iq(id, jid)
+          result = to_result
+          result << result.document.create_element('pubsub') do |node|
+            node.default_namespace = NS
+            node << result.document.create_element('subscription',
+              'node' => id,
+              'jid' => jid.to_s,
+              'subscription' => 'subscribed')
+          end
+          stream.write(result)
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/pubsub/unsubscribe.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class PubSub
+      class Unsubscribe < PubSub
+        NS = NAMESPACES[:pubsub]
+
+        register "/iq[@id and @type='set']/ns:pubsub/ns:unsubscribe", 'ns' => NS
+
+        def process
+          return if route_iq || !allowed?
+          validate_to_address
+
+          node = self.xpath('ns:pubsub/ns:unsubscribe', 'ns' => NS)
+          raise StanzaErrors::BadRequest.new(self, 'modify') if node.size != 1
+          node = node.first
+          id, jid = node['node'], JID.new(node['jid'])
+
+          raise StanzaErrors::Forbidden.new(self, 'auth') unless stream.user.jid.bare == jid.bare
+          raise StanzaErrors::ItemNotFound.new(self, 'cancel') unless pubsub.node?(id)
+          raise StanzaErrors::UnexpectedRequest.new(self, 'cancel') unless pubsub.subscribed?(id, jid)
+
+          pubsub.unsubscribe(id, jid)
+          stream.write(to_result)
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/pubsub.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class PubSub < Iq
+
+      private
+
+      # Return the Config::PubSub system for the domain to which this stanza is
+      # addressed or nil if it's not to a pubsub subdomain.
+      def pubsub
+        stream.config.pubsub(validate_to)
+      end
+
+      # Raise feature-not-implemented if this stanza is addressed to the chat
+      # server itself, rather than a pubsub subdomain.
+      def validate_to_address
+        raise StanzaErrors::FeatureNotImplemented.new(self, 'cancel') unless pubsub
+      end
+    end
+  end
+end

data/lib/vines/stanza.rb

@@ -6,12 +6,9 @@ module Vines
 
     attr_reader :stream
 
-    EMPTY   = ''.freeze
-    FROM    = 'from'.freeze
-    MESSAGE = 'message'.freeze
-    TO      = 'to'.freeze
-
-    ROUTABLE_STANZAS = %w[message iq presence].freeze
+    EMPTY = ''.freeze
+    FROM, MESSAGE, TO = %w[from message to].map {|s| s.freeze }
+    ROUTABLE_STANZAS  = %w[message iq presence].freeze
 
     @@types = {}
 
@@ -45,7 +42,7 @@ module Vines
     # if it's destined for a remote domain or external component.
     def local?
       return true unless ROUTABLE_STANZAS.include?(@node.name)
-      to = JID.new(@node['to'])
+      to = JID.new(@node[TO])
       to.empty? || local_jid?(to)
     end
 
@@ -53,6 +50,14 @@ module Vines
       stream.config.local_jid?(*jids)
     end
 
+    # Return true if this stanza is addressed to a pubsub subdomain hosted
+    # at this server. This helps differentiate between IQ stanzas addressed
+    # to the server and stanzas addressed to pubsub domains, both of which must
+    # be handled locally and not routed.
+    def to_pubsub_domain?
+      stream.config.pubsub?(validate_to)
+    end
+
     def route
       stream.router.route(@node)
     end
@@ -73,25 +78,17 @@ module Vines
     # recipient's available resources. Route the stanza to a remote server if
     # the recipient isn't hosted locally.
     def send_unavailable(from, to)
-      recipients = router.available_resources(to, from) if local_jid?(to)
-
-      router.available_resources(from, to).each do |stream|
-        el = unavailable(stream.user.jid, to)
-        if local_jid?(to)
-          recipients.each {|recipient| recipient.write(el) }
-        else
-          router.route(el)
-        end
-      end
+      available = router.available_resources(from, to)
+      stanzas = available.map {|stream| unavailable(stream.user.jid) }
+      broadcast_to_available_resources(stanzas, to)
     end
 
-    # Return an unavailable presence stanza addressed to the given JID.
-    def unavailable(from, to)
+    # Return an unavailable presence stanza addressed from the given JID.
+    def unavailable(from)
       doc = Document.new
       doc.create_element('presence',
         'from' => from.to_s,
         'id'   => Kit.uuid,
-        'to'   => to.to_s,
         'type' => 'unavailable')
     end
 
@@ -115,11 +112,64 @@ module Vines
 
     private
 
+    # Send the stanzas to the destination JID, routing to a s2s stream
+    # if the address is remote. This method properly stamps the to address
+    # on each stanza before it's sent. The caller must set the from address.
+    def broadcast_to_available_resources(stanzas, to)
+      return if send_to_remote(stanzas, to)
+      send_to_recipients(stanzas, stream.available_resources(to))
+    end
+
+    # Send the stanzas to the destination JID, routing to a s2s stream
+    # if the address is remote. This method properly stamps the to address
+    # on each stanza before it's sent. The caller must set the from address.
+    def broadcast_to_interested_resources(stanzas, to)
+      return if send_to_remote(stanzas, to)
+      send_to_recipients(stanzas, stream.interested_resources(to))
+    end
+
+    # Route the stanzas to a remote server, stamping a bare JID as the
+    # to address. Bare JIDs are required for presence subscription stanzas
+    # sent to the remote contact's server. Return true if the stanzas were
+    # routed, false if they must be delivered locally.
+    def send_to_remote(stanzas, to)
+      return false if local_jid?(to)
+      to = JID.new(to)
+      stanzas.each do |el|
+        el[TO] = to.bare.to_s
+        router.route(el)
+      end
+      true
+    end
+
+    # Send the stanzas to the local recipient streams, stamping a full JID as
+    # the to address. It's important to use full JIDs, even when sending to
+    # local clients, because the stanzas may be routed to other cluster nodes
+    # for delivery. We need the receiving cluster node to send the stanza just
+    # to this full JID, not to lookup all JIDs for this user.
+    def send_to_recipients(stanzas, recipients)
+      recipients.each do |recipient|
+        stanzas.each do |el|
+          el[TO] = recipient.user.jid.to_s
+          recipient.write(el)
+        end
+      end
+    end
+
+    # Return true if the to and from JIDs are allowed to communicate with one
+    # another based on the cross_domain_messages setting in conf/config.rb. If
+    # a domain's users are isolated to sending messages only within their own
+    # domain, pubsub stanzas must not be processed from remote JIDs.
+    def allowed?
+      stream.config.allowed?(validate_to || stream.domain, stream.user.jid)
+    end
+
     def validate_address(attr)
       jid = (self[attr] || EMPTY)
       return if jid.empty?
-      JID.new(jid) rescue
-        raise StanzaErrors::JidMalformed.new(self, 'modify')
+      JID.new(jid)
+    rescue
+      raise StanzaErrors::JidMalformed.new(self, 'modify')
     end
   end
 end