vines 0.1.0

data/lib/vines/storage/couchdb.rb

@@ -0,0 +1,119 @@
+# encoding: UTF-8
+
+module Vines
+  class Storage
+    class CouchDB < Storage
+      register :couchdb
+
+      %w[host port database tls username password].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 = {}
+        instance_eval(&block)
+        [:host, :port, :database].each {|key| raise "Must provide #{key}" unless @config[key] }
+        @url = url(@config)
+      end
+
+      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
+          end
+          yield user
+        end
+      end
+      fiber :find_user
+
+      def save_user(user, &callback)
+        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)
+        end
+      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
+      end
+      fiber :find_vcard
+
+      def save_vcard(jid, card, &callback)
+        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
+      end
+      fiber :save_vcard
+
+      private
+
+      def url(config)
+        scheme = config[:tls] ? 'https' : 'http'
+        user, password = config.values_at(:username, :password)
+        credentials = empty?(user, password) ? '' : "%s:%s@" % [user, password]
+        "%s://%s%s:%s/%s" % [scheme, credentials, *config.values_at(:host, :port, :database)]
+      end
+
+      def get(jid)
+        http = EM::HttpRequest.new("#{@url}/#{escape(jid)}").get
+        http.errback { yield }
+        http.callback do
+          doc = if http.response_header.status == 200
+            JSON.parse(http.response) rescue nil
+          end
+          yield doc
+        end
+      end
+
+      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
+      end
+
+      def escape(jid)
+        URI.escape(jid, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+      end
+    end
+  end
+end

data/lib/vines/storage/ldap.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+module Vines
+  class Storage
+
+    # Authenticates usernames and passwords against an LDAP directory. This can
+    # provide authentication logic for the other, full-featured Storage
+    # implementations while they store and retrieve the rest of the user
+    # information.
+    class Ldap
+      @@required = [:host, :port]
+      %w[tls dn password basedn object_class user_attr name_attr].each do |name|
+        @@required << name.to_sym
+        define_method name do |*args|
+          @config[name.to_sym] = args.first
+        end
+      end
+
+      def initialize(host='localhost', port=636, &block)
+        @config = {:host => host, :port => port}
+        instance_eval(&block)
+        @@required.each {|key| raise "Must provide #{key}" if @config[key].nil? }
+      end
+
+      # Validates a username and password by binding to the LDAP instance with
+      # those credentials. If the bind succeeds, the user's attributes are
+      # retrieved.
+      def authenticate(username, password)
+        return if [username, password].any? {|arg| (arg || '').strip.empty? }
+
+        clas = Net::LDAP::Filter.eq('objectClass', @config[:object_class])
+        uid = Net::LDAP::Filter.eq(@config[:user_attr], username)
+        filter = clas & uid
+        attrs = [@config[:name_attr], 'mail']
+
+        ldap = connect(@config[:dn], @config[:password])
+        entries = ldap.search(:attributes => attrs, :filter => filter)
+        return unless entries && entries.size == 1
+
+        user = if connect(entries.first.dn, password).bind
+          name = entries.first[@config[:name_attr]].first
+          User.new(:jid => username, :name => name.to_s, :roster => [])
+        end
+        user
+      end
+
+      private
+
+      def connect(dn, password)
+        options = [:host, :port, :base].zip(
+          @config.values_at(:host, :port, :basedn))
+        Net::LDAP.new(Hash[options]).tap do |ldap|
+          ldap.encryption(:simple_tls) if @config[:tls]
+          ldap.auth(dn, password)
+        end
+      end
+    end
+  end
+end

data/lib/vines/storage/local.rb

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+
+module Vines
+  class Storage
+
+    # A storage implementation that persists data to YAML files on the
+    # local file system.
+    class Local < Storage
+      register :fs
+
+      def initialize(&block)
+        instance_eval(&block)
+        unless @dir && File.directory?(@dir) && File.writable?(@dir)
+          raise 'Must provide a writable storage directory'
+        end
+      end
+
+      def dir(dir=nil)
+        dir ? @dir = File.expand_path(dir) : @dir
+      end
+
+      def find_user(jid)
+        jid = JID.new(jid || '').bare.to_s
+        file = File.join(@dir, "#{jid}.user") unless jid.empty?
+        record = YAML.load_file(file) rescue nil
+        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'] || [])
+          end
+        end if record
+      end
+
+      def save_user(user)
+        record = {'name' => user.name, 'password' => user.password, 'roster' => {}}
+        user.roster.each do |contact|
+          record['roster'][contact.jid.bare.to_s] = contact.to_h
+        end
+        file = File.join(@dir, "#{user.jid.bare.to_s}.user")
+        File.open(file, 'w') do |f|
+          YAML.dump(record, f)
+        end
+      end
+
+      def find_vcard(jid)
+        jid = JID.new(jid || '').bare.to_s
+        return if jid.empty?
+        file = File.join(@dir, "#{jid}.vcard")
+        Nokogiri::XML(File.read(file)).root rescue nil
+      end
+
+      def save_vcard(jid, card)
+        jid = JID.new(jid).bare.to_s
+        file = File.join(@dir, "#{jid}.vcard")
+        File.open(file, 'w') do |f|
+          f.write(card.to_xml)
+        end
+      end
+    end
+  end
+end

data/lib/vines/storage/redis.rb

@@ -0,0 +1,108 @@
+# encoding: UTF-8
+
+module Vines
+  class Storage
+    class Redis < Storage
+      register :redis
+
+      %w[host port database password].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 = {}
+        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
+        end
+      end
+      fiber :find_user
+
+      def save_user(user)
+        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
+      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
+      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
+      end
+      fiber :save_vcard
+
+      private
+
+      # 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
+      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
+      end
+
+      # Cache and return a redis connection object. The em-redis gem reconnects
+      # in unbind so only create one connection.
+      def redis
+        @redis ||= EM::Protocols::Redis.connect(@config)
+      end
+    end
+  end
+end

data/lib/vines/storage/sql.rb

@@ -0,0 +1,174 @@
+# encoding: UTF-8
+
+module Vines
+  class Storage
+    class Sql < Storage
+      register :sql
+
+      class Contact < ActiveRecord::Base
+        belongs_to :user
+      end
+      class Group < ActiveRecord::Base; end
+      class User < ActiveRecord::Base
+        has_many :contacts
+      end
+
+      %w[adapter host port database 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 = {}
+        instance_eval(&block)
+        required = [:adapter, :database]
+        required << [:host, :port] unless @config[:adapter] == 'sqlite3'
+        required.flatten.each {|key| raise "Must provide #{key}" unless @config[key] }
+        [:username, :password].each {|key| @config.delete(key) if empty?(@config[key]) }
+        establish_connection
+      end
+
+      def find_user(jid)
+        ActiveRecord::Base.clear_reloadable_connections!
+
+        jid = JID.new(jid || '').bare.to_s
+        return if jid.empty?
+        xuser = by_jid(jid)
+        return Vines::User.new(:jid => jid).tap do |user|
+          user.name, user.password = xuser.name, xuser.password
+          xuser.contacts.each do |contact|
+            groups = contact.groups.map {|group| group.name }
+            user.roster << Vines::Contact.new(
+              :jid => contact.jid,
+              :name => contact.name,
+              :subscription => contact.subscription,
+              :ask => contact.ask,
+              :groups => groups)
+          end
+        end if xuser
+      end
+      defer :find_user
+
+      def save_user(user)
+        ActiveRecord::Base.clear_reloadable_connections!
+
+        xuser = by_jid(user.jid) || Sql::User.new(:jid => user.jid.bare.to_s)
+        xuser.name = user.name
+        xuser.password = user.password
+
+        # remove deleted contacts from roster
+        xuser.contacts.delete(xuser.contacts.select do |contact|
+          !user.contact?(contact.jid)
+        end)
+
+        # update contacts
+        xuser.contacts.each do |contact|
+          fresh = user.contact(contact.jid)
+          contact.update_attributes(
+            :name => fresh.name,
+            :ask => fresh.ask,
+            :subscription => fresh.subscription,
+            :groups => groups(fresh))
+        end
+
+        # add new contacts to roster
+        jids = xuser.contacts.map {|c| c.jid }
+        user.roster.select {|contact| !jids.include?(contact.jid.bare.to_s) }
+          .each do |contact|
+            xuser.contacts.build(
+              :user => xuser,
+              :jid => contact.jid.bare.to_s,
+              :name => contact.name,
+              :ask => contact.ask,
+              :subscription => contact.subscription,
+              :groups => groups(contact))
+          end
+        xuser.save
+      end
+      defer :save_user
+
+      def find_vcard(jid)
+        ActiveRecord::Base.clear_reloadable_connections!
+
+        jid = JID.new(jid || '').bare.to_s
+        return if jid.empty?
+        if xuser = by_jid(jid)
+          Nokogiri::XML(xuser.vcard).root rescue nil
+        end
+      end
+      defer :find_vcard
+
+      def save_vcard(jid, card)
+        ActiveRecord::Base.clear_reloadable_connections!
+
+        xuser = by_jid(jid)
+        if xuser
+          xuser.vcard = card.to_xml
+          xuser.save
+        end
+      end
+      defer :save_vcard
+
+      # Create the tables and indexes used by this storage engine.
+      def create_schema(args={})
+        ActiveRecord::Base.clear_reloadable_connections!
+
+        args[:force] ||= false
+
+        ActiveRecord::Schema.define do
+          create_table :users, :force => args[:force] do |t|
+            t.string :jid,      :limit => 1000, :null => false
+            t.string :name,     :limit => 1000, :null => true
+            t.string :password, :limit => 1000, :null => true
+            t.text   :vcard,    :null => true
+          end
+          add_index :users, :jid, :unique => true
+
+          create_table :contacts, :force => args[:force] do |t|
+            t.integer :user_id,      :null => false
+            t.string  :jid,          :limit => 1000, :null => false
+            t.string  :name,         :limit => 1000, :null => true
+            t.string  :ask,          :limit => 1000, :null => true
+            t.string  :subscription, :limit => 1000, :null => false
+          end
+          add_index :contacts, [:user_id, :jid], :unique => true
+
+          create_table :groups, :force => args[:force] do |t|
+            t.string :name, :limit => 1000, :null => false
+          end
+          add_index :groups, :name, :unique => true
+
+          create_table :contacts_groups, :id => false, :force => args[:force] do |t|
+            t.integer :contact_id, :null => false
+            t.integer :group_id,   :null => false
+          end
+          add_index :contacts_groups, [:contact_id, :group_id], :unique => true
+        end
+      end
+
+      private
+
+      def establish_connection
+        ActiveRecord::Base.establish_connection(@config)
+        # has_and_belongs_to_many requires a connection so configure the
+        # associations here rather than in the class definitions above.
+        Sql::Contact.has_and_belongs_to_many :groups
+        Sql::Group.has_and_belongs_to_many :contacts
+      end
+
+      def by_jid(jid)
+        jid = JID.new(jid).bare.to_s
+        Sql::User.find_by_jid(jid, :include => {:contacts => :groups})
+      end
+
+      def groups(contact)
+        contact.groups.map {|name| Sql::Group.find_or_create_by_name(name.strip) }
+      end
+    end
+  end
+end