lygneo-vines 0.1.1

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
+
+      %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/config.rb

@@ -0,0 +1,223 @@
+# encoding: UTF-8
+
+module Vines
+
+  # A Config object is passed to the stream handlers to give them access
+  # to server configuration information like virtual host names, storage
+  # systems, etc. This class provides the DSL methods used in the
+  # conf/config.rb file.
+  class Config
+    LOG_LEVELS = %w[debug info warn error fatal].freeze
+
+    attr_reader :router
+
+    @@instance = nil
+    def self.configure(&block)
+      @@instance = self.new(&block)
+    end
+
+    def self.instance
+      @@instance
+    end
+
+    def initialize(&block)
+      @certs = File.expand_path('conf/certs')
+      @vhosts, @ports, @cluster = {}, {}, nil
+      @null = Storage::Null.new
+      @router = Router.new(self)
+      instance_eval(&block)
+      raise "must define at least one virtual host" if @vhosts.empty?
+    end
+
+    def certs(dir=nil)
+      dir ? @certs = File.expand_path(dir) : @certs
+    end
+
+    def host(*names, &block)
+      names = names.flatten.map {|name| name.downcase }
+      dupes = names.uniq.size != names.size || (@vhosts.keys & names).any?
+      raise "one host definition per domain allowed" if dupes
+      names.each do |name|
+        if name.eql? "lygneo"
+          @vhosts[domain_name] = Host.new(self, domain_name, &block)
+        else
+          @vhosts[name] = Host.new(self, name, &block)
+        end
+      end
+    end
+
+    def pepper(pepper=nil)
+      pepper ? @pepper = pepper : @pepper = ""
+    end
+
+    def domain_name
+      AppConfig.environment.url
+        .gsub(/^http(s){0,1}:\/\/|\/$/, '')
+        .to_s rescue "localhost"
+    end
+
+    %w[client server http component].each do |name|
+      define_method(name) do |*args, &block|
+        port = Vines::Config.const_get("#{name.capitalize}Port")
+        raise "one #{name} port definition allowed" if @ports[name.to_sym]
+        @ports[name.to_sym] = port.new(self, *args) do
+          instance_eval(&block) if block
+        end
+      end
+    end
+
+    def cluster(&block)
+      return @cluster unless block
+      raise "one cluster definition allowed" if @cluster
+      @cluster = Cluster.new(self, &block)
+    end
+
+    def log(level)
+      const = Logger.const_get(level.to_s.upcase) rescue nil
+      unless LOG_LEVELS.include?(level.to_s) && const
+        raise "log level must be one of: #{LOG_LEVELS.join(', ')}"
+      end
+      Class.new.extend(Vines::Log).log.level = const
+    end
+
+    def ports
+      @ports.values
+    end
+
+    # Return true if the domain is virtual hosted by this server.
+    def vhost?(domain)
+      !!vhost(domain)
+    end
+
+    # Return the Host config object for this domain if it's hosted by this
+    # server.
+    def vhost(domain)
+      @vhosts[domain.to_s]
+    end
+
+    # Returns the storage system for the domain or a Storage::Null instance if
+    # the domain is not hosted at this server.
+    def storage(domain)
+      host = vhost(domain)
+      host ? host.storage : @null
+    end
+
+    # Returns the PubSub system for the domain or nil if pubsub is not enabled
+    # for this domain.
+    def pubsub(domain)
+      host = @vhosts.values.find {|host| host.pubsub?(domain) }
+      host.pubsubs[domain.to_s] if host
+    end
+
+    # Return true if the domain is a pubsub service hosted at a virtual host
+    # at this server.
+    def pubsub?(domain)
+      @vhosts.values.any? {|host| host.pubsub?(domain) }
+    end
+
+    # Return true if all JIDs belong to components hosted by this server.
+    def component?(*jids)
+      !jids.flatten.index do |jid|
+        !component_password(JID.new(jid).domain)
+      end
+    end
+
+    # Return the password for the component or nil if it's not hosted here.
+    def component_password(domain)
+      host = @vhosts.values.find {|host| host.component?(domain) }
+      host.password(domain) if host
+    end
+
+    # Return true if all of the JIDs are hosted by this server.
+    def local_jid?(*jids)
+      !jids.flatten.index do |jid|
+        !vhost?(JID.new(jid).domain)
+      end
+    end
+
+    # Return true if private XML fragment storage is enabled for this domain.
+    def private_storage?(domain)
+      host = vhost(domain)
+      host.private_storage? if host
+    end
+
+    # Returns true if server-to-server connections are allowed with the
+    # given domain.
+    def s2s?(domain)
+      @ports[:server] && @ports[:server].hosts.include?(domain.to_s)
+    end
+
+    # Return true if the server is a member of a cluster, serving the same
+    # domains from different machines.
+    def cluster?
+      !!@cluster
+    end
+
+    # Retrieve the Port subclass with this name:
+    # [:client, :server, :http, :component]
+    def [](name)
+      @ports[name] or raise ArgumentError.new("no port named #{name}")
+    end
+
+    # Return true if the two JIDs are allowed to send messages to each other.
+    # Both domains must have enabled cross_domain_messages in their config files.
+    def allowed?(to, from)
+      to, from = JID.new(to), JID.new(from)
+      return false                      if to.empty? || from.empty?
+      return true                       if to.domain == from.domain # same domain always allowed
+      return cross_domain?(to, from)    if local_jid?(to, from)     # both virtual hosted here
+      return check_subdomains(to, from) if subdomain?(to, from)     # component/pubsub to component/pubsub
+      return check_subdomain(to, from)  if subdomain?(to)           # to component/pubsub
+      return check_subdomain(from, to)  if subdomain?(from)         # from component/pubsub
+      return cross_domain?(to)          if local_jid?(to)           # from is remote
+      return cross_domain?(from)        if local_jid?(from)         # to is remote
+      return false
+    end
+
+    private
+
+    # Return true if all of the JIDs are some kind of subdomain resource hosted
+    # here (either a component or a pubsub domain).
+    def subdomain?(*jids)
+      !jids.flatten.index do |jid|
+        !component?(jid) && !pubsub?(jid)
+      end
+    end
+
+    # Return true if the third-level subdomain JIDs (components and pubsubs)
+    # are allowed to communicate with each other. For example, a
+    # tea.wonderland.lit component should be allowed to send messages to
+    # pubsub.wonderland.lit because they share the second-level wonderland.lit
+    # domain.
+    def check_subdomains(to, from)
+      sub1, sub2 = strip_domain(to), strip_domain(from)
+      (sub1 == sub2) || cross_domain?(sub1, sub2)
+    end
+
+    # Return true if the third-level subdomain JID (component or pubsub) is
+    # allowed to communicate with the other JID. For example,
+    # pubsub.wonderland.lit should be allowed to send messages to
+    # alice@wonderland.lit because they share the second-level wonderland.lit
+    # domain.
+    def check_subdomain(subdomain, jid)
+      comp = strip_domain(subdomain)
+      return true if comp.domain == jid.domain
+      local_jid?(jid) ? cross_domain?(comp, jid) : cross_domain?(comp)
+    end
+
+    # Return the third-level JID's domain with the first subdomain stripped off
+    # to create a second-level domain. For example, alice@tea.wonderland.lit
+    # returns wonderland.lit.
+    def strip_domain(jid)
+      domain = jid.domain.split('.').drop(1).join('.')
+      JID.new(domain)
+    end
+
+    # Return true if all JIDs are allowed to exchange cross domain messages.
+    def cross_domain?(*jids)
+      !jids.flatten.index do |jid|
+        !vhost(jid.domain).cross_domain_messages?
+      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