vines 0.4.5 → 0.4.6

data/README

@@ -1,35 +0,0 @@
-== Welcome to Vines
-
-Vines is an XMPP chat server that supports thousands of simultaneous connections
-by using EventMachine for asynchronous IO. User data is stored in a SQL database,
-CouchDB, MongoDB, Redis, the file system, or a custom storage implementation
-that you provide. LDAP authentication can be used so user names and passwords
-aren't stored in the chat database. SSL encryption is mandatory on all client
-and server connections.
-
-The Vines XMPP server includes a web chat client. The web application is available
-immediately after starting the chat server at http://localhost:5280/chat/.
-
-Additional documentation can be found at www.getvines.org.
-
-== Usage
-
-1. gem install vines
-2. vines init wonderland.lit
-3. cd wonderland.lit && vines start
-4. Login with your favorite chat program (iChat, Adium, Pidgin, etc.) to
-   start chatting!
-
-== Dependencies
-
-Vines requires Ruby 1.9.2 or better. Instructions for installing the
-needed OS packages, as well as Ruby itself, are available at
-http://www.getvines.org/ruby.
-
-== Contact
-
-* David Graham <david@negativecode.com>
-
-== License
-
-Vines is released under the MIT license. Check the LICENSE file for details.

data/lib/vines/storage/couchdb.rb

@@ -1,129 +0,0 @@
-# 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
-        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
-        end
-      end
-
-      def save_user(user)
-        id = "user:#{user.jid.bare}"
-        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
-
-      def find_vcard(jid)
-        jid = JID.new(jid).bare.to_s
-        return if jid.empty?
-        doc = get("vcard:#{jid}")
-        return unless doc && doc['type'] == 'Vcard'
-        Nokogiri::XML(doc['card']).root rescue nil
-      end
-
-      def save_vcard(jid, card)
-        jid = JID.new(jid).bare.to_s
-        id = "vcard:#{jid}"
-        doc = get(id) || {'_id' => id}
-        doc['type'] = 'Vcard'
-        doc['card'] = card.to_xml
-        save_doc(doc)
-      end
-
-      def find_fragment(jid, node)
-        jid = JID.new(jid).bare.to_s
-        return if jid.empty?
-        doc = get(fragment_id(jid, node))
-        return unless doc && doc['type'] == 'Fragment'
-        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(id) || {'_id' => id}
-        doc['type'] = 'Fragment'
-        doc['xml'] = node.to_xml
-        save_doc(doc)
-      end
-
-      private
-
-      def fragment_id(jid, node)
-        id = Digest::SHA1.hexdigest("#{node.name}:#{node.namespace.href}")
-        "fragment:#{jid}:#{id}"
-      end
-
-      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
-      fiber :get
-
-      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}]"))
-      end
-    end
-  end
-end

data/lib/vines/storage/mongodb.rb

@@ -1,132 +0,0 @@
-# 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/redis.rb

@@ -1,127 +0,0 @@
-# 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)
-      end
-
-      def find_user(jid)
-        jid = JID.new(jid).bare.to_s
-        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
-
-      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.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
-        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
-
-      def save_vcard(jid, card)
-        jid = JID.new(jid).bare.to_s
-        doc = {card: card.to_xml}
-        query(:set, "vcard:#{jid}", doc.to_json)
-      end
-
-      def find_fragment(jid, node)
-        jid = JID.new(jid).bare.to_s
-        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
-
-      def save_fragment(jid, node)
-        jid = JID.new(jid).bare.to_s
-        doc = {xml: node.to_xml}
-        query(:hset, "fragments:#{jid}", fragment_id(node), doc.to_json)
-      end
-
-      private
-
-      def fragment_id(node)
-        Digest::SHA1.hexdigest("#{node.name}:#{node.namespace.href}")
-      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
-        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
-
-      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 ||= 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
-end

data/lib/vines/storage/sql.rb

