vines 0.3.2 → 0.4.0

data/lib/vines/storage/couchdb.rb

@@ -24,89 +24,68 @@ module Vines
 
       def find_user(jid)
         jid = JID.new(jid).bare.to_s
-        if jid.empty? then yield; return end
-        get("user:#{jid}") do |doc|
-          user = if doc && doc['type'] == 'User'
-            User.new(:jid => jid).tap do |user|
-              user.name, user.password = doc.values_at('name', 'password')
-              (doc['roster'] || {}).each_pair do |jid, props|
-                user.roster << Contact.new(
-                  :jid => jid,
-                  :name => props['name'],
-                  :subscription => props['subscription'],
-                  :ask => props['ask'],
-                  :groups => props['groups'] || [])
-              end
-            end
+        return if jid.empty?
+        doc = get("user:#{jid}")
+        return unless doc && doc['type'] == 'User'
+        User.new(jid: jid).tap do |user|
+          user.name, user.password = doc.values_at('name', 'password')
+          (doc['roster'] || {}).each_pair do |jid, props|
+            user.roster << Contact.new(
+              jid: jid,
+              name: props['name'],
+              subscription: props['subscription'],
+              ask: props['ask'],
+              groups: props['groups'] || [])
           end
-          yield user
         end
       end
-      fiber :find_user
 
-      def save_user(user, &callback)
+      def save_user(user)
         id = "user:#{user.jid.bare}"
-        get(id) do |doc|
-          doc ||= {'_id' => id}
-          doc['type'] = 'User'
-          doc['name'] = user.name
-          doc['password'] = user.password
-          doc['roster'] = {}
-          user.roster.each do |contact|
-            doc['roster'][contact.jid.bare.to_s] = contact.to_h
-          end
-          save_doc(doc, &callback)
+        doc = get(id) || {'_id' => id}
+        doc['type'] = 'User'
+        doc['name'] = user.name
+        doc['password'] = user.password
+        doc['roster'] = {}
+        user.roster.each do |contact|
+          doc['roster'][contact.jid.bare.to_s] = contact.to_h
         end
+        save_doc(doc)
       end
-      fiber :save_user
 
       def find_vcard(jid)
         jid = JID.new(jid).bare.to_s
-        if jid.empty? then yield; return end
-        get("vcard:#{jid}") do |doc|
-          card = if doc && doc['type'] == 'Vcard'
-            Nokogiri::XML(doc['card']).root rescue nil
-          end
-          yield card
-        end
+        return if jid.empty?
+        doc = get("vcard:#{jid}")
+        return unless doc && doc['type'] == 'Vcard'
+        Nokogiri::XML(doc['card']).root rescue nil
       end
-      fiber :find_vcard
 
-      def save_vcard(jid, card, &callback)
+      def save_vcard(jid, card)
         jid = JID.new(jid).bare.to_s
         id = "vcard:#{jid}"
-        get(id) do |doc|
-          doc ||= {'_id' => id}
-          doc['type'] = 'Vcard'
-          doc['card'] = card.to_xml
-          save_doc(doc, &callback)
-        end
+        doc = get(id) || {'_id' => id}
+        doc['type'] = 'Vcard'
+        doc['card'] = card.to_xml
+        save_doc(doc)
       end
-      fiber :save_vcard
 
       def find_fragment(jid, node)
         jid = JID.new(jid).bare.to_s
-        if jid.empty? then yield; return end
-        get(fragment_id(jid, node)) do |doc|
-          fragment = if doc && doc['type'] == 'Fragment'
-            Nokogiri::XML(doc['xml']).root rescue nil
-          end
-          yield fragment
-        end
+        return if jid.empty?
+        doc = get(fragment_id(jid, node))
+        return unless doc && doc['type'] == 'Fragment'
+        Nokogiri::XML(doc['xml']).root rescue nil
       end
-      fiber :find_fragment
 
