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())