gmcmillan-xmpp4r 0.5

data/data/doc/xmpp4r/examples/advanced/pep-aggregator/pep-aggregator.rb

@@ -0,0 +1,147 @@
+#!/usr/bin/env ruby
+
+require 'xmpp4r/framework/bot'
+require 'xmpp4r/pubsub'
+require 'xmpp4r/vcard'
+require 'ramaze'
+
+if ARGV.size < 3
+  puts "Usage: #{$0} <HTTP port> <JID> <Password> [Status message]"
+  exit
+end
+HTTP_PORT = ARGV.shift.to_i
+JID = ARGV.shift
+PASSWORD = ARGV.shift
+STATUS_MESSAGE = ARGV.shift
+
+def xml_namespaces(filename, excludes=[])
+  namespaces_recursive = nil
+  namespaces_recursive = lambda { |element|
+    namespaces = element.namespaces
+    element.each_element { |child|
+      namespaces.merge!(namespaces_recursive.call(child))
+    }
+    namespaces
+  }
+
+  root = REXML::Document.new(File.new(filename)).root
+  all = namespaces_recursive.call(root)
+  res = {}
+  all.each { |prefix,uri|
+    res[prefix] = uri unless excludes.include? prefix
+  }
+  res
+end
+
+Jabber::debug = true
+
+class VcardCache < Jabber::Vcard::Helper
+  attr_reader :vcards
+
+  def initialize(stream)
+    super
+    @vcards = {}
+  end
+
+  def get(jid)
+    unless @vcards[jid]
+      begin
+        @vcards[jid] = super
+      rescue Jabber::ServerError
+        @vcards[jid] = :error
+      end
+    end
+
+    @vcards[jid]
+  end
+
+  def get_until(jid, timeout=10)
+    begin
+      Timeout::timeout(timeout) {
+        get(jid)
+      }
+    rescue Timeout::Error
+      @vcards[jid] = :timeout
+    end
+
+    @vcards[jid]
+  end
+end
+
+MAX_ITEMS = 50
+$jid_items = []
+
+$bot = Jabber::Framework::Bot.new(JID, PASSWORD)
+class << $bot
+  def accept_subscription_from?(jid)
+    roster.add(jid, nil, true)
+    true
+  end
+end
+$vcards = VcardCache.new($bot.stream)
+xml_namespaces('index.xsl', %w(xmlns xsl pa j p)).each { |prefix,node|
+        $bot.add_pep_notification(node) do |from,item|
+          from.strip!
+          item.add_namespace(Jabber::PubSub::NS_PUBSUB)
+          item.attributes['node'] = node
+          is_duplicate = false
+          $jid_items.each { |jid1,item1|
+            if jid1.to_s == from.to_s and node == item1.attributes['node']
+              is_duplicate = (item.to_s == item1.to_s)
+              break
+            end
+          }
+          unless is_duplicate
+            $jid_items.unshift([from, item])
+            $jid_items = $jid_items[0..(MAX_ITEMS-1)]
+          end
+        end
+      }
+
+$bot.set_presence(nil, STATUS_MESSAGE || "Busy aggregating PEP events...")
+
+class WebController < Ramaze::Controller
+  map '/'
+  template_root __DIR__
+  engine :XSLT
+
+  def index
+    "<?xml version='1.0' encoding='UTF-8'?>" +
+      "<items xmlns:jabber='jabber:client' jabber:to='#{Jabber::JID.new(JID).strip}'>" +
+      $jid_items.collect do |jid,item_orig|
+        item = item_orig.deep_clone
+        item.attributes['jabber:from'] = jid.to_s
+        vcard = $vcards.get_until(jid)
+        if vcard.kind_of? Jabber::Vcard::IqVcard
+          item.attributes['jabber:from-name'] = vcard['NICKNAME'] || vcard['FN'] || jid.node
+          item.attributes['jabber:has-avatar'] = (vcard['PHOTO/TYPE'] and
+                                                  vcard['PHOTO/BINVAL']) ? 'true' : 'false'
+        else
+          item.attributes['jabber:from-name'] = jid.node
+          item.attributes['jabber:has-avatar'] = 'false'
+        end
+        item
+      end.join +
+      "</items>"
+  end
+
+  def avatar(jid)
+    trait :engine => :None
+
+    vcard = $vcards.get_until(jid)
+    if vcard.kind_of? Jabber::Vcard::IqVcard
+      if vcard['PHOTO/TYPE'] and vcard.photo_binval
+        response['Content-Type'] = vcard['PHOTO/TYPE']
+        response.body = vcard.photo_binval
+      else
+        response['Status'] = 404
+      end
+    else
+        response['Status'] = 404
+    end
+
+    throw :respond
+  end
+end
+
+Ramaze::start(:port => HTTP_PORT)