-      def save_fragment(jid, node, &callback)
+      def save_fragment(jid, node)
         jid = JID.new(jid).bare.to_s
         id = fragment_id(jid, node)
-        get(id) do |doc|
-          doc ||= {'_id' => id}
-          doc['type'] = 'Fragment'
-          doc['xml'] = node.to_xml
-          save_doc(doc, &callback)
-        end
+        doc = get(id) || {'_id' => id}
+        doc['type'] = 'Fragment'
+        doc['xml'] = node.to_xml
+        save_doc(doc)
       end
-      fiber :save_fragment
 
       private
 
@@ -132,13 +111,15 @@ module Vines
           yield doc
         end
       end
+      fiber :get
 
-      def save_doc(doc, &callback)
-        http = EM::HttpRequest.new(@url).post(
-          :head => {'Content-Type' => 'application/json'}, :body => doc.to_json)
-        http.callback(&callback) if callback
-        http.errback(&callback) if callback
+      def save_doc(doc)
+        head = {'Content-Type' => 'application/json'}
+        http = EM::HttpRequest.new(@url).post(head: head, body: doc.to_json)
+        http.callback { yield }
+        http.errback  { yield }
       end
+      fiber :save_doc
 
       def escape(jid)
         URI.escape(jid, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))

data/lib/vines/storage/local.rb

@@ -13,6 +13,11 @@ module Vines
         unless @dir && File.directory?(@dir) && File.writable?(@dir)
           raise 'Must provide a writable storage directory'
         end
+
+        %w[user vcard fragment].each do |sub|
+          sub = File.expand_path(sub, @dir)
+          Dir.mkdir(sub, 0700) unless File.exists?(sub)
+        end
       end
 
       def dir(dir=nil)
@@ -21,17 +26,17 @@ module Vines
 
       def find_user(jid)
         jid = JID.new(jid).bare.to_s
-        file = absolute_path("#{jid}.user") unless jid.empty?
+        file = absolute_path("user/#{jid}") unless jid.empty?
         record = YAML.load_file(file) rescue nil
-        return User.new(:jid => jid).tap do |user|
+        return User.new(jid: jid).tap do |user|
           user.name, user.password = record.values_at('name', 'password')
           (record['roster'] || {}).each_pair do |jid, props|
             user.roster << Contact.new(
-              :jid => jid,
-              :name => props['name'],
-              :subscription => props['subscription'],
-              :ask => props['ask'],
-              :groups => props['groups'] || [])
+              jid: jid,
+              name: props['name'],
+              subscription: props['subscription'],
+              ask: props['ask'],
+              groups: props['groups'] || [])
           end
         end if record
       end
@@ -41,7 +46,7 @@ module Vines
         user.roster.each do |contact|
           record['roster'][contact.jid.bare.to_s] = contact.to_h
         end
-        save("#{user.jid.bare.to_s}.user") do |f|
+        save("user/#{user.jid.bare}") do |f|
           YAML.dump(record, f)
         end
       end
@@ -49,14 +54,14 @@ module Vines
       def find_vcard(jid)
         jid = JID.new(jid).bare.to_s
         return if jid.empty?
-        file = absolute_path("#{jid}.vcard")
+        file = absolute_path("vcard/#{jid}")
         Nokogiri::XML(File.read(file)).root rescue nil
       end
 
       def save_vcard(jid, card)
         jid = JID.new(jid).bare.to_s
         return if jid.empty?
-        save("#{jid}.vcard") do |f|
+        save("vcard/#{jid}") do |f|
           f.write(card.to_xml)
         end
       end
@@ -64,14 +69,14 @@ module Vines
       def find_fragment(jid, node)
         jid = JID.new(jid).bare.to_s
         return if jid.empty?
-        file = absolute_path(fragment_id(jid, node))
+        file = absolute_path("fragment/#{fragment_id(jid, node)}")
         Nokogiri::XML(File.read(file)).root rescue nil
       end
 
       def save_fragment(jid, node)
         jid = JID.new(jid).bare.to_s
         return if jid.empty?
