vines 0.3.2 → 0.4.0

data/lib/vines/storage/sql.rb

@@ -13,8 +13,24 @@ module Vines
       end
       class Group < ActiveRecord::Base; end
       class User < ActiveRecord::Base
-        has_many :contacts
-        has_many :fragments
+        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 = "_with_connection_#{method}"
+        alias_method old, method
+        define_method method do |*args|
+          ActiveRecord::Base.connection_pool.with_connection do
+            method(old).call(*args)
+          end
+        end
+        defer(method) if deferrable
       end
 
       %w[adapter host port database username password pool].each do |name|
@@ -38,30 +54,26 @@ module Vines
       end
 
       def find_user(jid)
-        ActiveRecord::Base.clear_reloadable_connections!
-
         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|
+        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)
+              jid: contact.jid,
+              name: contact.name,
+              subscription: contact.subscription,
+              ask: contact.ask,
+              groups: groups)
           end
         end if xuser
       end
-      defer :find_user
+      with_connection :find_user
 
       def save_user(user)
-        ActiveRecord::Base.clear_reloadable_connections!
-
-        xuser = user_by_jid(user.jid) || Sql::User.new(:jid => user.jid.bare.to_s)
+        xuser = user_by_jid(user.jid) || Sql::User.new(jid: user.jid.bare.to_s)
         xuser.name = user.name
         xuser.password = user.password
 
@@ -74,10 +86,10 @@ module Vines
         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))
+            name: fresh.name,
+            ask: fresh.ask,
+            subscription: fresh.subscription,
+            groups: groups(fresh))
         end
 
         # add new contacts to roster
@@ -85,112 +97,104 @@ module Vines
         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))
+              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
+      with_connection :save_user
 
       def find_vcard(jid)
-        ActiveRecord::Base.clear_reloadable_connections!
-
         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
-      defer :find_vcard
+      with_connection :find_vcard
 
       def save_vcard(jid, card)
-        ActiveRecord::Base.clear_reloadable_connections!
-
         xuser = user_by_jid(jid)
         if xuser
           xuser.vcard = card.to_xml
           xuser.save
         end
       end
-      defer :save_vcard
+      with_connection :save_vcard
 
       def find_fragment(jid, node)
-        ActiveRecord::Base.clear_reloadable_connections!
-
         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
-      defer :find_fragment
+      with_connection :find_fragment
 
       def save_fragment(jid, node)
-        ActiveRecord::Base.clear_reloadable_connections!
-
         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)
+            user: user_by_jid(jid),
+            root: node.name,
+            namespace: node.namespace.href)
         fragment.xml = node.to_xml
         fragment.save
       end
-      defer :save_fragment
+      with_connection :save_fragment
 
       # 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 => 2048, :null => false
-            t.string :name,     :limit => 1000, :null => true
-            t.string :password, :limit => 1000, :null => true
-            t.text   :vcard,    :null => true
+          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 => 2048, :null => false
-            t.string  :name,         :limit => 1000, :null => true
-            t.string  :ask,          :limit => 1000, :null => true
-            t.string  :subscription, :limit => 1000, :null => false
+          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
+          add_index :contacts, [:user_id, :jid], unique: true
 
-          create_table :groups, :force => args[:force] do |t|
-            t.string :name, :limit => 1000, :null => false
+          create_table :groups, force: args[:force] do |t|
+            t.string :name, limit: 256, null: false
           end
-          add_index :groups, :name, :unique => true
+          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
+          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
+          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 => 1000, :null => false
-            t.string  :namespace, :limit => 1000, :null => false
-            t.text    :xml,       :null => false
+          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
+          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.

data/lib/vines/storage.rb

@@ -22,7 +22,7 @@ module Vines
 
     # 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
+    # with blocking IO don't need to worry about threading or blocking the
     # EventMachine reactor thread if they wrap their methods with this one.
     #
     # For example:

data/lib/vines/stream/client/bind.rb

@@ -17,7 +17,8 @@ module Vines
           raise StreamErrors::NotAuthorized unless bind?(node)
           raise StreamErrors::PolicyViolation.new('max bind attempts reached') if @attempts > MAX_ATTEMPTS
           raise StanzaErrors::ResourceConstraint.new(node, 'wait') if resource_limit_reached?
-          stream.user.jid.resource = resource(node)
+
+          stream.bind!(resource(node))
           doc = Document.new
           result = doc.create_element('iq', 'id' => node['id'], 'type' => 'result') do |el|
             el << doc.create_element('bind') do |bind|
@@ -25,7 +26,6 @@ module Vines
               bind << doc.create_element('jid', stream.user.jid.to_s)
             end
           end
-
           stream.write(result)
           send_empty_features
           advance

data/lib/vines/stream/client/session.rb

@@ -10,10 +10,11 @@ module Vines
       class Session
         include Comparable
 
