vines 0.1.0

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

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Subscribe < Presence
+        register "/presence[@type='subscribe']"
+
+        def process
+          inbound? ? process_inbound : process_outbound
+        end
+
+        def process_outbound
+          self['from'] = stream.user.jid.bare.to_s
+          to = stamp_to
+          route unless local?
+
+          stream.user.request_subscription(to)
+          storage.save_user(stream.user)
+          stream.update_user_streams(stream.user)
+
+          process_inbound if local?
+
+          router.interested_resources(stream.user.jid).each do |recipient|
+            send_subscribe_roster_push(recipient, stream.user.contact(to))
+          end
+        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')
+          elsif contact.subscribed_from?(stream.user.jid)
+            auto_reply_to_subscription_request(to, 'subscribed')
+          else
+            recipients = router.available_resources(to)
+            if recipients.empty?
+              # TODO store subscription request per RFC 6121 3.1.3 #4
+            else
+              recipients.each {|stream| stream.write(@node) }
+            end
+          end
+        end
+
+        private
+
+        def send_subscribe_roster_push(recipient, contact)
+          doc = Document.new
+          node = doc.create_element('iq') do |el|
+            el['id'] = Kit.uuid
+            el['to'] = recipient.user.jid.to_s
+            el['type'] = 'set'
+            el << doc.create_element('query') do |query|
+              query.default_namespace = NAMESPACES[:roster]
+              query << contact.to_roster_xml
+            end
+          end
+          recipient.write(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Subscribed < Presence
+        register "/presence[@type='subscribed']"
+
+        def process
+          inbound? ? process_inbound : process_outbound
+        end
+
+        def process_outbound
+          self['from'] = stream.user.jid.bare.to_s
+          to = stamp_to
+          route unless local?
+
+          stream.user.add_subscription_from(to)
+          storage.save_user(stream.user)
+          stream.update_user_streams(stream.user)
+
+          router.interested_resources(stream.user.jid).each do |recipient|
+            send_subscribed_roster_push(recipient, to, stream.user.contact(to).subscription)
+          end
+
+          presences = router.available_resources(stream.user.jid).map do |c|
+            doc = Document.new
+            doc.create_element('presence',
+              'from' => c.user.jid.to_s,
+              'id'   => Kit.uuid,
+              'to'   => to.to_s)
+          end
+
+          if local?
+            router.available_resources(to).each do |recipient|
+              presences.each {|el| recipient.write(el) }
+            end
+          else
+            presences.each {|el| router.route(el) }
+          end
+
+          process_inbound if local?
+        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)
+
+          router.interested_resources(to).each do |recipient|
+            recipient.write(@node)
+            send_subscribed_roster_push(recipient, stream.user.jid.bare, contact.subscription)
+          end
+        end
+      end
+    end
+  end
+end

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,57 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Unsubscribe < Presence
+        register "/presence[@type='unsubscribe']"
+
+        def process
+          inbound? ? process_inbound : process_outbound
+        end
+
+        def process_outbound
+          self['from'] = stream.user.jid.bare.to_s
+          to = stamp_to
+          route unless local?
+
+          stream.user.remove_subscription_to(to)
+          storage.save_user(stream.user)
+          stream.update_user_streams(stream.user)
+
+          process_inbound if local?
+
+          if contact = stream.user.contact(to)
+            router.interested_resources(stream.user.jid).each do |recipient|
+              send_subscribed_roster_push(recipient, to, contact.subscription)
+            end
+          end
+        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)
+
+          router.interested_resources(to).each do |recipient|
+            recipient.write(@node)
+            send_subscribed_roster_push(recipient, stream.user.jid.bare, contact.subscription)
+            doc = Document.new
+            el = doc.create_element('presence',
+              'from' => stream.user.jid.bare.to_s,
+              'id'   => Kit.uuid,
+              'to'   => recipient.user.jid.to_s,
+              'type' => 'unavailable')
+            recipient.write(el)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Unsubscribed < Presence
+        register "/presence[@type='unsubscribed']"
+
+        def process
+          inbound? ? process_inbound : process_outbound
+        end
+
+        def process_outbound
+          self['from'] = stream.user.jid.bare.to_s
+          to = stamp_to
+          route unless local?
+
+          stream.user.remove_subscription_from(to)
+          storage.save_user(stream.user)
+          stream.update_user_streams(stream.user)
+
+          if contact = stream.user.contact(to)
+            router.interested_resources(stream.user.jid).each do |recipient|
+              send_subscribed_roster_push(recipient, to, contact.subscription)
+            end
+          end
+
+          process_inbound if local?
+        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)
+
+          router.interested_resources(to).each do |recipient|
+            recipient.write(@node)
+            send_subscribed_roster_push(recipient, stream.user.jid.bare, contact.subscription)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/storage.rb

@@ -0,0 +1,216 @@
+# encoding: UTF-8
+
+module Vines
+  class Storage
+    include Vines::Log
+
+    attr_accessor :ldap
+
+    @@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 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 = "_deferred_#{method}"
+      alias_method old, method
+      define_method method do |*args|
+        fiber = Fiber.current
+        op = proc do
+          begin
+            method(old).call(*args)
+          rescue Exception => e
+            log.error("Thread pool operation failed: #{e.message}")
+            nil
+          end
+        end
+        cb = proc {|result| fiber.resume(result) }
+        EM.defer(op, cb)
+        Fiber.yield
+      end
+    end
+
+    # Wrap an authenticate method with a new method that uses LDAP if it's
+    # enabled in the config file. If LDAP is not enabled, invoke the original
+    # authenticate method as usual. This allows storage classes to implement
+    # their native authentication logic and not worry about handling LDAP.
+    #
+    # For example:
+    # def authenticate(username, password)
+    #   some_user_lookup_by_password(username, password)
+    # end
+    # wrap_ldap :authenticate
+    def self.wrap_ldap(method)
+      old = "_ldap_#{method}"
+      alias_method old, method
+      define_method method do |*args|
+        ldap? ? authenticate_with_ldap(*args) : method(old).call(*args)
+      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 = "_fiber_#{method}"
+      alias_method old, method
+      define_method method do |*args|
+        fiber, yielding = Fiber.current, true
+        method(old).call(*args) do |user|
+          fiber.resume(user) rescue yielding = false
+        end
+        Fiber.yield if yielding
+      end
+    end
+
+    # Return true if users are authenticated against an LDAP directory.
+    def ldap?
+      !!ldap
+    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
+    wrap_ldap :authenticate
+
+    # 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
+
+    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 Vines::User object if we are able to bind to the LDAP server
+    # using the username and password. Return nil if authentication failed. If
+    # authentication succeeds, but the user is not yet stored in our database,
+    # save the user to the database.
+    def authenticate_with_ldap(username, password, &block)
+      if empty?(username, password)
+        block.call; return
+      end
+
+      op = proc do
+        begin
+          ldap.authenticate(username, password)
+        rescue Exception => e
+          log.error("LDAP authentication failed: #{e.message}")
+          nil
+        end
+      end
+      cb = proc {|user| save_ldap_user(user, &block) }
+      EM.defer(op, cb)
+    end
+    fiber :authenticate_with_ldap
+
+    def save_ldap_user(user, &block)
+      Fiber.new do
+        if user.nil?
+          block.call
+        elsif found = find_user(user.jid)
+          block.call(found)
+        else
+          save_user(user)
+          block.call(user)
+        end
+      end.resume
+    end
+  end
+end