-        save(fragment_id(jid, node)) do |f|
+        save("fragment/#{fragment_id(jid, node)}") do |f|
           f.write(node.to_xml)
         end
       end
@@ -80,7 +85,8 @@ module Vines
 
       def absolute_path(file)
         File.expand_path(file, @dir).tap do |absolute|
-          raise 'path traversal' unless File.dirname(absolute) == @dir
+          parent = File.dirname(File.dirname(absolute))
+          raise 'path traversal' unless parent == @dir
         end
       end
 
@@ -92,7 +98,7 @@ module Vines
 
       def fragment_id(jid, node)
         id = Digest::SHA1.hexdigest("#{node.name}:#{node.namespace.href}")
-        "#{jid}-#{id}.fragment"
+        "#{jid}-#{id}"
       end
     end
   end

data/lib/vines/storage/mongodb.rb

@@ -0,0 +1,132 @@
+# encoding: UTF-8
+
+module Vines
+  class Storage
+    class MongoDB < Storage
+      register :mongodb
+
+      %w[database tls username password pool].each do |name|
+        define_method(name) do |*args|
+          if args.first
+            @config[name.to_sym] = args.first
+          else
+            @config[name.to_sym]
+          end
+        end
+      end
+
+      def initialize(&block)
+        @config, @hosts = {}, []
+        instance_eval(&block)
+        raise "Must provide database" unless @config[:database]
+        raise "Must provide at least one host connection" if @hosts.empty?
+      end
+
+      def host(name, port)
+        pair = [name, port]
+        raise "duplicate hosts not allowed: #{name}:#{port}" if @hosts.include?(pair)
+        @hosts << pair
+      end
+
+      def find_user(jid)
+        jid = JID.new(jid).bare.to_s
+        return if jid.empty?
+        doc = get(:users, jid)
+        return unless doc
+        User.new(jid: jid).tap do |user|
+          user.name, user.password = doc.values_at('name', 'password')
+          (doc['roster'] || {}).each_pair do |jid, props|
+            user.roster << Contact.new(
+              jid: jid,
+              name: props['name'],
+              subscription: props['subscription'],
+              ask: props['ask'],
+              groups: props['groups'] || [])
+          end
+        end
+      end
+
+      def save_user(user)
+        id = user.jid.bare.to_s
+        doc = get(:users, id) || {'_id' => id}
+        doc['name'] = user.name
+        doc['password'] = user.password
+        doc['roster'] = {}
+        user.roster.each do |contact|
+          doc['roster'][contact.jid.bare.to_s] = contact.to_h
+        end
+        save_doc(:users, doc)
+      end
+
+      def find_vcard(jid)
+        jid = JID.new(jid).bare.to_s
+        return if jid.empty?
+        doc = get(:vcards, jid)
+        return unless doc
+        Nokogiri::XML(doc['card']).root rescue nil
+      end
+
+      def save_vcard(jid, card)
+        jid = JID.new(jid).bare.to_s
+        doc = get(:vcards, jid) || {'_id' => jid}
+        doc['card'] = card.to_xml
+        save_doc(:vcards, doc)
+      end
+
+      def find_fragment(jid, node)
+        jid = JID.new(jid).bare.to_s
+        return if jid.empty?
+        doc = get(:fragments, fragment_id(jid, node))
+        return unless doc
+        Nokogiri::XML(doc['xml']).root rescue nil
+      end
+
+      def save_fragment(jid, node)
+        jid = JID.new(jid).bare.to_s
+        id = fragment_id(jid, node)
+        doc = get(:fragments, id) || {'_id' => id}
+        doc['xml'] = node.to_xml
+        save_doc(:fragments, doc)
+      end
+
+      private
+
+      def fragment_id(jid, node)
+        id = Digest::SHA1.hexdigest("#{node.name}:#{node.namespace.href}")
+        "#{jid}:#{id}"
+      end
+
+      def get(collection, id)
+        db.collection(collection).find_one({_id: id})
+      end
+      defer :get
+
+      def save_doc(collection, doc)
+        db.collection(collection).save(doc, safe: true)
+      end
+      defer :save_doc
+
+      def db
+        @db ||= connect
+      end
+
+      def connect
+        opts = {
+          pool_timeout: 5,
+          pool_size: @config[:pool] || 5,
+          ssl: @config[:tls]
+        }
+        conn = if @hosts.size == 1
+          Mongo::Connection.new(@hosts.first[0], @hosts.first[1], opts)
+        else
+          Mongo::ReplSetConnection.new(*@hosts, opts)
+        end
+        conn.db(@config[:database]).tap do |db|
+          user = @config[:username] || ''
+          pass = @config[:password] || ''
+          db.authenticate(user, pass) unless user.empty? || pass.empty?
+        end
+      end
+    end
+  end
+end

