vinesmod 0.4.5

data/conf/config.rb

@@ -0,0 +1,149 @@
+# encoding: UTF-8
+
+# This is the Vines XMPP server configuration file. Restart the server with
+# 'vines restart' after updating this file.
+
+Vines::Config.configure do
+  # Set the logging level to debug, info, warn, error, or fatal. The debug
+  # level logs all XML sent and received by the server.
+  log :info
+
+  # Set the directory in which to look for virtual hosts' TLS certificates.
+  # This is optional and defaults to the conf/certs directory created during
+  # `vines init`.
+  certs 'conf/certs'
+
+  # Each host element below is a virtual host domain name that this server will
+  # service. Hosts can share storage configurations or use separate databases.
+  # TLS encryption is mandatory so each host must have a <domain>.crt and
+  # <domain>.key file in the conf/certs directory. A self-signed certificate can
+  # be generated for a virtual host domain with the 'vines cert <domain.tld>'
+  # command. Change the example, 'wonderland.lit', domain name to your actual
+  # domain.
+  #
+  # The private_storage attribute allows clients to store XML fragments
+  # on the server, using the XEP-0049 Private XML Storage feature.
+  #
+  # The pubsub attribute defines the XEP-0060 Publish-Subscribe services hosted
+  # at these virtual host domains. In the example below, pubsub services are
+  # available at games.wonderland.lit and scores.wonderland.lit as well as
+  # games.verona.lit and scores.verona.lit.
+  #
+  # Shared storage example:
+  # host 'verona.lit', 'wonderland.lit' do
+  #   private_storage false
+  #   cross_domain_messages false
+  #   storage 'fs' do
+  #     dir 'data'
+  #   end
+  #   components 'tea'  => 'secr3t',
+  #              'cake' => 'passw0rd'
+  #   pubsub 'games', 'scores'
+  # end
+
+  host 'wonderland.lit' do
+    cross_domain_messages false
+    private_storage false
+    storage 'fs' do
+      dir 'data'
+    end
+    # components 'tea'  => 'secr3t',
+    #            'cake' => 'passw0rd'
+    # pubsub 'games', 'scores'
+  end
+
+  # Configure the client-to-server port. The max_resources_per_account attribute
+  # limits how many concurrent connections one user can have to the server.
+  client '0.0.0.0', 5222 do
+    max_stanza_size 65536
+    max_resources_per_account 5
+  end
+
+  # Configure the server-to-server port. The max_stanza_size attribute should be
+  # much larger than the setting for client-to-server. Add domain names to the
+  # 'hosts' white-list attribute to allow those servers to connect. Any connection
+  # attempt from a host not in this list will be denied.
+  server '0.0.0.0', 5269 do
+    max_stanza_size 131072
+    hosts []
+  end
+
+  # Configure the built-in HTTP server that serves static files and responds to
+  # XEP-0124 BOSH requests. This allows HTTP clients to connect to
+  # the XMPP server.
+  #
+  # The root attribute defines the web server's document root (default 'web/').
+  # It will only serve files out of this directory.
+  #
+  # The bind attribute defines the URL to which BOSH clients must POST their
+  # XMPP stanza requests (default /xmpp).
+  #
+  # The vroute attribute defines the value of the vroute cookie sent in each
+  # response that uniquely identifies this HTTP server. Reverse proxy servers
+  # (nginx/apache) can use this cookie to implement sticky sessions. This is
+  # only needed if the server is clustered behind a reverse proxy.
+  http '0.0.0.0', 5280 do
+    bind '/xmpp'
+    max_stanza_size 65536
+    max_resources_per_account 5
+    root 'web'
+    vroute ''
+  end
+
+  # Configure the XEP-0114 external component port. Component sub-domains and
+  # their passwords are defined with their virtual host entries above.
+  component '0.0.0.0', 5347 do
+    max_stanza_size 131072
+  end
+
+  # Configure the redis connection used to form a cluster of server instances,
+  # serving the same chat domains across many different machines.
+  #cluster do
+  #  host 'redis.wonderland.lit'
+  #  port 6379
+  #  database 0
+  #  password ''
+  #end
+end
+
+# Available storage implementations:
+
+#storage 'fs' do
+#  dir 'data'
+#end
+
+#storage 'couchdb' do
+#  host 'localhost'
+#  port 6984
+#  database 'xmpp'
+#  tls true
+#  username ''
+#  password ''
+#end
+
+#storage 'mongodb' do
+#  host 'localhost', 27017
+#  host 'localhost', 27018 # optional, connects to replica set
+#  database 'xmpp'
+#  tls true
+#  username ''
+#  password ''
+#  pool 5
+#end
+
+#storage 'redis' do
+#  host 'localhost'
+#  port 6379
+#  database 0
+#  password ''
+#end
+
+#storage 'sql' do
+#  adapter 'postgresql'
+#  host 'localhost'
+#  port 5432
+#  database 'xmpp'
+#  username ''
+#  password ''
+#  pool 5
+#end

