vinesmod 0.4.5

data/lib/vines/config/port.rb

@@ -0,0 +1,132 @@
+# encoding: UTF-8
+
+module Vines
+  class Config
+    class Port
+      include Vines::Log
+
+      attr_reader :config, :stream, :settings
+
+      %w[host port].each do |name|
+        define_method(name) do
+          @settings[name.to_sym]
+        end
+      end
+
+      def initialize(config, host, port, &block)
+        @config, @settings = config, {}
+        instance_eval(&block) if block
+        defaults = {:host => host, :port => port,
+          :max_resources_per_account => 5, :max_stanza_size => 128 * 1024}
+        @settings = defaults.merge(@settings)
+      end
+
+      def max_stanza_size(max=nil)
+        if max
+          # rfc 6120 section 13.12
+          @settings[:max_stanza_size] = [10000, max].max
+        else
+          @settings[:max_stanza_size]
+        end
+      end
+
+      def start
+        type = stream.name.split('::').last.downcase
+        log.info("Accepting #{type} connections on #{host}:#{port}")
+        EventMachine::start_server(host, port, stream, config)
+      end
+    end
+
+    class ClientPort < Port
+      def initialize(config, host='0.0.0.0', port=5222, &block)
+        @stream = Vines::Stream::Client
+        super(config, host, port, &block)
+      end
+
+      def max_resources_per_account(max=nil)
+        if max
+          @settings[:max_resources_per_account] = max
+        else
+          @settings[:max_resources_per_account]
+        end
+      end
+
+      def start
+        super
+        config.cluster.start if config.cluster?
+      end
+    end
+
+    class ServerPort < Port
+      def initialize(config, host='0.0.0.0', port=5269, &block)
+        @hosts, @stream = [], Vines::Stream::Server
+        super(config, host, port, &block)
+      end
+
+      def hosts(*hosts)
+        if hosts.any?
+          @hosts << hosts
+          @hosts.flatten!
+        else
+          @hosts
+        end
+      end
+    end
+
+    class HttpPort < Port
+      def initialize(config, host='0.0.0.0', port=5280, &block)
+        @stream = Vines::Stream::Http
+        super(config, host, port, &block)
+        defaults = {:root => File.expand_path('web'), :bind => '/xmpp'}
+        @settings = defaults.merge(@settings)
+      end
+
+      def max_resources_per_account(max=nil)
+        if max
+          @settings[:max_resources_per_account] = max
+        else
+          @settings[:max_resources_per_account]
+        end
+      end
+
+      def root(dir=nil)
+        if dir
+          @settings[:root] = File.expand_path(dir)
+        else
+          @settings[:root]
+        end
+      end
+
+      def bind(url=nil)
+        if url
+          @settings[:bind] = url
+        else
+          @settings[:bind]
+        end
+      end
+
+      def vroute(id=nil)
+        if id
+          id = id.to_s.strip
+          @settings[:vroute] = id.empty? ? nil : id
+        else
+          @settings[:vroute]
+        end
+      end
+
+      def start
+        super
+        if config.cluster? && vroute.nil?
+          log.warn("vroute sticky session cookie not set")
+        end
+      end
+    end
+
+    class ComponentPort < Port
+      def initialize(config, host='0.0.0.0', port=5347, &block)
+        @stream = Vines::Stream::Component
+        super(config, host, port, &block)
+      end
+    end
+  end
+end

data/lib/vines/config/pubsub.rb