data/lib/vines/storage/null.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+module Vines
+  class Storage
+    # A storage implementation that does not persist data to any form of storage.
+    # When looking up the storage object for a domain, it's easier to treat a
+    # missing domain with a Null storage than checking for nil.
+    #
+    # For example, presence subscription stanzas sent to a pubsub subdomain
+    # have no storage. Rather than checking for nil storage or pubsub addresses,
+    # it's easier to treat stanzas to pubsub domains as Null storage that never
+    # finds or saves users and their rosters.
+    class Null < Storage
+      def find_user(jid)
+        nil
+      end
+
+      def save_user(user)
+        # do nothing
+      end
+
+      def find_vcard(jid)
+        nil
+      end
+
+      def save_vcard(jid, card)
+        # do nothing
+      end
+
+      def find_fragment(jid, node)
+        nil
+      end
+
+      def save_fragment(jid, node)
+        # do nothing
+      end
+    end
+  end
+end

data/lib/vines/storage/redis.rb

@@ -18,83 +18,66 @@ module Vines
       def initialize(&block)
         @config = {}
         instance_eval(&block)
-        @config[:db] = @config.delete(:database) if @config.key?(:database)
       end
 
       def find_user(jid)
         jid = JID.new(jid).bare.to_s
-        if jid.empty? then yield; return end
-        find_roster(jid) do |contacts|
-          redis.get("user:#{jid}") do |response|
-            user = if response
-              doc = JSON.parse(response) rescue nil
-              User.new(:jid => jid).tap do |user|
-                user.name, user.password = doc.values_at('name', 'password')
-                user.roster = contacts
-              end if doc
-            end
-            yield user
-          end
+        return if jid.empty?
+        response = query(:get, "user:#{jid}")
+        return unless response
+        doc = JSON.parse(response) rescue nil
+        return unless doc
+        User.new(jid: jid).tap do |user|
+          user.name, user.password = doc.values_at('name', 'password')
+          user.roster = find_roster(jid)
         end
       end
-      fiber :find_user
 
       def save_user(user)
-        doc = {:name => user.name, :password => user.password}
+        doc = {name: user.name, password: user.password}
         contacts = user.roster.map {|c| [c.jid.to_s, c.to_h.to_json] }.flatten
         roster = "roster:#{user.jid.bare}"
 
-        redis.set("user:#{user.jid.bare}", doc.to_json) do
-          redis.del(roster) do
-            contacts.empty? ? yield : redis.hmset(roster, *contacts) { yield }
-          end
-        end
+        redis.multi
+        redis.set("user:#{user.jid.bare}", doc.to_json)
+        redis.del(roster)
+        redis.hmset(roster, *contacts) unless contacts.empty?
+
+        req = redis.exec
+        req.callback { yield }
+        req.errback  { yield }
       end
       fiber :save_user
 
       def find_vcard(jid)
         jid = JID.new(jid).bare.to_s
