Start implementing the non-incremental sync portion of the v2 /sync API

1 files changed, 62 insertions, 25 deletions

diff --git a/synapse/handlers/sync.py b/synapse/handlers/sync.py
index ec20ea4890..bbabaf3df1 100644
--- a/synapse/handlers/sync.py
+++ b/synapse/handlers/sync.py
@@ -1,26 +1,49 @@
+# -*- coding: utf-8 -*-
+# Copyright 2015 OpenMarket Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ._base import BaseHandler
+
+from synapse.streams.config import PaginationConfig
+from synapse.api.constants import Membership
+
+from twisted.internet import defer
+
 import collections
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 SyncConfig = collections.namedtuple("SyncConfig", [
     "user",
     "device",
-    "since",
     "limit",
     "gap",
-    "sort"
-    "backfill"
+    "sort",
+    "backfill",
     "filter",
-)
+])
 
 
 RoomSyncResult = collections.namedtuple("RoomSyncResult", [
     "room_id",
     "limited",
     "published",
-    "prev_batch",
-    "events",
+    "events", # dict of event
     "state",
-    "event_map",
+    "prev_batch",
 ])
 
 
@@ -41,10 +64,11 @@ class SyncHandler(BaseHandler):
     def __init__(self, hs):
         super(SyncHandler, self).__init__(hs)
         self.event_sources = hs.get_event_sources()
+        self.clock = hs.get_clock()
 
     def wait_for_sync_for_user(self, sync_config, since_token=None, timeout=0):
         if timeout == 0:
-            return self.current_sync_for_user(sync_config, since)
+            return self.current_sync_for_user(sync_config, since_token)
         else:
             def current_sync_callback(since_token):
                 return self.current_sync_for_user(
@@ -53,58 +77,71 @@ class SyncHandler(BaseHandler):
             return self.notifier.wait_for_events(
                 sync_config.filter, since_token, current_sync_callback
             )
-        defer.returnValue(result)
 
     def current_sync_for_user(self, sync_config, since_token=None):
         if since_token is None:
-            return self.inital_sync(sync_config)
+            return self.initial_sync(sync_config)
         else:
             return self.incremental_sync(sync_config)
 
     @defer.inlineCallbacks
     def initial_sync(self, sync_config):
+        if sync_config.sort == "timeline,desc":
+            # TODO(mjark): Handle going through events in reverse order?.
+            # What does "most recent events" mean when applying the limits mean
+            # in this case?
+            raise NotImplementedError()
+
         now_token = yield self.event_sources.get_current_token()
 
         presence_stream = self.event_sources.sources["presence"]
-        # TODO (markjh): This looks wrong, shouldn't we be getting the presence
+        # TODO (mjark): This looks wrong, shouldn't we be getting the presence
         # UP to the present rather than after the present?
         pagination_config = PaginationConfig(from_token=now_token)
         presence, _ = yield presence_stream.get_pagination_rows(
-            user, pagination_config.get_source_config("presence"), None
+            user=sync_config.user,
+            pagination_config=pagination_config.get_source_config("presence"),
+            key=None
         )
         room_list = yield self.store.get_rooms_for_user_where_membership_is(
-            user_id=user_id,
+            user_id=sync_config.user.to_string(),
             membership_list=[Membership.INVITE, Membership.JOIN]
         )
 
-        # TODO (markjh): Does public mean "published"?
+        # TODO (mjark): Does public mean "published"?
         published_rooms = yield self.store.get_rooms(is_public=True)
-        published_room_ids = set(r["room_id"] for r in public_rooms)
+        published_room_ids = set(r["room_id"] for r in published_rooms)
 
+        rooms = []
         for event in room_list:
-
-            messages, token = yield self.store.get_recent_events_for_room(
+            #TODO (mjark): Apply the event filter in sync_config.
+            recent_events, token = yield self.store.get_recent_events_for_room(
                 event.room_id,
                 limit=sync_config.limit,
                 end_token=now_token.room_key,
             )
             prev_batch_token = now_token.copy_and_replace("room_key", token[0])
-            current_state = yield self.state_handler.get_current_state(
+            current_state_events = yield self.state_handler.get_current_state(
                 event.room_id
             )
 
             rooms.append(RoomSyncResult(
                 room_id=event.room_id,
                 published=event.room_id in published_room_ids,
+                events=recent_events,
+                prev_batch=prev_batch_token,
+                state=current_state_events,
+                limited=True,
+            ))
 
-
-
+        defer.returnValue(SyncResult(
+            public_user_data=presence,
+            private_user_data=[],
+            rooms=rooms,
+            next_batch=now_token,
+        ))
 
 
     @defer.inlineCallbacks
     def incremental_sync(self, sync_config):
-        
-
-
-
-
+        pass