def plugin_init(self):
self._cids = {}
self.xmpp['xep_0030'].add_feature('urn:xmpp:bob')
register_stanza_plugin(Iq, BitsOfBinary)
self.xmpp.register_handler(
Callback('Bits of Binary - Iq',
StanzaPath('iq/bob'),
self._handle_bob_iq))
self.xmpp.register_handler(
Callback('Bits of Binary - Message',
StanzaPath('message/bob'),
self._handle_bob))
self.xmpp.register_handler(
Callback('Bits of Binary - Presence',
StanzaPath('presence/bob'),
self._handle_bob))
self.api.register(self._get_bob, 'get_bob', default=True)
self.api.register(self._set_bob, 'set_bob', default=True)
self.api.register(self._del_bob, 'del_bob', default=True)
def plugin_init(self):
self.gpg = GPG(gnupghome=self.gpg_home,
gpgbinary=self.gpg_binary,
use_agent=self.use_agent,
keyring=self.keyring)
self.xmpp.add_filter('out', self._sign_presence)
self._keyids = {}
self.api.register(self._set_keyid, 'set_keyid', default=True)
self.api.register(self._get_keyid, 'get_keyid', default=True)
self.api.register(self._del_keyid, 'del_keyid', default=True)
self.api.register(self._get_keyids, 'get_keyids', default=True)
register_stanza_plugin(Presence, Signed)
register_stanza_plugin(Message, Encrypted)
self.xmpp.add_event_handler('unverified_signed_presence',
self._handle_unverified_signed_presence,
threaded=True)
self.xmpp.register_handler(
Callback('Signed Presence',
StanzaPath('presence/signed'),
self._handle_signed_presence))
self.xmpp.register_handler(
Callback('Encrypted Message',
StanzaPath('message/encrypted'),
self._handle_encrypted_message))
def plugin_init(self):
""" Start the XEP-0325 plugin """
self.xmpp.register_handler(
Callback('Control Event:DirectSet',
StanzaPath('message/set'),
self._handle_direct_set))
self.xmpp.register_handler(
Callback('Control Event:SetReq',
StanzaPath('iq@type=set/set'),
self._handle_set_req))
self.xmpp.register_handler(
Callback('Control Event:SetResponse',
StanzaPath('iq@type=result/setResponse'),
self._handle_set_response))
self.xmpp.register_handler(
Callback('Control Event:SetResponseError',
StanzaPath('iq@type=error/setResponse'),
self._handle_set_response))
# Server side dicts
self.nodes = {}
self.sessions = {}
self.last_seqnr = 0
self.seqnr_lock = Lock()
## For testning only
self.test_authenticated_from = ""
def plugin_init(self):
register_stanza_plugin(Iq, RPCQuery)
register_stanza_plugin(RPCQuery, MethodCall)
register_stanza_plugin(RPCQuery, MethodResponse)
self.xmpp.registerHandler(
Callback('RPC Call', MatchXPath('{%s}iq/{%s}query/{%s}methodCall' % (self.xmpp.default_ns, RPCQuery.namespace, RPCQuery.namespace)),
self._handle_method_call)
)
self.xmpp.registerHandler(
Callback('RPC Call', MatchXPath('{%s}iq/{%s}query/{%s}methodResponse' % (self.xmpp.default_ns, RPCQuery.namespace, RPCQuery.namespace)),
self._handle_method_response)
)
self.xmpp.registerHandler(
Callback('RPC Call', MatchXPath('{%s}iq/{%s}error' % (self.xmpp.default_ns, self.xmpp.default_ns)),
self._handle_error)
)
self.xmpp.add_event_handler('jabber_rpc_method_call', self._on_jabber_rpc_method_call)
self.xmpp.add_event_handler('jabber_rpc_method_response', self._on_jabber_rpc_method_response)
self.xmpp.add_event_handler('jabber_rpc_method_fault', self._on_jabber_rpc_method_fault)
self.xmpp.add_event_handler('jabber_rpc_error', self._on_jabber_rpc_error)
self.xmpp.add_event_handler('error', self._handle_error)
#self.activeCalls = []
self.xmpp['xep_0030'].add_feature('jabber:iq:rpc')
self.xmpp['xep_0030'].add_identity('automation','rpc')
def plugin_init(self):
self.streams = {}
self.pending_streams = {3: 5}
self.pending_close_streams = {}
self._stream_lock = threading.Lock()
self.max_block_size = self.config.get('max_block_size', 8192)
self.window_size = self.config.get('window_size', 1)
self.auto_accept = self.config.get('auto_accept', True)
self.accept_stream = self.config.get('accept_stream', None)
register_stanza_plugin(Iq, Open)
register_stanza_plugin(Iq, Close)
register_stanza_plugin(Iq, Data)
self.xmpp.register_handler(
Callback('IBB Open', StanzaPath('iq@type=set/ibb_open'),
self._handle_open_request))
self.xmpp.register_handler(
Callback('IBB Close', StanzaPath('iq@type=set/ibb_close'),
self._handle_close))
self.xmpp.register_handler(
Callback('IBB Data', StanzaPath('iq@type=set/ibb_data'),
self._handle_data))
self.xmpp['xep_0030'].add_feature('http://jabber.org/protocol/ibb')
def __init__(self, hostname, jid, password, room, nick, roompass, loop,
jibri_start_callback, jibri_stop_callback,
jibri_health_callback, recording_lock, signal_queue):
sleekxmpp.ClientXMPP.__init__(self, jid, password)
self.hostname = hostname
self.room = room
self.nick = nick
self.roompass = roompass
self.jid = jid
self.jibri_start_callback = jibri_start_callback
self.jibri_stop_callback = jibri_stop_callback
self.jibri_health_callback = jibri_health_callback
self.iq_callback = self.on_jibri_iq
self.recording_lock = recording_lock
self.queue = signal_queue
self.loop = loop
self.controllerJid = ''
self.add_event_handler("session_start", self.start)
self.add_event_handler("muc::%s::got_online" % self.room,
self.muc_online)
self.register_handler(
Callback('Jibri IQ callback', StanzaPath('iq@type=set/jibri'),
self.on_jibri_iq))
self.xmpp.register_handler(
Callback('Disco Info', StanzaPath('iq/disco_info'),
self.handle_disco_info))
register_stanza_plugin(Iq, JibriElement)
register_stanza_plugin(Iq, JibriStatusElement)
def plugin_init(self):
self.node_event_map = {}
self.xmpp.register_handler(
Callback('Pubsub Event: Items',
StanzaPath('message/pubsub_event/items'),
self._handle_event_items))
self.xmpp.register_handler(
Callback('Pubsub Event: Purge',
StanzaPath('message/pubsub_event/purge'),
self._handle_event_purge))
self.xmpp.register_handler(
Callback('Pubsub Event: Delete',
StanzaPath('message/pubsub_event/delete'),
self._handle_event_delete))
self.xmpp.register_handler(
Callback('Pubsub Event: Configuration',
StanzaPath('message/pubsub_event/configuration'),
self._handle_event_configuration))
self.xmpp.register_handler(
Callback('Pubsub Event: Subscription',
StanzaPath('message/pubsub_event/subscription'),
self._handle_event_subscription))
self.xmpp['xep_0131'].supported_headers.add('SubID')
def plugin_init(self):
self.streams = {}
self.pending_streams = {}
self.pending_close_streams = {}
self._stream_lock = threading.Lock()
register_stanza_plugin(Iq, Open)
register_stanza_plugin(Iq, Close)
register_stanza_plugin(Iq, Data)
register_stanza_plugin(Message, Data)
self.xmpp.register_handler(
Callback('IBB Open', StanzaPath('iq@type=set/ibb_open'),
self._handle_open_request))
self.xmpp.register_handler(
Callback('IBB Close', StanzaPath('iq@type=set/ibb_close'),
self._handle_close))
self.xmpp.register_handler(
Callback('IBB Data', StanzaPath('iq@type=set/ibb_data'),
self._handle_data))
self.xmpp.register_handler(
Callback('IBB Message Data', StanzaPath('message/ibb_data'),
self._handle_data))
def plugin_init(self):
"""
Start the XEP-0030 plugin.
"""
self.xmpp.register_handler(
Callback('Disco Info',
StanzaPath('iq/disco_info'),
self._handle_disco_info))
self.xmpp.register_handler(
Callback('Disco Items',
StanzaPath('iq/disco_items'),
self._handle_disco_items))
register_stanza_plugin(Iq, DiscoInfo)
register_stanza_plugin(Iq, DiscoItems)
self.static = StaticDisco(self.xmpp, self)
self.use_cache = self.config.get('use_cache', True)
self.wrap_results = self.config.get('wrap_results', False)
self._disco_ops = [
'get_info', 'set_info', 'set_identities', 'set_features',
'get_items', 'set_items', 'del_items', 'add_identity',
'del_identity', 'add_feature', 'del_feature', 'add_item',
'del_item', 'del_identities', 'del_features', 'cache_info',
'get_cached_info', 'supports', 'has_identity']
for op in self._disco_ops:
self.api.register(getattr(self.static, op), op, default=True)
def __init__(self, sjid, password, room, nick, leaderboard):
"""Initialize EcheLOn."""
sleekxmpp.ClientXMPP.__init__(self, sjid, password)
self.whitespace_keepalive = False
self.sjid = sleekxmpp.jid.JID(sjid)
self.room = room
self.nick = nick
self.leaderboard = leaderboard
self.report_manager = ReportManager(self.leaderboard)
register_stanza_plugin(Iq, BoardListXmppPlugin)
register_stanza_plugin(Iq, GameReportXmppPlugin)
register_stanza_plugin(Iq, ProfileXmppPlugin)
self.register_handler(
Callback('Iq Boardlist', StanzaPath('iq@type=get/boardlist'),
self._iq_board_list_handler))
self.register_handler(
Callback('Iq GameReport', StanzaPath('iq@type=set/gamereport'),
self._iq_game_report_handler))
self.register_handler(
Callback('Iq Profile', StanzaPath('iq@type=get/profile'),
self._iq_profile_handler))
self.add_event_handler('session_start', self._session_start)
self.add_event_handler('muc::%s::got_online' % self.room,
self._muc_online)
self.add_event_handler('muc::%s::got_offline' % self.room,
self._muc_offline)
self.add_event_handler('groupchat_message', self._muc_message)
def plugin_init(self):
"""
Start the XEP-0030 plugin.
"""
self.xep = '0030'
self.description = 'Service Discovery'
self.stanza = sleekxmpp.plugins.xep_0030.stanza
self.xmpp.register_handler(
Callback('Disco Info', StanzaPath('iq/disco_info'),
self._handle_disco_info))
self.xmpp.register_handler(
Callback('Disco Items', StanzaPath('iq/disco_items'),
self._handle_disco_items))
register_stanza_plugin(Iq, DiscoInfo)
register_stanza_plugin(Iq, DiscoItems)
self.static = StaticDisco(self.xmpp)
self._disco_ops = [
'get_info', 'set_identities', 'set_features', 'get_items',
'set_items', 'del_items', 'add_identity', 'del_identity',
'add_feature', 'del_feature', 'add_item', 'del_item',
'del_identities', 'del_features'
]
self.default_handlers = {}
self._handlers = {}
for op in self._disco_ops:
self._add_disco_op(op, getattr(self.static, op))
def __init__(self, jid, password, plugin_config={}, plugin_whitelist=[],
escape_quotes=True, sasl_mech=None, lang='en'):
BaseXMPP.__init__(self, jid, 'jabber:client')
self.escape_quotes = escape_quotes
self.plugin_config = plugin_config
self.plugin_whitelist = plugin_whitelist
self.default_port = 5222
self.default_lang = lang
self.credentials = {}
self.password = password
self.stream_header = "<stream:stream to='%s' %s %s %s %s>" % (
self.boundjid.host,
"xmlns:stream='%s'" % self.stream_ns,
"xmlns='%s'" % self.default_ns,
"xml:lang='%s'" % self.default_lang,
"version='1.0'")
self.stream_footer = "</stream:stream>"
self.features = set()
self._stream_feature_handlers = {}
self._stream_feature_order = []
self.dns_service = 'xmpp-client'
#TODO: Use stream state here
self.authenticated = False
self.sessionstarted = False
self.bound = False
self.bindfail = False
self.add_event_handler('connected', self._reset_connection_state)
self.add_event_handler('session_bind', self._handle_session_bind)
self.add_event_handler('roster_update', self._handle_roster)
self.register_stanza(StreamFeatures)
self.register_handler(
Callback('Stream Features',
MatchXPath('{%s}features' % self.stream_ns),
self._handle_stream_features))
self.register_handler(
Callback('Roster Update',
StanzaPath('iq@type=set/roster'),
lambda iq: self.event('roster_update', iq)))
# Setup default stream features
self.register_plugin('feature_starttls')
self.register_plugin('feature_bind')
self.register_plugin('feature_session')
self.register_plugin('feature_rosterver')
self.register_plugin('feature_preapproval')
self.register_plugin('feature_mechanisms')
if sasl_mech:
self['feature_mechanisms'].use_mech = sasl_mech
def __init__(self, sjid, password, room, nick, ratingsbot):
sleekxmpp.ClientXMPP.__init__(self, sjid, password)
self.sjid = sjid
self.room = room
self.nick = nick
self.ratingsBotWarned = False
self.ratingsBot = ratingsbot
# Game collection
self.gameList = GameList()
# Store mapping of nicks and XmppIDs, attached via presence stanza
self.nicks = {}
self.presences = {} # Obselete when XEP-0060 is implemented.
self.lastLeft = ""
register_stanza_plugin(Iq, PlayerXmppPlugin)
register_stanza_plugin(Iq, GameListXmppPlugin)
register_stanza_plugin(Iq, BoardListXmppPlugin)
register_stanza_plugin(Iq, GameReportXmppPlugin)
register_stanza_plugin(Iq, ProfileXmppPlugin)
self.register_handler(
Callback('Iq Player',
StanzaPath('iq/player'),
self.iqhandler,
instream=True))
self.register_handler(
Callback('Iq Gamelist',
StanzaPath('iq/gamelist'),
self.iqhandler,
instream=True))
self.register_handler(
Callback('Iq Boardlist',
StanzaPath('iq/boardlist'),
self.iqhandler,
instream=True))
self.register_handler(
Callback('Iq GameReport',
StanzaPath('iq/gamereport'),
self.iqhandler,
instream=True))
self.register_handler(
Callback('Iq Profile',
StanzaPath('iq/profile'),
self.iqhandler,
instream=True))
self.add_event_handler("session_start", self.start)
self.add_event_handler("muc::%s::got_online" % self.room,
self.muc_online)
self.add_event_handler("muc::%s::got_offline" % self.room,
self.muc_offline)
self.add_event_handler("groupchat_message", self.muc_message)
self.add_event_handler("changed_status", self.presence_change)
def plugin_init(self):
register_stanza_plugin(Iq, BlockList)
register_stanza_plugin(Iq, Block)
register_stanza_plugin(Iq, Unblock)
self.xmpp.register_handler(
Callback('Blocked Contact', StanzaPath('iq@type=set/block'),
self._handle_blocked))
self.xmpp.register_handler(
Callback('Unblocked Contact', StanzaPath('iq@type=set/unblock'),
self._handle_unblocked))
def __init__(self, jid, password, ssl=False, plugin_config={},
plugin_whitelist=[], escape_quotes=True, sasl_mech=None):
BaseXMPP.__init__(self, jid, 'jabber:client')
self.set_jid(jid)
self.escape_quotes = escape_quotes
self.plugin_config = plugin_config
self.plugin_whitelist = plugin_whitelist
self.default_port = 5222
self.credentials = {}
self.password = password
self.stream_header = "<stream:stream to='%s' %s %s version='1.0'>" % (
self.boundjid.host,
"xmlns:stream='%s'" % self.stream_ns,
"xmlns='%s'" % self.default_ns)
self.stream_footer = "</stream:stream>"
self.features = set()
self._stream_feature_handlers = {}
self._stream_feature_order = []
#TODO: Use stream state here
self.authenticated = False
self.sessionstarted = False
self.bound = False
self.bindfail = False
self.add_event_handler('connected', self._handle_connected)
self.add_event_handler('session_bind', self._handle_session_bind)
self.register_stanza(StreamFeatures)
self.register_handler(
Callback('Stream Features',
MatchXPath('{%s}features' % self.stream_ns),
self._handle_stream_features))
self.register_handler(
Callback('Roster Update',
MatchXPath('{%s}iq/{%s}query' % (
self.default_ns,
'jabber:iq:roster')),
self._handle_roster))
# Setup default stream features
self.register_plugin('feature_starttls')
self.register_plugin('feature_bind')
self.register_plugin('feature_session')
self.register_plugin('feature_mechanisms',
pconfig={'use_mech': sasl_mech} if sasl_mech else None)
self.register_plugin('feature_rosterver')
def __init__(self, sjid, password, room, nick):
sleekxmpp.ClientXMPP.__init__(self, sjid, password)
self.sjid = sjid
self.room = room
self.nick = nick
self.ratingListCache = {}
self.ratingCacheReload = True
self.boardListCache = {}
self.boardCacheReload = True
# Init leaderboard object
self.leaderboard = LeaderboardList(room)
# gameReport to leaderboard abstraction
self.reportManager = ReportManager(self.leaderboard)
# Store mapping of nicks and XmppIDs, attached via presence stanza
self.nicks = {}
self.lastLeft = ""
register_stanza_plugin(Iq, PlayerXmppPlugin)
register_stanza_plugin(Iq, BoardListXmppPlugin)
register_stanza_plugin(Iq, GameReportXmppPlugin)
register_stanza_plugin(Iq, ProfileXmppPlugin)
self.register_handler(
Callback('Iq Player',
StanzaPath('iq/player'),
self.iqhandler,
instream=True))
self.register_handler(
Callback('Iq Boardlist',
StanzaPath('iq/boardlist'),
self.iqhandler,
instream=True))
self.register_handler(
Callback('Iq GameReport',
StanzaPath('iq/gamereport'),
self.iqhandler,
instream=True))
self.register_handler(
Callback('Iq Profile',
StanzaPath('iq/profile'),
self.iqhandler,
instream=True))
self.add_event_handler("session_start", self.start)
self.add_event_handler("muc::%s::got_online" % self.room,
self.muc_online)
self.add_event_handler("muc::%s::got_offline" % self.room,
self.muc_offline)
def plugin_init(self):
self.xmpp.register_handler(
Callback('Carbon Received', StanzaPath('message/carbon_received'),
self._handle_carbon_received))
self.xmpp.register_handler(
Callback('Carbon Sent', StanzaPath('message/carbon_sent'),
self._handle_carbon_sent))
register_stanza_plugin(Message, stanza.ReceivedCarbon)
register_stanza_plugin(Message, stanza.SentCarbon)
register_stanza_plugin(Message, stanza.PrivateCarbon)
register_stanza_plugin(Iq, stanza.CarbonEnable)
register_stanza_plugin(Iq, stanza.CarbonDisable)
def plugin_init(self):
self.xmpp.register_handler(
Callback('HTTP Request', StanzaPath('iq/http-req'),
self._handle_request))
self.xmpp.register_handler(
Callback('HTTP Response', StanzaPath('iq/http-resp'),
self._handle_response))
register_stanza_plugin(Iq, HTTPRequest, iterable=True)
register_stanza_plugin(Iq, HTTPResponse, iterable=True)
register_stanza_plugin(HTTPRequest, Headers, iterable=True)
register_stanza_plugin(HTTPRequest, HTTPData, iterable=True)
register_stanza_plugin(HTTPResponse, Headers, iterable=True)
register_stanza_plugin(HTTPResponse, HTTPData, iterable=True)
def plugin_init(self):
register_stanza_plugin(Message, Request)
register_stanza_plugin(Message, Received)
self.xmpp.add_filter('out', self._filter_add_receipt_request)
self.xmpp.register_handler(
Callback('Message Receipt', StanzaPath('message/receipt'),
self._handle_receipt_received))
self.xmpp.register_handler(
Callback('Message Receipt Request',
StanzaPath('message/request_receipt'),
self._handle_receipt_request))
def run(self, payload, instream=False):
"""
Execute the callback function with the matched stanza's
XML contents, instead of the stanza itself.
Overrides BaseHandler.run
Arguments:
payload -- The matched stanza object.
instream -- Force the handler to execute during
stream processing. Used only by prerun.
Defaults to False.
"""
Callback.run(self, payload.xml, instream)
def run(self, payload, instream=False):
"""
Execute the callback function with the matched stanza's
XML contents, instead of the stanza itself.
Overrides BaseHandler.run
Arguments:
payload -- The matched stanza object.
instream -- Force the handler to execute during
stream processing. Used only by prerun.
Defaults to False.
"""
Callback.run(self, payload.xml, instream)
def plugin_init(self):
register_stanza_plugin(Message, stanza.NoSave)
register_stanza_plugin(Iq, stanza.NoSaveQuery)
self.xmpp.register_handler(
Callback('Google Nosave', StanzaPath('iq@type=set/google_nosave'),
self._handle_nosave_change))
def plugin_init(self):
"""Start the XEP-0050 plugin."""
self.xep = '0050'
self.description = 'Ad-Hoc Commands'
self.stanza = stanza
self.threaded = self.config.get('threaded', True)
self.commands = {}
self.sessions = self.config.get('session_db', {})
self.xmpp.register_handler(
Callback("Ad-Hoc Execute", StanzaPath('iq@type=set/command'),
self._handle_command))
register_stanza_plugin(Iq, stanza.Command)
self.xmpp.add_event_handler('command_execute',
self._handle_command_start,
threaded=self.threaded)
self.xmpp.add_event_handler('command_next',
self._handle_command_next,
threaded=self.threaded)
self.xmpp.add_event_handler('command_cancel',
self._handle_command_cancel,
threaded=self.threaded)
self.xmpp.add_event_handler('command_complete',
self._handle_command_complete,
threaded=self.threaded)
def plugin_init(self):
"""Start the XEP-0050 plugin."""
self.threaded = self.config.get('threaded', True)
self.commands = {}
self.sessions = self.config.get('session_db', {})
self.xmpp.register_handler(
Callback("Ad-Hoc Execute", StanzaPath('iq@type=set/command'),
self._handle_command))
register_stanza_plugin(Iq, Command)
register_stanza_plugin(Command, Form)
self.xmpp.add_event_handler('command_execute',
self._handle_command_start,
threaded=self.threaded)
self.xmpp.add_event_handler('command_next',
self._handle_command_next,
threaded=self.threaded)
self.xmpp.add_event_handler('command_cancel',
self._handle_command_cancel,
threaded=self.threaded)
self.xmpp.add_event_handler('command_complete',
self._handle_command_complete,
threaded=self.threaded)
self.xmpp['xep_0030'].add_feature(Command.namespace)
self.xmpp['xep_0030'].set_items(node=Command.namespace, items=tuple())
def plugin_init(self):
register_stanza_plugin(Iq, stanza.UserSettings)
self.xmpp.register_handler(
Callback('Google Settings',
StanzaPath('iq@type=set/google_settings'),
self._handle_settings_change))
def __init__(self,
jid,
secret,
host=None,
port=None,
plugin_config={},
plugin_whitelist=[],
use_jc_ns=False):
if use_jc_ns:
default_ns = 'jabber:client'
else:
default_ns = 'jabber:component:accept'
BaseXMPP.__init__(self, jid, default_ns)
self.auto_authorize = None
self.stream_header = "<stream:stream %s %s to='%s'>" % (
'xmlns="jabber:component:accept"',
'xmlns:stream="%s"' % self.stream_ns, jid)
self.stream_footer = "</stream:stream>"
self.server_host = host
self.server_port = port
self.secret = secret
self.plugin_config = plugin_config
self.plugin_whitelist = plugin_whitelist
self.is_component = True
self.register_handler(
Callback('Handshake',
MatchXPath('{jabber:component:accept}handshake'),
self._handle_handshake))
self.add_event_handler('presence_probe', self._handle_probe)
def plugin_init(self):
self.xmpp.register_handler(
Callback('Direct MUC Invitations',
StanzaPath('message/groupchat_invite'),
self._handle_invite))
register_stanza_plugin(Message, Invite)
def plugin_init(self):
"""Start the XEP-0050 plugin."""
self.sessions = self.session_db
if self.sessions is None:
self.sessions = {}
self.commands = {}
self.xmpp.register_handler(
Callback("Ad-Hoc Execute", StanzaPath('iq@type=set/command'),
self._handle_command))
register_stanza_plugin(Iq, Command)
register_stanza_plugin(Command, Form, iterable=True)
self.xmpp.add_event_handler('command_execute',
self._handle_command_start,
threaded=self.threaded)
self.xmpp.add_event_handler('command_next',
self._handle_command_next,
threaded=self.threaded)
self.xmpp.add_event_handler('command_cancel',
self._handle_command_cancel,
threaded=self.threaded)
self.xmpp.add_event_handler('command_complete',
self._handle_command_complete,
threaded=self.threaded)
def testIqErrorException(self):
"""Test using error exceptions with Iq stanzas."""
def handle_iq(iq):
raise XMPPError(condition='feature-not-implemented',
text="We don't do things that way here.",
etype='cancel',
clear=False)
self.stream_start()
self.xmpp.register_handler(
Callback('Test Iq',
MatchXPath('{%s}iq/{test}query' % self.xmpp.default_ns),
handle_iq))
self.recv("""
<iq type="get" id="0">
<query xmlns="test" />
</iq>
""")
self.send("""
<iq type="error" id="0">
<query xmlns="test" />
<error type="cancel" code="501">
<feature-not-implemented
xmlns="urn:ietf:params:xml:ns:xmpp-stanzas" />
<text xmlns="urn:ietf:params:xml:ns:xmpp-stanzas">
We don't do things that way here.
</text>
</error>
</iq>
""",
use_values=False)
def start(self):
"""
Démarre le service
"""
xmppDomain = self.configService.value("XMPP_DOMAIN_NAME")
xmppUser = self.configService.value("XMPP_USERNAME")
self.xmpp = ClientXMPP(xmppUser,
self.configService.value("XMPP_PASSWORD"))
# ajout des listeners et plugins
self.xmpp.add_event_handler("session_start", self.session_start)
self.xmpp.register_plugin('XmppMessagePlugin', module=xmpp)
self.xmpp.register_handler(
Callback(
'SEN1 Message',
MatchXPath('{%s}message/{http://xmpp.rocks}Sen1Message' %
self.xmpp.default_ns), self.receiveMessage))
register_stanza_plugin(Message, XmppMessageStanza)
if (not self.xmpp.connect(address=(xmppDomain, 5222))):
raise Exception("Cannot bind XMPP session to {}".format(xmppUser))
self.logger.info(
"Start XMPP protocol : bind session {}...".format(xmppUser))
self.xmpp.process()
def __init__(self):
""" Initializes the CommonTranport with the XEP-0060 support.
"""
ClientXMPP.__init__(self, config['user']['jid'],
config['user']['passwd'])
self.connected = Event()
self.disconnected = Event()
self.rsync_running = Event()
self.rsync_finished = Event()
self.wait_close = False
self.failed_auth = False
# Register and configure pubsub plugin.
self.register_plugin('xep_0060')
self.register_handler(
Callback('Pubsub event', StanzaPath('message/pubsub_event'),
self._pubsub_event))
# Shortcut to access to the xep_0060 plugin.
self.pubsub = self.plugin["xep_0060"]
# Register and configure data form plugin.
self.register_plugin('xep_0004')
# Shortcuts to access to the xep_0004 plugin.
self.form = self.plugin['xep_0004']
# Shortcuts to access to the config server information
self.pubsub_addr = config['server']['pubsub']
self.server_addr = config['server']['master']
# Register events
self.add_event_handler('session_start', self.start)
self.add_event_handler('failed_auth', self._on_failed_auth)
self.add_event_handler('stream_error', self.stream_err)
self.add_event_handler('message', self.message)
self.add_event_handler('message_form', self.message_form)
self.add_event_handler('message_xform', self.message_form)
self.register_handler(
Callback('RsyncFinished Handler',
StanzaPath('iq@type=set/rsyncfinished'),
self._handle_rsync_finished))
eventbus.register('new-rsync', self._on_new_rsync)