-        if jid.empty? then yield; return end
-        redis.get("vcard:#{jid}") do |response|
-          card = if response
-            doc = JSON.parse(response) rescue nil
-            Nokogiri::XML(doc['card']).root rescue nil
-          end
-          yield card
-        end
+        return if jid.empty?
+        response = query(:get, "vcard:#{jid}")
+        return unless response
+        doc = JSON.parse(response) rescue nil
+        Nokogiri::XML(doc['card']).root rescue nil
       end
-      fiber :find_vcard
 
       def save_vcard(jid, card)
         jid = JID.new(jid).bare.to_s
-        doc = {:card => card.to_xml}
-        redis.set("vcard:#{jid}", doc.to_json) do
-          yield
-        end
+        doc = {card: card.to_xml}
+        query(:set, "vcard:#{jid}", doc.to_json)
       end
-      fiber :save_vcard
 
       def find_fragment(jid, node)
         jid = JID.new(jid).bare.to_s
-        if jid.empty? then yield; return end
-        redis.hget("fragments:#{jid}", fragment_id(node)) do |response|
-          fragment = if response
-            doc = JSON.parse(response) rescue nil
-            Nokogiri::XML(doc['xml']).root rescue nil
-          end
-          yield fragment
-        end
+        return if jid.empty?
+        response = query(:hget, "fragments:#{jid}", fragment_id(node))
+        return unless response
+        doc = JSON.parse(response) rescue nil
+        Nokogiri::XML(doc['xml']).root rescue nil
       end
-      fiber :find_fragment
 
       def save_fragment(jid, node)
         jid = JID.new(jid).bare.to_s
-        doc = {:xml => node.to_xml}
-        redis.hset("fragments:#{jid}", fragment_id(node), doc.to_json) do
-          yield
-        end
+        doc = {xml: node.to_xml}
+        query(:hset, "fragments:#{jid}", fragment_id(node), doc.to_json)
       end
-      fiber :save_fragment
 
       private
 
@@ -102,32 +85,42 @@ module Vines
         Digest::SHA1.hexdigest("#{node.name}:#{node.namespace.href}")
       end
 
-      # Retrieve the hash stored at roster:jid and yield an array of
-      # +Vines::Contact+ objects to the provided block.
-      #
-      # find_roster('alice@wonderland.lit') do |contacts|
-      #   puts contacts.size
-      # end
+      # Retrieve the hash stored at roster:jid and return an array of
+      # +Vines::Contact+ objects.
       def find_roster(jid)
         jid = JID.new(jid).bare
-        redis.hgetall("roster:#{jid}") do |roster|
-          contacts = roster.map do |jid, json|
-            contact = JSON.parse(json) rescue nil
-            Contact.new(
-              :jid => jid,
-              :name => contact['name'],
-              :subscription => contact['subscription'],
-              :ask => contact['ask'],
-              :groups => contact['groups'] || []) if contact
-          end.compact
-          yield contacts
-        end
+        roster = query(:hgetall, "roster:#{jid}")
+        Hash[*roster].map do |jid, json|
+          contact = JSON.parse(json) rescue nil
+          Contact.new(
+            jid: jid,
+            name: contact['name'],
+            subscription: contact['subscription'],
+            ask: contact['ask'],
+            groups: contact['groups'] || []) if contact
+        end.compact
       end
 
-      # Cache and return a redis connection object. The em-redis gem reconnects
+      def query(name, *args)
+        req = redis.send(name, *args)
+        req.callback {|response| yield response }
+        req.errback { yield }
+      end
+      fiber :query
+
+      # Cache and return a redis connection object. The em-hiredis gem reconnects
       # in unbind so only create one connection.
       def redis
-        @redis ||= EM::Protocols::Redis.connect(@config)
+        @redis ||= connect
+      end
+
+      # Return a new redis connection using the configuration attributes from the
+      # conf/config.rb file.
+      def connect
+        args = @config.values_at(:host, :port, :password, :database)
+        conn = EM::Hiredis::Client.new(*args)
+        conn.connect
+        conn
       end
     end
   end