Save current hash on the document

Author: krassowski

packages/docprovider/src/ydrive.ts

@@ -4,6 +4,7 @@
 import { PageConfig, URLExt } from '@jupyterlab/coreutils';
 import { TranslationBundle } from '@jupyterlab/translation';
 import { Contents, Drive, User } from '@jupyterlab/services';
+import { ISignal, Signal } from '@lumino/signaling';
 
 import { DocumentChange, ISharedDocument, YDocument } from '@jupyter/ydoc';
 
@@ -45,6 +46,10 @@ export class YDrive extends Drive implements ICollaborativeDrive {
     this._providers = new Map<string, WebSocketProvider>();
 
     this.sharedModelFactory = new SharedModelFactory(this._onCreate);
+    super.fileChanged.connect((_, change) => {
+      // pass through any events from the Drive superclass
+      this._ydriveFileChanged.emit(change);
+    });
   }
 
   /**
@@ -84,7 +89,7 @@ export class YDrive extends Drive implements ICollaborativeDrive {
       const provider = this._providers.get(key);
 
       if (provider) {
-        // If the document does't exist, `super.get` will reject with an
+        // If the document doesn't exist, `super.get` will reject with an
         // error and the provider will never be resolved.
         // Use `Promise.all` to reject as soon as possible. The Context will
         // show a dialog to the user.
@@ -132,6 +137,13 @@ export class YDrive extends Drive implements ICollaborativeDrive {
     return super.save(localPath, options);
   }
 
+  /**
+   * A signal emitted when a file operation takes place.
+   */
+  get fileChanged(): ISignal<this, Contents.IChangedArgs> {
+    return this._ydriveFileChanged;
+  }
+
   private _onCreate = (
     options: Contents.ISharedFactoryOptions,
     sharedModel: YDocument<DocumentChange>
@@ -161,6 +173,51 @@ export class YDrive extends Drive implements ICollaborativeDrive {
       const key = `${options.format}:${options.contentType}:${options.path}`;
       this._providers.set(key, provider);
 
+      sharedModel.changed.connect(async (_, change) => {
+        // TODO: make use of the hash
+        if (!change.stateChange) {
+          return;
+        }
+        const hashChanges = change.stateChange.filter(
+          change => change.name === 'hash'
+        );
+        if (hashChanges.length === 0) {
+          return;
+        }
+        if (hashChanges.length > 1) {
+          console.error(
+            'Unexpected multiple changes to hash value in a single transaction'
+          );
+        }
+        const hashChange = hashChanges[0];
+
+        // A change in hash signifies that a save occurred on the server-side
+        // (e.g. a collaborator performed the save) - we want notify the observers
+        // about this change so that they can store the new hash value.
+
+        const model = await this.get(options.path, { content: false });
+        /*
+        this._ydriveFileChanged.emit({
+          type: 'server-side-save',
+          newValue: {...model, hash: hashChange.newValue},
+          // we do not have the old model because it was discarded when server made the change,
+          // we only have the old hash here (which may be empty if the file was newly created!)
+          oldValue: {hash: hashChange.oldValue}
+        });
+        */
+        // TODO: add handler for `server-side-save` in
+        // https://github.com/jupyterlab/jupyterlab/blob/dca1ec376c66038b8df7001d32cf058c70fcd717/packages/docregistry/src/context.ts#L410-L444
+        // For now, fake it:
+        // it happens that "rename" will perform the update of context's internal
+        // contentsModel (which we desire to solve the spurious "File Changed" dialog)
+        // even if file path has not changed.
+        this._ydriveFileChanged.emit({
+          type: 'rename',
+          newValue: { ...model, hash: hashChange.newValue },
+          oldValue: { ...model, hash: hashChange.oldValue }
+        });
+      });
+
       sharedModel.disposed.connect(() => {
         const provider = this._providers.get(key);
         if (provider) {
@@ -190,6 +247,7 @@ export class YDrive extends Drive implements ICollaborativeDrive {
   private _trans: TranslationBundle;
   private _providers: Map<string, WebSocketProvider>;
   private _globalAwareness: Awareness | null;
+  private _ydriveFileChanged = new Signal<this, Contents.IChangedArgs>(this);
 }
 
 /**

projects/jupyter-server-ydoc/jupyter_server_ydoc/loaders.py

@@ -117,7 +117,7 @@ async def load_content(self, format: str, file_type: str) -> dict[str, Any]:
             self.last_modified = model["last_modified"]
             return model
 
-    async def maybe_save_content(self, model: dict[str, Any]) -> None:
+    async def maybe_save_content(self, model: dict[str, Any]) -> dict[str, Any] | None:
         """
         Save the content of the file.
 
@@ -149,20 +149,34 @@ async def maybe_save_content(self, model: dict[str, Any]) -> None:
                 # otherwise it could corrupt the file
                 done_saving = asyncio.Event()
                 task = asyncio.create_task(self._save_content(model, done_saving))
+                saved_model = None
                 try:
-                    await asyncio.shield(task)
+                    saved_model = await asyncio.shield(task)
                 except asyncio.CancelledError:
                     pass
                 await done_saving.wait()
+                return saved_model
             else:
                 # file changed on disk, raise an error
                 self.last_modified = m["last_modified"]
                 raise OutOfBandChanges
 
-    async def _save_content(self, model: dict[str, Any], done_saving: asyncio.Event) -> None:
+    async def _save_content(
+        self, model: dict[str, Any], done_saving: asyncio.Event
+    ) -> dict[str, Any]:
         try:
             m = await ensure_async(self._contents_manager.save(model, self.path))
             self.last_modified = m["last_modified"]
+            # TODO, get rid of the extra `get` here once upstream issue:
+            # https://github.com/jupyter-server/jupyter_server/issues/1453 is resolved
+            model_with_hash = await ensure_async(
+                self._contents_manager.get(
+                    self.path,
+                    content=False,
+                    require_hash=True,  # TODO require version supporting hash
+                )
+            )
+            return {**m, "hash": model_with_hash["hash"]}
         finally:
             done_saving.set()
 

projects/jupyter-server-ydoc/jupyter_server_ydoc/rooms.py

@@ -271,7 +271,7 @@ async def _maybe_save_document(self, saving_document: asyncio.Task | None) -> No
             await asyncio.sleep(self._save_delay)
 
             self.log.info("Saving the content from room %s", self._room_id)
-            await self._file.maybe_save_content(
+            saved_model = await self._file.maybe_save_content(
                 {
                     "format": self._file_format,
                     "type": self._file_type,
@@ -280,6 +280,11 @@ async def _maybe_save_document(self, saving_document: asyncio.Task | None) -> No
             )
             async with self._update_lock:
                 self._document.dirty = False
+                if saved_model:
+                    self._document.hash = saved_model["hash"]
+                    # for now circumvent the public API, TODO remove before undrafting,
+                    # once https://github.com/jupyter-server/jupyter_ydoc/pull/262 is merged
+                    self._document._ystate["hash"] = saved_model["hash"]
 
             self._emit(LogLevel.INFO, "save", "Content saved.")