@@ -0,0 +1,108 @@
+# encoding: UTF-8
+
+module Vines
+  class Config
+    # Provides the configuration DSL to conf/config.rb for pubsub subdomains and
+    # exposes the storage and notification systems that the pubsub stanzas need
+    # to process. This class hides the complexity of determining pubsub behavior
+    # in a standalone vs. clustered chat server environment from the stanzas.
+    class PubSub
+      def initialize(config, name)
+        @config, @name = config, name
+        @nodes = {}
+      end
+
+      def add_node(id)
+        if @config.cluster?
+          @config.cluster.add_pubsub_node(@name, id)
+        else
+          @nodes[id] ||= Set.new
+        end
+      end
+
+      def delete_node(id)
+        if @config.cluster?
+          @config.cluster.delete_pubsub_node(@name, id)
+        else
+          @nodes.delete(id)
+        end
+      end
+
+      def subscribe(node, jid)
+        return unless node?(node) && @config.allowed?(jid, @name)
+        if @config.cluster?
+          @config.cluster.subscribe_pubsub(@name, node, jid)
+        else
+          @nodes[node] << JID.new(jid)
+        end
+      end
+
+      def unsubscribe(node, jid)
+        return unless node?(node)
+        if @config.cluster?
+          @config.cluster.unsubscribe_pubsub(@name, node, jid)
+        else
+          @nodes[node].delete(JID.new(jid))
+          delete_node(node) if subscribers(node).empty?
+        end
+      end
+
+      def unsubscribe_all(jid)
+        if @config.cluster?
+          @config.cluster.unsubscribe_all_pubsub(@name, jid)
+        else
+          @nodes.keys.each do |node|
+            unsubscribe(node, jid)
+          end
+        end
+      end
+
+      def node?(node)
+        if @config.cluster?
+          @config.cluster.pubsub_node?(@name, node)
+        else
+          @nodes.key?(node)
+        end
+      end
+
+      def subscribed?(node, jid)
+        return false unless node?(node)
+        if @config.cluster?
+          @config.cluster.pubsub_subscribed?(@name, node, jid)
+        else
+          @nodes[node].include?(JID.new(jid))
+        end
+      end
+
+      def publish(node, stanza)
+        stanza['id'] = Kit.uuid
+        stanza['from'] = @name
+
+        local, remote = subscribers(node).partition {|jid| @config.local_jid?(jid) }
+
+        local.flat_map do |jid|
+          @config.router.connected_resources(jid, @name)
+        end.each do |recipient|
+          stanza['to'] = recipient.user.jid.to_s
+          recipient.write(stanza)
+        end
+
+        remote.each do |jid|
+          el = stanza.clone
+          el['to'] = jid.to_s
+          @config.router.route(el) rescue nil # ignore RemoteServerNotFound
+        end
+      end
+
+      private
+
+      def subscribers(node)
+        if @config.cluster?
+          @config.cluster.pubsub_subscribers(@name, node)
+        else
+          @nodes[node] || []
+        end
+      end
+    end
+  end
+end

data/lib/vines/contact.rb

@@ -0,0 +1,111 @@
+# encoding: UTF-8
+
+module Vines
+  class Contact
+    include Comparable
+
+    attr_accessor :name, :subscription, :ask, :groups
+    attr_reader :jid
+
+    def initialize(args={})
+      @jid = JID.new(args[:jid]).bare
+      raise ArgumentError, 'invalid jid' if @jid.empty?
+      @name = args[:name]
+      @subscription = args[:subscription] || 'none'
+      @ask = args[:ask]
+      @groups = args[:groups] || []
+    end
+
+    def <=>(contact)
+      contact.is_a?(Contact) ? self.jid.to_s <=> contact.jid.to_s : nil
+    end
+
+    alias :eql? :==
+
+    def hash
+      jid.to_s.hash
+    end
+
+    def update_from(contact)
+      @name = contact.name
+      @subscription = contact.subscription
+      @ask = contact.ask
+      @groups = contact.groups.clone
+    end
+
+    # Returns true if this contact is in a state that allows the user
+    # to subscribe to their presence updates.
+    def can_subscribe?
+      @ask == 'subscribe' && %w[none from].include?(@subscription)
+    end
+
+    def subscribe_to
+      @subscription = (@subscription == 'none') ? 'to' : 'both'
+      @ask = nil
+    end
+
+    def unsubscribe_to
+      @subscription = (@subscription == 'both') ? 'from' : 'none'
+    end
+
+    def subscribe_from
+      @subscription = (@subscription == 'none') ? 'from' : 'both'
+      @ask = nil
+    end
+
+    def unsubscribe_from
+      @subscription = (@subscription == 'both') ? 'to' : 'none'
+    end
+
+    # Returns true if the user is subscribed to this contact's
+    # presence updates.
+    def subscribed_to?
+      %w[to both].include?(@subscription)
+    end
+
+    # Returns true if the user has a presence subscription from
+    # this contact. The contact is subscribed to this user's presence.
+    def subscribed_from?
+      %w[from both].include?(@subscription)
+    end
+
+    # Returns a hash of this contact's attributes suitable for persisting in
+    # a document store.
+    def to_h
+      {
+        'name' => @name,
+        'subscription' => @subscription,
+        'ask' => @ask,
+        'groups' => @groups.sort!
+      }
+    end
+
+    # Write an iq stanza to the recipient stream representing this contact's
+    # current roster item state.
+    def send_roster_push(recipient)
+      doc = Nokogiri::XML::Document.new
+      node = doc.create_element('iq',
+        'id'   => Kit.uuid,
+        'to'   => recipient.user.jid.to_s,
+        'type' => 'set')
+      node << doc.create_element('query', 'xmlns' => NAMESPACES[:roster]) do |query|
+        query << to_roster_xml
+      end
+      recipient.write(node)
+    end
+
+    # Returns this contact as an xmpp <item> element.
+    def to_roster_xml
+      doc = Nokogiri::XML::Document.new
+      doc.create_element('item') do |el|
+        el['ask'] = @ask unless @ask.nil? || @ask.empty?
+        el['jid'] = @jid.bare.to_s
+        el['name'] = @name unless @name.nil? || @name.empty?
+        el['subscription'] = @subscription
+        @groups.sort!.each do |group|
+          el << doc.create_element('group', group)
+        end
+      end
+    end
+  end
+end