-        attr_accessor :domain, :last_broadcast_presence, :user
-        attr_reader   :id, :state
+        attr_accessor :domain, :user
+        attr_reader   :id, :last_broadcast_presence, :state
 
         def initialize(stream)
+          @stream = stream
           @id = Kit.uuid
           @config = stream.config
           @state = Client::Start.new(stream)
@@ -45,8 +46,12 @@ module Vines
           !@user.nil?
         end
 
+        # Notify the session that the client has sent an initial presence
+        # broadcast and is now considered to be an "available" resource.
+        # Available resources are sent presence subscription stanzas.
         def available!
           @available = true
+          save_to_cluster
         end
 
         # An available resource has sent initial presence and can
@@ -55,6 +60,15 @@ module Vines
           @available && connected?
         end
 
+        # Complete resource binding with the given resource name, provided by the
+        # client or generated by the server. Once resource binding is completed,
+        # the stream is considered to be "connected" and ready for traffic.
+        def bind!(resource)
+          @user.jid.resource = resource
+          router << self
+          save_to_cluster
+        end
+
         # A connected resource has authenticated and bound a resource
         # identifier.
         def connected?
@@ -67,22 +81,38 @@ module Vines
           @requested_roster && connected?
         end
 
+        def last_broadcast_presence=(node)
+          @last_broadcast_presence = node
+          save_to_cluster
+        end
+
         def ready?
           @state.class == Client::Ready
         end
 
+        # Notify the session that the client has requested its roster and is now
+        # considered to be an "interested" resource. Interested resources are sent
+        # roster pushes when changes are made to their contacts.
         def requested_roster!
           @requested_roster = true
+          save_to_cluster
         end
 
         def stream_type
           :client
         end
 
-        # Called by the stream when its disconnected from the client. The stream
+        def write(data)
+          @stream.write(data)
+        end
+
+        # Called by the stream when it's disconnected from the client. The stream
         # passes itself to this method in case multiple streams are accessing this
-        # session.
+        # session (e.g. BOSH/HTTP).
         def unbind!(stream)
+          router.delete(self)
+          delete_from_cluster
+          unsubscribe_pubsub
           @unbound = true
           @available = false
           broadcast_unavailable
@@ -123,20 +153,22 @@ module Vines
 
         def broadcast_unavailable
           return unless authenticated?
-
+          Fiber.new do
+            broadcast(unavailable, available_subscribers)
+            broadcast(unavailable, router.available_resources(@user.jid, @user.jid))
+            remote_subscribers.each do |contact|
+              node = unavailable
+              node['to'] = contact.jid.bare.to_s
+              router.route(node) rescue nil # ignore RemoteServerNotFound
+            end
+          end.resume
+        end
+
+        def unavailable
           doc = Nokogiri::XML::Document.new
