maxmustermann/synapse
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Various typos and bug fixes.

Browse source
This commit is contained in:
Erik Johnston 2014-12-08 09:08:26 +00:00
parent 6630e1b579
commit d044121168
8 changed files with 80 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
synapse/api/auth.py
View file

@ -24,6 +24,7 @@ from synapse.api.events.room import (
RoomJoinRulesEvent, RoomCreateEvent, RoomAliasesEvent, RoomJoinRulesEvent, RoomCreateEvent, RoomAliasesEvent,
) )
from synapse.util.logutils import log_function from synapse.util.logutils import log_function
from synapse.util.async import run_on_reactor
from syutil.base64util import encode_base64 from syutil.base64util import encode_base64
import logging import logging
@ -352,17 +353,19 @@ class Auth(object):
@defer.inlineCallbacks @defer.inlineCallbacks
def add_auth_events(self, builder, context): def add_auth_events(self, builder, context):
yield run_on_reactor()
if builder.type == RoomCreateEvent.TYPE: if builder.type == RoomCreateEvent.TYPE:
builder.auth_events = [] builder.auth_events = []
return return
auth_events = [] auth_ids = []
key = (RoomPowerLevelsEvent.TYPE, "", ) key = (RoomPowerLevelsEvent.TYPE, "", )
power_level_event = context.current_state.get(key) power_level_event = context.current_state.get(key)
if power_level_event: if power_level_event:
auth_events.append(power_level_event.event_id) auth_ids.append(power_level_event.event_id)
key = (RoomJoinRulesEvent.TYPE, "", ) key = (RoomJoinRulesEvent.TYPE, "", )
join_rule_event = context.current_state.get(key) join_rule_event = context.current_state.get(key)
@ -373,7 +376,7 @@ class Auth(object):
key = (RoomCreateEvent.TYPE, "", ) key = (RoomCreateEvent.TYPE, "", )
create_event = context.current_state.get(key) create_event = context.current_state.get(key)
if create_event: if create_event:
auth_events.append(create_event.event_id) auth_ids.append(create_event.event_id)
if join_rule_event: if join_rule_event:
join_rule = join_rule_event.content.get("join_rule") join_rule = join_rule_event.content.get("join_rule")
@ -385,15 +388,14 @@ class Auth(object):
e_type = builder.content["membership"] e_type = builder.content["membership"]
if e_type in [Membership.JOIN, Membership.INVITE]: if e_type in [Membership.JOIN, Membership.INVITE]:
if join_rule_event: if join_rule_event:
auth_events.append(join_rule_event.event_id) auth_ids.append(join_rule_event.event_id)
if member_event and not is_public: if member_event and not is_public:
auth_events.append(member_event.event_id) auth_ids.append(member_event.event_id)
elif member_event: elif member_event:
if member_event.content["membership"] == Membership.JOIN: if member_event.content["membership"] == Membership.JOIN:
auth_events.append(member_event.event_id) auth_ids.append(member_event.event_id)
auth_ids = [(a.event_id, h) for a, h in auth_events]
auth_events_entries = yield self.store.add_event_hashes( auth_events_entries = yield self.store.add_event_hashes(
auth_ids auth_ids
) )

3
synapse/events/snapshot.py
View file

@ -58,6 +58,7 @@ class EventCache(object):
class EventContext(object): class EventContext(object):
def __init__(self, current_state, auth_events): def __init__(self, current_state=None, auth_events=None):
self.current_state = current_state self.current_state = current_state
self.auth_events = auth_events self.auth_events = auth_events
self.state_group = None

2
synapse/events/utils.py
View file

@ -95,4 +95,6 @@ def serialize_event(hs, e):
d["unsigned"]["age"] = now - d["unsigned"]["age_ts"] d["unsigned"]["age"] = now - d["unsigned"]["age_ts"]
del d["unsigned"]["age_ts"] del d["unsigned"]["age_ts"]
d["user_id"] = d.pop("sender", None)
return d return d

12
synapse/federation/replication.py
View file

@ -558,7 +558,13 @@ class ReplicationLayer(object):
origin, pdu.event_id, do_auth=False origin, pdu.event_id, do_auth=False
) )
if existing and (not existing.outlier or pdu.outlier): already_seen = (
existing and (
not existing.internal_metadata.outlier
or pdu.internal_metadata.outlier
)
)
if already_seen:
logger.debug("Already seen pdu %s", pdu.event_id) logger.debug("Already seen pdu %s", pdu.event_id)
defer.returnValue({}) defer.returnValue({})
return return
@ -596,7 +602,7 @@ class ReplicationLayer(object):
# ) # )
# Get missing pdus if necessary. # Get missing pdus if necessary.
if not pdu.outlier: if not pdu.internal_metadata.outlier:
# We only backfill backwards to the min depth. # We only backfill backwards to the min depth.
min_depth = yield self.handler.get_min_depth_for_context( min_depth = yield self.handler.get_min_depth_for_context(
pdu.room_id pdu.room_id
@ -663,7 +669,7 @@ class ReplicationLayer(object):
pdu_json pdu_json
) )
builder.internal_metadata = outlier builder.internal_metadata.outlier = outlier
return builder.build() return builder.build()

