def __init__(self,
serial_number,
access_key,
password,
host="wa2-mz36-qrmzh6.bosch.de",
sasl_mech="DIGEST-MD5"):
"""
:param serial_number:
:param access_key:
:param password:
:param host:
:param sasl_mech:
"""
serial_number = str(serial_number)
self.serial_number = serial_number
self.access_key = access_key
self.password = password
self.encryption = AESCipher(self._magic, access_key, password)
identifier = serial_number + "@" + host
self.jid = jid = self._from = self._rrc_contact_prefix + identifier
self._to = self._rrc_gateway_prefix + identifier
self.client = ClientXMPP(jid=jid,
password=self._accesskey_prefix + access_key,
sasl_mech=sasl_mech)
self.client.add_event_handler("session_start", self.session_start)
self.client.register_plugin('xep_0199')
def __init__(self, config):
super(JabberListener, self).__init__(config)
self.name = config['name']
self.jid = config['jid']
self.password = config['password']
self.host = config['host']
self.port = config['port']
jid_parts = self.jid.split("@")
self.nick = jid_parts[0]
if "pm_list" in config:
self.pm_list = config["pm_list"]
self.pm_filter = True
else:
self.pm_list = []
self.pm_filter = False
if "filter_list" in config:
self.filter_list = config["filter_list"]
self.filter = True
else:
self.filter_list = []
self.filter = False
_log.info("{0} - Initializing Jabber client for: {1}".format(
self.name, self.jid))
self.client = ClientXMPP(self.jid, self.password)
self.client.add_event_handler("session_start", self.onConnect)
self.client.add_event_handler("disconnected", self.onDisconnect)
self.client.add_event_handler("message", self.parseMessage)
self.client.register_plugin("xep_0045") # Multi-User Chat
def setup_xmpp_client(self,
jid: str,
password: str,
proxy: Dict = None) -> ClientXMPP:
"""Setup XMPP client and return its instance.
:param jid: JID provided by HipChat.
:param password: Password provided by HipChat.
:param proxy: Proxy setting in dictionary.
:return: ClientXMPP instance
"""
client = ClientXMPP(jid, password)
if proxy:
client.use_proxy = True
for key in ('host', 'port', 'username', 'password'):
client.proxy_config[key] = proxy.get(key, None)
# TODO check later
# client.add_event_handler('ssl_invalid_cert', lambda cert: True)
client.add_event_handler('session_start', self.session_start)
client.add_event_handler('roster_update', self.join_rooms)
client.add_event_handler('message', self.message)
client.register_plugin('xep_0045')
client.register_plugin('xep_0203')
return client
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 connect(self, config):
"Connect to XMPP server"
socks_cfg = config.get('socks_proxy', required=False)
self.client = ClientXMPP(self.jid, config.password)
proxy_cfg = config.get('http_proxy', required=False)
if proxy_cfg is not None:
self.client.use_proxy = True
self.client.proxy_config = {
'host': proxy_cfg.host,
'port': proxy_cfg.get('port', assert_type=int),
'username': proxy_cfg.get('username', required=False),
'password': proxy_cfg.get('password', required=False),
}
print("Configured proxy", self.client.proxy_config)
use_tls = config.get('tls', default=True)
# Events
self.client.add_event_handler("session_start", self._session_start)
self.client.add_event_handler("message", self.message_dispatch)
log.info("Initializing connection to XMPP")
ip = config.get('ip', required=False)
if ip is not None:
print("port", config.port)
port = config.get('port', default=5222, assert_type=int)
self.client.connect((ip, port), use_tls=use_tls)
else:
self.client.connect(use_tls=use_tls)
def __init__(self, serial_number, access_key, password, host="wa2-mz36-qrmzh6.bosch.de", sasl_mech="SCRAM-SHA-1",
use_ssl=False, use_tls=False):
"""
:param serial_number:
:param access_key:
:param password:
:param host:
:param sasl_mech:
:param use_ssl:
:param use_tls:
"""
serial_number = str(serial_number)
self.serial_number = serial_number
self.access_key = access_key
self.password = password
self.use_ssl = use_ssl
self.use_tls = use_tls
self.encryption = AESCipher(self._magic, access_key, password)
identifier = serial_number + "@" + host
self.jid = jid = self._from = self._rrc_contact_prefix + identifier
self._to = self._rrc_gateway_prefix + identifier
self.client = ClientXMPP(
jid=jid,
password=self._accesskey_prefix + access_key,
sasl_mech=sasl_mech
)
self.client.ssl_version = PROTOCOL_SSLv23
self.client.add_event_handler("session_start", self.session_start)
self.client.register_plugin('xep_0199')
def __init__(self,
jid,
password,
feature=None,
keepalive=None,
ca_cert=None,
server=None,
bot=None):
if feature is None:
feature = {}
self._bot = bot
self.connected = False
self.server = server
self.client = ClientXMPP(jid,
password,
plugin_config={'feature_mechanisms': feature})
self.client.register_plugin('xep_0030') # Service Discovery
self.client.register_plugin('xep_0045') # Multi-User Chat
self.client.register_plugin('xep_0199') # XMPP Ping
self.client.register_plugin('xep_0203') # XMPP Delayed messages
self.client.register_plugin('xep_0249') # XMPP direct MUC invites
if keepalive is not None:
self.client.whitespace_keepalive = True # Just in case SleekXMPP's default changes to False in the future
self.client.whitespace_keepalive_interval = keepalive
self.client.ca_certs = ca_cert # Used for TLS certificate validation
self.client.add_event_handler("session_start", self.session_start)
def connect_to_jabber(self, jabber_id, password):
self.xmpp = ClientXMPP(jabber_id, password)
self.xmpp.reconnect_max_attempts = 1
connected = self.xmpp.connect()
if not connected:
raise XMPPError("Vyanse kwikonecta")
self.xmpp.process()
self.xmpp.send_presence()
self.xmpp.get_roster()
self.xmpp.add_event_handler('message', self.root.handle_xmpp_message)
def __init__(self, config):
super().__init__(config)
self.client = ClientXMPP(config["jid"], config["password"])
self.client.add_event_handler("session_start",
self._xmpp_connected_event)
self.client.add_event_handler("message", self._xmpp_msg_received_event)
self.client.add_event_handler("groupchat_message",
self._xmpp_muc_msg_received_event)
self.client.register_plugin("xep_0045") # Multi-User Chat
def _execute_xmpp(connected_callback):
"""Connects to the XMPP server and executes custom code
:param connected_callback: function to execute after connecting
:return: return value of the callback
"""
from indico_chat.plugin import ChatPlugin
check_config()
jid = ChatPlugin.settings.get('bot_jid')
password = ChatPlugin.settings.get('bot_password')
if '@' not in jid:
jid = '{}@{}'.format(jid, ChatPlugin.settings.get('server'))
result = [None, None] # result, exception
app = current_app._get_current_object() # callback runs in another thread
def _session_start(event):
try:
with app.app_context():
result[0] = connected_callback(xmpp)
except Exception as e:
result[1] = e
if isinstance(e, IqError):
current_plugin.logger.exception('XMPP callback failed: %s',
e.condition)
else:
current_plugin.logger.exception('XMPP callback failed')
finally:
xmpp.disconnect(wait=0)
xmpp = ClientXMPP(jid, password)
xmpp.register_plugin('xep_0045')
xmpp.register_plugin('xep_0004')
xmpp.register_plugin('xep_0030')
xmpp.add_event_handler('session_start', _session_start)
try:
xmpp.connect()
except Exception:
current_plugin.logger.exception('XMPP connection failed')
xmpp.disconnect()
raise
try:
xmpp.process(threaded=False)
finally:
xmpp.disconnect(wait=0)
if result[1] is not None:
raise result[1]
return result[0]
def __init__(self):
settings = Settings('tellduslive.config')
uuid = settings['uuid']
self.xmpp = ClientXMPP('*****@*****.**' % uuid,
'%s:%s' % (Board.getMacAddr(), Board.secret()))
self.xmpp.add_event_handler("session_start", self.sessionStart)
self.xmpp.add_event_handler("register", self.register)
self.xmpp.register_plugin('xep_0030') # Service Discovery
self.xmpp.register_plugin('xep_0077') # In-band registration
self.shuttingDown = False
# Connect is blocking. Do this in a separate thread
threading.Thread(target=self.__start, name='XMPP connector').start()
def connect(self, jid, password):
self.jid = jid
if self.connection == None:
self.connection = ClientXMPP(jid, password)
register_stanza_plugin(Message, WylioStanza)
register_stanza_plugin(WylioStanza, ValueStanza)
self.connection.add_event_handler("connected", self.connected)
self.connection.add_event_handler("session_start", self.start)
self.connection.add_event_handler("failed_auth", self.failed)
self.connection.add_event_handler("disconnected", self.disconnected)
self.connection.add_event_handler("message", self.message)
self.connection.connect(('talk.google.com', 5222))
self.connection.process()
def connect(self, jid, password):
if self.connection == None:
self.connection = ClientXMPP(jid, password)
register_stanza_plugin(Message, WylioStanza)
self.connection.add_event_handler("connected", self.connected)
self.connection.add_event_handler("disconnected", self.disconnected)
self.connection.add_event_handler("failed_auth", self.failed_auth)
self.connection.add_event_handler("session_start", self.start)
self.connection.add_event_handler("message", self.message)
print "connect"
self.connection.connect()
self.connection.process(block=True)
print "connected"
def __init__(self, jid, password, room, nick, address=()):
log.info('creating bot with {} {} {} {} {}'
.format(jid, password, room, nick, address))
self.nick = nick
self.room = room
self.jid = JID(jid)
self._presence_callbacks = []
self._message_callbacks = []
bot = ClientXMPP(jid, password)
# disable ipv6 for now since we're getting errors using it
bot.use_ipv6 = False
# Fix certain Jabber clients not showing messages by giving them an ID
bot.use_message_ids = True
# Don't try to auto reconnect after disconnections (we'll restart the
# process and retry that way)
bot.auto_reconnect = False
bot.add_event_handler('session_start', self.on_start)
bot.add_event_handler('message', self.on_message)
bot.add_event_handler('groupchat_presence', self.on_presence)
bot.add_event_handler('groupchat_subject', self.on_room_joined)
bot.add_event_handler('disconnected', self.on_disconnect)
bot.register_plugin('xep_0045')
self._muc = bot.plugin['xep_0045']
bot.register_plugin('xep_0199')
bot.plugin['xep_0199'].enable_keepalive(5, 10)
self.unknown_command_callback = None
def on_unknown_callback(message):
if self.unknown_command_callback is not None:
return self.unknown_command_callback(message)
self.message_processor = MessageProcessor(on_unknown_callback)
log.info('sb connect')
if bot.connect(address=address, reattempt=False):
log.info('sb process')
bot.process()
else:
log.error('failed to connect at first attempt')
self.on_disconnect(None)
self.add_presence_handler(self.rejoin_if_kicked)
self._bot = bot
def make_xmpp_client(connection_info: LoginConfig):
client = ClientXMPP('%s@%s' % (connection_info.user, connection_info.host),
connection_info.password)
client.use_signals()
# TODO: Make sure all events are handled, and check if we should support other XEPs.
client.register_plugin('xep_0030') # Service Discovery
client.register_plugin('xep_0045') # Multi-User Chat
client.register_plugin('xep_0085') # Chat State Notifications
client.register_plugin('xep_0199') # XMPP Ping
# TODO: Use XEP 0079 to add delivery failure notifications once the sleekxmpp plugin for this XEP is released.
# client.register_plugin('xep_0079') # Advanced Message Processing
return client
def make_client(self):
jid = 'admin@localhost'
password = '******'
client = ClientXMPP(jid, password)
[
client.register_plugin(plugin) for plugin in [
'xep_0030', # Service discovery
'xep_0199', # XMPP Ping
'xep_0133', # Adhoc admin
]
]
client.connect(address=('localhost', self.port))
client.process(block=False)
self.client = client
return client
def main():
startup_q()
jid, password = get_info()
server = ("chat.facebook.com", 5222)
print("Connecting... (it may takes some minutes)")
Loading.start()
threading.Thread(target=kwit).start()
global fbtts
fbtts = ClientXMPP(jid, password)
fbtts.add_event_handler("session_start", session_start)
fbtts.add_event_handler("message", message)
fbtts.auto_reconnect = True
fbtts.connect(server)
fbtts.process(block=True)
def __init__(self, jid, password):
# we set this as an attribute instead of sublcassing because many
# of ClientXMPP's attributes are named something we might accidentally
# overrite (breaking ClientXMPP). it's happened to me quite a bit
self.xmpp = ClientXMPP(jid, password)
self.xmpp.add_event_handler("session_start",
self._session_start_handler)
self.xmpp.add_event_handler("message", self._message_handler)
self.xmpp.register_plugin('xep_0030') # Service Discovery
self.xmpp.register_plugin('xep_0199') # XMPP Ping
self.match_requested = False
self.active_players = {}
self.match_players = []
self.state_machines = {}
def xmpp_connect(config):
bot = ClientXMPP(config.username, config.password)
bot.register_plugin('xep_0045')
muc = bot.plugin['xep_0045']
bot.register_plugin('xep_0199')
ping = bot.plugin['xep_0199']
ping.enable_keepalive(30, 30)
bot.use_ipv6 = False
bot.add_event_handler(
'session_start',
join_rooms_on_connect_handler(bot, muc, config.muc_domain,
config.chats, config.nickname))
bot.add_event_handler('message', on_message_handler(config))
if not bot.connect():
raise 'could not connect'
return bot
def setup_connection(self, configuration):
connection = ClientXMPP(configuration.jid, configuration.password)
# xep_0045 MUC
# xep_0199 XMPP Ping
for plugin in ['xep_0045', 'xep_0199']:
connection.register_plugin(plugin)
for type_, handler in (
('session_start', self.handle_start),
('groupchat_message', self.handle_message),
):
connection.add_event_handler(type_, handler)
connection_result = connection.connect(configuration.server)
server = configuration.server
if not connection_result:
raise Exception('Unable to connect to %s' % (server,))
return connection
def connect(self, config):
"Connect to XMPP server"
socks_cfg = config.get('socks_proxy', required=False)
if socks_cfg is not None:
# TODO: Doesn't work yet. Doesn't implement a makelist
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5,
socks_cfg.get('host', assert_type=str),
socks_cfg.get('port', assert_type=int),
rdns=True)
socket = socks.socksocket
else:
socket = None
self.client = ClientXMPP(self.jid, config.password, socket=socket)
proxy_cfg = config.get('http_proxy', required=False)
if proxy_cfg is not None:
self.client.use_proxy = True
self.client.proxy_config = {
'host': proxy_cfg.host,
'port': proxy_cfg.get('port', assert_type=int),
'username': proxy_cfg.get('username', required=False),
'password': proxy_cfg.get('password', required=False),
}
print("Configured proxy", self.client.proxy_config)
use_tls = config.get('tls', default=True)
# Events
self.client.add_event_handler("session_start", self._session_start)
self.client.add_event_handler("message", self.message_dispatch)
log.info("Initializing connection to XMPP")
ip = config.get('ip', required=False)
if ip is not None:
print("port", config.port)
port = config.get('port', default=5222, assert_type=int)
self.client.connect((ip, port), use_tls=use_tls)
else:
self.client.connect(use_tls=use_tls)
def __init__(self, jid, password):
self.connected = False
self.client = ClientXMPP(
jid,
password,
plugin_config={'feature_mechanisms': XMPP_FEATURE_MECHANISMS})
self.client.register_plugin('xep_0030') # Service Discovery
self.client.register_plugin('xep_0045') # Multi-User Chat
self.client.register_plugin(
'old_0004'
) # Multi-User Chat backward compability (necessary for join room)
self.client.register_plugin('xep_0199') # XMPP Ping
self.client.register_plugin('xep_0203') # XMPP Delayed messages
self.client.register_plugin('xep_0249') # XMPP direct MUC invites
if XMPP_KEEPALIVE_INTERVAL is not None:
self.client.whitespace_keepalive = True # Just in case SleekXMPP's default changes to False in the future
self.client.whitespace_keepalive_interval = XMPP_KEEPALIVE_INTERVAL
self.client.add_event_handler("session_start", self.session_start)
self.client.add_event_handler("ssl_invalid_cert",
self.ssl_invalid_cert)
def stream_start(self,
mode='client',
skip=True,
header=None,
socket='mock',
jid='tester@localhost',
password='******',
server='localhost',
port=5222):
"""
Initialize an XMPP client or component using a dummy XML stream.
Arguments:
mode -- Either 'client' or 'component'. Defaults to 'client'.
skip -- Indicates if the first item in the sent queue (the
stream header) should be removed. Tests that wish
to test initializing the stream should set this to
False. Otherwise, the default of True should be used.
socket -- Either 'mock' or 'live' to indicate if the socket
should be a dummy, mock socket or a live, functioning
socket. Defaults to 'mock'.
jid -- The JID to use for the connection.
Defaults to 'tester@localhost'.
password -- The password to use for the connection.
Defaults to 'test'.
server -- The name of the XMPP server. Defaults to 'localhost'.
port -- The port to use when connecting to the server.
Defaults to 5222.
"""
if mode == 'client':
self.xmpp = ClientXMPP(jid, password)
elif mode == 'component':
self.xmpp = ComponentXMPP(jid, password, server, port)
else:
raise ValueError("Unknown XMPP connection mode.")
if socket == 'mock':
self.xmpp.set_socket(TestSocket())
# Simulate connecting for mock sockets.
self.xmpp.auto_reconnect = False
self.xmpp.is_client = True
self.xmpp.state._set_state('connected')
# Must have the stream header ready for xmpp.process() to work.
if not header:
header = self.xmpp.stream_header
self.xmpp.socket.recv_data(header)
elif socket == 'live':
self.xmpp.socket_class = TestLiveSocket
self.xmpp.connect()
else:
raise ValueError("Unknown socket type.")
self.xmpp.register_plugins()
self.xmpp.process(threaded=True)
if skip:
# Clear startup stanzas
self.xmpp.socket.next_sent(timeout=1)
if mode == 'component':
self.xmpp.socket.next_sent(timeout=1)
def testFunction(domain_url):
status, briefing, message, answers = xmppServerAddressRecordLookup(
domain_url)
if (status != 0):
status = 2
briefing = "This test was skipped because previous test "
briefing += "<strong>xmpp_server_a_lookup</strong> has failed.<br/>"
new_message = briefing
new_message += "Reason:<br/>"
new_message += "<br/>" + message
return (status, briefing, new_message, None)
reachable = []
unreachable = []
for answer in answers:
xmpp_client = ClientXMPP("inspect@buddycloud", "ei3tseq")
if (xmpp_client.connect((answer['address'], int(answer['port'])),
reattempt=False,
use_ssl=False,
use_tls=False)):
reachable.append("%(domain)s = %(address)s:%(port)s" % answer)
else:
unreachable.append("%(domain)s = %(address)s:%(port)s" % answer)
if len(reachable) == 0:
status = 1
briefing = "Could not connect to all XMPP servers specified: "
briefing += "<strong>" + string.join(unreachable, " | ") + "</strong>"
message = "We could not connect to all XMPP servers specified!<br/>"
message += "<strong><br/>" + string.join(unreachable,
"<br/>") + "<br/></strong>"
message += "<br/>Please make sure your XMPP server which will have the buddycloud XMPP component"
message += " is up and running on the correct port and try again.<br/>"
message += "If that's not the case, please execute the command: <br/><br/><strong>"
message += "sudo /etc/init.d/prosody start</strong><br/><br/>"
message += "See <a href='https://buddycloud.org/wiki/Install#Prosody_Setup' target='_blank'>"
message += "https://buddycloud.org/wiki/Install#Prosody_Setup</a> for more information."
return (status, briefing, message, None)
else:
status = 0
briefing = "Could connect to your XMPP servers: "
briefing += "<strong>" + string.join(reachable, " | ") + "</strong>"
message = "We were able to connect to the following XMPP servers.<br/>"
message += "<strong><br/>" + string.join(reachable,
"<br/>") + "<br/></strong>"
if len(unreachable) != 0:
message += "<br/>But beware - we could NOT connect to the following XMPP servers:<br/>"
message += "<strong><br/>" + string.join(
unreachable, "<br/>") + "<br/></strong>"
message += "<br/>Be warned it might result in problems, if any of those "
message += "are meant to host the buddycloud component."
message += " <br/>To be safe, be sure these are also up and running"
message += " on the correct port and try again."
else:
message += "<br/>Congratulations!! All XMPP servers specified are up and running properly."
message += "<br/>Now, we expect that one of them has the buddycloud XMPP component."
return (status, briefing, message, None)
def __init__(self, config, plugins=None):
super(LudolphBot, self).__init__()
self._event_handlers = {
'bot_message': [self._run_command],
'bot_command_not_found': [self._command_not_found],
'muc_message': [],
'muc_user_online': [],
'muc_user_offline': [],
}
self.users = set()
self.admins = set()
self.broadcast_blacklist = set()
self.room_users = set()
self.room_admins = set()
self.room_users_invited = set()
self.room_users_last_seen = {}
self._load_config(config, init=True)
logger.info('Initializing jabber bot *%s*', self.nick)
self._load_plugins(config, plugins, init=True)
# Initialize the SleekXMPP client
self.client = client = ClientXMPP(config.get('xmpp', 'username'),
config.get('xmpp', 'password'))
# These XMPP-related attributes and methods are expected to exist by plugins
self.client_roster = client.client_roster
self.boundjid = client.boundjid
# Register XMPP plugins
client.register_plugin('xep_0030') # Service Discovery
client.register_plugin('xep_0045') # Multi-User Chat
client.register_plugin('xep_0198') # Stream Management
client.register_plugin('xep_0199') # XMPP Ping
client.register_plugin('xep_0203') # Delayed Delivery
client.register_plugin('xep_0084') # User Avatar
client.register_plugin('xep_0153') # User Avatar vCard
client.register_plugin('xep_0224') # Attention
# Auto-authorize is enabled by default. User subscriptions are controlled by self._handle_new_subscription
client.auto_authorize = True
# Register event handlers
client.add_event_handler('roster_subscription_request',
self._handle_new_subscription)
client.add_event_handler('session_start', self._session_start)
client.add_event_handler('message', self._bot_message, threaded=True)
client.add_event_handler('attention',
self.handle_attention,
threaded=True)
if self.room:
self.muc = client.plugin['xep_0045']
client.add_event_handler('groupchat_message',
self._muc_message,
threaded=True)
client.add_event_handler('muc::%s::got_online' % self.room,
self._muc_user_online,
threaded=True)
client.add_event_handler('muc::%s::got_offline' % self.room,
self._muc_user_offline,
threaded=True)
# Run post initialization methods for all plugins
self._post_init_plugins()
# Start the web server thread for processing HTTP requests
if self.webserver:
# noinspection PyProtectedMember
client._start_thread('webserver',
self.webserver.start,
track=False)
# Start the scheduler thread for running periodic cron jobs
if self.cron:
# noinspection PyProtectedMember
client._start_thread('cron', self.cron.run, track=False)
# Save start time
self._start_time = time.time()
logger.info('Jabber bot *%s* is up and running', self.nick)
def stream_start(self,
mode='client',
skip=True,
header=None,
socket='mock',
jid='tester@localhost',
password='******',
server='localhost',
port=5222,
sasl_mech=None,
plugins=None,
plugin_config={}):
"""
Initialize an XMPP client or component using a dummy XML stream.
Arguments:
mode -- Either 'client' or 'component'. Defaults to 'client'.
skip -- Indicates if the first item in the sent queue (the
stream header) should be removed. Tests that wish
to test initializing the stream should set this to
False. Otherwise, the default of True should be used.
socket -- Either 'mock' or 'live' to indicate if the socket
should be a dummy, mock socket or a live, functioning
socket. Defaults to 'mock'.
jid -- The JID to use for the connection.
Defaults to 'tester@localhost'.
password -- The password to use for the connection.
Defaults to 'test'.
server -- The name of the XMPP server. Defaults to 'localhost'.
port -- The port to use when connecting to the server.
Defaults to 5222.
plugins -- List of plugins to register. By default, all plugins
are loaded.
"""
if mode == 'client':
self.xmpp = ClientXMPP(jid,
password,
sasl_mech=sasl_mech,
plugin_config=plugin_config)
elif mode == 'component':
self.xmpp = ComponentXMPP(jid,
password,
server,
port,
plugin_config=plugin_config)
else:
raise ValueError("Unknown XMPP connection mode.")
# Remove unique ID prefix to make it easier to test
self.xmpp._id_prefix = ''
self.xmpp._disconnect_wait_for_threads = False
self.xmpp.default_lang = None
self.xmpp.peer_default_lang = None
# We will use this to wait for the session_start event
# for live connections.
skip_queue = Queue()
if socket == 'mock':
self.xmpp.set_socket(TestSocket())
# Simulate connecting for mock sockets.
self.xmpp.auto_reconnect = False
self.xmpp.state._set_state('connected')
# Must have the stream header ready for xmpp.process() to work.
if not header:
header = self.xmpp.stream_header
self.xmpp.socket.recv_data(header)
elif socket == 'live':
self.xmpp.socket_class = TestLiveSocket
def wait_for_session(x):
self.xmpp.socket.clear()
skip_queue.put('started')
self.xmpp.add_event_handler('session_start', wait_for_session)
if server is not None:
self.xmpp.connect((server, port))
else:
self.xmpp.connect()
else:
raise ValueError("Unknown socket type.")
if plugins is None:
self.xmpp.register_plugins()
else:
for plugin in plugins:
self.xmpp.register_plugin(plugin)
# Some plugins require messages to have ID values. Set
# this to True in tests related to those plugins.
self.xmpp.use_message_ids = False
self.xmpp.process(threaded=True)
if skip:
if socket != 'live':
# Mark send queue as usable
self.xmpp.session_started_event.set()
# Clear startup stanzas
self.xmpp.socket.next_sent(timeout=1)
if mode == 'component':
self.xmpp.socket.next_sent(timeout=1)
else:
skip_queue.get(block=True, timeout=10)
# -*- coding: utf-8 -*-
"""
Created on Mon Dec 9 22:50:45 2019
@author: tema
"""
import urllib.request
import time
from sleekxmpp import ClientXMPP
username = '******'
passwd = '0q1u0a1n2t0u0m'
to = '*****@*****.**'
client = ClientXMPP(username, passwd)
client.connect()
client.process()
while True:
req = urllib.request.Request('http://weather.nsu.ru/weather.xml')
response = urllib.request.urlopen(req)
page = response.read()
str_page = str(page)
index1 = str_page.find('current')
index2 = str_page.find('/current')
data = str_page[index1 + 8:index2 - 1]
client.send_message(to, 'Current temperature: ' + data + '°C')
time.sleep(1)
def __init__(self, jid, password, client_host, client_port, searchserver):
self.xmpp = ClientXMPP(jid, password)
self.con_address = client_host, client_port
self.searchserver = searchserver
def send_chatroom_message(self, context, message):
# Get context
session = self.__get_session(context)
res_id = context.reservation.reservation_id
current_user = context.reservation.running_user
admin_user, admin_password, api_server, api_port = self.__get_openfire_server_details(
context, session)
# Chatroom name is current sandbox name
chatroom_name = session.GetReservationDetails(
reservationId=res_id).ReservationDescription.Name
# Chatroom ID is reservation id
chatroom_id = res_id
# Get XMPP domain value
xmpp_domain = self.__get_xmpp_domain(server=api_server,
port=api_port,
user=admin_user,
password=admin_password)
# Construct full Jabber user id
JID = "%s@%s" % (admin_user, xmpp_domain)
session.WriteMessageToReservationOutput(
context.reservation.reservation_id,
"\nSending message to chat room \"%s\" as %s" %
(chatroom_name, current_user))
xmpp = ClientXMPP(jid=JID, password=admin_password)
xmpp.register_plugin('xep_0045')
conn = xmpp.connect(use_ssl=False,
use_tls=False,
address=(api_server, '5222'))
room = '%s@conference.%s' % (chatroom_id, xmpp_domain)
# need to join chat room before sending message
session.WriteMessageToReservationOutput(
context.reservation.reservation_id, " Joining room")
xmpp.plugin['xep_0045'].joinMUC(
room,
current_user,
wait=True,
)
# Send message to room
xmpp.send_message(mtype='groupchat',
mbody=message,
mto=room,
mnick=current_user)
# Run commands above
session.WriteMessageToReservationOutput(
context.reservation.reservation_id,
" Sending message \"%s\"" % message)
session.WriteMessageToReservationOutput(
context.reservation.reservation_id, "Completed")
xmpp.process(block=False)
# Ensure we have enough time to send the message before disconnecting
time.sleep(5)
xmpp.disconnect()
pass
