diaspora-vines 0.1.2

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? "diaspora"
+          @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/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