vines-redis 0.1.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010-2013 Negative Code
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,49 @@
+# Welcome to Vines
+
+Vines is a scalable XMPP chat server, using EventMachine for asynchronous IO.
+This gem provides support for storing user data in [Redis](http://redis.io/).
+
+Additional documentation can be found at [getvines.org](http://www.getvines.org/).
+
+## Usage
+
+```
+$ gem install vines vines-redis
+$ vines init wonderland.lit
+$ cd wonderland.lit && vines start
+```
+
+## Dependencies
+
+Vines requires Ruby 1.9.3 or better. Instructions for installing the
+needed OS packages, as well as Ruby itself, are available at
+[getvines.org/ruby](http://www.getvines.org/ruby).
+
+## Configuration
+
+Add the following configuration block to a virtual host definition in
+the server's `conf/config.rb` file.
+
+```ruby
+storage 'redis' do
+  host 'localhost'
+  port 6379
+  database 0
+  password ''
+end
+```
+
+## Development
+
+```
+$ script/bootstrap
+$ script/tests
+```
+
+## Contact
+
+* David Graham <david@negativecode.com>
+
+## License
+
+Vines is released under the MIT license. Check the LICENSE file for details.

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+
+CLOBBER.include('pkg')
+
+directory 'pkg'
+
+desc 'Build distributable packages'
+task :build => [:pkg] do
+  system 'gem build vines-redis.gemspec && mv vines-*.gem pkg/'
+end
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'spec'
+  test.pattern = 'spec/**/*_spec.rb'
+  test.warning = false
+end
+
+task :default => [:clobber, :test, :build]

data/lib/vines/storage/redis.rb

@@ -0,0 +1,127 @@
+require 'em-hiredis'
+
+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/spec/mock_redis.rb

@@ -0,0 +1,95 @@
+# A mock redis storage implementation that saves data to an in-memory Hash.
+class MockRedis
+  attr_reader :db
+
+  # Mimic em-hiredis behavior.
+  def self.defer(method)
+    old = instance_method(method)
+    define_method method do |*args, &block|
+      result = old.bind(self).call(*args)
+      deferred = EM::DefaultDeferrable.new
+      deferred.callback(&block) if block
+      EM.next_tick { deferred.succeed(result) }
+      deferred
+    end
+  end
+
+  def initialize
+    @db = {}
+  end
+
+  def del(key)
+    @db.delete(key)
+  end
+  defer :del
+
+  def get(key)
+    @db[key]
+  end
+  defer :get
+
+  def set(key, value)
+    @db[key] = value
+  end
+  defer :set
+
+  def hget(key, field)
+    @db[key][field] rescue nil
+  end
+  defer :hget
+
+  def hdel(key, field)
+    @db[key].delete(field) rescue nil
+  end
+  defer :hdel
+
+  def hgetall(key)
+    (@db[key] || {}).map do |k, v|
+      [k, v]
+    end.flatten
+  end
+  defer :hgetall
+
+  def hset(key, field, value)
+    @db[key] ||= {}
+    @db[key][field] = value
+  end
+  defer :hset
+
+  def hmset(key, *args)
+    @db[key] = Hash[*args]
+  end
+  defer :hmset
+
+  def sadd(key, obj)
+    @db[key] ||= Set.new
+    @db[key] << obj
+  end
+  defer :sadd
+
+  def srem(key, obj)
+    @db[key].delete(obj) rescue nil
+  end
+  defer :srem
+
+  def smembers
+    @db[key].to_a rescue []
+  end
+  defer :smembers
+
+  def flushdb
+    @db.clear
+  end
+  defer :flushdb
+
+  def multi
+    @transaction = true
+  end
+  defer :multi
+
+  def exec
+    raise 'transaction must start with multi' unless @transaction
+    @transaction = false
+  end
+  defer :exec
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'vines'
+require 'mock_redis'
+require 'storage_specs'
+require 'minitest/autorun'

data/spec/storage/redis_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Vines::Storage::Redis do
+  include StorageSpecs
+
+  MOCK_REDIS = MockRedis.new
+
+  before do
+    fibered do
+      db = MOCK_REDIS
+      db.set('user:empty@wonderland.lit', {}.to_json)
+      db.set('user:no_password@wonderland.lit', {'foo' => 'bar'}.to_json)
+      db.set('user:clear_password@wonderland.lit', {'password' => 'secret'}.to_json)
+      db.set('user:bcrypt_password@wonderland.lit', {'password' => BCrypt::Password.create('secret')}.to_json)
+      db.set('user:full@wonderland.lit', {
+        'password' => BCrypt::Password.create('secret'),
+        'name' => 'Tester'
+      }.to_json)
+      db.hmset('roster:full@wonderland.lit',
+        'contact1@wonderland.lit',
+        {'name' => 'Contact1', 'groups' => %w[Group1 Group2]}.to_json,
+        'contact2@wonderland.lit',
+        {'name' => 'Contact2', 'groups' => %w[Group3 Group4]}.to_json)
+      db.set('vcard:full@wonderland.lit', {'card' => vcard.to_xml}.to_json)
+      db.hset('fragments:full@wonderland.lit', fragment_id, {'xml' => fragment.to_xml}.to_json)
+    end
+  end
+
+  after do
+    MOCK_REDIS.flushdb
+  end
+
+  def storage
+    storage = Vines::Storage::Redis.new { host 'localhost'; port 6397 }
+    def storage.redis; MOCK_REDIS; end
+    storage
+  end
+
+  describe 'creating a new instance' do
+    it 'does not raise with no arguments' do
+      fibered do
+        obj = Vines::Storage::Redis.new {}
+        obj.wont_be_nil
+      end
+    end
+
+    it 'does not raise when port is missing' do
+      fibered do
+        obj = Vines::Storage::Redis.new { host 'localhost' }
+        obj.wont_be_nil
+      end
+    end
+
+    it 'does not raise with host and port' do
+      fibered do
+        obj = Vines::Storage::Redis.new { host'localhost'; port '6379' }
+        obj.wont_be_nil
+      end
+    end
+  end
+end

data/spec/storage_specs.rb

@@ -0,0 +1,182 @@
+# Mixin methods for storage implementation test classes. The behavioral
+# tests are the same regardless of implementation so share those methods
+# here.
+module StorageSpecs
+  def fragment_id
+    Digest::SHA1.hexdigest("characters:urn:wonderland")
+  end
+
+  def fragment
+    Nokogiri::XML(%q{
+      <characters xmlns="urn:wonderland">
+        <character>Alice</character>
+      </characters>
+    }.strip).root
+  end
+
+  def vcard
+    Nokogiri::XML(%q{
+      <vCard xmlns="vcard-temp">
+        <FN>Alice in Wonderland</FN>
+      </vCard>
+    }.strip).root
+  end
+
+  def fibered
+    EM.run do
+      Fiber.new do
+        yield
+        EM.stop
+      end.resume
+    end
+  end
+
+  def test_authenticate
+    fibered do
+      db = storage
+      db.authenticate(nil, nil).must_be_nil
+      db.authenticate(nil, 'secret').must_be_nil
+      db.authenticate('bogus', nil).must_be_nil
+      db.authenticate('bogus', 'secret').must_be_nil
+      db.authenticate('empty@wonderland.lit', 'secret').must_be_nil
+      db.authenticate('no_password@wonderland.lit', 'secret').must_be_nil
+      db.authenticate('clear_password@wonderland.lit', 'secret').must_be_nil
+
+      user = db.authenticate('bcrypt_password@wonderland.lit', 'secret')
+      user.wont_be_nil
+      user.jid.to_s.must_equal 'bcrypt_password@wonderland.lit'
+
+      user = db.authenticate('full@wonderland.lit', 'secret')
+      user.wont_be_nil
+      user.name.must_equal 'Tester'
+      user.jid.to_s.must_equal 'full@wonderland.lit'
+
+      user.roster.length.must_equal 2
+      user.roster[0].jid.to_s.must_equal 'contact1@wonderland.lit'
+      user.roster[0].name.must_equal 'Contact1'
+      user.roster[0].groups.length.must_equal 2
+      user.roster[0].groups[0].must_equal 'Group1'
+      user.roster[0].groups[1].must_equal 'Group2'
+
+      user.roster[1].jid.to_s.must_equal 'contact2@wonderland.lit'
+      user.roster[1].name.must_equal 'Contact2'
+      user.roster[1].groups.length.must_equal 2
+      user.roster[1].groups[0].must_equal 'Group3'
+      user.roster[1].groups[1].must_equal 'Group4'
+    end
+  end
+
+  def test_find_user
+    fibered do
+      db = storage
+      user = db.find_user(nil)
+      user.must_be_nil
+
+      user = db.find_user('full@wonderland.lit')
+      user.wont_be_nil
+      user.jid.to_s.must_equal 'full@wonderland.lit'
+
+      user = db.find_user(Vines::JID.new('full@wonderland.lit'))
+      user.wont_be_nil
+      user.jid.to_s.must_equal 'full@wonderland.lit'
+
+      user = db.find_user(Vines::JID.new('full@wonderland.lit/resource'))
+      user.wont_be_nil
+      user.jid.to_s.must_equal 'full@wonderland.lit'
+    end
+  end
+
+  def test_save_user
+    fibered do
+      db = storage
+      user = Vines::User.new(
+        jid: 'save_user@domain.tld/resource1',
+        name: 'Save User',
+        password: 'secret')
+      user.roster << Vines::Contact.new(
+        jid: 'contact1@domain.tld/resource2',
+        name: 'Contact 1')
+      db.save_user(user)
+      user = db.find_user('save_user@domain.tld')
+      user.wont_be_nil
+      user.jid.to_s.must_equal 'save_user@domain.tld'
+      user.name.must_equal 'Save User'
+      user.roster.length.must_equal 1
+      user.roster[0].jid.to_s.must_equal 'contact1@domain.tld'
+      user.roster[0].name.must_equal 'Contact 1'
+    end
+  end
+
+  def test_find_vcard
+    fibered do
+      db = storage
+      card = db.find_vcard(nil)
+      card.must_be_nil
+
+      card = db.find_vcard('full@wonderland.lit')
+      card.wont_be_nil
+      card.to_s.must_equal vcard.to_s
+
+      card = db.find_vcard(Vines::JID.new('full@wonderland.lit'))
+      card.wont_be_nil
+      card.to_s.must_equal vcard.to_s
+
+      card = db.find_vcard(Vines::JID.new('full@wonderland.lit/resource'))
+      card.wont_be_nil
+      card.to_s.must_equal vcard.to_s
+    end
+  end
+
+  def test_save_vcard
+    fibered do
+      db = storage
+      db.save_user(Vines::User.new(jid: 'save_user@domain.tld'))
+      db.save_vcard('save_user@domain.tld/resource1', vcard)
+      card = db.find_vcard('save_user@domain.tld')
+      card.wont_be_nil
+      card.to_s.must_equal vcard.to_s
+    end
+  end
+
+  def test_find_fragment
+    fibered do
+      db = storage
+      root = Nokogiri::XML(%q{<characters xmlns="urn:wonderland"/>}).root
+      bad_name = Nokogiri::XML(%q{<not_characters xmlns="urn:wonderland"/>}).root
+      bad_ns = Nokogiri::XML(%q{<characters xmlns="not:wonderland"/>}).root
+
+      node = db.find_fragment(nil, nil)
+      node.must_be_nil
+
+      node = db.find_fragment('full@wonderland.lit', bad_name)
+      node.must_be_nil
+
+      node = db.find_fragment('full@wonderland.lit', bad_ns)
+      node.must_be_nil
+
+      node = db.find_fragment('full@wonderland.lit', root)
+      node.wont_be_nil
+      node.to_s.must_equal fragment.to_s
+
+      node = db.find_fragment(Vines::JID.new('full@wonderland.lit'), root)
+      node.wont_be_nil
+      node.to_s.must_equal fragment.to_s
+
+      node = db.find_fragment(Vines::JID.new('full@wonderland.lit/resource'), root)
+      node.wont_be_nil
+      node.to_s.must_equal fragment.to_s
+    end
+  end
+
+  def test_save_fragment
+    fibered do
+      db = storage
+      root = Nokogiri::XML(%q{<characters xmlns="urn:wonderland"/>}).root
+      db.save_user(Vines::User.new(jid: 'save_user@domain.tld'))
+      db.save_fragment('save_user@domain.tld/resource1', fragment)
+      node = db.find_fragment('save_user@domain.tld', root)
+      node.wont_be_nil
+      node.to_s.must_equal fragment.to_s
+    end
+  end
+end

data/vines-redis.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |s|
+  s.name         = 'vines-redis'
+  s.version      = '0.1.0'
+  s.summary      = %q[Provides a Redis storage adapter for the Vines XMPP chat server.]
+  s.description  = %q[Stores Vines user data in Redis.]
+
+  s.authors      = ['David Graham']
+  s.email        = %w[david@negativecode.com]
+  s.homepage     = 'http://www.getvines.org'
+  s.license      = 'MIT'
+
+  s.files        = Dir['[A-Z]*', 'vines-redis.gemspec', 'lib/**/*'] - ['Gemfile.lock']
+  s.test_files   = Dir['spec/**/*']
+  s.require_path = 'lib'
+
+  s.add_dependency 'em-hiredis', '~> 0.1.1'
+  s.add_dependency 'vines', '>= 0.4.5'
+
+  s.add_development_dependency 'minitest', '~> 4.7.4'
+  s.add_development_dependency 'rake', '~> 10.1.0'
+
+  s.required_ruby_version = '>= 1.9.3'
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: vines-redis
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- David Graham
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-hiredis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: vines
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.5
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.7.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.7.4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+description: Stores Vines user data in Redis.
+email:
+- david@negativecode.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- Rakefile
+- README.md
+- vines-redis.gemspec
+- lib/vines/storage/redis.rb
+- spec/mock_redis.rb
+- spec/spec_helper.rb
+- spec/storage/redis_spec.rb
+- spec/storage_specs.rb
+homepage: http://www.getvines.org
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 8918539191823912
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Provides a Redis storage adapter for the Vines XMPP chat server.
+test_files:
+- spec/mock_redis.rb
+- spec/spec_helper.rb
+- spec/storage/redis_spec.rb
+- spec/storage_specs.rb