8
synapse/handlers/_base.py
View file

@ -62,6 +62,8 @@ class BaseHandler(object):
@defer.inlineCallbacks @defer.inlineCallbacks
def _create_new_client_event(self, builder): def _create_new_client_event(self, builder):
yield run_on_reactor()
context = EventContext() context = EventContext()
latest_ret = yield self.store.get_latest_events_in_room( latest_ret = yield self.store.get_latest_events_in_room(
@ -79,7 +81,7 @@ class BaseHandler(object):
builder, builder,
context, context,
) )
group, prev_state = ret prev_state = ret
if builder.is_state(): if builder.is_state():
prev_state = yield self.store.add_event_hashes( prev_state = yield self.store.add_event_hashes(
@ -88,8 +90,6 @@ class BaseHandler(object):
builder.prev_state = prev_state builder.prev_state = prev_state
builder.internal_metadata.state_group = group
yield self.auth.add_auth_events(builder, context) yield self.auth.add_auth_events(builder, context)
add_hashes_and_signatures( add_hashes_and_signatures(
@ -105,6 +105,8 @@ class BaseHandler(object):
@defer.inlineCallbacks @defer.inlineCallbacks
def handle_new_client_event(self, event, context, extra_destinations=[], def handle_new_client_event(self, event, context, extra_destinations=[],
extra_users=[], suppress_auth=False): extra_users=[], suppress_auth=False):
yield run_on_reactor()
# We now need to go and hit out to wherever we need to hit out to. # We now need to go and hit out to wherever we need to hit out to.
if not suppress_auth: if not suppress_auth:

97
synapse/handlers/federation.py
View file

@ -149,7 +149,7 @@ class FederationHandler(BaseHandler):
event.room_id, event.room_id,
self.server_name self.server_name
) )
if not is_in_room and not event.outlier: if not is_in_room and not event.internal_metadata.outlier:
logger.debug("Got event for room we're not in.") logger.debug("Got event for room we're not in.")
replication_layer = self.replication_layer replication_layer = self.replication_layer
@ -160,7 +160,7 @@ class FederationHandler(BaseHandler):
) )
for e in auth_chain: for e in auth_chain:
e.outlier = True e.internal_metadata.outlier = True
try: try:
yield self._handle_new_event(e, fetch_missing=False) yield self._handle_new_event(e, fetch_missing=False)
except: except:
@ -180,7 +180,7 @@ class FederationHandler(BaseHandler):
if state: if state:
for e in state: for e in state:
e.outlier = True e.internal_metadata.outlier = True
try: try:
yield self._handle_new_event(e) yield self._handle_new_event(e)
except: except:
@ -254,11 +254,18 @@ class FederationHandler(BaseHandler):
event = pdu event = pdu
# FIXME (erikj): Not sure this actually works :/ # FIXME (erikj): Not sure this actually works :/
yield self.state_handler.annotate_event_with_state(event) context = EventContext()
yield self.state_handler.annotate_context_with_state(event, context)
events.append(event) events.append(
(event, context)
)
yield self.store.persist_event(event, backfilled=True) yield self.store.persist_event(
event,
context=context,
backfilled=True
)
defer.returnValue(events) defer.returnValue(events)
@ -326,7 +333,7 @@ class FederationHandler(BaseHandler):
assert(event.state_key == joinee) assert(event.state_key == joinee)
assert(event.room_id == room_id) assert(event.room_id == room_id)
event.outlier = False event.internal_metadata.outlier = False
self.room_queues[room_id] = [] self.room_queues[room_id] = []
@ -369,7 +376,7 @@ class FederationHandler(BaseHandler):
pass pass
for e in auth_chain: for e in auth_chain:
e.outlier = True e.internal_metadata.outlier = True
try: try:
yield self._handle_new_event(e, fetch_missing=False) yield self._handle_new_event(e, fetch_missing=False)
except: except:
@ -380,7 +387,7 @@ class FederationHandler(BaseHandler):
for e in state: for e in state:
# FIXME: Auth these. # FIXME: Auth these.
e.outlier = True e.internal_metadata.outlier = True
try: try:
yield self._handle_new_event( yield self._handle_new_event(
e, e,
@ -448,7 +455,7 @@ class FederationHandler(BaseHandler):
""" """
event = pdu event = pdu
event.outlier = False event.internal_metadata.outlier = False
yield self._handle_new_event(event) yield self._handle_new_event(event)
@ -643,70 +650,42 @@ class FederationHandler(BaseHandler):
def _handle_new_event(self, event, state=None, backfilled=False, def _handle_new_event(self, event, state=None, backfilled=False,
current_state=None, fetch_missing=True): current_state=None, fetch_missing=True):
context = EventContext() context = EventContext()
is_new_state = yield self.state_handler.annotate_event_with_state( yield self.state_handler.annotate_context_with_state(
event, event,
old_state=state old_state=state
) )
if event.old_state_events: is_new_state = not event.internal_metadata.outlier
known_ids = set(
[s.event_id for s in event.old_state_events.values()]
)
for e_id, _ in event.auth_events:
if e_id not in known_ids:
e = yield self.store.get_event(
e_id,
allow_none=True,
)
if not e: known_ids = set(
# TODO: Do some conflict res to make sure that we're [s.event_id for s in context.auth_events.values()]
# not the ones who are wrong. )
logger.info( for e_id, _ in event.auth_events:
"Rejecting %s as %s not in %s", if e_id not in known_ids:
event.event_id, e_id, known_ids,
)
raise AuthError(403, "Auth events are stale")
auth_events = event.old_state_events
else:
# We need to get the auth events from somewhere.
# TODO: Don't just hit the DBs?
auth_events = {}
for e_id, _ in event.auth_events:
e = yield self.store.get_event( e = yield self.store.get_event(
e_id, e_id,
context,
allow_none=True, allow_none=True,
) )
if not e: if not e:
e = yield self.replication_layer.get_pdu( # TODO: Do some conflict res to make sure that we're
event.origin, e_id, outlier=True # not the ones who are wrong.
logger.info(
"Rejecting %s as %s not in %s",
event.event_id, e_id, known_ids,
) )
raise AuthError(403, "Auth events are stale")
if e and fetch_missing: context.auth_events[(e.type, e.state_key)] = e
try:
yield self.on_receive_pdu(event.origin, e, False)
except:
logger.exception(
"Failed to parse auth event %s",
e_id,
)
if not e: if event.type == RoomMemberEvent.TYPE and not event.auth_events:
logger.warn("Can't find auth event %s.", e_id) if len(event.prev_events) == 1:
c = yield self.store.get_event(event.prev_events[0][0])
if c.type == RoomCreateEvent.TYPE:
context.auth_events[(c.type, c.state_key)] = c
auth_events[(e.type, e.state_key)] = e self.auth.check(event, auth_events=context.auth_events)
if event.type == RoomMemberEvent.TYPE and not event.auth_events:
if len(event.prev_events) == 1:
c = yield self.store.get_event(event.prev_events[0][0])
if c.type == RoomCreateEvent.TYPE:
auth_events[(c.type, c.state_key)] = c
self.auth.check(event, auth_events=auth_events)
yield self.store.persist_event( yield self.store.persist_event(
event, event,

16
synapse/state.py
View file

@ -136,7 +136,16 @@ class StateHandler(object):
defer.returnValue(res[1].values()) defer.returnValue(res[1].values())
@defer.inlineCallbacks @defer.inlineCallbacks
def annotate_context_with_state(self, event, context): def annotate_context_with_state(self, event, context, old_state=None):
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
defer.returnValue([])
if event.is_state(): if event.is_state():
ret = yield self.resolve_state_groups( ret = yield self.resolve_state_groups(
[e for e, _ in event.prev_events], [e for e, _ in event.prev_events],
@ -151,6 +160,7 @@ class StateHandler(object):
group, curr_state, prev_state = ret group, curr_state, prev_state = ret
context.current_state = curr_state context.current_state = curr_state
context.state_group = group
prev_state = yield self.store.add_event_hashes( prev_state = yield self.store.add_event_hashes(
prev_state prev_state
@ -164,9 +174,7 @@ class StateHandler(object):
if v.event_id in auth_ids if v.event_id in auth_ids
} }
defer.returnValue( defer.returnValue(prev_state)
(group, prev_state)
)
@defer.inlineCallbacks @defer.inlineCallbacks
@log_function @log_function

6
synapse/storage/state.py
View file

@ -87,10 +87,10 @@ class StateStore(SQLBaseStore):
) )
def _store_state_groups_txn(self, txn, event, context): def _store_state_groups_txn(self, txn, event, context):
if context.current_state_events is None: if context.current_state is None:
return return
state_events = context.current_state_events state_events = context.current_state
if event.is_state(): if event.is_state():
state_events[(event.type, event.state_key)] = event state_events[(event.type, event.state_key)] = event
@ -107,7 +107,7 @@ class StateStore(SQLBaseStore):
or_ignore=True, or_ignore=True,
) )
for state in context.state_events.values(): for state in state_events.values():
self._simple_insert_txn( self._simple_insert_txn(
txn, txn,
table="state_groups_state", table="state_groups_state",