-          el = doc.create_element('presence',
+          doc.create_element('presence',
             'from' => @user.jid.to_s,
             'type' => 'unavailable')
-
-          broadcast(el, available_subscribers)
-          broadcast(el, router.available_resources(@user.jid, @user.jid))
-
-          remote_subscribers.each do |contact|
-            node = el.clone
-            node['to'] = contact.jid.bare.to_s
-            router.route(node) rescue nil # ignore RemoteServerNotFound
-          end
         end
 
         def broadcast(stanza, recipients)
@@ -147,7 +179,30 @@ module Vines
         end
 
         def router
-          Router.instance
+          @config.router
+        end
+
+        def save_to_cluster
+          if @config.cluster?
+            @config.cluster.save_session(@user.jid, to_hash)
+          end
+        end
+
+        def delete_from_cluster
+          if connected? && @config.cluster?
+            @config.cluster.delete_session(@user.jid)
+          end
+        end
+
+        def unsubscribe_pubsub
+          if connected?
+            @config.vhosts[@user.jid.domain].unsubscribe_pubsub(@user.jid)
+          end
+        end
+
+        def to_hash
+          presence = @last_broadcast_presence ? @last_broadcast_presence.to_s : nil
+          {available: @available, interested: @requested_roster, presence: presence.to_s}
         end
       end
     end

data/lib/vines/stream/component/handshake.rb

@@ -11,6 +11,7 @@ module Vines
         def node(node)
           raise StreamErrors::NotAuthorized unless handshake?(node)
           stream.write('<handshake/>')
+          stream.router << stream
           advance
         end
 

data/lib/vines/stream/component/ready.rb

@@ -10,8 +10,8 @@ module Vines
           to, from = stanza.validate_to, stanza.validate_from
           raise StreamErrors::ImproperAddressing unless to && from
           raise StreamErrors::InvalidFrom unless from.domain == stream.remote_domain
-          stream.user = User.new(:jid => from)
-          if stanza.local?
+          stream.user = User.new(jid: from)
+          if stanza.local? || stanza.to_pubsub_domain?
             stanza.process
           else
             stanza.route

data/lib/vines/stream/http/session.rb

@@ -22,6 +22,8 @@ module Vines
         def close
           Sessions.delete(@id)
           router.delete(self)
+          delete_from_cluster
+          unsubscribe_pubsub
           @requests.each {|req| req.stream.close_connection }
           @requests.clear
           @responses.clear

data/lib/vines/stream/http.rb

@@ -10,11 +10,6 @@ module Vines
         @session = Http::Session.new(self)
       end
 
-      def post_init
-        super
-        router.delete(self)
-      end
-
       # Override +Stream#create_parser+ to provide an HTTP parser rather than
       # a Nokogiri XML parser.
       def create_parser
@@ -96,7 +91,6 @@ module Vines
         raise StreamErrors::InvalidNamespace unless node.namespaces['xmlns'] == NAMESPACES[:http_bind]
 
         Sessions[@session.id] = @session
-        router << @session
         send_stream_header
       end
 

data/lib/vines/stream/server/final_restart.rb

@@ -12,6 +12,7 @@ module Vines
           raise StreamErrors::NotAuthorized unless stream?(node)
           stream.start(node)
           stream.write('<stream:features/>')
+          stream.router << stream
           advance
         end
       end

data/lib/vines/stream/server/outbound/final_features.rb

@@ -11,6 +11,7 @@ module Vines
 
           def node(node)
             raise StreamErrors::NotAuthorized unless empty_features?(node)
+            stream.router << stream
             advance
             stream.notify_connected
           end

data/lib/vines/stream/server/ready.rb

@@ -11,8 +11,12 @@ module Vines
           raise StreamErrors::ImproperAddressing unless to && from
           raise StreamErrors::InvalidFrom unless from.domain == stream.remote_domain
           raise StreamErrors::HostUnknown unless to.domain == stream.domain
-          stream.user = User.new(:jid => from)
-          stanza.process
+          stream.user = User.new(jid: from)
+          if stanza.local? || stanza.to_pubsub_domain?
+            stanza.process
+          else
+            stanza.route
+          end
         end
       end
     end

data/lib/vines/stream/server.rb

@@ -35,7 +35,8 @@ module Vines
 
       def self.connect(config, to, from, srv, callback)
         if srv.empty?
-          callback.call(nil)
+          # fiber so storage calls work properly
+          Fiber.new { callback.call(nil) }.resume
         else
           begin
             rr = srv.shift
@@ -108,8 +109,8 @@ module Vines
         send_stream_header
         raise StreamErrors::UnsupportedVersion unless node['version'] == '1.0'
         raise StreamErrors::ImproperAddressing unless valid_address?(@domain) && valid_address?(@remote_domain)
-        raise StreamErrors::HostUnknown unless config.vhost?(@domain)
-        raise StreamErrors::NotAuthorized unless config.s2s?(@remote_domain)
+        raise StreamErrors::HostUnknown unless config.vhost?(@domain) || config.pubsub?(@domain) || config.component?(@domain)
+        raise StreamErrors::NotAuthorized unless config.s2s?(@remote_domain) && config.allowed?(@domain, @remote_domain)
         raise StreamErrors::InvalidNamespace unless node.namespaces['xmlns'] == NAMESPACES[:server]
         raise StreamErrors::InvalidNamespace unless node.namespaces['xmlns:stream'] == NAMESPACES[:stream]
       end

data/lib/vines/stream.rb

@@ -18,7 +18,6 @@ module Vines
     end
 
     def post_init
-      router << self
       @remote_addr, @local_addr = addresses
       @user, @closed, @stanza_size = nil, false, 0
       @bucket = TokenBucket.new(100, 10)
@@ -67,8 +66,12 @@ module Vines
     # Returns the storage system for the domain. If no domain is given,
     # the stream's storage mechanism is returned.
     def storage(domain=nil)
-      host = @config.vhosts[domain || self.domain]
-      host.storage if host
+      @config.storage(domain || self.domain)
+    end
+
+    # Returns the Vines::Config::Host virtual host for the stream's domain.
+    def vhost
+      @config.vhosts[domain]
     end
 
     # Reload the user's information into their active connections. Call this
@@ -156,7 +159,7 @@ module Vines
     end
 
     def router
-      Router.instance
+      @config.router
     end
 
     private
@@ -236,9 +239,10 @@ module Vines
       %w[crt key].map {|ext| File.join(VINES_ROOT, 'conf', 'certs', "#{domain}.#{ext}") }
     end
 
+    # Return true if this is a valid domain-only JID that can be used in
+    # stream initiation stanza headers.
     def valid_address?(jid)
-      jid = JID.new(jid) rescue nil
-      jid && !jid.empty?
+      JID.new(jid).domain? rescue false
     end
   end
 end

data/lib/vines/version.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
 
 module Vines
-  VERSION = '0.3.2'
+  VERSION = '0.4.0'
 end