vines 0.1.0

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

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class FinalRestart < State
+        def initialize(stream, success=Ready)
+          super
+        end
+
+        def node(node)
+          raise StreamErrors::NotAuthorized unless stream?(node)
+          stream.start(node)
+          stream.write('<stream:features/>')
+          advance
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class Outbound
+        class Auth < State
+          NS = NAMESPACES[:sasl]
+
+          def initialize(stream, success=AuthResult)
+            super
+          end
+
+          def node(node)
+            raise StreamErrors::NotAuthorized unless external?(node)
+            authz = Base64.encode64(stream.domain).chomp
+            stream.write(%Q{<auth xmlns="#{NS}" mechanism="EXTERNAL">#{authz}</auth>})
+            advance
+          end
+
+          private
+
+          def external?(node)
+            external = node.xpath("ns:mechanisms/ns:mechanism[text()='EXTERNAL']", 'ns' => NS).any?
+            node.name == 'features' && namespace(node) == NAMESPACES[:stream] && external
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class Outbound
+        class AuthRestart < State
+          def initialize(stream, success=Auth)
+            super
+          end
+
+          def node(node)
+            raise StreamErrors::NotAuthorized unless stream?(node)
+            advance
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/server/outbound/auth_result.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class Outbound
+        class AuthResult < State
+          def initialize(stream, success=FinalRestart)
+            super
+          end
+
+          def node(node)
+            raise StreamErrors::NotAuthorized unless namespace(node) == NAMESPACES[:sasl]
+            case node.name
+              when 'success'
+                stream.start(node)
+                advance
+              when 'failure'
+                stream.close_connection
+              else
+                raise StreamErrors::NotAuthorized
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/server/outbound/final_features.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class Outbound
+        class FinalFeatures < State
+          def initialize(stream, success=Server::Ready)
+            super
+          end
+
+          def node(node)
+            raise StreamErrors::NotAuthorized unless empty_features?(node)
+            advance
+            stream.notify_connected
+          end
+
+          private
+
+          def empty_features?(node)
+            node.name == 'features' && namespace(node) == NAMESPACES[:stream] && node.elements.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/server/outbound/final_restart.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class Outbound
+        class FinalRestart < State
+          def initialize(stream, success=FinalFeatures)
+            super
+          end
+
+          def node(node)
+            raise StreamErrors::NotAuthorized unless stream?(node)
+            advance
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/server/outbound/start.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class Outbound
+        class Start < State
+          def initialize(stream, success=TLS)
+            super
+          end
+
+          def node(node)
+            raise StreamErrors::NotAuthorized unless stream?(node)
+            advance
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/server/outbound/tls.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class Outbound
+        class TLS < State
+          NS = NAMESPACES[:tls]
+
+          def initialize(stream, success=TLSResult)
+            super
+          end
+
+          def node(node)
+            raise StreamErrors::NotAuthorized unless tls?(node)
+            stream.write("<starttls xmlns='#{NS}'/>")
+            advance
+          end
+
+          private
+
+          def tls?(node)
+            tls = node.xpath('ns:starttls', 'ns' => NS).any?
+            node.name == 'features' && namespace(node) == NAMESPACES[:stream] && tls
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/server/outbound/tls_result.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class Outbound
+        class TLSResult < State
+          NS = NAMESPACES[:tls]
+
+          def initialize(stream, success=AuthRestart)
+            super
+          end
+
+          def node(node)
+            raise StreamErrors::NotAuthorized unless namespace(node) == NS
+            case node.name
+              when 'proceed'
+                stream.encrypt
+                stream.start(node)
+                advance
+              when 'failure'
+                stream.close_connection
+              else
+                raise StreamErrors::NotAuthorized
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Server
+      class Ready < State
+        def node(node)
+          stanza = to_stanza(node)
+          raise StreamErrors::UnsupportedStanzaType unless stanza
+          to, from = %w[to from].map {|attr| JID.new(stanza[attr] || '') }
+          raise StreamErrors::ImproperAddressing if [to, from].any? {|addr| (addr.domain || '').strip.empty? }
+          raise StreamErrors::InvalidFrom unless from.domain == stream.remote_domain
+          raise StreamErrors::HostUnknown unless to.domain == stream.domain
+          stream.user = User.new(:jid => from)
+          stanza.process
+        end
+      end
+    end
+  end
+end

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

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

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

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

data/lib/vines/stream/state.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+
+    # The base class of Stream state machines. States know how to process XML
+    # nodes and advance to their next valid state or fail the stream.
+    class State
+      include Nokogiri::XML
+      include Vines::Log
+
+      attr_reader :stream
+
+      STREAM = 'stream'.freeze
+
+      def initialize(stream, success=nil)
+        @stream, @success = stream, success
+      end
+
+      def node(node)
+        raise 'subclass must implement'
+      end
+
+      def ==(state)
+        self.class == state.class
+      end
+
+      def eql?(state)
+        state.is_a?(State) && self == state
+      end
+
+      def hash
+        self.class.hash
+      end
+
+      private
+
+      def advance
+        stream.advance(@success.new(stream))
+      end
+
+      def stream?(node)
+        node.name == STREAM && namespace(node) == NAMESPACES[:stream]
+      end
+
+      def namespace(node)
+        node.namespace ? node.namespace.href : nil
+      end
+
+      def to_stanza(node)
+        Stanza.from_node(node, stream)
+      end
+    end
+  end
+end

data/lib/vines/token_bucket.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+
+module Vines
+
+  # The token bucket algorithm is useful for rate limiting.
+  # Before an operation can be completed, a token is taken from
+  # the bucket.  If no tokens are available, the operation fails.
+  # The bucket is refilled with tokens at the maximum allowed rate
+  # of operations.
+  class TokenBucket
+
+    # Create a full bucket with capacity number of tokens to be filled
+    # at the given rate of tokens/second.
+    def initialize(capacity, rate)
+      raise ArgumentError.new('capacity must be > 0') unless capacity > 0
+      raise ArgumentError.new('rate must be > 0') unless rate > 0
+      @capacity = capacity
+      @tokens = capacity
+      @rate = rate
+      @timestamp = Time.new
+    end
+
+    # Returns true if tokens can be taken from the bucket.
+    def take(tokens)
+      raise ArgumentError.new('tokens must be > 0') unless tokens > 0
+      if tokens <= fill
+        @tokens -= tokens
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    def fill
+      if @tokens < @capacity
+        now = Time.new
+        delta = (@rate * (now - @timestamp)).round
+        @tokens = [@capacity, @tokens + delta].min
+        @timestamp = now
+      end
+      @tokens
+    end
+  end
+end

data/lib/vines/user.rb

@@ -0,0 +1,124 @@
+# encoding: UTF-8
+
+module Vines
+  class User
+    include Comparable
+
+    attr_accessor :name, :password, :roster
+    attr_reader :jid
+
+    def initialize(args={})
+      @jid = JID.new(args[:jid])
+      raise ArgumentError, 'invalid jid' unless @jid.node && !@jid.domain.empty?
+      @name = args[:name]
+      @password = args[:password]
+      @roster = args[:roster] || []
+    end
+
+    def <=>(user)
+      self.jid.to_s <=> user.jid.to_s
+    end
+
+    def eql?(user)
+      user.is_a?(User) && self == user
+    end
+
+    def hash
+      jid.to_s.hash
+    end
+
+    # Update this user's information from the given user object.
+    def update_from(user)
+      @name = user.name
+      @password = user.password
+      @roster = user.roster.map {|c| c.clone }
+    end
+
+    # Return true if the jid is on this user's roster.
+    def contact?(jid)
+      !contact(jid).nil?
+    end
+
+    # Returns the contact with this jid or nil if not found.
+    def contact(jid)
+      bare = JID.new(jid).bare
+      @roster.find {|c| c.jid.bare == bare }
+    end
+
+    # Returns true if the user is subscribed to this contact's
+    # presence updates.
+    def subscribed_to?(jid)
+      contact = contact(jid)
+      contact && contact.subscribed_to?
+    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?(jid)
+      contact = contact(jid)
+      contact && contact.subscribed_from?
+    end
+
+    # Removes the contact with this jid from the user's roster.
+    def remove_contact(jid)
+      bare = JID.new(jid).bare
+      @roster.reject! {|c| c.jid.bare == bare }
+    end
+
+    # Returns a list of the contacts to which this user has
+    # successfully subscribed.
+    def subscribed_to_contacts
+      @roster.select {|c| c.subscribed_to? }
+    end
+
+    # Returns a list of the contacts that are subscribed to this user's
+    # presence updates.
+    def subscribed_from_contacts
+      @roster.select {|c| c.subscribed_from? }
+    end
+
+    # Update the contact's jid on this user's roster to signal that this user
+    # has requested the contact's permission to receive their presence updates.
+    def request_subscription(jid)
+      unless contact = contact(jid)
+        contact = Contact.new(:jid => jid)
+        @roster << contact
+      end
+      contact.ask = 'subscribe' if %w[none from].include?(contact.subscription)
+    end
+
+    # Add the user's jid to this contact's roster with a subscription state of
+    # 'from.' This signals that this contact has approved a user's subscription.
+    def add_subscription_from(jid)
+      unless contact = contact(jid)
+        contact = Contact.new(:jid => jid)
+        @roster << contact
+      end
+      contact.subscribe_from
+    end
+
+    def remove_subscription_to(jid)
+      if contact = contact(jid)
+        contact.unsubscribe_to
+      end
+    end
+
+    def remove_subscription_from(jid)
+      if contact = contact(jid)
+        contact.unsubscribe_from
+      end
+    end
+
+    # Returns this user's roster contacts as an iq query element.
+    def to_roster_xml(id)
+      doc = Nokogiri::XML::Document.new
+      doc.create_element('iq', 'id' => id, 'type' => 'result') do |el|
+        el << doc.create_element('query', 'xmlns' => 'jabber:iq:roster') do |query|
+          @roster.sort!.each do |contact|
+            query << contact.to_roster_xml
+          end
+        end
+      end
+    end
+  end
+end