data/data/doc/xmpp4r/examples/advanced/recvfile.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+require 'xmpp4r'
+require 'xmpp4r/bytestreams/helper/filetransfer'
+
+Jabber::debug = true
+
+if ARGV.size != 3
+  puts "Usage: #{$0} <jid> <password> <incoming-directory>"
+  exit
+end
+
+
+#Jabber::debug = true
+
+cl = Jabber::Client.new(Jabber::JID.new(ARGV[0]))
+puts "Connecting Jabber client..."
+cl.connect
+puts "Authenticating..."
+cl.auth ARGV[1]
+
+ft = Jabber::FileTransfer::Helper.new(cl)
+ft.add_incoming_callback { |iq,file|
+  puts "Incoming file transfer from #{iq.from}: #{file.fname} (#{file.size / 1024} KB)"
+
+  filename = "#{ARGV[2]}/#{file.fname.split(/\//).last}"
+  offset = nil
+  if File::exist?(filename)
+    puts "#{filename} already exists"
+    if File::size(filename) < file.size and file.range
+      offset = File::size(filename)
+      puts "Peer supports <range/>, will retrieve #{file.fname} starting at #{offset}"
+    else
+      puts "#{file.fname} is already fully retrieved, declining file-transfer"
+      ft.decline(iq)
+      next
+    end
+  end
+
+  Thread.new {
+    begin
+      puts "Accepting #{file.fname}"
+      stream = ft.accept(iq, offset)
+      if stream.kind_of?(Jabber::Bytestreams::SOCKS5Bytestreams)
+        stream.connect_timeout = 5
+        stream.add_streamhost_callback { |streamhost,state,e|
+          case state
+            when :connecting
+              puts "Connecting to #{streamhost.jid} (#{streamhost.host}:#{streamhost.port})"
+            when :success
+              puts "Successfully using #{streamhost.jid} (#{streamhost.host}:#{streamhost.port})"
+            when :failure
+              puts "Error using #{streamhost.jid} (#{streamhost.host}:#{streamhost.port}): #{e}"
+          end
+        }
+      end
+
+      puts "Waiting for stream configuration"
+      if stream.accept
+        puts "Stream established"
+        outfile = File.new(filename, (offset ? 'ab' : 'wb'))
+        while buf = stream.read(65536)
+          outfile.write(buf)
+          print '.'
+          $stdout.flush
+        end
+        puts '!'
+        outfile.close
+        stream.close
+      else
+        puts "Stream failed"
+      end
+    rescue Exception => e
+      puts "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+    end
+  }
+}
+
+cl.send(Jabber::Presence.new(:chat, 'Send me files!'))
+
+puts "Waiting."
+
+Thread.stop
+
+cl.close