@@ -1,220 +0,0 @@
-# encoding: UTF-8
-
-module Vines
-  class Storage
-    class Sql < Storage
-      register :sql
-
-      class Contact < ActiveRecord::Base
-        belongs_to :user
-      end
-      class Fragment < ActiveRecord::Base
-        belongs_to :user
-      end
-      class Group < ActiveRecord::Base; end
-      class User < ActiveRecord::Base
-        has_many :contacts,  :dependent => :destroy
-        has_many :fragments, :dependent => :delete_all
-      end
-
-      # Wrap the method with ActiveRecord connection pool logic, so we properly
-      # return connections to the pool when we're finished with them. This also
-      # defers the original method by pushing it onto the EM thread pool because
-      # ActiveRecord uses blocking IO.
-      def self.with_connection(method, args={})
-        deferrable = args.key?(:defer) ? args[:defer] : true
-        old = instance_method(method)
-        define_method method do |*args|
-          ActiveRecord::Base.connection_pool.with_connection do
-            old.bind(self).call(*args)
-          end
-        end
-        defer(method) if deferrable
-      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)
-        jid = JID.new(jid).bare.to_s
-        return if jid.empty?
-        xuser = user_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
-      with_connection :find_user
-
-      def save_user(user)
-        xuser = user_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
-      with_connection :save_user
-
-      def find_vcard(jid)
-        jid = JID.new(jid).bare.to_s
-        return if jid.empty?
-        if xuser = user_by_jid(jid)
-          Nokogiri::XML(xuser.vcard).root rescue nil
-        end
-      end
-      with_connection :find_vcard
-
-      def save_vcard(jid, card)
-        xuser = user_by_jid(jid)
-        if xuser
-          xuser.vcard = card.to_xml
-          xuser.save
-        end
-      end
-      with_connection :save_vcard
-
-      def find_fragment(jid, node)
-        jid = JID.new(jid).bare.to_s
-        return if jid.empty?
-        if fragment = fragment_by_jid(jid, node)
-          Nokogiri::XML(fragment.xml).root rescue nil
-        end
-      end
-      with_connection :find_fragment
-
-      def save_fragment(jid, node)
-        jid = JID.new(jid).bare.to_s
-        fragment = fragment_by_jid(jid, node) ||
-          Sql::Fragment.new(
-            user: user_by_jid(jid),
-            root: node.name,
-            namespace: node.namespace.href)
-        fragment.xml = node.to_xml
-        fragment.save
-      end
-      with_connection :save_fragment
-
-      # Create the tables and indexes used by this storage engine.
-      def create_schema(args={})
-        args[:force] ||= false
-
-        ActiveRecord::Schema.define do
-          create_table :users, force: args[:force] do |t|
-            t.string :jid,      limit: 512, null: false
-            t.string :name,     limit: 256, null: true
-            t.string :password, limit: 256, 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: 512, null: false
-            t.string  :name,         limit: 256, null: true
-            t.string  :ask,          limit: 128, null: true
-            t.string  :subscription, limit: 128, null: false
-          end
-          add_index :contacts, [:user_id, :jid], unique: true
-
-          create_table :groups, force: args[:force] do |t|
-            t.string :name, limit: 256, 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
-
-          create_table :fragments, force: args[:force] do |t|
-            t.integer :user_id,   null: false
-            t.string  :root,      limit: 256, null: false
-            t.string  :namespace, limit: 256, null: false
-            t.text    :xml,       null: false
-          end
-          add_index :fragments, [:user_id, :root, :namespace], unique: true
-        end
-      end
-      with_connection :create_schema, defer: false
-
-      private
-
-      def establish_connection
-        ActiveRecord::Base.logger = Logger.new('/dev/null')
-        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 user_by_jid(jid)
-        jid = JID.new(jid).bare.to_s
-        Sql::User.find_by_jid(jid, :include => {:contacts => :groups})
-      end
-
-      def fragment_by_jid(jid, node)
-        jid = JID.new(jid).bare.to_s
-        clause = 'user_id=(select id from users where jid=?) and root=? and namespace=?'
-        Sql::Fragment.where(clause, jid, node.name, node.namespace.href).first
-      end
-
-      def groups(contact)
-        contact.groups.map {|name| Sql::Group.find_or_create_by_name(name.strip) }
-      end
-    end
-  end
-end