cerberus 0.6 → 0.7

data/lib/vendor/xmpp4r/data/doc/xmpp4r/examples/advanced/shellmgr/shellmgr_jabber.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/ruby -w
+
+$:.unshift '../../lib'
+require 'shellmgr'
+require 'xmpp4r'
+include Jabber
+
+if ARGV.length != 3
+  puts "usage: ./shellmgr_jabber.rb jid_to_use password jid_to_authorize"
+  exit(1)
+end
+
+myjid = JID.new(ARGV[0])
+mypassword = ARGV[1]
+authjid = JID.new(ARGV[2])
+
+myjid = JID.new(myjid.node, myjid.domain, 'RSM')
+cl = Client.new(myjid)
+cl.connect
+cl.auth(mypassword)
+mainthread = Thread.current
+sh = Shell.new { |str|
+  puts "-----RECEIVING-----\n#{str}"
+  cl.send(Message.new(authjid, str)) }
+cl.add_message_callback do |m|
+  if JID.new(m.from).strip.to_s != authjid.strip.to_s
+    puts "Received message from non-authorized user #{m.from}"
+  else
+    if m.body == "killshell"
+      cl.send(Message.new(authjid, "Exiting..."))
+      mainthread.wakeup
+    else
+      puts "-----EXECUTING-----\n#{m.body}"
+      sh.puts(m.body)
+    end
+  end
+end
+cl.send(Presence.new)
+puts "Connected ! Ask #{authjid.to_s} to send commands to #{myjid.to_s}"
+cl.send(Message.new(authjid, "I'm ready to receive commands from you."))
+Thread.stop
+cl.close
+sh.kill

data/lib/vendor/xmpp4r/data/doc/xmpp4r/examples/advanced/shellmgr/shellmgr_test.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/ruby -w
+
+require 'shellmgr'
+
+sh = Shell.new { |s| puts s }
+
+while true do
+  l = gets
+  sh.puts l
+end

data/lib/vendor/xmpp4r/data/doc/xmpp4r/examples/advanced/versionpoll.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/ruby
+
+# This script will request the version information of a list of JID given
+# on stdin.
+
+$:.unshift '../../../../../lib'
+
+require 'optparse'
+require 'xmpp4r/client'
+require 'xmpp4r/version/iq/version'
+include Jabber
+#Jabber::debug = true
+
+# settings
+jid = JID.new('bot@localhost/Bot')
+password = 'bot'
+domains = []
+OptionParser.new do |opts|
+  opts.banner = 'Usage: versionpoll.rb -j jid -p password -d DOMAINS'
+  opts.separator ''
+  opts.on('-j', '--jid JID', 'sets the jid') { |j| jid = JID.new(j) }
+  opts.on('-p', '--password PASSWORD', 'sets the password') { |p| password = p }
+  opts.on('-d', '--domain DOMAIN', 'sets the domain') { |d| domains << d }
+  opts.on_tail('-h', '--help', 'Show this message') {
+    puts opts
+    exit
+  }
+  opts.parse!(ARGV)
+end
+
+cl = Client.new(jid)
+cl.connect
+cl.auth(password)
+sent = []
+queried = []
+activity = false
+cl.add_iq_callback do |i|
+  fjid = JID.new(i.from)
+  if i.type == :result and fjid.resource == "admin"
+    domain = fjid.domain
+    items = i.first_element('item')
+    raise "items nil" if items.nil?
+    items.each_element('user') do |e|
+      j = e.attribute('jid')
+      if not queried.include?(j)
+        activity = true
+        queried << j
+        cl.send(Iq.new_browseget.set_to(j))
+      end
+    end
+  end
+end
+
+cl.add_iq_callback do |i|
+  if i.type == :result
+    u = i.first_element('user')
+    if u
+      u.each_element('user') do |e|
+        if (a = e.attribute('type'))
+          if a.value == 'client'
+            activity = true
+            iq = Iq.new(:get)
+            iq.query = Version::IqQueryVersion.new
+            iq.set_to(JID.new(e.attribute('jid').to_s))
+            cl.send(iq)
+          end
+        end
+      end
+    end
+  end
+end
+cl.add_iq_callback do |iq|
+  if iq.type == :result and iq.query.class == Version::IqQueryVersion
+    activity = true
+    r = [ iq.from.to_s, iq.query.iname, iq.query.version, iq.query.os ]
+    puts r.inspect
+  end
+end
+cl.send(Presence.new)
+for d in domains do
+  cl.send(Iq.new_browseget.set_to("#{d}/admin"))
+end
+
+activity = true
+while activity
+  activity = false
+  # other threads might set activity to true
+  sleep 10
+end
+cl.close