data/lib/vines/daemon.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+
+module Vines
+
+  # Fork the current process into the background and manage pid
+  # files so we can kill the process later.
+  class Daemon
+
+    # Configure a new daemon process.  Arguments hash can include the following
+    # keys: :pid (pid file name, required),
+    # :stdin, :stdout, :stderr (default to /dev/null)
+    def initialize(args)
+      @pid = args[:pid]
+      raise ArgumentError.new('pid file is required') unless @pid
+      raise ArgumentError.new('pid must be a file name') if File.directory?(@pid)
+      raise ArgumentError.new('pid file must be writable') unless File.writable?(File.dirname(@pid))
+      @stdin, @stdout, @stderr = [:stdin, :stdout, :stderr].map {|k| args[k] || '/dev/null' }
+    end
+
+    # Fork the current process into the background to start the
+    # daemon. Do nothing if the daemon is already running.
+    def start
+      daemonize unless running?
+    end
+
+    # Use the pid stored in the pid file created from a previous
+    # call to start to send a TERM signal to the process. Do nothing
+    # if the daemon is not running.
+    def stop
+      10.times do
+        break unless running?
+        Process.kill('TERM', pid)
+        sleep(0.1)
+      end
+    end
+
+    # Returns true if the process is running as determined by the numeric
+    # pid stored in the pid file created by a previous call to start.
+    def running?
+      begin
+        pid && Process.kill(0, pid)
+      rescue Errno::ESRCH
+        delete_pid
+        false
+      rescue Errno::EPERM
+        true
+      end
+    end
+
+    # Returns the numeric process ID from the pid file.
+    # If the pid file does not exist, returns nil.
+    def pid
+      File.read(@pid).to_i if File.exists?(@pid) 
+    end
+
+    private
+
+    def delete_pid
+      File.delete(@pid) if File.exists?(@pid)
+    end
+
+    # Fork process into background twice to release it from
+    # the controlling tty. Point open file descriptors shared
+    # with the parent process to separate destinations (e.g. /dev/null).
+    def daemonize
+      exit if fork
+      Process.setsid
+      exit if fork
+      Dir.chdir('/')
+      $stdin.reopen(@stdin)
+      $stdout.reopen(@stdout, 'a').sync = true
+      $stderr.reopen(@stderr, 'a').sync = true
+      File.open(@pid, 'w') {|f| f.write(Process.pid) }
+      at_exit { delete_pid }
+      trap('TERM') { exit }
+    end
+  end
+end

data/lib/vines/error.rb

