def start_get_pdu_cache(self): self._get_pdu_cache = ExpiringCache( cache_name="get_pdu_cache", clock=self._clock, max_len=1000, expiry_ms=120*1000, reset_expiry_on_get=False, ) self._get_pdu_cache.start()
def start_caching(self): logger.debug("start_caching") self._state_cache = ExpiringCache( cache_name="state_cache", clock=self.clock, max_len=SIZE_OF_CACHE, expiry_ms=EVICTION_TIMEOUT_SECONDS * 1000, reset_expiry_on_get=True, ) self._state_cache.start()
def start_caching(self): logger.debug("start_caching") self._state_cache = ExpiringCache( cache_name="state_cache", clock=self.clock, max_len=SIZE_OF_CACHE, expiry_ms=EVICTION_TIMEOUT_SECONDS*1000, reset_expiry_on_get=True, ) self._state_cache.start()
class StateHandler(object): """ Responsible for doing state conflict resolution. """ def __init__(self, hs): self.clock = hs.get_clock() self.store = hs.get_datastore() self.hs = hs # dict of set of event_ids -> _StateCacheEntry. self._state_cache = None def start_caching(self): logger.debug("start_caching") self._state_cache = ExpiringCache( cache_name="state_cache", clock=self.clock, max_len=SIZE_OF_CACHE, expiry_ms=EVICTION_TIMEOUT_SECONDS * 1000, reset_expiry_on_get=True, ) self._state_cache.start() @defer.inlineCallbacks def get_current_state(self, room_id, event_type=None, state_key=""): """ Returns the current state for the room as a list. This is done by calling `get_latest_events_in_room` to get the leading edges of the event graph and then resolving any of the state conflicts. This is equivalent to getting the state of an event that were to send next before receiving any new events. If `event_type` is specified, then the method returns only the one event (or None) with that `event_type` and `state_key`. """ event_ids = yield self.store.get_latest_event_ids_in_room(room_id) cache = None if self._state_cache is not None: cache = self._state_cache.get(frozenset(event_ids), None) if cache: cache.ts = self.clock.time_msec() state = cache.state else: res = yield self.resolve_state_groups(event_ids) state = res[1] if event_type: defer.returnValue(state.get((event_type, state_key))) return defer.returnValue(state) @defer.inlineCallbacks def compute_event_context(self, event, old_state=None): """ Fills out the context with the `current state` of the graph. The `current state` here is defined to be the state of the event graph just before the event - i.e. it never includes `event` If `event` has `auth_events` then this will also fill out the `auth_events` field on `context` from the `current_state`. Args: event (EventBase) Returns: an EventContext """ context = EventContext() yield run_on_reactor() if old_state: context.current_state = {(s.type, s.state_key): s for s in old_state} context.state_group = None if event.is_state(): key = (event.type, event.state_key) if key in context.current_state: replaces = context.current_state[key] if replaces.event_id != event.event_id: # Paranoia check event.unsigned["replaces_state"] = replaces.event_id context.prev_state_events = [] defer.returnValue(context) if event.is_state(): ret = yield self.resolve_state_groups( [e for e, _ in event.prev_events], event_type=event.type, state_key=event.state_key, ) else: ret = yield self.resolve_state_groups( [e for e, _ in event.prev_events], ) group, curr_state, prev_state = ret context.current_state = curr_state context.state_group = group if not event.is_state() else None prev_state = yield self.store.add_event_hashes(prev_state) if event.is_state(): key = (event.type, event.state_key) if key in context.current_state: replaces = context.current_state[key] event.unsigned["replaces_state"] = replaces.event_id context.prev_state_events = prev_state defer.returnValue(context) @defer.inlineCallbacks @log_function def resolve_state_groups(self, event_ids, event_type=None, state_key=""): """ Given a list of event_ids this method fetches the state at each event, resolves conflicts between them and returns them. Return format is a tuple: (`state_group`, `state_events`), where the first is the name of a state group if one and only one is involved, otherwise `None`. """ logger.debug("resolve_state_groups event_ids %s", event_ids) if self._state_cache is not None: cache = self._state_cache.get(frozenset(event_ids), None) if cache and cache.state_group: cache.ts = self.clock.time_msec() prev_state = cache.state.get((event_type, state_key), None) if prev_state: prev_state = prev_state.event_id prev_states = [prev_state] else: prev_states = [] defer.returnValue( (cache.state_group, cache.state, prev_states)) state_groups = yield self.store.get_state_groups(event_ids) logger.debug("resolve_state_groups state_groups %s", state_groups.keys()) group_names = set(state_groups.keys()) if len(group_names) == 1: name, state_list = state_groups.items().pop() state = {(e.type, e.state_key): e for e in state_list} prev_state = state.get((event_type, state_key), None) if prev_state: prev_state = prev_state.event_id prev_states = [prev_state] else: prev_states = [] if self._state_cache is not None: cache = _StateCacheEntry(state=state, state_group=name, ts=self.clock.time_msec()) self._state_cache[frozenset(event_ids)] = cache defer.returnValue((name, state, prev_states)) new_state, prev_states = self._resolve_events(state_groups.values(), event_type, state_key) if self._state_cache is not None: cache = _StateCacheEntry(state=new_state, state_group=None, ts=self.clock.time_msec()) self._state_cache[frozenset(event_ids)] = cache defer.returnValue((None, new_state, prev_states)) def resolve_events(self, state_sets, event): if event.is_state(): return self._resolve_events(state_sets, event.type, event.state_key) else: return self._resolve_events(state_sets) def _resolve_events(self, state_sets, event_type=None, state_key=""): state = {} for st in state_sets: for e in st: state.setdefault((e.type, e.state_key), {})[e.event_id] = e unconflicted_state = { k: v.values()[0] for k, v in state.items() if len(v.values()) == 1 } conflicted_state = { k: v.values() for k, v in state.items() if len(v.values()) > 1 } if event_type: prev_states_events = conflicted_state.get((event_type, state_key), []) prev_states = [s.event_id for s in prev_states_events] else: prev_states = [] auth_events = { k: e for k, e in unconflicted_state.items() if k[0] in AuthEventTypes } try: resolved_state = self._resolve_state_events( conflicted_state, auth_events) except: logger.exception("Failed to resolve state") raise new_state = unconflicted_state new_state.update(resolved_state) return new_state, prev_states @log_function def _resolve_state_events(self, conflicted_state, auth_events): """ This is where we actually decide which of the conflicted state to use. We resolve conflicts in the following order: 1. power levels 2. memberships 3. other events. """ resolved_state = {} power_key = (EventTypes.PowerLevels, "") if power_key in conflicted_state.items(): power_levels = conflicted_state[power_key] resolved_state[power_key] = self._resolve_auth_events(power_levels) auth_events.update(resolved_state) for key, events in conflicted_state.items(): if key[0] == EventTypes.JoinRules: resolved_state[key] = self._resolve_auth_events( events, auth_events) auth_events.update(resolved_state) for key, events in conflicted_state.items(): if key[0] == EventTypes.Member: resolved_state[key] = self._resolve_auth_events( events, auth_events) auth_events.update(resolved_state) for key, events in conflicted_state.items(): if key not in resolved_state: resolved_state[key] = self._resolve_normal_events( events, auth_events) return resolved_state def _resolve_auth_events(self, events, auth_events): reverse = [i for i in reversed(self._ordered_events(events))] auth_events = dict(auth_events) prev_event = reverse[0] for event in reverse[1:]: auth_events[(prev_event.type, prev_event.state_key)] = prev_event try: # FIXME: hs.get_auth() is bad style, but we need to do it to # get around circular deps. self.hs.get_auth().check(event, auth_events) prev_event = event except AuthError: return prev_event return event def _resolve_normal_events(self, events, auth_events): for event in self._ordered_events(events): try: # FIXME: hs.get_auth() is bad style, but we need to do it to # get around circular deps. self.hs.get_auth().check(event, auth_events) return event except AuthError: pass # Use the last event (the one with the least depth) if they all fail # the auth check. return event def _ordered_events(self, events): def key_func(e): return -int(e.depth), hashlib.sha1(e.event_id).hexdigest() return sorted(events, key=key_func)
class FederationClient(FederationBase): def start_get_pdu_cache(self): self._get_pdu_cache = ExpiringCache( cache_name="get_pdu_cache", clock=self._clock, max_len=1000, expiry_ms=120*1000, reset_expiry_on_get=False, ) self._get_pdu_cache.start() @log_function def send_pdu(self, pdu, destinations): """Informs the replication layer about a new PDU generated within the home server that should be transmitted to others. TODO: Figure out when we should actually resolve the deferred. Args: pdu (Pdu): The new Pdu. Returns: Deferred: Completes when we have successfully processed the PDU and replicated it to any interested remote home servers. """ order = self._order self._order += 1 sent_pdus_destination_dist.inc_by(len(destinations)) logger.debug("[%s] transaction_layer.enqueue_pdu... ", pdu.event_id) # TODO, add errback, etc. self._transaction_queue.enqueue_pdu(pdu, destinations, order) logger.debug( "[%s] transaction_layer.enqueue_pdu... done", pdu.event_id ) @log_function def send_edu(self, destination, edu_type, content): edu = Edu( origin=self.server_name, destination=destination, edu_type=edu_type, content=content, ) sent_edus_counter.inc() # TODO, add errback, etc. self._transaction_queue.enqueue_edu(edu) return defer.succeed(None) @log_function def send_failure(self, failure, destination): self._transaction_queue.enqueue_failure(failure, destination) return defer.succeed(None) @log_function def make_query(self, destination, query_type, args, retry_on_dns_fail=True): """Sends a federation Query to a remote homeserver of the given type and arguments. Args: destination (str): Domain name of the remote homeserver query_type (str): Category of the query type; should match the handler name used in register_query_handler(). args (dict): Mapping of strings to strings containing the details of the query request. Returns: a Deferred which will eventually yield a JSON object from the response """ sent_queries_counter.inc(query_type) return self.transport_layer.make_query( destination, query_type, args, retry_on_dns_fail=retry_on_dns_fail ) @defer.inlineCallbacks @log_function def backfill(self, dest, context, limit, extremities): """Requests some more historic PDUs for the given context from the given destination server. Args: dest (str): The remote home server to ask. context (str): The context to backfill. limit (int): The maximum number of PDUs to return. extremities (list): List of PDU id and origins of the first pdus we have seen from the context Returns: Deferred: Results in the received PDUs. """ logger.debug("backfill extrem=%s", extremities) # If there are no extremeties then we've (probably) reached the start. if not extremities: return transaction_data = yield self.transport_layer.backfill( dest, context, extremities, limit) logger.debug("backfill transaction_data=%s", repr(transaction_data)) pdus = [ self.event_from_pdu_json(p, outlier=False) for p in transaction_data["pdus"] ] # FIXME: We should handle signature failures more gracefully. pdus[:] = yield defer.gatherResults( [self._check_sigs_and_hash(pdu) for pdu in pdus], consumeErrors=True, ).addErrback(unwrapFirstError) defer.returnValue(pdus) @defer.inlineCallbacks @log_function def get_pdu(self, destinations, event_id, outlier=False, timeout=None): """Requests the PDU with given origin and ID from the remote home servers. Will attempt to get the PDU from each destination in the list until one succeeds. This will persist the PDU locally upon receipt. Args: destinations (list): Which home servers to query pdu_origin (str): The home server that originally sent the pdu. event_id (str) outlier (bool): Indicates whether the PDU is an `outlier`, i.e. if it's from an arbitary point in the context as opposed to part of the current block of PDUs. Defaults to `False` timeout (int): How long to try (in ms) each destination for before moving to the next destination. None indicates no timeout. Returns: Deferred: Results in the requested PDU. """ # TODO: Rate limit the number of times we try and get the same event. if self._get_pdu_cache: e = self._get_pdu_cache.get(event_id) if e: defer.returnValue(e) pdu = None for destination in destinations: try: limiter = yield get_retry_limiter( destination, self._clock, self.store, ) with limiter: transaction_data = yield self.transport_layer.get_event( destination, event_id, timeout=timeout, ) logger.debug("transaction_data %r", transaction_data) pdu_list = [ self.event_from_pdu_json(p, outlier=outlier) for p in transaction_data["pdus"] ] if pdu_list and pdu_list[0]: pdu = pdu_list[0] # Check signatures are correct. pdu = yield self._check_sigs_and_hash(pdu) break except SynapseError: logger.info( "Failed to get PDU %s from %s because %s", event_id, destination, e, ) continue except CodeMessageException as e: if 400 <= e.code < 500: raise logger.info( "Failed to get PDU %s from %s because %s", event_id, destination, e, ) continue except NotRetryingDestination as e: logger.info(e.message) continue except Exception as e: logger.info( "Failed to get PDU %s from %s because %s", event_id, destination, e, ) continue if self._get_pdu_cache is not None and pdu: self._get_pdu_cache[event_id] = pdu defer.returnValue(pdu) @defer.inlineCallbacks @log_function def get_state_for_room(self, destination, room_id, event_id): """Requests all of the `current` state PDUs for a given room from a remote home server. Args: destination (str): The remote homeserver to query for the state. room_id (str): The id of the room we're interested in. event_id (str): The id of the event we want the state at. Returns: Deferred: Results in a list of PDUs. """ result = yield self.transport_layer.get_room_state( destination, room_id, event_id=event_id, ) pdus = [ self.event_from_pdu_json(p, outlier=True) for p in result["pdus"] ] auth_chain = [ self.event_from_pdu_json(p, outlier=True) for p in result.get("auth_chain", []) ] signed_pdus = yield self._check_sigs_and_hash_and_fetch( destination, pdus, outlier=True ) signed_auth = yield self._check_sigs_and_hash_and_fetch( destination, auth_chain, outlier=True ) signed_auth.sort(key=lambda e: e.depth) defer.returnValue((signed_pdus, signed_auth)) @defer.inlineCallbacks @log_function def get_event_auth(self, destination, room_id, event_id): res = yield self.transport_layer.get_event_auth( destination, room_id, event_id, ) auth_chain = [ self.event_from_pdu_json(p, outlier=True) for p in res["auth_chain"] ] signed_auth = yield self._check_sigs_and_hash_and_fetch( destination, auth_chain, outlier=True ) signed_auth.sort(key=lambda e: e.depth) defer.returnValue(signed_auth) @defer.inlineCallbacks def make_join(self, destinations, room_id, user_id): for destination in destinations: try: ret = yield self.transport_layer.make_join( destination, room_id, user_id ) pdu_dict = ret["event"] logger.debug("Got response to make_join: %s", pdu_dict) defer.returnValue( (destination, self.event_from_pdu_json(pdu_dict)) ) break except CodeMessageException: raise except Exception as e: logger.warn( "Failed to make_join via %s: %s", destination, e.message ) raise RuntimeError("Failed to send to any server.") @defer.inlineCallbacks def send_join(self, destinations, pdu): for destination in destinations: try: time_now = self._clock.time_msec() _, content = yield self.transport_layer.send_join( destination=destination, room_id=pdu.room_id, event_id=pdu.event_id, content=pdu.get_pdu_json(time_now), ) logger.debug("Got content: %s", content) state = [ self.event_from_pdu_json(p, outlier=True) for p in content.get("state", []) ] auth_chain = [ self.event_from_pdu_json(p, outlier=True) for p in content.get("auth_chain", []) ] signed_state, signed_auth = yield defer.gatherResults( [ self._check_sigs_and_hash_and_fetch( destination, state, outlier=True ), self._check_sigs_and_hash_and_fetch( destination, auth_chain, outlier=True ) ], consumeErrors=True ).addErrback(unwrapFirstError) auth_chain.sort(key=lambda e: e.depth) defer.returnValue({ "state": signed_state, "auth_chain": signed_auth, "origin": destination, }) except CodeMessageException: raise except Exception as e: logger.warn( "Failed to send_join via %s: %s", destination, e.message ) raise RuntimeError("Failed to send to any server.") @defer.inlineCallbacks def send_invite(self, destination, room_id, event_id, pdu): time_now = self._clock.time_msec() code, content = yield self.transport_layer.send_invite( destination=destination, room_id=room_id, event_id=event_id, content=pdu.get_pdu_json(time_now), ) pdu_dict = content["event"] logger.debug("Got response to send_invite: %s", pdu_dict) pdu = self.event_from_pdu_json(pdu_dict) # Check signatures are correct. pdu = yield self._check_sigs_and_hash(pdu) # FIXME: We should handle signature failures more gracefully. defer.returnValue(pdu) @defer.inlineCallbacks def query_auth(self, destination, room_id, event_id, local_auth): """ Params: destination (str) event_it (str) local_auth (list) """ time_now = self._clock.time_msec() send_content = { "auth_chain": [e.get_pdu_json(time_now) for e in local_auth], } code, content = yield self.transport_layer.send_query_auth( destination=destination, room_id=room_id, event_id=event_id, content=send_content, ) auth_chain = [ self.event_from_pdu_json(e) for e in content["auth_chain"] ] signed_auth = yield self._check_sigs_and_hash_and_fetch( destination, auth_chain, outlier=True ) signed_auth.sort(key=lambda e: e.depth) ret = { "auth_chain": signed_auth, "rejects": content.get("rejects", []), "missing": content.get("missing", []), } defer.returnValue(ret) @defer.inlineCallbacks def get_missing_events(self, destination, room_id, earliest_events_ids, latest_events, limit, min_depth): """Tries to fetch events we are missing. This is called when we receive an event without having received all of its ancestors. Args: destination (str) room_id (str) earliest_events_ids (list): List of event ids. Effectively the events we expected to receive, but haven't. `get_missing_events` should only return events that didn't happen before these. latest_events (list): List of events we have received that we don't have all previous events for. limit (int): Maximum number of events to return. min_depth (int): Minimum depth of events tor return. """ try: content = yield self.transport_layer.get_missing_events( destination=destination, room_id=room_id, earliest_events=earliest_events_ids, latest_events=[e.event_id for e in latest_events], limit=limit, min_depth=min_depth, ) events = [ self.event_from_pdu_json(e) for e in content.get("events", []) ] signed_events = yield self._check_sigs_and_hash_and_fetch( destination, events, outlier=False ) have_gotten_all_from_destination = True except HttpResponseException as e: if not e.code == 400: raise # We are probably hitting an old server that doesn't support # get_missing_events signed_events = [] have_gotten_all_from_destination = False if len(signed_events) >= limit: defer.returnValue(signed_events) servers = yield self.store.get_joined_hosts_for_room(room_id) servers = set(servers) servers.discard(self.server_name) failed_to_fetch = set() while len(signed_events) < limit: # Are we missing any? seen_events = set(earliest_events_ids) seen_events.update(e.event_id for e in signed_events if e) missing_events = {} for e in itertools.chain(latest_events, signed_events): if e.depth > min_depth: missing_events.update({ e_id: e.depth for e_id, _ in e.prev_events if e_id not in seen_events and e_id not in failed_to_fetch }) if not missing_events: break have_seen = yield self.store.have_events(missing_events) for k in have_seen: missing_events.pop(k, None) if not missing_events: break # Okay, we haven't gotten everything yet. Lets get them. ordered_missing = sorted(missing_events.items(), key=lambda x: x[0]) if have_gotten_all_from_destination: servers.discard(destination) def random_server_list(): srvs = list(servers) random.shuffle(srvs) return srvs deferreds = [ self.get_pdu( destinations=random_server_list(), event_id=e_id, ) for e_id, depth in ordered_missing[:limit - len(signed_events)] ] res = yield defer.DeferredList(deferreds, consumeErrors=True) for (result, val), (e_id, _) in zip(res, ordered_missing): if result and val: signed_events.append(val) else: failed_to_fetch.add(e_id) defer.returnValue(signed_events) def event_from_pdu_json(self, pdu_json, outlier=False): event = FrozenEvent( pdu_json ) event.internal_metadata.outlier = outlier return event
class StateHandler(object): """ Responsible for doing state conflict resolution. """ def __init__(self, hs): self.clock = hs.get_clock() self.store = hs.get_datastore() self.hs = hs # dict of set of event_ids -> _StateCacheEntry. self._state_cache = None def start_caching(self): logger.debug("start_caching") self._state_cache = ExpiringCache( cache_name="state_cache", clock=self.clock, max_len=SIZE_OF_CACHE, expiry_ms=EVICTION_TIMEOUT_SECONDS*1000, reset_expiry_on_get=True, ) self._state_cache.start() @defer.inlineCallbacks def get_current_state(self, room_id, event_type=None, state_key=""): """ Returns the current state for the room as a list. This is done by calling `get_latest_events_in_room` to get the leading edges of the event graph and then resolving any of the state conflicts. This is equivalent to getting the state of an event that were to send next before receiving any new events. If `event_type` is specified, then the method returns only the one event (or None) with that `event_type` and `state_key`. """ event_ids = yield self.store.get_latest_event_ids_in_room(room_id) cache = None if self._state_cache is not None: cache = self._state_cache.get(frozenset(event_ids), None) if cache: cache.ts = self.clock.time_msec() state = cache.state else: res = yield self.resolve_state_groups(event_ids) state = res[1] if event_type: defer.returnValue(state.get((event_type, state_key))) return defer.returnValue(state) @defer.inlineCallbacks def compute_event_context(self, event, old_state=None, outlier=False): """ Fills out the context with the `current state` of the graph. The `current state` here is defined to be the state of the event graph just before the event - i.e. it never includes `event` If `event` has `auth_events` then this will also fill out the `auth_events` field on `context` from the `current_state`. Args: event (EventBase) Returns: an EventContext """ yield run_on_reactor() context = EventContext() if outlier: # If this is an outlier, then we know it shouldn't have any current # state. Certainly store.get_current_state won't return any, and # persisting the event won't store the state group. if old_state: context.current_state = { (s.type, s.state_key): s for s in old_state } else: context.current_state = {} context.prev_state_events = [] context.state_group = None defer.returnValue(context) if old_state: context.current_state = { (s.type, s.state_key): s for s in old_state } context.state_group = None if event.is_state(): key = (event.type, event.state_key) if key in context.current_state: replaces = context.current_state[key] if replaces.event_id != event.event_id: # Paranoia check event.unsigned["replaces_state"] = replaces.event_id context.prev_state_events = [] defer.returnValue(context) if event.is_state(): ret = yield self.resolve_state_groups( [e for e, _ in event.prev_events], event_type=event.type, state_key=event.state_key, ) else: ret = yield self.resolve_state_groups( [e for e, _ in event.prev_events], ) group, curr_state, prev_state = ret context.current_state = curr_state context.state_group = group if not event.is_state() else None if event.is_state(): key = (event.type, event.state_key) if key in context.current_state: replaces = context.current_state[key] event.unsigned["replaces_state"] = replaces.event_id context.prev_state_events = prev_state defer.returnValue(context) @defer.inlineCallbacks @log_function def resolve_state_groups(self, event_ids, event_type=None, state_key=""): """ Given a list of event_ids this method fetches the state at each event, resolves conflicts between them and returns them. Return format is a tuple: (`state_group`, `state_events`), where the first is the name of a state group if one and only one is involved, otherwise `None`. """ logger.debug("resolve_state_groups event_ids %s", event_ids) if self._state_cache is not None: cache = self._state_cache.get(frozenset(event_ids), None) if cache and cache.state_group: cache.ts = self.clock.time_msec() prev_state = cache.state.get((event_type, state_key), None) if prev_state: prev_state = prev_state.event_id prev_states = [prev_state] else: prev_states = [] defer.returnValue( (cache.state_group, cache.state, prev_states) ) state_groups = yield self.store.get_state_groups( event_ids ) logger.debug( "resolve_state_groups state_groups %s", state_groups.keys() ) group_names = set(state_groups.keys()) if len(group_names) == 1: name, state_list = state_groups.items().pop() state = { (e.type, e.state_key): e for e in state_list } prev_state = state.get((event_type, state_key), None) if prev_state: prev_state = prev_state.event_id prev_states = [prev_state] else: prev_states = [] if self._state_cache is not None: cache = _StateCacheEntry( state=state, state_group=name, ts=self.clock.time_msec() ) self._state_cache[frozenset(event_ids)] = cache defer.returnValue((name, state, prev_states)) new_state, prev_states = self._resolve_events( state_groups.values(), event_type, state_key ) if self._state_cache is not None: cache = _StateCacheEntry( state=new_state, state_group=None, ts=self.clock.time_msec() ) self._state_cache[frozenset(event_ids)] = cache defer.returnValue((None, new_state, prev_states)) def resolve_events(self, state_sets, event): if event.is_state(): return self._resolve_events( state_sets, event.type, event.state_key ) else: return self._resolve_events(state_sets) def _resolve_events(self, state_sets, event_type=None, state_key=""): state = {} for st in state_sets: for e in st: state.setdefault( (e.type, e.state_key), {} )[e.event_id] = e unconflicted_state = { k: v.values()[0] for k, v in state.items() if len(v.values()) == 1 } conflicted_state = { k: v.values() for k, v in state.items() if len(v.values()) > 1 } if event_type: prev_states_events = conflicted_state.get( (event_type, state_key), [] ) prev_states = [s.event_id for s in prev_states_events] else: prev_states = [] auth_events = { k: e for k, e in unconflicted_state.items() if k[0] in AuthEventTypes } try: resolved_state = self._resolve_state_events( conflicted_state, auth_events ) except: logger.exception("Failed to resolve state") raise new_state = unconflicted_state new_state.update(resolved_state) return new_state, prev_states @log_function def _resolve_state_events(self, conflicted_state, auth_events): """ This is where we actually decide which of the conflicted state to use. We resolve conflicts in the following order: 1. power levels 2. memberships 3. other events. """ resolved_state = {} power_key = (EventTypes.PowerLevels, "") if power_key in conflicted_state.items(): power_levels = conflicted_state[power_key] resolved_state[power_key] = self._resolve_auth_events(power_levels) auth_events.update(resolved_state) for key, events in conflicted_state.items(): if key[0] == EventTypes.JoinRules: resolved_state[key] = self._resolve_auth_events( events, auth_events ) auth_events.update(resolved_state) for key, events in conflicted_state.items(): if key[0] == EventTypes.Member: resolved_state[key] = self._resolve_auth_events( events, auth_events ) auth_events.update(resolved_state) for key, events in conflicted_state.items(): if key not in resolved_state: resolved_state[key] = self._resolve_normal_events( events, auth_events ) return resolved_state def _resolve_auth_events(self, events, auth_events): reverse = [i for i in reversed(self._ordered_events(events))] auth_events = dict(auth_events) prev_event = reverse[0] for event in reverse[1:]: auth_events[(prev_event.type, prev_event.state_key)] = prev_event try: # FIXME: hs.get_auth() is bad style, but we need to do it to # get around circular deps. self.hs.get_auth().check(event, auth_events) prev_event = event except AuthError: return prev_event return event def _resolve_normal_events(self, events, auth_events): for event in self._ordered_events(events): try: # FIXME: hs.get_auth() is bad style, but we need to do it to # get around circular deps. self.hs.get_auth().check(event, auth_events) return event except AuthError: pass # Use the last event (the one with the least depth) if they all fail # the auth check. return event def _ordered_events(self, events): def key_func(e): return -int(e.depth), hashlib.sha1(e.event_id).hexdigest() return sorted(events, key=key_func)
class FederationClient(FederationBase): def __init__(self): self._get_pdu_cache = None def start_get_pdu_cache(self): self._get_pdu_cache = ExpiringCache( cache_name="get_pdu_cache", clock=self._clock, max_len=1000, expiry_ms=120 * 1000, reset_expiry_on_get=False, ) self._get_pdu_cache.start() @log_function def send_pdu(self, pdu, destinations): """Informs the replication layer about a new PDU generated within the home server that should be transmitted to others. TODO: Figure out when we should actually resolve the deferred. Args: pdu (Pdu): The new Pdu. Returns: Deferred: Completes when we have successfully processed the PDU and replicated it to any interested remote home servers. """ order = self._order self._order += 1 logger.debug("[%s] transaction_layer.enqueue_pdu... ", pdu.event_id) # TODO, add errback, etc. self._transaction_queue.enqueue_pdu(pdu, destinations, order) logger.debug("[%s] transaction_layer.enqueue_pdu... done", pdu.event_id) @log_function def send_edu(self, destination, edu_type, content): edu = Edu( origin=self.server_name, destination=destination, edu_type=edu_type, content=content, ) # TODO, add errback, etc. self._transaction_queue.enqueue_edu(edu) return defer.succeed(None) @log_function def send_failure(self, failure, destination): self._transaction_queue.enqueue_failure(failure, destination) return defer.succeed(None) @log_function def make_query(self, destination, query_type, args, retry_on_dns_fail=True): """Sends a federation Query to a remote homeserver of the given type and arguments. Args: destination (str): Domain name of the remote homeserver query_type (str): Category of the query type; should match the handler name used in register_query_handler(). args (dict): Mapping of strings to strings containing the details of the query request. Returns: a Deferred which will eventually yield a JSON object from the response """ return self.transport_layer.make_query( destination, query_type, args, retry_on_dns_fail=retry_on_dns_fail) @defer.inlineCallbacks @log_function def backfill(self, dest, context, limit, extremities): """Requests some more historic PDUs for the given context from the given destination server. Args: dest (str): The remote home server to ask. context (str): The context to backfill. limit (int): The maximum number of PDUs to return. extremities (list): List of PDU id and origins of the first pdus we have seen from the context Returns: Deferred: Results in the received PDUs. """ logger.debug("backfill extrem=%s", extremities) # If there are no extremeties then we've (probably) reached the start. if not extremities: return transaction_data = yield self.transport_layer.backfill( dest, context, extremities, limit) logger.debug("backfill transaction_data=%s", repr(transaction_data)) pdus = [ self.event_from_pdu_json(p, outlier=False) for p in transaction_data["pdus"] ] for i, pdu in enumerate(pdus): pdus[i] = yield self._check_sigs_and_hash(pdu) # FIXME: We should handle signature failures more gracefully. defer.returnValue(pdus) @defer.inlineCallbacks @log_function def get_pdu(self, destinations, event_id, outlier=False): """Requests the PDU with given origin and ID from the remote home servers. Will attempt to get the PDU from each destination in the list until one succeeds. This will persist the PDU locally upon receipt. Args: destinations (list): Which home servers to query pdu_origin (str): The home server that originally sent the pdu. event_id (str) outlier (bool): Indicates whether the PDU is an `outlier`, i.e. if it's from an arbitary point in the context as opposed to part of the current block of PDUs. Defaults to `False` Returns: Deferred: Results in the requested PDU. """ # TODO: Rate limit the number of times we try and get the same event. if self._get_pdu_cache: e = self._get_pdu_cache.get(event_id) if e: defer.returnValue(e) pdu = None for destination in destinations: try: limiter = yield get_retry_limiter( destination, self._clock, self.store, ) with limiter: transaction_data = yield self.transport_layer.get_event( destination, event_id) logger.debug("transaction_data %r", transaction_data) pdu_list = [ self.event_from_pdu_json(p, outlier=outlier) for p in transaction_data["pdus"] ] if pdu_list: pdu = pdu_list[0] # Check signatures are correct. pdu = yield self._check_sigs_and_hash(pdu) break except SynapseError: logger.info( "Failed to get PDU %s from %s because %s", event_id, destination, e, ) continue except CodeMessageException as e: if 400 <= e.code < 500: raise logger.info( "Failed to get PDU %s from %s because %s", event_id, destination, e, ) continue except NotRetryingDestination as e: logger.info(e.message) continue except Exception as e: logger.info( "Failed to get PDU %s from %s because %s", event_id, destination, e, ) continue if self._get_pdu_cache is not None: self._get_pdu_cache[event_id] = pdu defer.returnValue(pdu) @defer.inlineCallbacks @log_function def get_state_for_room(self, destination, room_id, event_id): """Requests all of the `current` state PDUs for a given room from a remote home server. Args: destination (str): The remote homeserver to query for the state. room_id (str): The id of the room we're interested in. event_id (str): The id of the event we want the state at. Returns: Deferred: Results in a list of PDUs. """ result = yield self.transport_layer.get_room_state( destination, room_id, event_id=event_id, ) pdus = [ self.event_from_pdu_json(p, outlier=True) for p in result["pdus"] ] auth_chain = [ self.event_from_pdu_json(p, outlier=True) for p in result.get("auth_chain", []) ] signed_pdus = yield self._check_sigs_and_hash_and_fetch(destination, pdus, outlier=True) signed_auth = yield self._check_sigs_and_hash_and_fetch(destination, auth_chain, outlier=True) signed_auth.sort(key=lambda e: e.depth) defer.returnValue((signed_pdus, signed_auth)) @defer.inlineCallbacks @log_function def get_event_auth(self, destination, room_id, event_id): res = yield self.transport_layer.get_event_auth( destination, room_id, event_id, ) auth_chain = [ self.event_from_pdu_json(p, outlier=True) for p in res["auth_chain"] ] signed_auth = yield self._check_sigs_and_hash_and_fetch(destination, auth_chain, outlier=True) signed_auth.sort(key=lambda e: e.depth) defer.returnValue(signed_auth) @defer.inlineCallbacks def make_join(self, destinations, room_id, user_id): for destination in destinations: try: ret = yield self.transport_layer.make_join( destination, room_id, user_id) pdu_dict = ret["event"] logger.debug("Got response to make_join: %s", pdu_dict) defer.returnValue( (destination, self.event_from_pdu_json(pdu_dict))) break except CodeMessageException: raise except Exception as e: logger.warn("Failed to make_join via %s: %s", destination, e.message) raise RuntimeError("Failed to send to any server.") @defer.inlineCallbacks def send_join(self, destinations, pdu): for destination in destinations: try: time_now = self._clock.time_msec() _, content = yield self.transport_layer.send_join( destination=destination, room_id=pdu.room_id, event_id=pdu.event_id, content=pdu.get_pdu_json(time_now), ) logger.debug("Got content: %s", content) state = [ self.event_from_pdu_json(p, outlier=True) for p in content.get("state", []) ] auth_chain = [ self.event_from_pdu_json(p, outlier=True) for p in content.get("auth_chain", []) ] signed_state = yield self._check_sigs_and_hash_and_fetch( destination, state, outlier=True) signed_auth = yield self._check_sigs_and_hash_and_fetch( destination, auth_chain, outlier=True) auth_chain.sort(key=lambda e: e.depth) defer.returnValue({ "state": signed_state, "auth_chain": signed_auth, "origin": destination, }) except CodeMessageException: raise except Exception as e: logger.warn("Failed to send_join via %s: %s", destination, e.message) raise RuntimeError("Failed to send to any server.") @defer.inlineCallbacks def send_invite(self, destination, room_id, event_id, pdu): time_now = self._clock.time_msec() code, content = yield self.transport_layer.send_invite( destination=destination, room_id=room_id, event_id=event_id, content=pdu.get_pdu_json(time_now), ) pdu_dict = content["event"] logger.debug("Got response to send_invite: %s", pdu_dict) pdu = self.event_from_pdu_json(pdu_dict) # Check signatures are correct. pdu = yield self._check_sigs_and_hash(pdu) # FIXME: We should handle signature failures more gracefully. defer.returnValue(pdu) @defer.inlineCallbacks def query_auth(self, destination, room_id, event_id, local_auth): """ Params: destination (str) event_it (str) local_auth (list) """ time_now = self._clock.time_msec() send_content = { "auth_chain": [e.get_pdu_json(time_now) for e in local_auth], } code, content = yield self.transport_layer.send_query_auth( destination=destination, room_id=room_id, event_id=event_id, content=send_content, ) auth_chain = [ self.event_from_pdu_json(e) for e in content["auth_chain"] ] signed_auth = yield self._check_sigs_and_hash_and_fetch(destination, auth_chain, outlier=True) signed_auth.sort(key=lambda e: e.depth) ret = { "auth_chain": signed_auth, "rejects": content.get("rejects", []), "missing": content.get("missing", []), } defer.returnValue(ret) def event_from_pdu_json(self, pdu_json, outlier=False): event = FrozenEvent(pdu_json) event.internal_metadata.outlier = outlier return event