vines 0.1.0

data/lib/vines/stream/http/http_request.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class HttpState
+        class HttpRequest
+          attr_accessor :rid
+
+          def initialize(rid)
+            @rid = rid
+            @received = Time.now
+          end
+
+          def timed_out?
+            Time.now - @received > 55
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/http/http_state.rb

@@ -0,0 +1,139 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class HttpState
+        include Nokogiri::XML
+
+        attr_reader :domain
+        attr_accessor :last_broadcast_presence, :expiration, :domain
+        attr_accessor :last_activity, :queued_stanzas, :queued_requests, :user
+
+        def initialize(stream, sid, rid, domain=nil)
+          @stream, @sid, @domain = stream, sid, domain
+          @last_activity = Time.now
+          @state = Stream::Client::Start.new(self)
+          @queued_stanzas = []
+          @queued_requests = []
+          @expiration = 65
+          @pinged = false
+          create_session(rid, sid)
+        end
+
+        def method_missing(method, *args, &block)
+          @stream.send(method, *args, &block)
+        end
+
+        def send_response(data, sid, rid)
+          doc = Document.new
+          body = doc.create_element('body',
+            'rid' => rid,
+            'sid' => sid,
+            'xmlns' => NAMESPACES[:http_bind]) do |node|
+              node.inner_html = data
+            end.to_s
+          @stream.log_node(body, :out)
+          @stream.send_data([create_header(body.bytesize), body].join("\r\n\r\n"))
+        end
+
+        def create_header(content_length)
+          ["HTTP/1.1 200 OK",
+            "Content-Type: text/xml; charset=utf-8",
+            "Content-Length: #{content_length}"].join("\r\n")
+        end
+
+        def expired?
+          cleanup_requests
+          (Time.now - @last_activity > @expiration) && @queued_requests.empty?
+        end
+
+        def cleanup_requests
+          timed_out_requests.each do |request|
+            log.debug("Clearing out #{request.rid}")
+            send_response("", @sid, request.rid)
+            @queued_requests.delete(request)
+          end
+        end
+
+        def ping
+          log.debug("Pinging #{self}. Request queue: #{@queued_requests}")
+          @last_activity = Time.now
+          write("")
+          @pinged = true
+        end
+
+        def pinged?
+          @pinged
+        end
+
+        def create_session(rid, sid)
+          doc = Document.new
+          node = doc.create_element('body',
+            'accept'     => 'deflate,gzip',
+            'ack'        => rid,
+            'charsets'   => 'UTF-8',
+            'from'       => domain, 
+            'hold'       => '1',
+            'inactivity' => '30',
+            'maxpause'   => '120',
+            'polling'    => '5',
+            'requests'   => '2',
+            'sid'        => sid,
+            'ver'        => '1.6',
+            'wait'       => '60',
+            'xmlns'      => 'http://jabber.org/protocol/httpbind')
+
+          node << doc.create_element('features', 'xmlns' => 'jabber:client') do |el|
+            el << doc.create_element('mechanisms') do |parent|
+              parent.default_namespace = NAMESPACES[:sasl]
+              mechanisms.each {|name| parent << doc.create_element('mechanism', name) }
+            end
+          end
+
+          @stream.send_data([create_header(node.to_s.bytesize), node.to_s].join("\r\n\r\n"))
+        end
+
+        def request(rid)
+          @pinged = false
+          @last_activity = Time.now
+          if @queued_stanzas.size > 0
+            send_response(@queued_stanzas.join(" "), @sid, rid)
+            @queued_stanzas.clear
+          else
+            @queued_requests << HttpRequest.new(rid)
+          end
+        end
+
+        def write(node)
+          request = @queued_requests.shift
+          unless request.nil?
+            send_response(node.to_s, @sid, request.rid)
+          else
+            @queued_stanzas << node.to_s
+          end
+        end
+
+        def timed_out_requests
+          @queued_requests.select {|request| request.timed_out? }
+        end
+
+        def mechanisms
+          ['EXTERNAL', 'PLAIN']
+        end
+
+        def handle_restart
+          doc = Document.new
+          node = doc.create_element('body',
+            'xmlns' => NAMESPACES[:http_bind],
+            'xmlns:stream' => NAMESPACES[:stream])
+          node << doc.create_element('stream:features') do |features|
+            features << doc.create_element('bind', 'xmlns' => NAMESPACES[:bind])
+          end
+          @available = true
+          @stream.send_data([create_header(node.to_s.bytesize), node.to_s].join("\r\n\r\n"))
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/http/http_states.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class HttpStates
+        include Vines::Log
+
+        def start_timer
+          @timer ||= EventMachine::PeriodicTimer.new(5) { cleanup }
+        end
+
+        def initialize
+          @http_states = {}
+          start_timer
+        end
+
+        def cleanup
+          # An expired HTTP client is one that has no queued requests
+          # and has no activity in more than 60 seconds
+          expired.each do |sid, http_state|
+            @http_states.delete(sid)
+            log.debug("Removed expired HTTP client #{sid}")
+          end
+        rescue Exception => e
+          log.error("Failed to cleanup HTTP connections: #{e}")
+        end
+
+        def []=(sid, http_state)
+          @http_states[sid] = http_state
+        end
+
+        def [](sid)
+          @http_states[sid]
+        end
+
+        def connected_http_clients
+          @http_states
+        end
+
+        def delete
+          @http_states
+        end
+
+        private
+
+        def expired
+          @http_states.select {|sid, http_state| http_state.expired? }
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/parser.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Parser < Nokogiri::XML::SAX::Document
+      include Nokogiri::XML
+      STREAM_NAME = 'stream'.freeze
+      STREAM_URI  = 'http://etherx.jabber.org/streams'.freeze
+      IGNORE = NAMESPACES.values_at(:client, :component, :server)
+
+      def initialize(&block)
+        @listeners, @node = Hash.new {|h, k| h[k] = []}, nil
+        @parser = Nokogiri::XML::SAX::PushParser.new(self)
+        instance_eval(&block) if block
+      end
+
+      [:stream_open, :stream_close, :stanza].each do |name|
+        define_method(name) do |&block|
+          @listeners[name] << block
+        end
+      end
+
+      def <<(data)
+        @parser << data
+        self
+      end
+
+      def start_element_namespace(name, attrs=[], prefix=nil, uri=nil, ns=[])
+        el = node(name, attrs, prefix, uri, ns)
+        if stream?(name, uri)
+          notify(:stream_open, el)
+        else
+          @node << el if @node
+          @node = el
+        end
+      end
+
+      def end_element_namespace(name, prefix=nil, uri=nil)
+        if stream?(name, uri)
+          notify(:stream_close)
+        elsif @node.parent != @node.document
+          @node = @node.parent
+        else
+          notify(:stanza, @node)
+          @node = nil
+        end
+      end
+
+      def characters(chars)
+        @node << Text.new(chars, @node.document) if @node
+      end
+      alias :cdata_block :characters
+
+      private
+
+      def notify(msg, node=nil)
+        @listeners[msg].each do |b|
+          (node ? b.call(node) : b.call) rescue nil
+        end
+      end
+
+      def stream?(name, uri)
+        name == STREAM_NAME && uri == STREAM_URI
+      end
+
+      def node(name, attrs=[], prefix=nil, uri=nil, ns=[])
+        ignore = stream?(name, uri) ? [] : IGNORE
+        doc = @node ? @node.document : Document.new
+        doc.create_element(name) do |node|
+          attrs.each {|attr| node[attr.localname] = attr.value }
+          ns.each {|prefix, uri| node.add_namespace(prefix, uri) unless ignore.include?(uri) }
+          node.namespace = node.add_namespace(prefix, uri) unless ignore.include?(uri)
+          doc << node unless @node
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/server.rb

