def user_left_chat(self, event):
log.debug("user_left_chat %s" % event)
idd = self.build_identifier(event['from'].full)
p = Presence(chatroom=idd, nick=idd.resource, status=OFFLINE)
self.callback_presence(p)
def user_left_chat(self, event):
log.debug("user_left_chat %s", event)
self.callback_presence(
Presence(identifier=self._idd_from_event(event), status=OFFLINE))
def contact_offline(self, event):
log.debug("contact_offline %s" % event)
p = Presence(identifier=self.build_identifier(event['from'].full),
status=OFFLINE)
self.callback_presence(p)
def _hello_event_handler(self, event):
"""Event handler for the 'hello' event"""
self.connect_callback()
self.callback_presence(
Presence(identifier=self.bot_identifier, status=ONLINE))
def contact_offline(self, event):
log.debug("contact_offline %s.", event)
self.callback_presence(
Presence(identifier=self._idd_from_event(event), status=OFFLINE))
def serve_once(self):
"""
Run the bot until the connection is disconnected.
:return: None.
"""
# Log message
self._log_debug('# ----- serve_once -----')
# Log message
self._log_debug(('# ----- Create meteor client -----\n'
'SERVER_URI: {}').format(self._server_uri))
# Create meteor client
self._meteor_client = MeteorClient(
self._server_uri,
# Disable the meteor client's auto reconnect.
# Let `serve_forever` handle reconnect.
auto_reconnect=False,
)
# Log message
self._log_debug('# ----- Hook meteor client callbacks -----')
# 5DI82
# Hook meteor client `connected` callback
self._meteor_client.on('connected', self._meteor_connected_callback)
# 2RAYF
# Hook meteor client `changed` callback
self._meteor_client.on('changed', self._meteor_changed_callback)
# 4XIZB
# Hook meteor client `added` callback
self._meteor_client.on('added', self._meteor_added_callback)
# 2JEIK
# Hook meteor client `removed` callback
self._meteor_client.on('removed', self._meteor_removed_callback)
# 32TF2
# Hook meteor client `failed` callback
self._meteor_client.on('failed', self._meteor_failed_callback)
# 5W6RX
# Hook meteor client `reconnected` callback
self._meteor_client.on('reconnected',
self._meteor_reconnected_callback)
# 7MOJX
# Hook meteor client `closed` callback
self._meteor_client.on('closed', self._meteor_closed_callback)
# Clear the event
self._subscribing_done_event.clear()
# Clear the event
self._meteor_closed_event.clear()
# Log message
self._log_debug('# ----- Connect to meteor server -----')
try:
# Connect to meteor server.
#
# If the connecting succeeds, the meteor client's thread will call
# `self._meteor_connected_callback` hooked at 5DI82. The login,
# topic subscribing, and message handling are run in that thread.
#
# The main thread merely waits until the meteor client is closed,
# meanwhile it calls heartbeat function at interval if specified.
#
self._meteor_client.connect()
# If have error
except:
# Log message
self._log_debug('# ----- Connecting failed -----')
# Log message
self._log_debug('# ----- Unhook meteor client callbacks -----')
# Remove meteor client callbacks
self._meteor_client.remove_all_listeners()
# Remove meteor client reference
self._meteor_client = None
# The two events below should not have been set if the connecting
# failed. Just in case.
#
# Clear the event
self._subscribing_done_event.clear()
# Clear the event
self._meteor_closed_event.clear()
# Raise the error
raise
# Get whether heartbeat is enabled
heartbeat_enabled = self._get_bool_config(
CONFIG_KEYS.HEARTBEAT_ENABLED)
try:
# Wait until the topic subscribing is done in another thread at
# 5MS7A
self._subscribing_done_event.wait()
# If heartbeat is enabled
if heartbeat_enabled:
# Get heartbeat function
heartbeat_func = self._get_config(CONFIG_KEYS.HEARTBEAT_FUNC)
# Assert the function is callable
assert callable(heartbeat_func), repr(heartbeat_func)
# Get heartbeat interval
heartbeat_interval = self._get_config(
CONFIG_KEYS.HEARTBEAT_INTERVAL,
default=10,
)
# Convert heartbeat interval to float
heartbeat_interval = float(heartbeat_interval)
# 65ZNO
# Loop until the meteor client is disconnected
while self._meteor_client.connected:
# Send heartbeat
heartbeat_func(self)
# Sleep before sending next heartbeat
time.sleep(heartbeat_interval)
# 5W6XQ
# Wait until the meteor client is closed and the `closed` callback
# is called at 3DMYH
self._meteor_closed_event.wait()
# If have error
except:
# Close meteor client.
#
# This will cause `self._meteor_closed_callback` to be called,
# which will set the `self._meteor_closed_event` below.
#
self._meteor_client.close()
# See 5W6XQ
self._meteor_closed_event.wait()
# Raise the error
raise
# Always do
finally:
# Log message
self._log_debug('# ----- Unhook meteor client callbacks -----')
# Remove meteor client callbacks
self._meteor_client.remove_all_listeners()
# Remove meteor client reference.
#
# Do this before calling `callback_presence` below so that the
# plugins will not be able to access the already closed client.
#
self._meteor_client = None
# Log message
self._log_debug('# ----- Call `callback_presence` -----')
# Call `callback_presence`
self.callback_presence(
Presence(identifier=self.bot_identifier, status=OFFLINE))
# Log message
self._log_debug('# ----- Call `disconnect_callback` -----')
# Call `disconnect_callback` to unload plugins
self.disconnect_callback()
# Clear the event
self._subscribing_done_event.clear()
# Clear the event
self._meteor_closed_event.clear()
# Log message
self._log_debug('# ===== serve_once =====')
def user_joined_chat(self, event):
log.debug("user_join_chat %s" % event)
idd = self.build_identifier(event['from'].full)
p = Presence(identifier=idd, status=ONLINE)
self.callback_presence(p)
def user_joined_chat(self, event):
log.debug('user_join_chat %s', event)
self.callback_presence(
Presence(identifier=self._idd_from_event(event), status=ONLINE))
def serve_forever(self):
self.readline_support()
if not self._rooms:
# artificially join a room if None were specified.
self.query_room('#testroom').join()
if self.demo_mode:
# disable the console logging once it is serving in demo mode.
root = logging.getLogger()
root.removeHandler(console_hdlr)
root.addHandler(logging.NullHandler())
self.connect_callback() # notify that the connection occured
self.callback_presence(Presence(identifier=self.user, status=ONLINE))
self.send_message(Message(INTRO))
try:
while True:
if self._inroom:
frm = TextOccupant(self.user, self.rooms[0])
to = self.rooms[0]
else:
frm = self.user
to = self.bot_identifier
print()
full_msg = ''
while True:
prompt = '[␍] ' if full_msg else '>>> '
if ANSI or self.demo_mode:
color = fg.red if self.user.person in self.bot_config.BOT_ADMINS[
0] else fg.green
prompt = f'{color}[{frm} ➡ {to}] {fg.cyan}{prompt}{fx.reset}'
entry = input(prompt)
else:
entry = input(f'[{frm} ➡ {to}] {prompt}')
if not self._multiline:
full_msg = entry
break
if not entry:
break
full_msg += entry + '\n'
msg = Message(full_msg)
msg.frm = frm
msg.to = to
self.callback_message(msg)
mentioned = [
self.build_identifier(word)
for word in re.findall(r'(?<=\s)@[\w]+', entry)
]
if mentioned:
self.callback_mention(msg, mentioned)
sleep(.5)
except EOFError:
pass
except KeyboardInterrupt:
pass
finally:
# simulate some real presence
self.callback_presence(
Presence(identifier=self.user, status=OFFLINE))
log.debug("Trigger disconnect callback")
self.disconnect_callback()
log.debug("Trigger shutdown")
self.shutdown()
def on_connection_status(self, friend_number, status):
logging.debug("TOX: user %s changed connection status", friend_number)
pres = Presence(identifier=self.friend_to_idd(friend_number),
status=ONLINE if status else OFFLINE)
self.backend.callback_presence(pres)
def contact_online(self, event):
log.debug('contact_online %s.', event)
self.callback_presence(
Presence(identifier=self._idd_from_event(event), status=ONLINE))
def on_status_message(self, friend_number, message):
pres = Presence(identifier=self.friend_to_idd(friend_number),
message=message)
self.backend.callback_presence(pres)
def on_user_status(self, friend_number, kind):
logging.debug("TOX: user %s changed state", friend_number)
pres = Presence(identifier=self.friend_to_idd(friend_number),
status=TOX_TO_ERR_STATUS[kind])
self.backend.callback_presence(pres)
def contact_offline(self, event):
logging.debug("contact_offline %s" % event)
p = Presence(identifier=Identifier(str(event['from'])),
status=OFFLINE)
self.callback_presence(p)
def user_left_chat(self, event):
logging.debug("user_left_chat %s" % event)
idd = Identifier(str(event['from']))
p = Presence(chatroom=idd, nick=idd.resource, status=OFFLINE)
self.callback_presence(p)
def serve_forever(self):
self.readline_support()
# Add custom commands just for this backend.
self.inject_commands_from(TextPlugin(self, 'TextPlugin'))
if not self._rooms:
# artificially join a room if None were specified.
self.query_room('#testroom').join()
if self.demo_mode:
# disable the console logging once it is serving in demo mode.
root = logging.getLogger()
root.removeHandler(console_hdlr)
root.addHandler(logging.NullHandler())
self.connect_callback() # notify that the connection occured
self.callback_presence(Presence(identifier=self.user, status=ONLINE))
self.send_message(Message(INTRO))
try:
while True:
if self._inroom:
frm = TextOccupant(self.user, self.rooms[0])
to = self.rooms[0]
else:
frm = self.user
to = self.bot_identifier
print()
multiline = ''
while True:
prompt = '[␍] ' if multiline else '>>> '
if ANSI or self.demo_mode:
color = fg.red if self.user.person in self.bot_config.BOT_ADMINS[0] else fg.green
entry = input(str(color) +
'[%s ➡ %s] ' % (frm, to) +
str(fg.cyan) +
prompt +
str(fx.reset))
else:
entry = input('[%s ➡ %s] ' % (frm, to) + prompt)
if not entry:
break
multiline += entry + '\n'
msg = Message(multiline)
msg.frm = frm
msg.to = to
self.callback_message(msg)
mentioned = [self.build_identifier(word[1:]) for word in re.findall(r"@[\w']+", entry)
if word.startswith('@')]
if mentioned:
self.callback_mention(msg, mentioned)
sleep(.5)
except EOFError:
pass
except KeyboardInterrupt:
pass
finally:
# simulate some real presence
self.callback_presence(Presence(identifier=self.user, status=OFFLINE))
log.debug("Trigger disconnect callback")
self.disconnect_callback()
log.debug("Trigger shutdown")
self.shutdown()
