def select_pdus(cursor): cursor.execute( "SELECT pdu_id, origin FROM pdus ORDER BY depth ASC" ) ids = cursor.fetchall() pdu_tuples = store._get_pdu_tuples(cursor, ids) pdus = [Pdu.from_pdu_tuple(p) for p in pdu_tuples] reference_hashes = {} for pdu in pdus: try: if pdu.prev_pdus: print "PROCESS", pdu.pdu_id, pdu.origin, pdu.prev_pdus for pdu_id, origin, hashes in pdu.prev_pdus: ref_alg, ref_hsh = reference_hashes[(pdu_id, origin)] hashes[ref_alg] = encode_base64(ref_hsh) store._store_prev_pdu_hash_txn(cursor, pdu.pdu_id, pdu.origin, pdu_id, origin, ref_alg, ref_hsh) print "SUCCESS", pdu.pdu_id, pdu.origin, pdu.prev_pdus pdu = add_event_pdu_content_hash(pdu) ref_alg, ref_hsh = compute_pdu_event_reference_hash(pdu) reference_hashes[(pdu.pdu_id, pdu.origin)] = (ref_alg, ref_hsh) store._store_pdu_reference_hash_txn(cursor, pdu.pdu_id, pdu.origin, ref_alg, ref_hsh) for alg, hsh_base64 in pdu.hashes.items(): print alg, hsh_base64 store._store_pdu_content_hash_txn(cursor, pdu.pdu_id, pdu.origin, alg, decode_base64(hsh_base64)) except: print "FAILED_", pdu.pdu_id, pdu.origin, pdu.prev_pdus
def test_invite_join_target_this(self): room_id = "foo" user_id = "@bob:red" pdu = Pdu( pdu_type=InviteJoinEvent.TYPE, user_id=user_id, target_host=self.hostname, context=room_id, content={}, ts=0, pdu_id="a", origin="b", ) yield self.handlers.federation_handler.on_receive_pdu(pdu, False) mem_handler = self.handlers.room_member_handler self.assertEquals(1, mem_handler.change_membership.call_count) call_args = get_mock_call_args(lambda event, do_auth: None, mem_handler.change_membership) self.assertEquals(False, call_args["do_auth"]) new_event = call_args["event"] self.assertEquals(RoomMemberEvent.TYPE, new_event.type) self.assertEquals(room_id, new_event.room_id) self.assertEquals(user_id, new_event.state_key) self.assertEquals(Membership.JOIN, new_event.membership)
def new_fake_pdu(pdu_id, context, pdu_type, state_key, prev_state_id, user_id, depth=0): new_pdu = Pdu( pdu_id=pdu_id, pdu_type=pdu_type, state_key=state_key, user_id=user_id, prev_state_id=prev_state_id, origin="example.com", context="context", ts=1405353060021, depth=depth, content_json="{}", unrecognized_keys="{}", outlier=True, is_state=True, prev_state_origin="example.com", have_processed=True, content={}, ) return new_pdu
def send_message(self, room_name, sender, body): """ Send a message to a room! """ destinations = yield self.get_servers_for_context(room_name) try: yield self.replication_layer.send_pdu( Pdu.create_new( context=room_name, pdu_type="sy.room.message", content={"sender": sender, "body": body}, origin=self.server_name, destinations=destinations, ) ) except Exception as e: logger.exception(e)
def invite_to_room(self, room_name, sender, invitee): """Invite someone to a room!""" self._on_invite(self.server_name, room_name, invitee) destinations = yield self.get_servers_for_context(room_name) try: yield self.replication_layer.send_pdu( Pdu.create_new( context=room_name, is_state=True, pdu_type="sy.room.member", state_key=invitee, content={"membership": "invite"}, origin=self.server_name, destinations=destinations, )) except Exception as e: logger.exception(e)
def join_room(self, room_name, sender, joinee): """Join a room!""" self._on_join(room_name, joinee) destinations = yield self.get_servers_for_context(room_name) try: pdu = Pdu.create_new( context=room_name, pdu_type="sy.room.member", is_state=True, state_key=joinee, content={"membership": "join"}, origin=self.server_name, destinations=destinations, ) yield self.replication_layer.send_pdu(pdu) except Exception as e: logger.exception(e)
def test_msg(self): pdu = Pdu( pdu_type=MessageEvent.TYPE, context="foo", content={"msgtype": u"fooo"}, ts=0, pdu_id="a", origin="b", ) store_id = "ASD" self.datastore.persist_event.return_value = defer.succeed(store_id) self.datastore.get_room.return_value = defer.succeed(True) yield self.handlers.federation_handler.on_receive_pdu(pdu, False) self.datastore.persist_event.assert_called_once_with( ANY, False, is_new_state=False) self.notifier.on_new_room_event.assert_called_once_with(ANY)
def test_invite_join_target_other(self): room_id = "foo" user_id = "@bob:red" pdu = Pdu( pdu_type=InviteJoinEvent.TYPE, user_id=user_id, state_key="@red:not%s" % self.hostname, context=room_id, content={}, ts=0, pdu_id="a", origin="b", ) yield self.handlers.federation_handler.on_receive_pdu(pdu, False) mem_handler = self.handlers.room_member_handler self.assertEquals(0, mem_handler.change_membership.call_count)
def join_room(self, room_name, sender, joinee): """ Join a room! """ self._on_join(room_name, joinee) destinations = yield self.get_servers_for_context(room_name) try: pdu = Pdu.create_new( context=room_name, pdu_type="sy.room.member", is_state=True, state_key=joinee, content={"membership": "join"}, origin=self.server_name, destinations=destinations, ) yield self.replication_layer.send_pdu(pdu) except Exception as e: logger.exception(e)
def invite_to_room(self, room_name, sender, invitee): """ Invite someone to a room! """ self._on_invite(self.server_name, room_name, invitee) destinations = yield self.get_servers_for_context(room_name) try: yield self.replication_layer.send_pdu( Pdu.create_new( context=room_name, is_state=True, pdu_type="sy.room.member", state_key=invitee, content={"membership": "invite"}, origin=self.server_name, destinations=destinations, ) ) except Exception as e: logger.exception(e)
def test_event_from_pdu(self): pdu = Pdu( pdu_id="foo", context="rooooom", pdu_type="m.room.message", origin="bar.com", ts=12345, depth=5, prev_pdus=[("alice", "bob.com")], is_state=False, content={"msgtype": u"test"}, ) event = self.codec.event_from_pdu(pdu) self.assertEquals("*****@*****.**", event.event_id) self.assertEquals(pdu.context, event.room_id) self.assertEquals(pdu.is_state, event.is_state) self.assertEquals(pdu.depth, event.depth) self.assertEquals(["*****@*****.**"], event.prev_events) self.assertEquals(pdu.content, event.content)
def test_send_pdu(self): self.mock_http_client.put_json.return_value = defer.succeed( (200, "OK") ) pdu = Pdu( pdu_id="abc123def456", origin="red", destinations=["remote"], context="my-context", ts=123456789002, pdu_type="m.test", content={"testing": "content here"}, depth=1, ) yield self.federation.send_pdu(pdu) self.mock_http_client.put_json.assert_called_with( "remote", path="/_matrix/federation/v1/send/1000000/", data={ "ts": 1000000, "origin": "test", "pdus": [ { "origin": "red", "pdu_id": "abc123def456", "prev_pdus": [], "ts": 123456789002, "context": "my-context", "pdu_type": "m.test", "is_state": False, "content": {"testing": "content here"}, "depth": 1, }, ] }, on_send_callback=ANY, )
def select_pdus(cursor): cursor.execute("SELECT pdu_id, origin FROM pdus ORDER BY depth ASC") ids = cursor.fetchall() pdu_tuples = store._get_pdu_tuples(cursor, ids) pdus = [Pdu.from_pdu_tuple(p) for p in pdu_tuples] reference_hashes = {} for pdu in pdus: try: if pdu.prev_pdus: print("PROCESS", pdu.pdu_id, pdu.origin, pdu.prev_pdus) for pdu_id, origin, hashes in pdu.prev_pdus: ref_alg, ref_hsh = reference_hashes[(pdu_id, origin)] hashes[ref_alg] = encode_base64(ref_hsh) store._store_prev_pdu_hash_txn( cursor, pdu.pdu_id, pdu.origin, pdu_id, origin, ref_alg, ref_hsh ) print("SUCCESS", pdu.pdu_id, pdu.origin, pdu.prev_pdus) pdu = add_event_pdu_content_hash(pdu) ref_alg, ref_hsh = compute_pdu_event_reference_hash(pdu) reference_hashes[(pdu.pdu_id, pdu.origin)] = (ref_alg, ref_hsh) store._store_pdu_reference_hash_txn( cursor, pdu.pdu_id, pdu.origin, ref_alg, ref_hsh ) for alg, hsh_base64 in pdu.hashes.items(): print(alg, hsh_base64) store._store_pdu_content_hash_txn( cursor, pdu.pdu_id, pdu.origin, alg, decode_base64(hsh_base64) ) except Exception: print("FAILED_", pdu.pdu_id, pdu.origin, pdu.prev_pdus)
def _enumerate_state_branches(self, txn, pdu_a, pdu_b): branch_a = pdu_a branch_b = pdu_b while True: if (branch_a.pdu_id == branch_b.pdu_id and branch_a.origin == branch_b.origin): # Woo! We found a common ancestor logger.debug("_enumerate_state_branches Found common ancestor") break do_branch_a = ( hasattr(branch_a, "prev_state_id") and branch_a.prev_state_id ) do_branch_b = ( hasattr(branch_b, "prev_state_id") and branch_b.prev_state_id ) logger.debug( "do_branch_a=%s, do_branch_b=%s", do_branch_a, do_branch_b ) if do_branch_a and do_branch_b: do_branch_a = int(branch_a.depth) > int(branch_b.depth) if do_branch_a: pdu_tuple = PduIdTuple( branch_a.prev_state_id, branch_a.prev_state_origin ) prev_branch = branch_a logger.debug("getting branch_a prev %s", pdu_tuple) branch_a = self._get_pdu_tuple(txn, *pdu_tuple) if branch_a: branch_a = Pdu.from_pdu_tuple(branch_a) logger.debug("branch_a=%s", branch_a) yield (0, prev_branch, branch_a) if not branch_a: break elif do_branch_b: pdu_tuple = PduIdTuple( branch_b.prev_state_id, branch_b.prev_state_origin ) prev_branch = branch_b logger.debug("getting branch_b prev %s", pdu_tuple) branch_b = self._get_pdu_tuple(txn, *pdu_tuple) if branch_b: branch_b = Pdu.from_pdu_tuple(branch_b) logger.debug("branch_b=%s", branch_b) yield (1, prev_branch, branch_b) if not branch_b: break else: break