data/lib/vines.rb

@@ -0,0 +1,197 @@
+# encoding: UTF-8
+
+module Vines
+  NAMESPACES = {
+    :stream           => 'http://etherx.jabber.org/streams'.freeze,
+    :client           => 'jabber:client'.freeze,
+    :server           => 'jabber:server'.freeze,
+    :component        => 'jabber:component:accept'.freeze,
+    :roster           => 'jabber:iq:roster'.freeze,
+    :register         => 'jabber:iq:register'.freeze,
+    :non_sasl         => 'jabber:iq:auth'.freeze,
+    :storage          => 'jabber:iq:private'.freeze,
+    :version          => 'jabber:iq:version'.freeze,
+    :sasl             => 'urn:ietf:params:xml:ns:xmpp-sasl'.freeze,
+    :tls              => 'urn:ietf:params:xml:ns:xmpp-tls'.freeze,
+    :bind             => 'urn:ietf:params:xml:ns:xmpp-bind'.freeze,
+    :session          => 'urn:ietf:params:xml:ns:xmpp-session'.freeze,
+    :ping             => 'urn:xmpp:ping'.freeze,
+    :pubsub           => 'http://jabber.org/protocol/pubsub'.freeze,
+    :pubsub_event     => 'http://jabber.org/protocol/pubsub#event'.freeze,
+    :pubsub_create    => 'http://jabber.org/protocol/pubsub#create-nodes'.freeze,
+    :pubsub_delete    => 'http://jabber.org/protocol/pubsub#delete-nodes'.freeze,
+    :pubsub_instant   => 'http://jabber.org/protocol/pubsub#instant-nodes'.freeze,
+    :pubsub_item_ids  => 'http://jabber.org/protocol/pubsub#item-ids'.freeze,
+    :pubsub_publish   => 'http://jabber.org/protocol/pubsub#publish'.freeze,
+    :pubsub_subscribe => 'http://jabber.org/protocol/pubsub#subscribe'.freeze,
+    :disco_items      => 'http://jabber.org/protocol/disco#items'.freeze,
+    :disco_info       => 'http://jabber.org/protocol/disco#info'.freeze,
+    :http_bind        => 'http://jabber.org/protocol/httpbind'.freeze,
+    :bosh             => 'urn:xmpp:xbosh'.freeze,
+    :vcard            => 'vcard-temp'.freeze,
+    :si               => 'http://jabber.org/protocol/si'.freeze,
+    :byte_streams     => 'http://jabber.org/protocol/bytestreams'.freeze
+  }.freeze
+
+  module Log
+    @@logger = nil
+    def log
+      unless @@logger
+        @@logger = Logger.new(STDOUT)
+        @@logger.level = Logger::INFO
+        @@logger.progname = 'vines'
+        @@logger.formatter = Class.new(Logger::Formatter) do
+          def initialize
+            @time = "%Y-%m-%dT%H:%M:%SZ".freeze
+            @fmt  = "[%s] %5s -- %s: %s\n".freeze
+          end
+          def call(severity, time, program, msg)
+            @fmt % [time.utc.strftime(@time), severity, program, msg2str(msg)]
+          end
+        end.new
+      end
+      @@logger
+    end
+  end
+end
+
+%w[
+  active_record
+  base64
+  bcrypt
+  digest/sha1
+  em-http
+  em-hiredis
+  eventmachine
+  fiber
+  fileutils
+  http/parser
+  logger
+  nokogiri
+  openssl
+  resolv
+  set
+  socket
+  uri
+  yaml
+  UPnP
+
+  vines/log
+  vines/jid
+
+  vines/stanza
+  vines/stanza/iq
+  vines/stanza/iq/query
+  vines/stanza/iq/auth
+  vines/stanza/iq/disco_info
+  vines/stanza/iq/disco_items
+  vines/stanza/iq/error
+  vines/stanza/iq/ping
+  vines/stanza/iq/private_storage
+  vines/stanza/iq/register
+  vines/stanza/iq/result
+  vines/stanza/iq/roster
+  vines/stanza/iq/session
+  vines/stanza/iq/vcard
+  vines/stanza/iq/version
+  vines/stanza/message
+  vines/stanza/presence
+  vines/stanza/presence/error
+  vines/stanza/presence/probe
+  vines/stanza/presence/subscribe
+  vines/stanza/presence/subscribed
+  vines/stanza/presence/unavailable
+  vines/stanza/presence/unsubscribe
+  vines/stanza/presence/unsubscribed
+  vines/stanza/pubsub
+  vines/stanza/pubsub/create
+  vines/stanza/pubsub/delete
+  vines/stanza/pubsub/publish
+  vines/stanza/pubsub/subscribe
+  vines/stanza/pubsub/unsubscribe
+
+  vines/storage
+  vines/storage/local
+  vines/storage/null
+  vines/storage/sql
+
+  vines/config
+  vines/config/host
+  vines/config/port
+  vines/config/pubsub
+
+  vines/store
+  vines/contact
+  vines/daemon
+  vines/error
+  vines/kit
+  vines/router
+  vines/token_bucket
+  vines/user
+  vines/version
+  vines/xmpp_server
+
+  vines/cluster
+  vines/cluster/connection
+  vines/cluster/publisher
+  vines/cluster/pubsub
+  vines/cluster/sessions
+  vines/cluster/subscriber
+
+  vines/stream
+  vines/stream/sasl
+  vines/stream/state
+  vines/stream/parser
+
+  vines/stream/client
+  vines/stream/client/session
+  vines/stream/client/start
+  vines/stream/client/tls
+  vines/stream/client/auth_restart
+  vines/stream/client/auth
+  vines/stream/client/bind_restart
+  vines/stream/client/bind
+  vines/stream/client/ready
+  vines/stream/client/closed
+
+  vines/stream/component
+  vines/stream/component/start
+  vines/stream/component/handshake
+  vines/stream/component/ready
+
+  vines/stream/http
+  vines/stream/http/session
+  vines/stream/http/sessions
+  vines/stream/http/request
+  vines/stream/http/start
+  vines/stream/http/auth
+  vines/stream/http/bind_restart
+  vines/stream/http/bind
+  vines/stream/http/ready
+
+  vines/stream/server
+  vines/stream/server/start
+  vines/stream/server/tls
+  vines/stream/server/auth_restart
+  vines/stream/server/auth
+  vines/stream/server/final_restart
+  vines/stream/server/ready
+
+  vines/stream/server/outbound/start
+  vines/stream/server/outbound/tls
+  vines/stream/server/outbound/tls_result
+  vines/stream/server/outbound/auth_restart
+  vines/stream/server/outbound/auth
+  vines/stream/server/outbound/auth_result
+  vines/stream/server/outbound/final_restart
+  vines/stream/server/outbound/final_features
+
+  vines/command/bcrypt
+  vines/command/cert
+  vines/command/init
+  vines/command/restart
+  vines/command/schema
+  vines/command/start
+  vines/command/stop
+  vines/command/register
+].each {|f| require f }

