xmpp4r 0.3.1 → 0.3.2

data/lib/xmpp4r/roster/helper/roster.rb

@@ -2,7 +2,7 @@
 # License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
 # Website::http://home.gna.org/xmpp4r/
 
-require 'callbacks'
+require 'xmpp4r/callbacks'
 require 'thread'
 require 'xmpp4r/roster/iq/roster'
 
@@ -45,12 +45,20 @@ module Jabber
 
         # Register cbs
         stream.add_iq_callback(120, self) { |iq|
-          Thread.new do
-            handle_iq(iq)
+          if iq.query.kind_of?(IqQueryRoster)
+            Thread.new do
+              Thread.current.abort_on_exception = true
+              handle_iq_query_roster(iq)
+            end
+
+            true
+          else
+            false
           end
         }
         stream.add_presence_callback(120, self) { |pres|
           Thread.new do
+            Thread.current.abort_on_exception = true
             handle_presence(pres)
           end
         }
@@ -141,43 +149,28 @@ module Jabber
       ##
       # Handle received <tt><iq/></tt> stanzas,
       # used internally
-      def handle_iq(iq)
-        if iq.query.kind_of?(IqQueryRoster)
-          # If the <iq/> contains <error/> we just ignore that
-          # and assume an empty roster
-          iq.query.each_element('item') do |item|
+      def handle_iq_query_roster(iq)
+        # If the <iq/> contains <error/> we just ignore that
+        # and assume an empty roster
+        iq.query.each_element('item') do |item|
+          olditem, newitem = nil, nil
+
+          @items_lock.synchronize {
+            olditem = @items[item.jid]
+
             # Handle deletion of item
             if item.subscription == :remove
-              @items_lock.synchronize {
-                @items.delete(item.jid)
-              }
-
+              @items.delete(item.jid)
             else
-              olditem = nil
-              @items_lock.synchronize {
-                if @items.has_key?(item.jid)
-                  olditem = RosterItem.new(@stream).import(@items[item.jid])
-
-                  # Clear first, because import doesn't
-                  @items[item.jid].iname = nil
-                  @items[item.jid].subscription = nil
-                  @items[item.jid].ask = nil
-
-                  @items[item.jid].import(item)
-                else
-                  @items[item.jid] = RosterItem.new(@stream).import(item)
-                end
-              }
-              @update_cbs.process(olditem, @items[item.jid])
+              newitem = @items[item.jid] = RosterItem.new(@stream).import(item)
             end
-          end
-
-          @query_cbs.process(iq)
-        else
-          false
+          }
+          @update_cbs.process(olditem, newitem)
         end
+          
+        @query_cbs.process(iq)
       end
-
+      
       ##
       # Handle received <tt><presence/></tt> stanzas,
       # used internally
@@ -322,7 +315,7 @@ module Jabber
           request = Iq.new_rosterset
           request.query.add(Jabber::Roster::RosterItem.new(jid, iname))
           @stream.send_with_id(request) { true }
-          # Adding to list is handled by handle_iq
+          # Adding to list is handled by handle_iq_query_roster
         end
 
         if subscribe
@@ -375,20 +368,6 @@ module Jabber
           @presences_lock = Mutex.new
         end
 
-        ##
-        # Import another element,
-        # also import presences if xe is a RosterItem
-        # return:: [RosterItem] self
-        def import(xe)
-          super
-          if xe.kind_of?(RosterItem)
-            xe.each_presence { |pres|
-              add_presence(Presence.new.import(pres))
-            }
-          end
-          self
-        end
-
         ##
         # Send the updated RosterItem to the server,
         # i.e. if you modified iname, groups, ...
@@ -410,7 +389,7 @@ module Jabber
           request = Iq.new_rosterset
           request.query.add(Jabber::Roster::RosterItem.new(jid, nil, :remove))
           @stream.send_with_id(request) { true }
-          # Removing from list is handled by Roster#handle_iq
+          # Removing from list is handled by Roster#handle_iq_query_roster
         end
 
         ##

data/lib/xmpp4r/roster/iq/roster.rb

@@ -19,29 +19,7 @@ module Jabber
     #
     # This <query/> contains multiple <item/> children. See RosterItem.
     class IqQueryRoster < IqQuery
-      ##
-      # Create a new <query xmlns='jabber:iq:roster'/>
-      # stream:: [Stream] Stream to handle
-      def initialize
-        super
-        add_namespace('jabber:iq:roster')
-      end
-      
-      ##
-      # Add an element to the roster
-      #
-      # Converts <item/> elements to RosterItem
-      #
-      # Previous RosterItems with the same JID will
-      # *not* be deleted!
-      def typed_add(element)
-        if element.kind_of?(REXML::Element) && (element.name == 'item')
-          item = RosterItem::new.import(element)
-          super(item)
-        else
-          super(element)
-        end
-      end
+      name_xmlns 'query', 'jabber:iq:roster'
       
       ##
       # Iterate through all items