data/lib/vendor/xmpp4r/data/doc/xmpp4r/examples/advanced/xmpping.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+
+# This is PING for Jabber
+#
+# Please customize your ~/.xmppingrc
+
+
+require 'xmpp4r'
+require 'xmpp4r/httpbinding'
+require 'xmpp4r/version/iq/version'
+require 'xmpp4r/discovery/iq/discoinfo'
+require 'optparse'
+require 'yaml'
+require 'thread'
+
+
+##
+# Options
+##
+
+interval = 5
+jid = nil
+conf_filename = "#{ENV['HOME']}/.xmppingrc"
+accountname = 'default'
+
+OptionParser.new { |opts|
+  opts.banner = 'Usage: xmpping.rb [-d] [-a ACCOUNT] [-c FILENAME] [-i SECONDS] -t <JID>'
+  opts.separator 'Ping a destination JID with various <iq/> stanzas'
+  opts.on('-t', '--to JID', 'Destionation Jabber-ID') { |j| jid = Jabber::JID.new(j) }
+  opts.on('-a', '--account ACCOUNT', 'Account tag to use (default: default)') { |a| accountname = a }
+  opts.on('-c', '--config FILENAME', 'Configuration file (default: ~/.xmppingrc)') { |c| conf_filename = c }
+  opts.on('-i', '--interval SECONDS', 'Wait SECONDS between each stanza (default: 5)') { |sec| interval = sec.to_i }
+  opts.on('-d', '--debug', 'Enable XMPP4R debugging (print stanzas)') { Jabber::debug = true }
+  opts.on_tail('-h', '--help', 'Show help') {
+    puts opts
+    exit
+  }
+  opts.parse!(ARGV)
+
+  unless jid
+    puts opts
+    exit
+  end
+}
+
+
+##
+# Configuration
+##
+
+begin
+  conf_file = File.new(conf_filename)
+rescue Exception => e
+  puts "Unable to open config file: #{e.to_s}"
+  exit
+end
+
+conf = YAML::load(conf_file)
+unless conf
+  puts "#{conf_filename} is no valid YAML document"
+  exit
+end
+account = conf[accountname]
+unless account
+  puts "Account #{accountname} not found in #{conf_filename}"
+  exit
+end
+
+##
+# Connection
+##
+
+if account['http bind']
+  cl = Jabber::HTTPBinding::Client.new(Jabber::JID.new(account['jid']))
+  cl.connect(account['http bind'])
+else
+  cl = Jabber::Client.new(Jabber::JID.new(account['jid']))
+  cl.connect(account['host'], (account['port'] ? account['port'].to_i : 5222))
+end
+cl.auth(account['password'])
+
+##
+# Reply printer
+##
+
+def print_reply(iq, roundtrip)
+  roundtrip_s = ((roundtrip * 100).round / 100.0).to_s + " sec"
+  output = "Received a #{iq.query.namespace} #{iq.type} (id: #{iq.id}) from #{iq.from} (#{roundtrip_s}): "
+
+  if iq.query.kind_of?(Jabber::Version::IqQueryVersion)
+    output += "#{iq.query.iname}-#{iq.query.version} #{iq.query.os}"
+  elsif iq.query.namespace == 'jabber:iq:time'
+    output += "#{iq.query.first_element_text('display')} (#{iq.query.first_element_text('tz')})"
+  elsif iq.query.kind_of?(Jabber::Discovery::IqQueryDiscoInfo)
+    identity = iq.query.identity
+    if identity
+      output += "#{identity.iname} (#{identity.category} #{identity.type})"
+    else
+      output += "<identity/> missing"
+    end
+  else
+    output += iq.query.to_s
+  end
+
+  puts output
+end
+
+##
+# Main loop
+##
+
+  require 'mprofiler'
+  MemoryProfiler.start(:string_debug=>true)
+
+puts "XMPPING #{cl.jid} -> #{jid}"
+query_methods = ['jabber:iq:version', 'jabber:iq:time', 'http://jabber.org/protocol/disco#info']
+query_method = 0
+
+loop {
+  Thread.new {
+    iq = Jabber::Iq.new_query(:get, jid)
+    iq.query.add_namespace(query_methods[query_method])
+
+    time1 = Time.new
+
+    begin
+      cl.send_with_id(iq) { |reply|
+        print_reply(reply, Time.new - time1)
+        true
+      }
+    rescue Jabber::ServerError => e
+      puts "Error for #{iq.query.namespace} to #{iq.to}: #{e.error.to_s.inspect}"
+    end
+  }
+
+  query_method += 1
+  if query_method >= query_methods.size
+    query_method = 0
+  end
+
+  sleep(interval)
+}