data/data/doc/xmpp4r/examples/advanced/rosterdiscovery.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+#
+# XMPP4R - XMPP Library for Ruby
+# Copyright (C) 2005 Stephan Maka <stephan@spaceboyz.net>
+# Released under Ruby's license (see the LICENSE file) or GPL, at your option
+#
+#
+# Roster-Discovery example
+#
+# If you don't understand this code read JEP-0030 (Service Discovery) first:
+# http://www.jabber.org/jeps/jep-0030.html
+#
+# This examples exposes your roster to Service Discovery and can be browsed
+# by anyone. Please use with care if you want to keep your roster private!
+#
+# The Psi client has a very pretty Service Discovery dialog. But be sure
+# to turn off "Auto-browse into objects" for big rosters.
+#
+
+$:.unshift '../../../../../lib'
+
+require 'thread'
+
+require 'xmpp4r'
+require 'xmpp4r/helpers/roster'
+require 'xmpp4r/iq/query/discoinfo'
+require 'xmpp4r/iq/query/discoitems'
+
+# Command line argument checking
+
+if ARGV.size != 2
+  puts("Usage: ./rosterdiscovery.rb <jid> <password>")
+  exit
+end
+
+# Building up the connection
+
+#Jabber::debug = true
+
+jid = Jabber::JID.new(ARGV[0])
+
+cl = Jabber::Client.new(jid)
+cl.connect
+cl.auth(ARGV[1])
+
+
+# The roster instance
+roster = Jabber::Helpers::Roster.new(cl)
+
+
+cl.add_iq_callback { |iq|
+  if iq.query.kind_of?(Jabber::IqQueryDiscoInfo) || iq.query.kind_of?(Jabber::IqQueryDiscoItems)
+
+    # Prepare the <iq/> stanza for result
+    iq.from, iq.to = iq.to, iq.from
+    iq.type = :result
+
+
+    if iq.query.kind_of?(Jabber::IqQueryDiscoInfo)
+      # iq.to and iq.from are already switched here:
+      puts("#{iq.to} requests info of #{iq.from} node #{iq.query.node.inspect}")
+
+      if iq.query.node.nil?
+        iq.query.add(Jabber::DiscoIdentity.new('directory', 'Roster discovery', 'user'))
+      else
+        # Count contacts in group
+        in_group = 0
+        roster.items.each { |jid,item|
+          if item.groups.include?(iq.query.node)
+            in_group += 1
+          end
+        }
+
+        iq.query.add(Jabber::DiscoIdentity.new('directory', "#{iq.query.node} (#{in_group})", 'group'))
+      end
+
+      iq.query.add(Jabber::DiscoFeature.new(Jabber::IqQueryDiscoInfo.new.namespace))
+      iq.query.add(Jabber::DiscoFeature.new(Jabber::IqQueryDiscoItems.new.namespace))
+
+    elsif iq.query.kind_of?(Jabber::IqQueryDiscoItems)
+      # iq.to and iq.from are already switched here:
+      puts("#{iq.to} requests items of #{iq.from} node #{iq.query.node.inspect}")
+
+      if iq.query.node.nil?
+        # Make items from group names
+        groups = []
+
+        roster.items.each { |jid,item|
+          groups += item.groups
+        }
+
+        groups.uniq.each { |group|
+          iq.query.add(Jabber::DiscoItem.new(cl.jid, group, group))
+        }
+
+        # Collect all ungrouped roster items
+        roster.items.each { |jid,item|
+          if item.groups == []
+            iq.query.add(Jabber::DiscoItem.new(item.jid, item.iname.to_s == '' ? item.jid : item.iname))
+          end
+        }
+      else
+        # Add a discovery item for each roster item in that group
+        roster.items.each { |jid,item|
+          if item.groups.include?(iq.query.node)
+            iq.query.add(Jabber::DiscoItem.new(item.jid, item.iname.to_s == '' ? item.jid : item.iname))
+          end
+        }
+      end
+
+    end
+
+    cl.send(iq)
+
+    true
+  end
+}
+
+# Initial presence
+cl.send(Jabber::Presence.new.set_status("Discover my roster at #{jid}"))
+
+# Main loop:
+
+loop do
+  cl.process
+  Thread.stop
+end
+
+cl.close

data/data/doc/xmpp4r/examples/advanced/sendfile.conf

@@ -0,0 +1,10 @@
+---
+jabber:
+  jid: user@server/resource
+  password: password
+local:
+  port: 65010
+  addresses: [172.22.16.3]
+proxies:
+  - proxy.jabber.org
+  - transfer.jabber.freenet.de

data/data/doc/xmpp4r/examples/advanced/sendfile.rb

