def plugin_init(self): self.xmpp.register_feature('preapproval', self._handle_preapproval, restart=False, order=9001) register_stanza_plugin(StreamFeatures, stanza.PreApproval)
def plugin_init(self): register_stanza_plugin(Presence, LastActivity) self.xmpp.add_filter('out', self._initial_presence_activity) self.xmpp.add_event_handler('connected', self._reset_presence_activity) self._initial_presence = set()
def plugin_init(self): register_stanza_plugin(self.xmpp['xep_0060'].stanza.Item, Bookmarks) self.xmpp['xep_0049'].register(Bookmarks) self.xmpp['xep_0163'].register_pep('bookmarks', Bookmarks) self.xmpp.add_event_handler('session_start', self._autojoin)
def plugin_init(self): self._idle_stamps = {} register_stanza_plugin(Presence, stanza.Idle) self.api.register(self._set_idle, "set_idle", default=True) self.api.register(self._get_idle, "get_idle", default=True) self.xmpp.register_handler(Callback("Idle Presence", StanzaPath("presence/idle"), self._idle_presence)) self.xmpp.add_filter("out", self._stamp_idle_presence)
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._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 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): self.xmpp.register_feature('rosterver', self._handle_rosterver, restart=False, order=9000) register_stanza_plugin(StreamFeatures, stanza.RosterVer)
def testPublishSingle(self): """Test publishing a single item.""" payload = AtomEntry() payload['title'] = 'Test' register_stanza_plugin(self.xmpp['xep_0060'].stanza.Item, AtomEntry) self.xmpp['xep_0060'].publish( 'pubsub.example.com', 'somenode', id='id42', payload=payload) self.send(""" <iq type="set" id="1" to="pubsub.example.com"> <pubsub xmlns="http://jabber.org/protocol/pubsub"> <publish node="somenode"> <item id="id42"> <entry xmlns="http://www.w3.org/2005/Atom"> <title>Test</title> </entry> </item> </publish> </pubsub> </iq> """, use_values=False)
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) 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): self.xmpp.namespace_map['http://www.google.com/talk/protocol/auth'] = 'ga' register_stanza_plugin(self.xmpp['feature_mechanisms'].stanza.Auth, stanza.GoogleAuth) self.xmpp.add_filter('out', self._auth)
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 plugin_init(self): self.xmpp.register_handler( Callback('Explicit Message Encryption', StanzaPath('message/eme'), self._handle_eme)) register_stanza_plugin(Message, Encryption)
def plugin_init(self): self.xmpp.register_feature('session', self._handle_start_session, restart=False, order=10001) register_stanza_plugin(Iq, stanza.Session) register_stanza_plugin(StreamFeatures, stanza.Session)
def plugin_init(self): """Start the XEP-0224 plugin.""" register_stanza_plugin(Message, stanza.Attention) self.xmpp.register_handler( Callback('Attention', StanzaPath('message/attention'), self._handle_attention))
def plugin_init(self): self.xmpp.register_feature('bind', self._handle_bind_resource, restart=False, order=10000) register_stanza_plugin(Iq, stanza.Bind) register_stanza_plugin(StreamFeatures, stanza.Bind)
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): self.xmpp.register_handler( Callback('Message Correction', StanzaPath('message/replace'), self._handle_correction)) register_stanza_plugin(Message, Replace) self.xmpp.use_message_ids = True
def _process_command_response(self, iq, session): """ Generate a command reply stanza based on the provided session data. Arguments: iq -- The command request stanza. session -- A dictionary of relevant session data. """ sessionid = session['id'] payload = session['payload'] if payload is None: payload = [] if not isinstance(payload, list): payload = [payload] interfaces = session.get('interfaces', set()) payload_classes = session.get('payload_classes', set()) interfaces.update(set([item.plugin_attrib for item in payload])) payload_classes.update(set([item.__class__ for item in payload])) session['interfaces'] = interfaces session['payload_classes'] = payload_classes self.sessions[sessionid] = session for item in payload: register_stanza_plugin(Command, item.__class__, iterable=True) iq = iq.reply() iq['command']['node'] = session['node'] iq['command']['sessionid'] = session['id'] if session['next'] is None: iq['command']['actions'] = [] iq['command']['status'] = 'completed' elif session['has_next']: actions = ['next'] if session['allow_complete']: actions.append('complete') if session['allow_prev']: actions.append('prev') iq['command']['actions'] = actions iq['command']['status'] = 'executing' else: iq['command']['actions'] = ['complete'] iq['command']['status'] = 'executing' iq['command']['notes'] = session['notes'] for item in payload: iq['command'].append(item) iq.send()
def testInitialPayloadCommand(self): """Test a command with an initial payload.""" class TestPayload(ElementBase): name = "foo" namespace = "test" interfaces = {"bar"} plugin_attrib = name Command = self.xmpp["xep_0050"].stanza.Command register_stanza_plugin(Command, TestPayload, iterable=True) def handle_command(iq, session): initial = session["payload"] logging.debug(initial) new_payload = TestPayload() if initial: new_payload["bar"] = "Received: %s" % initial["bar"] else: new_payload["bar"] = "Failed" logging.debug(initial) session["payload"] = new_payload session["next"] = None session["has_next"] = False return session self.xmpp["xep_0050"].add_command("tester@localhost", "foo", "Do Foo", handle_command) self.recv( """ <iq id="11" type="set" to="tester@localhost" from="foo@bar"> <command xmlns="http://jabber.org/protocol/commands" node="foo" action="execute"> <foo xmlns="test" bar="baz" /> </command> </iq> """ ) self.send( """ <iq id="11" type="result" to="foo@bar"> <command xmlns="http://jabber.org/protocol/commands" node="foo" status="completed" sessionid="_sessionid_"> <foo xmlns="test" bar="Received: baz" /> </command> </iq> """ )
def plugin_init(self): self.xmpp.register_feature('auth', self._handle_auth, restart=False, order=self.order) self.xmpp.add_event_handler('legacy_protocol', self._handle_legacy_protocol) register_stanza_plugin(Iq, stanza.IqAuth) register_stanza_plugin(StreamFeatures, stanza.AuthFeature)
def plugin_init(self): register_stanza_plugin(Iq, Request) register_stanza_plugin(Iq, Slot) register_stanza_plugin(Slot, Put) register_stanza_plugin(Slot, Get) register_stanza_plugin(Put, Header, iterable=True) self.xmpp.register_handler( Callback('HTTP Upload Request', StanzaPath('iq@type=get/http_upload_request'), self._handle_request))
def plugin_init(self): self.xmpp.register_handler( Callback('Chat State', StanzaPath('message/chat_state'), self._handle_chat_state)) register_stanza_plugin(Message, stanza.Active) register_stanza_plugin(Message, stanza.Composing) register_stanza_plugin(Message, stanza.Gone) register_stanza_plugin(Message, stanza.Inactive) register_stanza_plugin(Message, stanza.Paused)
def plugin_init(self): """Start the XEP-0203 plugin.""" if not self.local_time: def default_local_time(jid): return xep_0082.datetime(offset=self.tz_offset) self.local_time = default_local_time self.xmpp.register_handler(Callback("Entity Time", StanzaPath("iq/entity_time"), self._handle_time_request)) register_stanza_plugin(Iq, stanza.EntityTime)
def plugin_init(self): """ Start the XEP-0092 plugin. """ if "name" in self.config: self.software_name = self.config["name"] self.xmpp.register_handler( Callback("Software Version", StanzaPath("iq@type=get/software_version"), self._handle_version) ) register_stanza_plugin(Iq, Version)
def _handle_command_complete(self, iq): """ Process a request to finish the execution of command and terminate the workflow. All data related to the command session will be removed. Arguments: iq -- The command completion request. """ node = iq['command']['node'] sessionid = iq['command']['sessionid'] session = self.sessions.get(sessionid) if session: handler = session['next'] interfaces = session['interfaces'] results = [] for stanza in iq['command']['substanzas']: if stanza.plugin_attrib in interfaces: results.append(stanza) if len(results) == 1: results = results[0] if handler: handler(results, session) del self.sessions[sessionid] payload = session['payload'] if payload is None: payload = [] if not isinstance(payload, list): payload = [payload] for item in payload: register_stanza_plugin(Command, item.__class__, iterable=True) iq = iq.reply() iq['command']['node'] = node iq['command']['sessionid'] = sessionid iq['command']['actions'] = [] iq['command']['status'] = 'completed' iq['command']['notes'] = session['notes'] for item in payload: iq['command'].append(item) iq.send() else: raise XMPPError('item-not-found')
def plugin_init(self): register_stanza_plugin(Iq, Confirm) register_stanza_plugin(Message, Confirm) self.xmpp.register_handler( Callback('Confirm', StanzaPath('iq@type=get/confirm'), self._handle_iq_confirm)) self.xmpp.register_handler( Callback('Confirm', StanzaPath('message/confirm'), self._handle_message_confirm))
def plugin_init(self): """ Start the XEP-0092 plugin. """ if 'name' in self.config: self.software_name = self.config['name'] self.xmpp.register_handler( Callback('Software Version', StanzaPath('iq@type=get/software_version'), self._handle_version)) register_stanza_plugin(Iq, Version)
def plugin_init(self): """Start the XEP-0352 plugin.""" self.enabled = False register_stanza_plugin(StreamFeatures, ClientStateIndication) self.xmpp.register_stanza(stanza.Active) self.xmpp.register_stanza(stanza.Inactive) self.xmpp.register_feature('csi', self._handle_csi_feature, restart=False, order=self.order)
def plugin_init(self): self.hashes = {'sha-1': hashlib.sha1, 'sha1': hashlib.sha1, 'md5': hashlib.md5} if self.caps_node is None: self.caps_node = 'http://slixmpp.com/ver/%s' % __version__ if self.cache is None: self.cache = MemoryCache() register_stanza_plugin(Presence, stanza.Capabilities) register_stanza_plugin(StreamFeatures, stanza.Capabilities) self._disco_ops = ['cache_caps', 'get_caps', 'assign_verstring', 'get_verstring', 'supports', 'has_identity'] self.xmpp.register_handler( Callback('Entity Capabilites', StanzaPath('presence/caps'), self._handle_caps)) self.xmpp.add_filter('out', self._filter_add_caps) self.xmpp.add_event_handler('entity_caps', self._process_caps) if not self.xmpp.is_component: self.xmpp.register_feature('caps', self._handle_caps_feature, restart=False, order=10010) disco = self.xmpp['xep_0030'] self.static = StaticCaps(self.xmpp, disco.static) for op in self._disco_ops: self.api.register(getattr(self.static, op), op, default=True) for op in ('supports', 'has_identity'): self.xmpp['xep_0030'].api.register(getattr(self.static, op), op) self._run_node_handler = disco._run_node_handler disco.cache_caps = self.cache_caps disco.update_caps = self.update_caps disco.assign_verstring = self.assign_verstring disco.get_verstring = self.get_verstring
def plugin_init(self): self._idle_stamps = {} register_stanza_plugin(Presence, stanza.Idle) self.api.register(self._set_idle, 'set_idle', default=True) self.api.register(self._get_idle, 'get_idle', default=True) self.xmpp.register_handler( Callback('Idle Presence', StanzaPath('presence/idle'), self._idle_presence)) self.xmpp.add_filter('out', self._stamp_idle_presence)
def plugin_init(self): """ Start the XEP-0059 plugin. """ register_stanza_plugin(self.xmpp['xep_0030'].stanza.DiscoItems, self.stanza.Set)
def setUp(self): register_stanza_plugin(Message, stanza.Reactions) register_stanza_plugin(stanza.Reactions, stanza.Reaction)
result = [] senders = self.xml.findall('{%s}senders/{%s}sender' % (self.namespace, self.namespace)) for sender in senders: result.append(MailSender(xml=sender)) return result class MailSender(ElementBase): namespace = 'google:mail:notify' name = 'sender' plugin_attrib = name interfaces = set(['address', 'name', 'originator', 'unread']) def get_originator(self): return self.xml.attrib.get('originator', '0') == '1' def get_unread(self): return self.xml.attrib.get('unread', '0') == '1' class NewMail(ElementBase): namespace = 'google:mail:notify' name = 'new-mail' plugin_attrib = 'gmail_notification' register_stanza_plugin(MailBox, MailThread, iterable=True)
def plugin_init(self): register_stanza_plugin(Message, Store) register_stanza_plugin(Message, NoStore) register_stanza_plugin(Message, NoPermanentStore) register_stanza_plugin(Message, NoCopy)
def register_plugins(): register_stanza_plugin(Iq, ClientJoin) register_stanza_plugin(ClientJoin, Join) register_stanza_plugin(Iq, ClientLeave) register_stanza_plugin(ClientLeave, Leave) register_stanza_plugin(Roster, Annotate) register_stanza_plugin(RosterItem, Channel)
def __init__(self, jid, password): ''' x ''' slixmpp.ClientXMPP.__init__(self, jid, password) import os, binascii self.requested_jid.resource = binascii.b2a_hex(os.urandom(4)) # register pluginss self.register_plugin('xep_0030') # RPC self.register_plugin('xep_0060') # PubSub self.register_plugin('xep_0199', { 'keepalive': True, 'frequency': 60 }) # ping register_stanza_plugin(Iq, RPCQuery) register_stanza_plugin(RPCQuery, MethodCall) register_stanza_plugin(RPCQuery, MethodResponse) register_stanza_plugin(Message, Event) register_stanza_plugin(Event, EventItems) register_stanza_plugin(EventItems, EventItem, iterable=True) register_stanza_plugin(EventItem, ItemUpdate) # handle session_start and message events self.add_event_handler("session_start", self.start) self.add_event_handler("roster_update", self.roster_callback) self.add_event_handler("pubsub_publish", self.pub_sub_callback) self.add_event_handler("failed_auth", self.failed_auth)
def __init__(self, jid, password, host, port, fahversion, iterations=None, salt=None, reconnect=True): """ x """ slixmpp.ClientXMPP.__init__(self, jid, password, sasl_mech='SCRAM-SHA-1') self.fahversion = fahversion self.x_jid = jid self._host = host self._port = port self.reconnect = reconnect LOG.info(' version: %s', self.fahversion) self.password = password self.iterations = iterations self.salt = salt if version.parse(self.fahversion) >= version.parse("2.3.0"): self.saslhandler = SaslHandler(self, self.x_jid, self.password, self.iterations, self.salt) import os import binascii self.requested_jid.resource = binascii.b2a_hex(os.urandom(4)) # handle session_start and message events self.add_event_handler("session_start", self.start) self.add_event_handler("roster_update", self.roster_callback) self.add_event_handler("pubsub_publish", self.pub_sub_callback) self.add_event_handler("failed_auth", self.failed_auth) self.add_event_handler("disconnected", self._disconnected) # register plugins self.register_plugin('xep_0030') # RPC self.register_plugin('xep_0060') # PubSub self.register_plugin('xep_0199', {'keepalive': True, 'frequency': 60}) # ping register_stanza_plugin(Iq, RPCQuery) register_stanza_plugin(RPCQuery, MethodCall) register_stanza_plugin(RPCQuery, MethodResponse) register_stanza_plugin(Message, Event) register_stanza_plugin(Event, EventItems) register_stanza_plugin(EventItems, EventItem, iterable=True) register_stanza_plugin(EventItem, ItemUpdate) register_stanza_plugin(EventItem, ItemUpdateEncrypted)
else: self._set_attr('action', value) def set_presence_in(self, value): keep = True if value else False self._set_sub_text('presence-in', '', keep=keep) def get_presence_in(self): pres = self.xml.find('{%s}presence-in' % self.namespace) return pres is not None def del_presence_in(self): self._del_sub('{%s}presence-in' % self.namespace) def set_presence_out(self, value): keep = True if value else False self._set_sub_text('presence-in', '', keep=keep) def get_presence_out(self): pres = self.xml.find('{%s}presence-in' % self.namespace) return pres is not None def del_presence_out(self): self._del_sub('{%s}presence-in' % self.namespace) register_stanza_plugin(Privacy, Active) register_stanza_plugin(Privacy, Default) register_stanza_plugin(Privacy, List, iterable=True) register_stanza_plugin(List, Item, iterable=True)
interfaces = {'name', 'size', 'date', 'hash', 'desc'} sub_interfaces = {'desc'} def set_size(self, value): self._set_attr('size', str(value)) def get_date(self): timestamp = self._get_attr('date') return xep_0082.parse(timestamp) def set_date(self, value): if isinstance(value, dt.datetime): value = xep_0082.format_datetime(value) self._set_attr('date', value) class Range(ElementBase): name = 'range' namespace = 'http://jabber.org/protocol/si/profile/file-transfer' plugin_attrib = 'range' interfaces = {'length', 'offset'} def set_length(self, value): self._set_attr('length', str(value)) def set_offset(self, value): self._set_attr('offset', str(value)) register_stanza_plugin(File, Range)
""" Slixmpp: The Slick XMPP Library Copyright (C) 2010 Nathanael C. Fritz This file is part of Slixmpp. See the file LICENSE for copying permission. """ from slixmpp.stanza import Message from slixmpp.xmlstream import register_stanza_plugin from slixmpp.plugins.xep_0071 import XHTML_IM as HTMLIM register_stanza_plugin(Message, HTMLIM)
def get_expiry(self): expiry = self._get_attr('expiry') if expiry.lower() == 'presence': return expiry return xep_0082.parse(expiry) def set_expiry(self, value): if isinstance(value, dt.datetime): value = xep_0082.format_datetime(value) self._set_attr('expiry', value) def set_jid(self, value): self._set_attr('jid', str(value)) def get_jid(self): return JID(self._get_attr('jid')) register_stanza_plugin(Message, Event) register_stanza_plugin(Event, EventCollection) register_stanza_plugin(Event, EventConfiguration) register_stanza_plugin(Event, EventPurge) register_stanza_plugin(Event, EventDelete) register_stanza_plugin(Event, EventItems) register_stanza_plugin(Event, EventSubscription) register_stanza_plugin(EventCollection, EventAssociate) register_stanza_plugin(EventCollection, EventDisassociate) register_stanza_plugin(EventConfiguration, Form) register_stanza_plugin(EventItems, EventItem, iterable=True) register_stanza_plugin(EventItems, EventRetract, iterable=True)
""" Cancel element used to signal that a request shall be cancelled """ namespace = 'urn:xmpp:iot:sensordata' name = 'cancel' plugin_attrib = name interfaces = set(['seqnr']) class Cancelled(ElementBase): """ Cancelled element used to signal that cancellation is confirmed """ namespace = 'urn:xmpp:iot:sensordata' name = 'cancelled' plugin_attrib = name interfaces = set(['seqnr']) register_stanza_plugin(Iq, Request) register_stanza_plugin(Request, RequestNode, iterable=True) register_stanza_plugin(Request, RequestField, iterable=True) register_stanza_plugin(Iq, Accepted) register_stanza_plugin(Message, Failure) register_stanza_plugin(Failure, Error) register_stanza_plugin(Iq, Rejected) register_stanza_plugin(Message, Fields) register_stanza_plugin(Fields, FieldsNode, iterable=True) register_stanza_plugin(FieldsNode, Timestamp, iterable=True) register_stanza_plugin(Timestamp, Field, iterable=True) register_stanza_plugin(Timestamp, DataNumeric, iterable=True) register_stanza_plugin(Timestamp, DataString, iterable=True)
from slixmpp import Callback, JID from slixmpp.exceptions import XMPPError from slixmpp.stanza import Iq, roster as roster_stanza from slixmpp.xmlstream import register_stanza_plugin from .matcher import ServerStanzaPath register_stanza_plugin(Iq, roster_stanza.Roster) class Roster(object): def __init__(self, stream): self.stream = stream self.interested = False self.cached = None self.delay_pushes = 0 self.delayed_pushes = [] stream.register_plugin('feature_preapproval') # TBD: should we try to support roster versioning? stream.register_handler( Callback('Roster', ServerStanzaPath('iq/roster'), self._handle_roster)) def _handle_roster(self, iq): iq['from'] = self.stream.boundjid type = iq['type'] if type == 'get': self.interested = True self.stream.loop.create_task(self._get_roster(iq)) elif type == 'set': self.stream.loop.create_task(self._set_roster(iq))
def set_publish_options(self, value): if value is None: self.del_publish_options() else: self.xml.append(value.getXML()) return self def del_publish_options(self): config = self.xml.find('{jabber:x:data}x') if config is not None: self.xml.remove(config) self.parent().xml.remove(self.xml) register_stanza_plugin(Iq, Pubsub) register_stanza_plugin(Pubsub, Affiliations) register_stanza_plugin(Pubsub, Configure) register_stanza_plugin(Pubsub, Create) register_stanza_plugin(Pubsub, Default) register_stanza_plugin(Pubsub, Items) register_stanza_plugin(Pubsub, Options) register_stanza_plugin(Pubsub, Publish) register_stanza_plugin(Pubsub, PublishOptions) register_stanza_plugin(Pubsub, Retract) register_stanza_plugin(Pubsub, Subscribe) register_stanza_plugin(Pubsub, Subscription) register_stanza_plugin(Pubsub, Subscriptions) register_stanza_plugin(Pubsub, Unsubscribe) register_stanza_plugin(Affiliations, Affiliation, iterable=True) register_stanza_plugin(Configure, xep_0004.Form)
def plugin_init(self): register_stanza_plugin(self.xmpp['xep_0095'].stanza.SI, File) self.xmpp['xep_0095'].register_profile(File.namespace, self)
def plugin_init(self): """Start the XEP-0203 plugin.""" register_stanza_plugin(Message, stanza.Delay) register_stanza_plugin(Presence, stanza.Delay)
def plugin_init(self) -> None: # XXX: This should be MucMessage. Someday.. register_stanza_plugin(Message, OccupantId)
def plugin_init(self): register_stanza_plugin(Iq, stanza.Preferences)
def plugin_init(self): register_stanza_plugin(FormField, Media)
def plugin_init(self): register_stanza_plugin(Message, stanza.AMP) register_stanza_plugin(Error, stanza.InvalidRules) register_stanza_plugin(Error, stanza.UnsupportedConditions) register_stanza_plugin(Error, stanza.UnsupportedActions) register_stanza_plugin(Error, stanza.FailedRules) self.xmpp.register_handler( Callback( 'AMP Response', MatchMany([ StanzaPath('message/error/failed_rules'), StanzaPath('message/amp') ]), self._handle_amp_response)) if not self.xmpp.is_component: self.xmpp.register_feature('amp', self._handle_amp_feature, restart=False, order=9000) register_stanza_plugin(StreamFeatures, stanza.AMPFeature)
name = 'media' namespace = 'urn:xmpp:media-element' plugin_attrib = 'media' interfaces = set(['height', 'width', 'alt']) def add_uri(self, value, itype): uri = URI() uri['value'] = value uri['type'] = itype self.append(uri) class URI(ElementBase): name = 'uri' namespace = 'urn:xmpp:media-element' plugin_attrib = 'uri' plugin_multi_attrib = 'uris' interfaces = set(['type', 'value']) def get_value(self): return self.xml.text def set_value(self, value): self.xml.text = value def del_value(self): sel.xml.text = '' register_stanza_plugin(Media, URI, iterable=True)
def plugin_init(self): register_stanza_plugin(Message, Addresses) register_stanza_plugin(Presence, Addresses)
def plugin_init(self): register_stanza_plugin(Block, stanza.Report) register_stanza_plugin(stanza.Report, stanza.Text)
def plugin_init(self): register_stanza_plugin(Message, SecurityLabel) register_stanza_plugin(Iq, Catalog)
def __init__(self, jid, password): slixmpp.ClientXMPP.__init__(self, jid, password) # register plugins self.register_plugin('xep_0030') # RPC self.register_plugin('xep_0060') # PubSub self.register_plugin('xep_0199', {'keepalive': True, 'frequency': 60}) register_stanza_plugin(Iq, RPCQuery) register_stanza_plugin(RPCQuery, MethodCall) register_stanza_plugin(RPCQuery, MethodResponse) register_stanza_plugin(Message, Event) register_stanza_plugin(Event, EventItems) register_stanza_plugin(EventItems, EventItem, iterable=True) register_stanza_plugin(EventItem, ItemUpdate) # handle session_start and message events self.add_event_handler("session_start", self.start) self.add_event_handler("message", self.message) self.add_event_handler("roster_update_complete", self.roster_callback) self.add_event_handler("pubsub_publish", self.pub_sub_callback)
def plugin_init(self): register_stanza_plugin(Iq, stanza.Offline) register_stanza_plugin(Message, stanza.Offline)
def register_plugins(): register_stanza_plugin(Iq, ClientJoin) register_stanza_plugin(ClientJoin, Join) register_stanza_plugin(Iq, ClientLeave) register_stanza_plugin(ClientLeave, Leave)
def plugin_init(self): """Start the XEP-0198 plugin.""" # Only enable stream management for non-components, # since components do not yet perform feature negotiation. if self.xmpp.is_component: return self.window_counter = self.window self.window_counter_lock = threading.Lock() self.enabled = threading.Event() self.unacked_queue = collections.deque() self.seq_lock = threading.Lock() self.handled_lock = threading.Lock() self.ack_lock = threading.Lock() register_stanza_plugin(StreamFeatures, stanza.StreamManagement) self.xmpp.register_stanza(stanza.Enable) self.xmpp.register_stanza(stanza.Enabled) self.xmpp.register_stanza(stanza.Resume) self.xmpp.register_stanza(stanza.Resumed) self.xmpp.register_stanza(stanza.Ack) self.xmpp.register_stanza(stanza.RequestAck) # Only end the session when a </stream> element is sent, # not just because the connection has died. self.xmpp.end_session_on_disconnect = False # Register the feature twice because it may be ordered two # different ways: enabling after binding and resumption # before binding. self.xmpp.register_feature('sm', self._handle_sm_feature, restart=True, order=self.order) self.xmpp.register_feature('sm', self._handle_sm_feature, restart=True, order=self.resume_order) self.xmpp.register_handler( Callback('Stream Management Enabled', MatchXPath(stanza.Enabled.tag_name()), self._handle_enabled, instream=True)) self.xmpp.register_handler( Callback('Stream Management Resumed', MatchXPath(stanza.Resumed.tag_name()), self._handle_resumed, instream=True)) self.xmpp.register_handler( Callback('Stream Management Failed', MatchXPath(stanza.Failed.tag_name()), self._handle_failed, instream=True)) self.xmpp.register_handler( Callback('Stream Management Ack', MatchXPath(stanza.Ack.tag_name()), self._handle_ack, instream=True)) self.xmpp.register_handler( Callback('Stream Management Request Ack', MatchXPath(stanza.RequestAck.tag_name()), self._handle_request_ack, instream=True)) self.xmpp.add_filter('in', self._handle_incoming) self.xmpp.add_filter('out_sync', self._handle_outgoing) self.xmpp.add_event_handler('session_end', self.session_end)
def plugin_init(self): register_stanza_plugin(Iq, Certs) register_stanza_plugin(Iq, AppendCert) register_stanza_plugin(Iq, DisableCert) register_stanza_plugin(Iq, RevokeCert)
def plugin_init(self): register_stanza_plugin(Iq, IPCheck)