@@ -0,0 +1,150 @@
+# encoding: UTF-8
+
+module Vines
+  class XmppError < StandardError
+    include Nokogiri::XML
+
+    # Returns the XML element name based on the exception class name.
+    # For example, Vines::BadFormat becomes bad-format.
+    def element_name
+      name = self.class.name.split('::').last
+      name.gsub(/([A-Z])/, '-\1').downcase[1..-1]
+    end
+  end
+
+  class SaslError < XmppError
+    NAMESPACE = 'urn:ietf:params:xml:ns:xmpp-sasl'.freeze
+
+    def initialize(text=nil)
+      @text = text
+    end
+
+    def to_xml
+      doc = Document.new
+      doc.create_element('failure') do |node|
+        node.add_namespace(nil, NAMESPACE)
+        node << doc.create_element(element_name)
+        if @text
+          node << doc.create_element('text') do |text|
+            text['xml:lang'] = 'en'
+            text.content = @text
+          end
+        end
+      end.to_xml(:indent => 0).gsub(/\n/, '')
+    end
+  end
+
+  class StreamError < XmppError
+    NAMESPACE = 'urn:ietf:params:xml:ns:xmpp-streams'.freeze
+
+    def initialize(text=nil)
+      @text = text
+    end
+
+    def to_xml
+      doc = Document.new
+      doc.create_element('stream:error') do |el|
+        el << doc.create_element(element_name, 'xmlns' => NAMESPACE)
+        if @text
+          el << doc.create_element('text', @text, 'xmlns' => NAMESPACE, 'xml:lang' => 'en')
+        end
+      end.to_xml(:indent => 0).gsub(/\n/, '')
+    end
+  end
+
+  class StanzaError < XmppError
+    TYPES = %w[auth cancel continue modify wait].freeze
+    KINDS = %w[message presence iq].freeze
+    NAMESPACE = 'urn:ietf:params:xml:ns:xmpp-stanzas'.freeze
+
+    def initialize(el, type, text=nil)
+      raise "type must be one of: %s"   % TYPES.join(', ') unless TYPES.include?(type)
+      raise "stanza must be one of: %s" % KINDS.join(', ') unless KINDS.include?(el.name)
+      @stanza_kind, @type, @text = el.name, type, text
+      @id, @from, @to = %w[id from to].map {|a| el[a] }
+    end
+
+    def to_xml
+      doc = Document.new
+      doc.create_element(@stanza_kind) do |el|
+        el['from'] = @to   if @to
+        el['id']   = @id   if @id
+        el['to']   = @from if @from
+        el['type'] = 'error'
+        el << doc.create_element('error', 'type' => @type) do |error|
+          error << doc.create_element(element_name, 'xmlns' => NAMESPACE)
+          if @text
+            error << doc.create_element('text', @text, 'xmlns' => NAMESPACE, 'xml:lang' => 'en')
+          end
+        end
+      end.to_xml(:indent => 0).gsub(/\n/, '')
+    end
+  end
+
+  module SaslErrors
+    class Aborted < SaslError; end
+    class AccountDisabled < SaslError; end
+    class CredentialsExpired < SaslError; end
+    class EncryptionRequired < SaslError; end
+    class IncorrectEncoding < SaslError; end
+    class InvalidAuthzid < SaslError; end
+    class InvalidMechanism < SaslError; end
+    class MalformedRequest < SaslError; end
+    class MechanismTooWeak < SaslError; end
+    class NotAuthorized < SaslError; end
+    class TemporaryAuthFailure < SaslError; end
+  end
+
+  module StreamErrors
+    class BadFormat < StreamError; end
+    class BadNamespacePrefix < StreamError; end
+    class Conflict < StreamError; end
+    class ConnectionTimeout < StreamError; end
+    class HostGone < StreamError; end
+    class HostUnknown < StreamError; end
+    class ImproperAddressing < StreamError; end
+    class InternalServerError < StreamError; end
+    class InvalidFrom < StreamError; end
+    class InvalidNamespace < StreamError; end
+    class InvalidXml < StreamError; end
+    class NotAuthorized < StreamError; end
+    class NotWellFormed < StreamError; end
+    class PolicyViolation < StreamError; end
+    class RemoteConnectionFailed < StreamError; end
+    class Reset < StreamError; end
+    class ResourceConstraint < StreamError; end
+    class RestrictedXml < StreamError; end
+    class SeeOtherHost < StreamError; end
+    class SystemShutdown < StreamError; end
+    class UndefinedCondition < StreamError; end
+    class UnsupportedEncoding < StreamError; end
+    class UnsupportedFeature < StreamError; end
+    class UnsupportedStanzaType < StreamError; end
+    class UnsupportedVersion < StreamError; end
+  end
+
+  module StanzaErrors
+    class BadRequest < StanzaError; end
+    class Conflict < StanzaError; end
+    class FeatureNotImplemented < StanzaError; end
+    class Forbidden < StanzaError; end
+    class Gone < StanzaError; end
+    class InternalServerError < StanzaError; end
+    class ItemNotFound < StanzaError; end
+    class JidMalformed < StanzaError; end
+    class NotAcceptable < StanzaError; end
+    class NotAllowed < StanzaError; end
+    class NotAuthorized < StanzaError; end
+    class PolicyViolation < StanzaError; end
+    class RecipientUnavailable < StanzaError; end
+    class Redirect < StanzaError; end
+    class RegistrationRequired < StanzaError; end
+    class RemoteServerNotFound < StanzaError; end
+    class RemoteServerTimeout < StanzaError; end
+    class ResourceConstraint < StanzaError; end
+    class ServiceUnavailable < StanzaError; end
+    class SubscriptionRequired < StanzaError; end
+    class UndefinedCondition < StanzaError; end
+    class UnexpectedRequest < StanzaError; end
+  end
+end