vinesmod 0.4.5

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

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Unavailable < Presence
+        register "/presence[@type='unavailable']"
+
+        def process
+          inbound? ? inbound_broadcast_presence : outbound_broadcast_presence
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Unsubscribe < Presence
+        register "/presence[@type='unsubscribe']"
+
+        def process
+          stamp_from
+          inbound? ? process_inbound : process_outbound
+        end
+
+        def process_outbound
+          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
+          send_roster_push(to)
+        end
+
+        def process_inbound
+          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)
+          broadcast_subscription_change(contact)
+          send_unavailable(to, stream.user.jid.bare)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Unsubscribed < Presence
+        register "/presence[@type='unsubscribed']"
+
+        def process
+          stamp_from
+          inbound? ? process_inbound : process_outbound
+        end
+
+        def process_outbound
+          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
+          send_roster_push(to)
+        end
+
+        def process_inbound
+          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)
+          broadcast_subscription_change(contact)
+        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/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/storage.rb

@@ -0,0 +1,188 @@
+# encoding: UTF-8
+
+module Vines
+  class Storage
+    include Vines::Log
+
+    @@nicks = {}
+
+    # Register a nickname that can be used in the config file to specify this
+    # storage implementation.
+    def self.register(name)
+      @@nicks[name.to_sym] = self
+    end
+
+    def self.from_name(name, &block)
+      klass = @@nicks[name.to_sym]
+      raise "#{name} storage class not found" unless klass
+      klass.new(&block)
+    end
+
+    # Wrap a blocking IO method in a new method that pushes the original method
+    # onto EventMachine's thread pool using EM#defer. Storage classes implemented
+    # with blocking IO don't need to worry about threading or blocking the
+    # EventMachine reactor thread if they wrap their methods with this one.
+    #
+    # For example:
+    # def find_user(jid)
+    #   some_blocking_lookup(jid)
+    # end
+    # defer :find_user
+    #
+    # Storage classes that use asynchronous IO (through an EventMachine
+    # enabled library like em-http-request or em-redis) don't need any special
+    # consideration and must not use this method.
+    def self.defer(method)
+      old = instance_method(method)
+      define_method method do |*args|
+        fiber = Fiber.current
+        op = operation { old.bind(self).call(*args) }
+        cb = proc {|result| fiber.resume(result) }
+        EM.defer(op, cb)
+        Fiber.yield
+      end
+    end
+
+    # Wrap a method with Fiber yield and resume logic. The method must yield
+    # its result to a block. This makes it easier to write asynchronous
+    # implementations of +authenticate+, +find_user+, and +save_user+ that
+    # block and return a result rather than yielding.
+    #
+    # For example:
+    # def find_user(jid)
+    #   http = EM::HttpRequest.new(url).get
+    #   http.callback { yield build_user_from_http_response(http) }
+    # end
+    # fiber :find_user
+    #
+    # Because +find_user+ has been wrapped in Fiber logic, we can call it
+    # synchronously even though it uses asynchronous EventMachine calls.
+    #
+    # user = storage.find_user('alice@wonderland.lit')
+    # puts user.nil?
+    def self.fiber(method)
+      old = instance_method(method)
+      define_method method do |*args|
+        fiber, yielding = Fiber.current, true
+        old.bind(self).call(*args) do |user|
+          fiber.resume(user) rescue yielding = false
+        end
+        Fiber.yield if yielding
+      end
+    end
+
+    # Validate the username and password pair and return a +Vines::User+ object
+    # on success. Return +nil+ on failure.
+    #
+    # For example:
+    # user = storage.authenticate('alice@wonderland.lit', 'secr3t')
+    # puts user.nil?
+    #
+    # This default implementation validates the password against a bcrypt hash
+    # of the password stored in the database. Sub-classes not using bcrypt
+    # passwords must override this method.
+    def authenticate(username, password)
+      user = find_user(username)
+      hash = BCrypt::Password.new(user.password) rescue nil
+      (hash && hash == password) ? user : nil
+    end
+
+    # Return the +Vines::User+ associated with the JID. Return +nil+ if the user
+    # could not be found. JID may be +nil+, a +String+, or a +Vines::JID+
+    # object. It may be a bare JID or a full JID. Implementations of this method
+    # must convert the JID to a bare JID before searching for the user in the
+    # database.
+    #
+    # user = storage.find_user('alice@wonderland.lit')
+    # puts user.nil?
+    def find_user(jid)
+      raise 'subclass must implement'
+    end
+
+    # Persist the +Vines::User+ object to the database and return when the save
+    # is complete.
+    #
+    # alice = Vines::User.new(:jid => 'alice@wonderland.lit')
+    # storage.save_user(alice)
+    # puts 'saved'
+    def save_user(user)
+      raise 'subclass must implement'
+    end
+
+    # Return the Nokogiri::XML::Node for the vcard stored for this JID. Return
+    # nil if the vcard could not be found. JID may be +nil+, a +String+, or a
+    # +Vines::JID+ object. It may be a bare JID or a full JID. Implementations
+    # of this method must convert the JID to a bare JID before searching for the
+    # vcard in the database.
+    #
+    # card = storage.find_vcard('alice@wonderland.lit')
+    # puts card.nil?
+    def find_vcard(jid)
+      raise 'subclass must implement'
+    end
+
+    # Save the vcard to the database and return when the save is complete. JID
+    # may be a +String+ or a +Vines::JID+ object.  It may be a bare JID or a
+    # full JID. Implementations of this method must convert the JID to a bare
+    # JID before saving the vcard. Card is a +Nokogiri::XML::Node+ object.
+    #
+    # card = Nokogiri::XML('<vCard>...</vCard>').root
+    # storage.save_vcard('alice@wonderland.lit', card)
+    # puts 'saved'
+    def save_vcard(jid, card)
+      raise 'subclass must implement'
+    end
+
+    # Return the Nokogiri::XML::Node for the XML fragment stored for this JID.
+    # Return nil if the fragment could not be found. JID may be +nil+, a
+    # +String+, or a +Vines::JID+ object. It may be a bare JID or a full JID.
+    # Implementations of this method must convert the JID to a bare JID before
+    # searching for the fragment in the database.
+    #
+    # Private XML storage uniquely identifies fragments by JID, root element name,
+    # and root element namespace.
+    #
+    # root = Nokogiri::XML('<custom xmlns="urn:custom:ns"/>').root
+    # fragment = storage.find_fragment('alice@wonderland.lit', root)
+    # puts fragment.nil?
+    def find_fragment(jid, node)
+      raise 'subclass must implement'
+    end
+
+    # Save the XML fragment to the database and return when the save is complete.
+    # JID may be a +String+ or a +Vines::JID+ object.  It may be a bare JID or a
+    # full JID. Implementations of this method must convert the JID to a bare
+    # JID before saving the fragment. Fragment is a +Nokogiri::XML::Node+ object.
+    #
+    # fragment = Nokogiri::XML('<custom xmlns="urn:custom:ns">some data</custom>').root
+    # storage.save_fragment('alice@wonderland.lit', fragment)
+    # puts 'saved'
+    def save_fragment(jid, fragment)
+      raise 'subclass must implement'
+    end
+
+    private
+
+    # Return true if any of the arguments are nil or empty strings.
+    # For example:
+    # username, password = 'alice@wonderland.lit', ''
+    # empty?(username, password) #=> true
+    def empty?(*args)
+      args.flatten.any? {|arg| (arg || '').strip.empty? }
+    end
+
+    # Return a +proc+ suitable for running on the +EM.defer+ thread pool that traps
+    # and logs any errors thrown by the provided block.
+    def operation
+      proc do
+        begin
+          yield
+        rescue => e
+          log.error("Thread pool operation failed: #{e.message}")
+          nil
+        end
+      end
+    end
+
+  end
+end