def get_nick_from_jid(self, jid):
# sleekxmpp has a method for this but it uses full jids
room_details = self._muc.rooms[self.room]
log.debug('room details '+str(room_details))
for nick, props in room_details.items():
if JID(props['jid']).bare == JID(jid).bare:
return nick
def __init__(self, jid, password, client1_jid, client2_jid):
sleekxmpp.ClientXMPP.__init__(self, jid, password)
self.add_event_handler("session_start", self.start)
self.add_event_handler("message", self.message)
self.client1_jid = JID(client1_jid)
self.client2_jid = JID(client2_jid)
self.incoming_cnt = 0
def on_presence_available_room(self, msg):
if str(JID(msg['from']).bare) == self.curr_match_room:
self.match_msg_frm.on_presence_available_room(msg)
room = str(JID(msg['muc']['room']).bare)
nick = str(msg['muc']['nick'])
self.eng.log('user %s has logged in the chat %s' % (nick, room))
chat = self.__find_chat(room)
chat.users += [nick]
if str(JID(msg['from']).bare) != self.curr_match_room:
if self.curr_chat.dst == room:
self.set_title(chat.title)
def test_remove_unknown(self):
"""Test removal of a game, which doesn't exist."""
games = Games()
jid = JID(jid='*****@*****.**')
# TODO: Check how the real format of data looks like
game_data = {
'players': ['player1', 'player2'],
'nbp': 'foo',
'state': 'init'
}
games.add_game(jid, game_data)
self.assertFalse(games.remove_game(JID('*****@*****.**')))
def on_groupchat_msg(self, msg):
src = str(JID(msg['mucnick']))
src = src.split('@')[0] + '\1smaller\1@' + src.split('@')[1] + '\2'
self.eng.log('received groupchat message from %s in the chat %s' %(msg['mucnick'], JID(msg['from']).bare))
str_msg = '\1italic\1' + src + '\2: ' + str(msg['body'])
if not self.chat:
self.chat = MUC(str(JID(msg['from']).bare))
self.chat.messages += [str_msg]
if self.dst_txt['text'] == '':
self.set_chat(self.chat)
elif self.chat.dst == str(JID(msg['from']).bare):
self.add_msg_txt(str_msg)
def on_presence(self, presence_stanza):
log.debug('creating Presence from {}'.format(presence_stanza))
muc_jid = JID(presence_stanza['from'])
user = JID(presence_stanza['muc']['jid'])
ptype = presence_stanza['type']
status_text = presence_stanza['status']
log.debug('created muc_jid={} user={} ptype={} status_text={}'.format(
muc_jid, user, ptype, status_text))
nick = presence_stanza['muc']['nick']
presence = Presence(muc_jid, user, ptype, status_text)
for callback in self._presence_callbacks:
callback(presence)
def on_presence_unavailable_room(self, msg):
if self.match_msg_frm and str(JID(msg['from']).bare) == self.curr_match_room:
self.match_msg_frm.on_presence_unavailable_room(msg)
return
room = str(JID(msg['muc']['room']).bare)
nick = str(msg['muc']['nick'])
self.eng.log('user %s has left the chat %s' %(nick, room))
chat = self.__find_chat(room)
if nick == self.eng.xmpp.client.boundjid.bare:
self.on_close()
else:
chat.users.remove(nick)
if self.curr_chat.dst == room:
self.set_title(chat.title)
def on_click(self, i):
self.eng.log('selected driver ' + str(i))
name = JID(self.eng.xmpp.client.boundjid).bare
self.eng.server.send([NetMsgs.driver_selection, i, name])
for btn in self._buttons(i):
btn.disable()
btn._name_txt['text'] = name
if self in self.current_drivers_dct:
curr_drv = self.current_drivers_dct[self]
self.eng.log_mgr.log('driver deselected: %s' % curr_drv)
self.eng.server.send([NetMsgs.driver_deselection, curr_drv])
for btn in self._buttons(curr_drv):
btn.enable()
btn._name_txt['text'] = ''
self.current_drivers_dct[self] = i
gprops = self.props.gameprops
txt_path = gprops.drivers_img.path_sel
self.sel_drv_img.set_texture(self.t_s, loader.loadTexture(txt_path % i))
self.widgets[-1]['state'] = DISABLED
#self.enable_buttons(False)
self.current_drivers += [self]
cars = gprops.cars_names[:]
car_idx = cars.index(self.mediator.car)
cars.remove(self.mediator.car)
prev_drv = gprops.drivers_info[car_idx]
#gprops.drivers_info[car_idx] = gprops.drivers_info[i]
gprops.drivers_info[car_idx].img_idx = i
nname = self.this_name()
gprops.drivers_info[car_idx].name = nname
#gprops.drivers_info[i] = prev_drv
self.evaluate_starting()
def carbon_sent(self, msg):
#print str(self)+": on_carbon_sent: "+str(msg)
mfrom = msg['carbon_sent']['from']
mbody = msg['carbon_sent']['body']
if mfrom == self.jid:
# Carbons are delivered with from==JID/other_resource, or with Spectrum, "/bot"
print(str(self)+": Weird carbon_sent: from == own exact JID")
self.weird_cnt += 1
return
if (mfrom.bare != JID(self.jid).bare) and (mfrom.bare != self.alt_jid.bare):
# Carbons should be from our other resources
print(str(self)+": Weird carbon_sent: from.bare != our JID")
self.weird_cnt += 1
return
if (mbody.startswith("Message 1 from")):
#print str(self)+": message1 carbon!"
self.cs_m1_cnt += 1
return
if (mbody == "Message 2"):
#print str(self)+": message2 carbon!"
self.cs_m2_cnt += 1
return
if (mbody.startswith("Message 3 from")):
#print str(self)+": message3 carbon!"
self.cs_m3_cnt += 1
return
print(str(self)+": Weird unexpected carbon_sent: "+str(msg))
self.weird_cnt += 1
def _handle_bind_resource(self, features):
"""
Handle requesting a specific resource.
Arguments:
features -- The stream features stanza.
"""
log.debug("Requesting resource: %s", self.xmpp.requested_jid.resource)
iq = self.xmpp.Iq()
iq['type'] = 'set'
iq.enable('bind')
if self.xmpp.requested_jid.resource:
iq['bind']['resource'] = self.xmpp.requested_jid.resource
response = iq.send(now=True)
self.xmpp.boundjid = JID(response['bind']['jid'], cache_lock=True)
self.xmpp.bound = True
self.xmpp.event('session_bind', self.xmpp.boundjid, direct=True)
self.xmpp.session_bind_event.set()
self.xmpp.features.add('bind')
log.info("JID set to: %s", self.xmpp.boundjid.full)
if 'session' not in features['features']:
log.debug("Established Session")
self.xmpp.sessionstarted = True
self.xmpp.session_started_event.set()
self.xmpp.event('session_start')
def car_request(self, car, sender):
self.eng.log_mgr.log('car requested: ' + car)
btn = self._buttons(car)[0]
if btn['state'] == DISABLED:
self.eng.log_mgr.log('car already selected: ' + car)
return False
elif btn['state'] == NORMAL:
self.eng.log_mgr.log('car selected: ' + car)
if sender in self.current_cars:
_btn = self._buttons(self.current_cars[sender])[0]
_btn.enable()
_btn._name_txt['text'] = ''
self.current_cars[sender] = car
btn.disable()
for conn in self.eng.server.connections:
if conn == sender:
curr_addr = conn.getpeername()
username = ''
for usr in self.eng.xmpp.users:
if usr.local_addr == curr_addr:
username = usr.name
if not username:
for usr in self.eng.xmpp.users:
if usr.public_addr == curr_addr:
username = usr.name
btn._name_txt['text'] = JID(username).bare
self.eng.server.send([NetMsgs.car_selection, car, username])
ip_string = sender.getpeername()[0]
if ip_string.startswith('::ffff:'): ip_string = ip_string[7:]
self.eng.car_mapping[ip_string] = car
self.evaluate_starting()
return True
def __init__(self, jid, password, room, nick, mq):
self.nick = nick
self.room = room
self.jid = JID(jid)
bot = ClientXMPP(jid, password)
# disable ipv6 for now since we're getting errors using it
bot.use_ipv6 = False
bot.add_event_handler('session_start', self.on_start)
bot.add_event_handler('message', self.on_message)
bot.register_plugin('xep_0045')
self._muc = bot.plugin['xep_0045']
bot.register_plugin('xep_0199')
bot.plugin['xep_0199'].enable_keepalive(30, 30)
resource = 'sweetiewatch' + self.randomstr()
self.mq = mq
if not bot.connect(): raise 'could not connect'
bot.process()
self._bot = bot
def add_chat(self, usr):
self.set_title(JID(usr).bare)
chat = self.__find_chat(usr)
if not chat:
chat = Chat(usr)
self.chats += [chat]
self.set_chat(chat)
self.ent['focus'] = 1
def _load_data(self):
_members = set()
_admins = set()
with open('%s/xsf_roster.txt' % self.data_dir) as roster:
for jid in roster:
jid = jid.strip()
if jid:
_members.add(JID(jid))
with open('%s/xsf_admins.txt' % self.data_dir) as admins:
for jid in admins:
jid = jid.strip()
if jid:
_admins.add(JID(jid))
self._members = _members
self._admins = _admins
def on_msg(self, msg):
src = str(JID(msg['from']).bare)
src = src.split('@')[0] + '\1smaller\1@' + src.split('@')[1] + '\2'
str_msg = '\1italic\1' + src + '\2: ' + str(msg['body'])
chat = self.__find_chat(msg['from'])
if not chat:
chat = Chat(msg['from'])
self.chats += [chat]
chat.messages += [str_msg]
if self.dst_txt['text'] == '':
self.set_chat(chat)
elif JID(self.curr_chat.dst).bare == JID(msg['from']).bare:
self.add_msg_txt(str_msg)
else:
chat.read = False
chat.closed = False
self.arrow_btn['frameTexture'] = 'assets/images/gui/message.txo'
def offline_buddy(self, presence):
""" Process presence notifications """
jid = JID(presence['from']).bare
self.logger.debug('%s got offline' % jid)
try:
self.online_buddys.remove(jid)
except ValueError:
self.logger.warn('%s was available but unoticed' % jid)
def __init__(self, jid, password, alt_jid, responder_jid):
sleekxmpp.ClientXMPP.__init__(self, jid, password)
self.full_jid = jid
self.alt_jid = JID(alt_jid) # our own alternative jid (backend/spectrum)
self.responder_jid = JID(responder_jid)
self.register_plugin('xep_0030') # Service Discovery
self.register_plugin('xep_0199') # XMPP Ping
self.register_plugin('xep_0280') # Message Carbons
self.add_event_handler("session_start", self.start)
self.add_event_handler("message", self.message)
self.add_event_handler("carbon_sent", self.carbon_sent)
self.add_event_handler("carbon_received", self.carbon_received)
self['feature_mechanisms'].unencrypted_plain = True
self.weird_cnt = 0
self.cs_m1_cnt = 0
self.cs_m2_cnt = 0
self.cs_m3_cnt = 0
def test_create_player(self):
"""Test creating a new player."""
player = self.leaderboard.get_or_create_player(JID('john@localhost'))
self.assertEqual(player.id, 1)
self.assertEqual(player.jid, 'john@localhost')
self.assertEqual(player.rating, -1)
self.assertEqual(player.highest_rating, None)
self.assertEqual(player.games, [])
self.assertEqual(player.games_info, [])
self.assertEqual(player.games_won, [])
def get_never(self):
results = set()
jids = self.xml.findall('{%s}never/{%s}jid' % (
self.namespace, self.namespace))
for jid in jids:
results.add(JID(jid.text))
return results
def __init__(self,
project_name,
jid,
dest_jid,
merge_conflict=False,
conflict_files=[]):
""" Initialize the AlertTask. By default, there's no merge
conflict.
"""
# The priority is 2. It means that it's the higher possible
# priority for baboonsrv except the EndTask.
super(AlertTask, self).__init__(2)
self.project_name = project_name
self.username = JID(jid).user
self.dest_username = JID(dest_jid).user
self.merge_conflict = merge_conflict
self.conflict_files = conflict_files
def users(self, message):
'''[group] Lists users currently in a pingable group'''
if not message.args:
return 'Usage: users group_name'
group = message.args
targets = self.store.smembers(self.key(group))
if not len(targets):
return "no users found in group '{}'".format(group)
usernames = map(lambda x: JID(x.decode('utf-8')).user, targets)
return ('Users in {}: {}'.format(group, ', '.join(usernames)) +
'. See also !groups and !mygroups')
def _sleekxmpp_fix_jid(jid):
"""
SleekXMPP MUC plugin (xep_0045.py) has changed and return string instead of object. Backward compatible fix!
Looks like the xep_0045.py is using getStanzaValues() in handle_groupchat_presence and get_stanza_values got
changed in https://github.com/fritzy/SleekXMPP/commit/79f3c1ac8f1aa0b099958e824dc53c17daf9849f
"""
if isinstance(jid, JID):
return jid
else:
return JID(jid)
def received_message_from_sleek(cls, msg):
jid = JID(msg['from']).bare
try:
obj = Friend.get(jid=jid)
except Friend.DoesNotExist:
logger.warning(
"-- have a message received but [{0}] not in your roster".
format(jid))
else:
cls.create(friend=obj, body=msg['body'])
def handle_result(form, session):
jid = JID(form['values']['jid'])
if jid.bare in self._members:
self._members.remove(jid)
self._save_data()
self.xmpp.event('xsf_jid_removed', jid)
session['payload'] = None
session['next'] = None
return session
def on_groupchat_msg(self, msg):
if str(JID(msg['from']).bare) == self.curr_match_room:
if self.match_msg_frm: # we're still in the room page
self.match_msg_frm.on_groupchat_msg(msg)
src = str(JID(msg['mucnick']))
src = src.split('@')[0] + '\1smaller\1@' + src.split('@')[1] + '\2'
self.eng.log('received groupchat message from %s in the chat %s' %(msg['mucnick'], JID(msg['from']).bare))
str_msg = '\1italic\1' + src + '\2: ' + str(msg['body'])
chat = self.curr_chat
if not chat:
chat = MUC(str(JID(msg['from']).bare))
self.chats += [chat]
chat.messages += [str_msg]
if self.dst_txt['text'] == '':
self.set_chat(chat)
elif self.curr_chat.dst == str(JID(msg['from']).bare):
self.add_msg_txt(str_msg)
else:
chat.read = False
chat.closed = False
self.arrow_btn['frameTexture'] = 'assets/images/gui/message.txo'
def log_deowl(self, speaker, success):
speaker = JID(speaker)
timestamp = datetime.utcnow()
mq_message = {
'deowl': True,
'room': speaker.user,
'server': speaker.domain,
'speaker': speaker.resource,
'timestamp': timestamp.isoformat(' '),
'success': success,
}
self.mq.send(json.dumps(mq_message).encode('utf-8'))
def on_declined(self, msg):
usr = str(JID(msg['from']).bare)
self.eng.log('user %s has declined' % usr)
for i, frm in enumerate(self.forms[:]):
lab = frm.lab.lab['text']
lab = lab.replace('\1smaller\1', '').replace('\2', '')
if lab.startswith('? '): lab = lab[2:]
if lab == usr:
for j in range(i + 1, 8):
if j < len(self.forms):
self.set_frm_pos(self.forms[j], j - 1)
self.forms.remove(frm)
frm.destroy()
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 on_car(self, car):
self.eng.log_mgr.log('car request: ' + car)
if self.eng.client.car_request(car):
if self.car:
_btn = self._buttons(self.car)[0]
_btn.enable()
_btn._name_txt['text'] = ''
self.car = car
self.eng.log_mgr.log('car confirmed: ' + car)
btn = self._buttons(car)[0]
btn.disable()
btn._name_txt['text'] = JID(self.eng.xmpp.client.boundjid).bare
else:
self.eng.log_mgr.log('car denied')
def test_remove(self):
"""Test removal of games."""
games = Games()
jid1 = JID(jid='*****@*****.**')
jid2 = JID(jid='*****@*****.**')
# TODO: Check how the real format of data looks like
game_data1 = {
'players': ['player1', 'player2'],
'nbp': 'foo',
'state': 'init'
}
games.add_game(jid1, game_data1)
game_data2 = {
'players': ['player3', 'player4'],
'nbp': 'bar',
'state': 'init'
}
games.add_game(jid2, game_data2)
game_data1.update({
'players-init': game_data1['players'],
'nbp-init': game_data1['nbp'],
'state': game_data1['state']
})
game_data2.update({
'players-init': game_data2['players'],
'nbp-init': game_data2['nbp'],
'state': game_data2['state']
})
self.assertDictEqual(games.get_all_games(), {
jid1: game_data1,
jid2: game_data2
})
games.remove_game(jid1)
self.assertDictEqual(games.get_all_games(), {jid2: game_data2})
games.remove_game(jid2)
self.assertDictEqual(games.get_all_games(), dict())