@@ -105,7 +83,9 @@ module Jabber
     # The 'name' attribute has been renamed to 'iname' here
     # as 'name' is already used by REXML::Element for the
     # element's name. It's still name='...' in XML.
-    class RosterItem < REXML::Element
+    class RosterItem < XMPPElement
+      name_xmlns 'item', 'jabber:iq:roster'
+
       ##
       # Construct a new roster item
       # jid:: [JID] Jabber ID
@@ -113,19 +93,12 @@ module Jabber
       # subscription:: [Symbol] Type of subscription (see RosterItem#subscription=)
       # ask:: [Symbol] or [Nil] Can be :subscribe
       def initialize(jid=nil, iname=nil, subscription=nil, ask=nil)
-        super('item')
+        super()
         self.jid = jid
         self.iname = iname
         self.subscription = subscription
         self.ask = ask
       end
-      
-      ##
-      # Create new RosterItem from REXML::Element
-      # item:: [REXML::Element] source element to copy attributes and children from
-      def RosterItem.import(item)
-        RosterItem::new.import(item)
-      end
     
       ##
       # Get name of roster item
@@ -219,7 +192,7 @@ module Jabber
         each_element('group') { |group|
           result.push(group.text)
         }
-        result
+        result.uniq
       end
       
       ##
@@ -238,7 +211,5 @@ module Jabber
         }
       end
     end
-    
-    IqQuery.add_namespaceclass('jabber:iq:roster', IqQueryRoster)
   end #Module Roster
 end #Module Jabber

data/lib/xmpp4r/roster/x/roster.rb

@@ -17,28 +17,12 @@ module Jabber
   # Pay attention to the namespace which is <tt>jabber:x:roster</tt>
   # for JEP-0093!
     class XRoster < X
-      ##
-      # Initialize a new XRoster element
-      def initialize
-        super()
-        add_namespace('http://jabber.org/protocol/rosterx')
-      end
-      
-      ##
-      # Add an element to the roster attachment
-      #
-      # Converts <item/> elements to XRosterItem
-      def typed_add(element)
-        if element.kind_of?(REXML::Element) && (element.name == 'item')
-          super(XRosterItem::new.import(element))
-        else
-          super(element)
-        end
-      end
+      name_xmlns 'x', 'jabber:x:roster'
     end #Class XRoster
-    
-    X.add_namespaceclass('jabber:x:roster', XRoster)
-    X.add_namespaceclass('http://jabber.org/protocol/rosterx', XRoster)
+
+    class RosterX < XRoster
+      name_xmlns 'x', 'http://jabber.org/protocol/rosterx'
+    end
     
     ##
     # Class containing an <item/> element
@@ -50,24 +34,19 @@ module Jabber
     # This is all a bit analoguous to Jabber::RosterItem, used by
     # Jabber::IqQueryRoster. But this class lacks the subscription and
     # ask attributes.
-    class XRosterItem < REXML::Element
+    class XRosterItem < XMPPElement
+      name_xmlns 'item', 'jabber:x:roster'
+
       ##
       # Construct a new roster item
       # jid:: [JID] Jabber ID
       # iname:: [String] Name in the roster
       def initialize(jid=nil, iname=nil)
-        super('item')
+        super()
         self.jid = jid
         self.iname = iname
       end
       
-      ##
-      # Create new XRosterItem from REXML::Element
-      # item:: [REXML::Element] source element to copy attributes and children from
-      def XRosterItem.import(item)
-        XRosterItem::new.import(item)
-      end
-      
       ##
       # Get name of roster item
       #
@@ -151,5 +130,9 @@ module Jabber
         }
       end
     end #Class XRosterItem
+
+    class RosterXItem < XRosterItem
+      name_xmlns 'item', 'http://jabber.org/protocol/rosterx'
+    end
   end #Module Roster
 end #Module Jabber

data/lib/xmpp4r/rpc.rb

@@ -0,0 +1,2 @@
+require 'xmpp4r/rpc/helper/client'
+require 'xmpp4r/rpc/helper/server'

data/lib/xmpp4r/rpc/helper/client.rb