data/lib/vines/cluster.rb

@@ -0,0 +1,246 @@
+# encoding: UTF-8
+
+module Vines
+  # Server instances may be connected to one another in a cluster so they
+  # can host a single chat domain, or set of domains, across many servers,
+  # transparently to users. A redis database is used for the session routing
+  # table, mapping JIDs to their node's location. Redis pubsub channels are
+  # used to communicate amongst nodes.
+  #
+  # Using a shared in-memory cache, like redis, rather than synchronizing the
+  # cache to each node, allows us to add cluster nodes dynamically, without
+  # updating all other nodes' config files. It also greatly reduces the amount
+  # of memory required by the chat server processes.
+  class Cluster
+    include Vines::Log
+
+    attr_reader :id
+
+    %w[host port database password].each do |name|
+      define_method(name) do |*args|
+        if args.first
+          @connection.send("#{name}=", args.first)
+        else
+          @connection.send(name)
+        end
+      end
+    end
+
+    def initialize(config, &block)
+      @config, @id = config, Kit.uuid
+      @connection = Connection.new
+      @sessions = Sessions.new(self)
+      @publisher = Publisher.new(self)
+      @subscriber = Subscriber.new(self)
+      @pubsub = PubSub.new(self)
+      instance_eval(&block)
+    end
+
+    # Join this node to the cluster by broadcasting its state to the
+    # other nodes, subscribing to redis channels, and scheduling periodic
+    # heartbeat broadcasts. This method must be called after initialize
+    # or this node will not be a cluster member.
+    def start
+      @connection.connect
+      @publisher.broadcast(:online)
+      @subscriber.subscribe
+
+      EM.add_periodic_timer(1) { heartbeat }
+
+      at_exit do
+        @publisher.broadcast(:offline)
+        @sessions.delete_all(@id)
+      end
+    end
+
+    # Returns any streams hosted at remote nodes for these JIDs. The streams act
+    # like normal EM::Connections, but are actually proxies that route stanzas
+    # over redis pubsub channels to remote nodes.
+    def remote_sessions(*jids)
+      @sessions.find(*jids).map do |session|
+        StreamProxy.new(self, session)
+      end
+    end
+
+    # Persist the user's session to the shared redis cache so that other cluster
+    # nodes can locate the node hosting this user's connection and route messages
+    # to them.
+    def save_session(jid, attrs)
+      @sessions.save(jid, attrs)
+    end
+
+    # Remove this user from the cluster routing table so that no further stanzas
+    # may be routed to them. This must be called when the user's session is
+    # terminated, either by logout or stream disconnect.
+    def delete_session(jid)
+      @sessions.delete(jid)
+    end
+
+    # Remove all user sessions from the routing table associated with the
+    # given node ID. Cluster nodes call this themselves during normal shutdown.
+    # However, if a node dies without being properly shutdown, the other nodes
+    # will cleanup its sessions when they detect the node is offline.
+    def delete_sessions(node)
+      @sessions.delete_all(node)
+    end
+
+    # Notify the session store that this node is still alive. The node
+    # broadcasts its current time, so all cluster members' clocks don't
+    # necessarily need to be in sync.
+    def poke(node, time)
+      @sessions.poke(node, time)
+    end
+
+    # Send the stanza to the node hosting the user's session. The stanza is
+    # published to the channel to which the remote node is listening for
+    # messages.
+    def route(stanza, node)
+      @publisher.route(stanza, node)
+    end
+
+    # Notify the remote node that the user's roster has changed and it should
+    # reload the user from storage.
+    def update_user(jid, node)
+      @publisher.update_user(jid, node)
+    end
+
+    # Return the shared redis connection for most queries to use.
+    def connection
+      @connection.connect
+    end
+
+    # Create a new redis connection.
+    def connect
+      @connection.create
+    end
+
+    # Turn an asynchronous redis query into a blocking call by pausing the
+    # fiber in which this code is running. Return the result of the query
+    # from this method, rather than passing it to a callback block.
+    def query(name, *args)
+      fiber, yielding = Fiber.current, true
+      req = connection.send(name, *args)
+      req.errback  { fiber.resume rescue yielding = false }
+      req.callback {|response| fiber.resume(response) }
+      Fiber.yield if yielding
+    end
+
+    # Return the connected streams for this user, without any proxy streams
+    # to remote cluster nodes (locally connected streams only).
+    def connected_resources(jid)
+      @config.router.connected_resources(jid, jid, false)
+    end
+
+    # Return the Storage implementation for this domain or nil if the
+    # domain is not hosted here.
+    def storage(domain)
+      @config.storage(domain)
+    end
+
+    # Create a pubsub topic (a.k.a. node), in the given domain, to which
+    # messages may be published. The domain argument will be one of the
+    # configured pubsub subdomains in conf/config.rb (e.g. games.wonderland.lit,
+    # topics.wonderland.lit, etc).
+    def add_pubsub_node(domain, node)
+      @pubsub.add_node(domain, node)
+    end
+
+    # Remove a pubsub topic so messages may no longer be broadcast to it.
+    def delete_pubsub_node(domain, node)
+      @pubsub.delete_node(domain, node)
+    end
+
+    # Subscribe the JID to the pubsub topic so it will receive any messages
+    # published to it.
+    def subscribe_pubsub(domain, node, jid)
+      @pubsub.subscribe(domain, node, jid)
+    end
+
+    # Unsubscribe the JID from the pubsub topic, deregistering its interest
+    # in receiving any messages published to it.
+    def unsubscribe_pubsub(domain, node, jid)
+      @pubsub.unsubscribe(domain, node, jid)
+    end
+
+    # Unsubscribe the JID from all pubsub topics. This is useful when the
+    # JID's session ends by logout or disconnect.
+    def unsubscribe_all_pubsub(domain, jid)
+      @pubsub.unsubscribe_all(domain, jid)
+    end
+
+    # Return true if the pubsub topic exists and messages may be published to it.
+    def pubsub_node?(domain, node)
+      @pubsub.node?(domain, node)
+    end
+
+    # Return true if the JID is a registered subscriber to the pubsub topic and
+    # messages published to it should be routed to the JID.
+    def pubsub_subscribed?(domain, node, jid)
+      @pubsub.subscribed?(domain, node, jid)
+    end
+
+    # Return a list of JIDs subscribed to the pubsub topic.
+    def pubsub_subscribers(domain, node)
+      @pubsub.subscribers(domain, node)
+    end
+
+    private
+
+    # Call this method once per second to broadcast this node's heartbeat and
+    # expire stale user sessions. This method must not raise exceptions or the
+    # timer will stop.
+    def heartbeat
+      @publisher.broadcast(:heartbeat)
+      @sessions.expire
+    rescue => e
+      log.error("Cluster session cleanup failed: #{e}")
+    end
+
+    # StreamProxy behaves like an EM::Connection so that stanzas may be sent to
+    # remote nodes just as they are to locally connected streams. The rest of the
+    # system doesn't know or care that these "streams" send their traffic over
+    # redis pubsub channels.
+    class StreamProxy
+      attr_reader :user
+
+      def initialize(cluster, session)
+        @cluster, @user = cluster, UserProxy.new(cluster, session)
+        @node, @available, @interested, @presence =
+          session.values_at('node', 'available', 'interested', 'presence')
+
+        unless @presence.nil? || @presence.empty?
+          @presence = Nokogiri::XML(@presence).root rescue nil
+        end
+      end
+
+      def available?
+        @available
+      end
+
+      def interested?
+        @interested
+      end
+
+      def last_broadcast_presence
+        @presence
+      end
+
+      def write(stanza)
+        @cluster.route(stanza, @node)
+      end
+    end
+
+    # Proxy User#update_from calls to remote cluster nodes over redis
+    # pubsub channels.
+    class UserProxy < User
+      def initialize(cluster, session)
+        super(jid: session['jid'])
+        @cluster, @node = cluster, session['node']
+      end
+
+      def update_from(user)
+        @cluster.update_user(@jid.bare, @node)
+      end
+    end
+  end
+end