vines 0.1.0

data/lib/vines/command/start.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+module Vines
+  module Command
+    class Start
+      def run(opts)
+        raise 'vines [--pid FILE] start' unless opts[:args].size == 0
+        require opts[:config]
+        server = XmppServer.new(Config.instance)
+        daemonize(opts) if opts[:daemonize]
+        server.start
+      end
+
+      private
+
+      def daemonize(opts)
+        daemon = Daemon.new(:pid => opts[:pid], :stdout => opts[:log],
+          :stderr => opts[:log])
+        if daemon.running?
+          raise "Vines is running as process #{daemon.pid}"
+        else
+          puts "Vines has started"
+          daemon.start
+        end
+      end
+    end
+  end
+end

data/lib/vines/command/stop.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Vines
+  module Command
+    class Stop
+      def run(opts)
+        raise 'vines [--pid FILE] stop' unless opts[:args].size == 0
+        daemon = Daemon.new(:pid => opts[:pid])
+        if daemon.running?
+          daemon.stop
+          puts 'Vines has been shutdown'
+        else
+          puts 'Vines is not running'
+        end
+      end
+    end
+  end
+end

data/lib/vines/config.rb

@@ -0,0 +1,191 @@
+# 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
+  # config/vines.rb file.
+  class Config
+    LOG_LEVELS = %w[debug info warn error fatal].freeze
+
+    attr_reader :vhosts
+
+    @@instance = nil
+    def self.configure(&block)
+      @@instance = self.new(&block)
+    end
+
+    def self.instance
+      @@instance
+    end
+
+    def initialize(&block)
+      @vhosts, @ports = {}, {}
+      instance_eval(&block)
+      raise "must define at least one virtual host" if @vhosts.empty?
+    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|
+        @vhosts.merge! Host.new(name, &block).to_hash
+      end
+    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 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
+
+    def vhost?(domain)
+      @vhosts.key?(domain)
+    end
+
+    # Returns true if server-to-server connections are allowed with the
+    # given domain.
+    def s2s?(domain)
+      @ports[:server] && @ports[:server].hosts.include?(domain)
+    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
+
+    class Host
+      def initialize(name, &block)
+        @name, @storage, @ldap = name, nil, nil
+        instance_eval(&block)
+      end
+
+      def storage(name, &block)
+        raise "one storage mechanism per host allowed" if @storage
+        @storage = Storage.from_name(name, &block)
+        @storage.ldap = @ldap
+      end
+
+      def ldap(host='localhost', port=636, &block)
+        @ldap = Storage::Ldap.new(host, port, &block)
+        @storage.ldap = @ldap if @storage
+      end
+
+      def to_hash
+        raise "storage required for #{@name}" unless @storage
+        {@name => @storage}
+      end
+    end
+
+    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
+    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)
+      end
+    end
+
+    class ComponentPort < Port
+      def initialize(config, host='0.0.0.0', port=5347, &block)
+        @components, @stream = {}, Vines::Stream::Component
+        super(config, host, port, &block)
+      end
+
+      def components(options=nil)
+        if options
+          @components = options
+        else
+          @components
+        end
+      end
+
+      def password(component)
+        @components[component]
+      end
+    end
+  end
+end

data/lib/vines/contact.rb

@@ -0,0 +1,99 @@
+# 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' unless @jid.node && !@jid.domain.empty?
+      @name = args[:name]
+      @subscription = args[:subscription] || 'none'
+      @ask = args[:ask]
+      @groups = args[:groups] || []
+    end
+
+    def <=>(contact)
+      self.jid.to_s <=> contact.jid.to_s
+    end
+
+    def eql?(contact)
+      contact.is_a?(Contact) && self == contact
+    end
+
+    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
+
+    # 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 Confict < 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