@@ -0,0 +1,114 @@
+require 'xmlrpc/server'
+require 'xmlrpc/parser'
+require 'xmlrpc/create'
+require 'xmlrpc/config'
+require 'xmlrpc/utils'         # ParserWriterChooseMixin
+
+require 'xmpp4r/dataforms/x/data'
+require 'xmpp4r/rpc/iq/rpc'
+require 'xmpp4r/rpc/helper/xmlrpcaddons'
+
+module Jabber
+  module RPC
+
+    ##
+    # XMLRPC Client
+    class Client
+
+      include XMLRPC::ParserWriterChooseMixin
+      include XMLRPC::ParseContentType
+
+      attr_accessor :my_jid
+
+      ##
+      # xmppstream
+      # stream:: [Stream]
+      # jid where you want to send the rpc requests to
+      # jid:: [JID] rpcserver@jabberserver/ressource
+      def initialize(stream,jid)
+        @jid    = JID.new(jid)
+        @my_jid = stream.jid
+        @stream =  stream
+        @parser = nil
+        @create = XMLRPC::Create.new
+      end
+
+      def call(method, *args)
+        ok, param = call2(method, *args)
+        if ok
+          param
+        else
+          raise param
+        end
+      end
+
+      def call2(method, *args)
+        request = @create.methodCall(method, *args)
+        data = do_rpc(request)
+        parser().parseMethodResponse(data)
+      end
+
+      ##
+      # adds multi rpcalls to the query
+      # methods:: [Array]
+      def multicall(*methods)
+        ok, params = multicall2(*methods)
+        if ok
+          params
+        else
+          raise params
+        end
+      end
+
+      ##
+      # generate a multicall
+      # methods:: [Array]
+      def multicall2(*methods)
+        gen_multicall(methods)
+      end
+
+      def do_rpc(xmlrpc)
+        iq = Iq.new(:set, @jid)
+        iq.from = @my_jid
+        iq.id = IdGenerator::generate_id
+        rpcquery = iq.add(IqQueryRPC.new)
+        rpcquery.typed_add(xmlrpc)
+
+        result = nil
+        @stream.send_with_id(iq) { |iqreply|
+          if iqreply.type == :result and iqreply.query.kind_of?(IqQueryRPC)
+            result = iqreply.query.to_s
+            true
+          else
+            false
+          end
+        }
+
+        result
+      end
+
+      private
+
+      def gen_multicall(methods=[])
+        ok, params = call2("system.multicall",
+          methods.collect { |m| {'methodName' => m[0], 'params' => m[1..-1]} }
+        )
+
+        if ok
+          params = params.collect{ |param|
+            if param.is_a? Array
+              param[0]
+            elsif param.is_a? Hash
+              XMLRPC::FaultException.new(param["faultCode"], param["faultString"])
+            else
+              raise "Wrong multicall return value"
+            end
+          }
+        end
+
+        return ok, params
+      end
+    end
+  end  # Helpers
+end   # Jabber
+

data/lib/xmpp4r/rpc/helper/server.rb

@@ -0,0 +1,75 @@
+require 'xmlrpc/server'
+require 'xmlrpc/parser'
+require 'xmlrpc/create'
+require 'xmlrpc/config'
+require 'xmlrpc/utils'         # ParserWriterChooseMixin
+
+require 'xmpp4r/dataforms/x/data'
+require 'xmpp4r/rpc/iq/rpc'
+require 'xmpp4r/rpc/helper/xmlrpcaddons'
+
+module Jabber
+  module RPC
+
+    ##
+    # XMLRPC Server
+    class Server < XMLRPC::BasicServer
+
+      include XMLRPC::ParserWriterChooseMixin
+      include XMLRPC::ParseContentType
+
+      ##
+      # new - creates a new server
+      #
+      def initialize(stream,class_delim=".")
+        super(class_delim)
+        @stream = stream
+        @stream.add_iq_callback(120,"Helpers::RPCServer") { |iq|
+          if iq.type == :set and iq.type != :result
+            handle_iq(iq)
+            true
+          else
+            false
+          end
+        }
+      end
+
+      ##
+      # handles incoming iqs
+      # iq:: [Jabber::IQ] - the jabber iq
+      def handle_iq(iq)
+        if iq.type == :set
+          if iq.query.kind_of?(IqQueryRPC)
+            data = iq.query
+            response = IqQueryRPC.new
+            data.elements.each { |rpc|
+              if rpc
+                response.typed_add(handle_rpc_requests(rpc))
+              end
+            }
+
+            respiq = iq.answer(false)
+            respiq.type = :result
+            respiq.add(response)
+            @stream.send(respiq)
+          end
+        end
+      end
+
+      private
+
+      ##
+      # handles the rpc requests
+      # takes rpcdata:: [String]
+      def handle_rpc_requests(rpcdata)
+        resp = process(rpcdata.to_s)
+        if resp == nil or resp.size <= 0
+          raise Jabber::Error.new(:forbidden)
+        else
+          return resp
+        end
+      end
+    end # RPCServer
+  end  # Helpers
+end   # Jabber
+