@@ -0,0 +1,72 @@
+require 'xmpp4r'
+require 'xmpp4r/bytestreams'
+require 'yaml'
+
+Jabber::debug = true
+
+if ARGV.size != 3
+  puts "Usage: #{$0} <jid> <description> <file>"
+  exit
+end
+
+conf = YAML::load File.new('sendfile.conf')
+
+cl = Jabber::Client.new(Jabber::JID.new(conf['jabber']['jid']))
+puts "Connecting Jabber client..."
+cl.connect
+puts "Authenticating..."
+cl.auth conf['jabber']['password']
+
+puts "Starting local Bytestreams server"
+bss = Jabber::Bytestreams::SOCKS5BytestreamsServer.new(conf['local']['port'])
+conf['local']['addresses'].each { |address|
+  bss.add_address(address)
+}
+ft = Jabber::FileTransfer::Helper.new(cl)
+#ft.allow_bytestreams = false
+source = Jabber::FileTransfer::FileSource.new(ARGV[2])
+puts "Offering #{source.filename} to #{ARGV[0]}"
+stream = ft.offer(Jabber::JID.new(ARGV[0]), source, ARGV[1])
+
+if stream
+  puts "Starting stream initialization (#{stream.class})"
+
+  if stream.kind_of? Jabber::Bytestreams::SOCKS5BytestreamsInitiator
+    stream.add_streamhost(bss)
+    (conf['proxies'] || []).each { |proxy|
+      puts "Querying proxy #{proxy}"
+      stream.add_streamhost proxy
+    }
+    puts "Offering streamhosts " + stream.streamhosts.collect { |sh| sh.jid }.join(' ')
+
+    stream.add_streamhost_callback { |streamhost,state,e|
+      case state
+        when :connecting
+          puts "Connecting to #{streamhost.jid} (#{streamhost.host}:#{streamhost.port})"
+        when :success
+          puts "Successfully using #{streamhost.jid} (#{streamhost.host}:#{streamhost.port})"
+        when :failure
+          puts "Error using #{streamhost.jid} (#{streamhost.host}:#{streamhost.port}): #{e}"
+      end
+    }
+  end
+
+  stream.open
+  if stream.kind_of? Jabber::Bytestreams::SOCKS5BytestreamsInitiator
+    puts "Using streamhost #{stream.streamhost_used.jid} (#{stream.streamhost_used.host}:#{stream.streamhost_used.port})"
+  end
+
+  while buf = source.read
+    print "."
+    $stdout.flush
+    stream.write buf
+    stream.flush
+  end
+  puts "!"
+  stream.close
+
+else
+  puts "Peer declined"
+end
+
+cl.close

data/data/doc/xmpp4r/examples/advanced/shellmgr/shellmgr.rb

@@ -0,0 +1,51 @@
+require 'thread'
+
+class Shell
+
+  PROMPT = "_-=READY=-_"
+
+  def initialize(shell = "/bin/bash", delay = 1, &block)
+    @cb = block
+    @shell = shell
+    @delay = delay
+    @parent_to_child_read, @parent_to_child_write = IO.pipe
+    @child_to_parent_read, @child_to_parent_write = IO.pipe
+    @child_pid = fork do
+      @parent_to_child_write.close
+      @child_to_parent_read.close
+      $stdin.reopen(@parent_to_child_read)
+      $stdout.reopen(@child_to_parent_write)
+      $stderr.reopen(@child_to_parent_write)
+      exec("/bin/bash")
+    end
+    buffer = ""
+    semaphore = Mutex.new
+    Thread.new do
+      while true
+        c = @child_to_parent_read.read(1)
+        semaphore.synchronize { buffer += c }
+      end
+    end
+    Thread.new do
+      ch = ""
+      while true do
+        sleep @delay
+        semaphore.synchronize {
+          if buffer == ch and ch != ""
+            @cb.call buffer
+            buffer = ""
+          end
+          ch = buffer
+        }
+      end
+    end
+  end
+
+  def puts(str)
+    @parent_to_child_write.puts(str)
+  end
+
+  def kill
+    @child_pid.kill
+  end
+end