data/lib/vendor/xmpp4r/data/doc/xmpp4r/examples/advanced/xmppingrc.sample

@@ -0,0 +1,14 @@
+default:
+  jid: user@host/xmpping
+  password: secret
+
+other_account:
+  jid: me@domain/ping
+  password: xxx
+  host: 127.0.0.1
+  port: 65222
+
+web_account:
+  jid: me@domain/ping
+  password: xxx
+  http bind: http://domain/http-bind/

data/lib/vendor/xmpp4r/data/doc/xmpp4r/examples/basic/change_password.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/ruby
+#
+# A tool to change the password of a Jabber account
+#
+
+
+$:.unshift('../../../../../lib')
+
+require 'xmpp4r'
+include Jabber
+
+def with_status(str, &block)
+  print "#{str}..."
+  $stdout.flush
+  begin
+    yield
+    puts " Ok"
+  rescue Exception => e
+    puts " Exception: #{e.to_s}"
+    raise e
+  end
+end
+
+
+# settings
+if ARGV.length != 3
+  puts "Run with ./change_password.rb user@server/resource oldpassword newpassword"
+  exit 1
+end
+my_jid = JID.new(ARGV[0])
+my_jid.resource = 'change_password' if my_jid.resource.nil?
+old_password = ARGV[1]
+new_password = ARGV[2]
+
+cl = Client.new(my_jid)
+
+with_status('Connecting') { cl.connect }
+with_status('Authenticating') { cl.auth(old_password) }
+with_status('Changing password') { cl.password = new_password }
+
+cl.close

data/lib/vendor/xmpp4r/data/doc/xmpp4r/examples/basic/client.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/ruby
+
+# Basic console client that does nothing, but easy to modify to test things.
+# to test, start, then type :
+# connect login@server/resource password
+# auth
+
+$:.unshift '../../../../../lib'
+
+require 'xmpp4r/client'
+include Jabber
+
+Jabber::debug = true
+
+class BasicClient
+  def initialize
+    puts "Welcome to this Basic Console Jabber Client!"
+    quit = false
+    # main loop
+    while not quit do
+      print "> "
+      $defout.flush
+      line = gets
+      quit = true if line.nil?
+      if not quit
+        command, args = line.split(' ', 2)
+        args = args.to_s.chomp
+        # main case
+        case command
+        when 'exit'
+          quit = true
+        when 'connect'
+          do_connect(args)
+        when 'help'
+          do_help
+        when 'auth'
+          do_auth
+        else
+          puts "Command \"#{command}\" unknown"
+        end
+      end
+    end
+    puts "Goodbye!"
+  end
+
+  def do_help
+    puts <<-EOF
+# exit - exits
+# connect user@server/resource password - connects
+# auth - sends authentification
+    EOF
+  end
+
+  ##
+  # connect <jid> <password>
+  def do_connect(args)
+    @jid, @password = args.split(' ', 2)
+    @jid = JID.new(@jid)
+    @cl = Client.new(@jid)
+    @cl.connect
+  end
+
+  ##
+  # auth
+  def do_auth
+    @cl.auth(@password, false)
+  end
+end
+
+BasicClient.new

data/lib/vendor/xmpp4r/data/doc/xmpp4r/examples/basic/component.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/ruby
+
+$:.unshift '../../../../../lib'
+
+require 'xmpp4r'
+include Jabber
+
+c = Component.new('tada', 'localhost', 60001)
+c.connect
+c.auth('jabber-rocks')
+Thread.stop

data/lib/vendor/xmpp4r/data/doc/xmpp4r/examples/basic/echo.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/ruby
+
+# This bot will reply to every message it receives. To end the game, send 'exit'
+
+$:.unshift '../../../../../lib'
+
+require 'xmpp4r/client'
+include Jabber
+
+# settings
+if ARGV.length != 2
+  puts "Run with ./echo_thread.rb user@server/resource password"
+  exit 1
+end
+myJID = JID.new(ARGV[0])
+myPassword = ARGV[1]
+cl = Client.new(myJID)
+cl.connect
+cl.auth(myPassword)
+cl.send(Presence.new)
+puts "Connected ! send messages to #{myJID.strip.to_s}."
+mainthread = Thread.current
+cl.add_message_callback do |m|
+  if m.type != :error
+    m2 = Message.new(m.from, "You sent: #{m.body}")
+    m2.type = m.type
+    cl.send(m2)
+    if m.body == 'exit'
+      m2 = Message.new(m.from, "Exiting ...")
+      m2.type = m.type
+      cl.send(m2)
+      mainthread.wakeup
+    end
+  end
+end
+Thread.stop
+cl.close