@@ -0,0 +1,126 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+
+    # Implements the XMPP protocol for server-to-server (s2s) streams. This
+    # serves connected streams using the jabber:server namespace. This handles
+    # both accepting incoming s2s streams and initiating outbound s2s streams
+    # to other servers.
+    class Server < Stream
+
+      # Starts the connection to the remote server. When the stream is
+      # connected and ready to send stanzas it will yield to the callback
+      # block. The callback is run on the EventMachine reactor thread. The
+      # yielded stream will be nil if the remote connection failed. We need to
+      # use a background thread to avoid blocking the server on DNS SRV
+      # lookups.
+      def self.start(config, to, from, &callback)
+        op = proc do
+          Resolv::DNS.open do |dns|
+            dns.getresources("_xmpp-server._tcp.#{to}", Resolv::DNS::Resource::IN::SRV)
+          end.sort! {|a,b| a.priority == b.priority ? b.weight <=> a.weight : a.priority <=> b.priority }
+        end
+        cb = proc do |srv|
+          if srv.empty?
+            srv << {:target => to, :port => 5269}
+            class << srv.first
+              def method_missing(name); self[name]; end
+            end
+          end
+          Server.connect(config, to, from, srv, callback)
+        end
+        EM.defer(proc { op.call rescue [] }, cb)
+      end
+
+      def self.connect(config, to, from, srv, callback)
+        if srv.empty?
+          callback.call(nil)
+        else
+          begin
+            rr = srv.shift
+            opts = {:to => to, :from => from, :srv => srv, :callback => callback}
+            EM.connect(rr.target.to_s, rr.port, Server, config, opts)
+          rescue Exception => e
+            connect(config, to, from, srv, callback)
+          end
+        end
+      end
+
+      attr_reader :config, :domain
+      attr_accessor :remote_domain
+
+      def initialize(config, options={})
+        @config = config
+        @remote_domain = options[:to]
+        @domain = options[:from]
+        @srv = options[:srv]
+        @callback = options[:callback]
+        @outbound = @remote_domain && @domain
+        @state = @outbound ? Outbound::Start.new(self) : Start.new(self)
+      end
+
+      def post_init
+        super
+        send_stream_header if @outbound
+      end
+
+      def max_stanza_size
+        @config[:server].max_stanza_size
+      end
+
+      def ssl_handshake_completed
+        close_connection unless cert_domain_matches?(@remote_domain)
+      end
+
+      def unbind
+        super
+        if @outbound && @state.class != Ready
+          Server.connect(@config, @remote_domain, @domain, @srv, @callback)
+        end
+      end
+
+      def vhost?(domain)
+        @config.vhost?(domain)
+      end
+
+      def notify_connected
+        if @callback
+          @callback.call(self)
+          @callback = nil
+        end
+      end
+
+      def ready?
+        @state.class == Server::Ready
+      end
+
+      def start(node)
+        if @outbound then send_stream_header; return end
+        @domain, @remote_domain = %w[to from].map {|a| node[a] }
+        send_stream_header
+        raise StreamErrors::UnsupportedVersion unless node['version'] == '1.0'
+        raise StreamErrors::ImproperAddressing if [@domain, @remote_domain].any? {|addr| (addr || '').strip.empty? }
+        raise StreamErrors::HostUnknown unless @config.vhost?(@domain)
+        raise StreamErrors::NotAuthorized unless @config.s2s?(@remote_domain)
+        raise StreamErrors::InvalidNamespace unless node.namespaces['xmlns'] == NAMESPACES[:server]
+        raise StreamErrors::InvalidNamespace unless node.namespaces['xmlns:stream'] == NAMESPACES[:stream]
+      end
+
+      private
+
+      def send_stream_header
+        attrs = {
+          'xmlns' => NAMESPACES[:server],
+          'xmlns:stream' => NAMESPACES[:stream],
+          'xml:lang' => 'en',
+          'id' => Kit.uuid,
+          'from' => @domain,
+          'to' => @remote_domain,
+          'version' => '1.0'
+        }
+        write "<stream:stream %s>" % attrs.to_a.map{|k,v| "#{k}='#{v}'"}.join(' ')
+      end
+    end
+  end
+end

data/lib/vines/stream/server/auth.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class Auth < Client::Auth
+        def initialize(stream, success=FinalRestart)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/server/auth_restart.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class AuthRestart < Client::AuthRestart
+        def initialize(stream, success=Auth)
+          super
+        end
+
+        private
+
+        def mechanisms
+          ['EXTERNAL']
+        end
+      end
+    end
+  end
+end