[WIP] Live Collab M3 - Proofreading (without segments list)

app/controllers/AnnotationController.scala

@@ -454,4 +454,12 @@ class AnnotationController @Inject()(
       }
     }
 
+  def releaseMutex(id: ObjectId): Action[AnyContent] = sil.SecuredAction.async { implicit request =>
+    logTime(slackNotificationService.noticeSlowRequest, durationThreshold = 1 second) {
+      for {
+        _ <- annotationMutexService.release(id, request.identity._id) ?~> "annotation.mutex.failed"
+      } yield Ok
+    }
+  }
+
 }

app/models/annotation/AnnotationMutexService.scala

@@ -68,6 +68,17 @@ class AnnotationMutexService @Inject()(val lifecycle: ApplicationLifecycle,
       _ <- annotationMutexDAO.upsertOne(mutex.copy(expiry = Instant.in(defaultExpiryTime)))
     } yield MutexResult(canEdit = true, None)
 
+  def release(annotationId: ObjectId, userId: ObjectId): Fox[Unit] =
+    for {
+      mutex <- annotationMutexDAO.findOne(annotationId).shiftBox
+      _ <- mutex match {
+        case Full(mutex) if mutex.userId == userId =>
+          annotationMutexDAO.deleteOne(annotationId).map(_ => ())
+        case _ =>
+          Fox.successful(())
+      }
+    } yield ()
+
   def publicWrites(mutexResult: MutexResult): Fox[JsObject] =
     for {
       userOpt <- Fox.runOptional(mutexResult.blockedByUser)(user => userDAO.findOne(user)(GlobalAccessContext))
@@ -114,4 +125,6 @@ class AnnotationMutexDAO @Inject()(sqlClient: SqlClient)(implicit ec: ExecutionC
   def deleteExpired(): Fox[Int] =
     run(q"DELETE FROM webknossos.annotation_mutexes WHERE expiry < NOW()".asUpdate)
 
+  def deleteOne(annotationId: ObjectId): Fox[Int] =
+    run(q"DELETE FROM webknossos.annotation_mutexes WHERE _annotation = $annotationId".asUpdate)
 }

conf/webknossos.latest.routes

@@ -155,6 +155,7 @@ DELETE        /annotations/:id
 POST          /annotations/:id/merge/:mergedTyp/:mergedId                                       controllers.AnnotationController.mergeWithoutType(id: ObjectId, mergedTyp: String, mergedId: ObjectId)
 GET           /annotations/:id/download                                                         controllers.AnnotationIOController.downloadWithoutType(id: ObjectId, version: Option[Long], skipVolumeData: Option[Boolean], volumeDataZipFormat: Option[String])
 POST          /annotations/:id/acquireMutex                                                     controllers.AnnotationController.tryAcquiringAnnotationMutex(id: ObjectId)
+DELETE        /annotations/:id/mutex                                                            controllers.AnnotationController.releaseMutex(id: ObjectId)
 
 GET           /annotations/:typ/:id/info                                                        controllers.AnnotationController.info(typ: String, id: ObjectId, timestamp: Option[Long])
 DELETE        /annotations/:typ/:id                                                             controllers.AnnotationController.cancel(typ: String, id: ObjectId)

frontend/javascripts/admin/rest_api.ts

@@ -729,6 +729,12 @@ export async function acquireAnnotationMutex(
   return { canEdit, blockedByUser };
 }
 
+export async function releaseAnnotationMutex(annotationId: string): Promise<void> {
+  await Request.receiveJSON(`/api/annotations/${annotationId}/mutex`, {
+    method: "DELETE",
+  });
+}
+
 export async function getTracingForAnnotationType(
   annotation: APIAnnotation,
   annotationLayerDescriptor: AnnotationLayerDescriptor,

frontend/javascripts/test/sagas/annotation_saga.spec.ts

@@ -12,7 +12,7 @@ import {
 } from "viewer/model/actions/annotation_actions";
 import { ensureWkReady } from "viewer/model/sagas/ready_sagas";
 import { wkReadyAction } from "viewer/model/actions/actions";
-import { acquireAnnotationMutexMaybe } from "viewer/model/sagas/annotation_saga";
+import { acquireAnnotationMutexMaybe } from "viewer/model/sagas/saving/save_mutex_saga";
 
 const createInitialState = (
   othersMayEdit: boolean,

frontend/javascripts/viewer/api/wk_dev.ts

@@ -11,7 +11,7 @@ import type ApiLoader from "./api_loader";
 // Can be accessed via window.webknossos.DEV.flags. Only use this
 // for debugging or one off scripts.
 export const WkDevFlags = {
-  logActions: false,
+  logActions: true,
   sam: {
     useLocalMask: true,
   },
@@ -28,7 +28,7 @@ export const WkDevFlags = {
     disableLayerNameSanitization: false,
   },
   debugging: {
-    showCurrentVersionInInfoTab: false,
+    showCurrentVersionInInfoTab: true,
   },
   meshing: {
     marchingCubeSizeInTargetMag: [64, 64, 64] as Vector3,

frontend/javascripts/viewer/default_state.ts

@@ -178,6 +178,7 @@ const defaultState: WebknossosState = {
     contributors: [],
     othersMayEdit: false,
     blockedByUser: null,
+    isMutexAcquired: false,
     annotationLayers: [],
     version: 0,
     earliestAccessibleVersion: 0,

frontend/javascripts/viewer/model/actions/annotation_actions.ts

@@ -52,6 +52,7 @@ export type EditAnnotationLayerAction = ReturnType<typeof editAnnotationLayerAct
 export type SetAnnotationDescriptionAction = ReturnType<typeof setAnnotationDescriptionAction>;
 type SetAnnotationAllowUpdateAction = ReturnType<typeof setAnnotationAllowUpdateAction>;
 type SetBlockedByUserAction = ReturnType<typeof setBlockedByUserAction>;
+export type SetIsMutexAcquiredAction = ReturnType<typeof setIsMutexAcquiredAction>;
 type SetUserBoundingBoxesAction = ReturnType<typeof setUserBoundingBoxesAction>;
 type FinishedResizingUserBoundingBoxAction = ReturnType<
   typeof finishedResizingUserBoundingBoxAction
@@ -87,6 +88,7 @@ export type AnnotationActionTypes =
   | SetAnnotationDescriptionAction
   | SetAnnotationAllowUpdateAction
   | SetBlockedByUserAction
+  | SetIsMutexAcquiredAction
   | SetUserBoundingBoxesAction
   | ChangeUserBoundingBoxAction
   | FinishedResizingUserBoundingBoxAction
@@ -176,6 +178,12 @@ export const setBlockedByUserAction = (blockedByUser: APIUserCompact | null | un
     blockedByUser,
   }) as const;
 
+export const setIsMutexAcquiredAction = (isMutexAcquired: boolean) =>
+  ({
+    type: "SET_IS_MUTEX_ACQUIRED",
+    isMutexAcquired,
+  }) as const;
+
 // Strictly speaking this is no annotation action but a tracing action, as the boundingBox is saved with
 // the tracing, hence no ANNOTATION in the action type.
 export const setUserBoundingBoxesAction = (userBoundingBoxes: Array<UserBoundingBox>) =>

frontend/javascripts/viewer/model/actions/save_actions.ts

@@ -26,6 +26,8 @@ type DisableSavingAction = ReturnType<typeof disableSavingAction>;
 export type EnsureTracingsWereDiffedToSaveQueueAction = ReturnType<
   typeof ensureTracingsWereDiffedToSaveQueueAction
 >;
+export type EnsureMaySaveNowAction = ReturnType<typeof ensureMaySaveNowAction>;
+export type DoneSavingAction = ReturnType<typeof doneSavingAction>;
 
 export type SaveAction =
   | PushSaveQueueTransaction
@@ -38,7 +40,9 @@ export type SaveAction =
   | UndoAction
   | RedoAction
   | DisableSavingAction
-  | EnsureTracingsWereDiffedToSaveQueueAction;
+  | EnsureTracingsWereDiffedToSaveQueueAction
+  | EnsureMaySaveNowAction
+  | DoneSavingAction;
 
 // The action creators pushSaveQueueTransaction and pushSaveQueueTransactionIsolated
 // are typed so that update actions that need isolation are isolated in a group each.
@@ -132,3 +136,21 @@ export const ensureTracingsWereDiffedToSaveQueueAction = (callback: (tracingId:
     type: "ENSURE_TRACINGS_WERE_DIFFED_TO_SAVE_QUEUE",
     callback,
   }) as const;
+
+export const ensureMaySaveNowAction = (callback: () => void) =>
+  ({
+    type: "ENSURE_MAY_SAVE_NOW",
+    callback,
+  }) as const;
+
+export const dispatchEnsureMaySaveNowAsync = async (dispatch: Dispatch<any>): Promise<void> => {
+  const readyDeferred = new Deferred();
+  const action = ensureMaySaveNowAction(() => readyDeferred.resolve(null));
+  dispatch(action);
+  await readyDeferred.promise();
+};
+
+export const doneSavingAction = () =>
+  ({
+    type: "DONE_SAVING",
+  }) as const;

frontend/javascripts/viewer/model/reducers/annotation_reducer.ts

@@ -137,6 +137,13 @@ function AnnotationReducer(state: WebknossosState, action: Action): WebknossosSt
       });
     }
 
+    case "SET_IS_MUTEX_ACQUIRED": {
+      const { isMutexAcquired } = action;
+      return updateKey(state, "annotation", {
+        isMutexAcquired,
+      });
+    }
+
     case "SET_USER_BOUNDING_BOXES": {
       return updateUserBoundingBoxes(state, action.userBoundingBoxes);
     }

frontend/javascripts/viewer/model/reducers/reducer_helpers.ts

@@ -156,6 +156,7 @@ export function convertServerAnnotationToFrontendAnnotation(
     othersMayEdit,
     annotationLayers,
     blockedByUser: null,
+    isMutexAcquired: false,
   };
 }
 

frontend/javascripts/viewer/model/sagas/annotation_saga.tsx

@@ -1,36 +1,19 @@
 import type { EditableAnnotation } from "admin/rest_api";
-import { acquireAnnotationMutex, editAnnotation } from "admin/rest_api";
-import { Button } from "antd";
+import { editAnnotation } from "admin/rest_api";
 import ErrorHandling from "libs/error_handling";
 import Toast from "libs/toast";
 import * as Utils from "libs/utils";
 import _ from "lodash";
 import messages from "messages";
-import React from "react";
 import type { ActionPattern } from "redux-saga/effects";
-import {
-  call,
-  cancel,
-  cancelled,
-  delay,
-  fork,
-  put,
-  retry,
-  take,
-  takeEvery,
-  takeLatest,
-} from "typed-redux-saga";
-import type { APIUserCompact } from "types/api_types";
+import { call, delay, put, retry, take, takeLatest } from "typed-redux-saga";
 import constants, { MappingStatusEnum } from "viewer/constants";
 import { getMappingInfo, is2dDataset } from "viewer/model/accessors/dataset_accessor";
 import { getActiveMagIndexForLayer } from "viewer/model/accessors/flycam_accessor";
 import type { Action } from "viewer/model/actions/actions";
-import {
-  type EditAnnotationLayerAction,
-  type SetAnnotationDescriptionAction,
-  type SetOthersMayEditForAnnotationAction,
-  setAnnotationAllowUpdateAction,
-  setBlockedByUserAction,
+import type {
+  EditAnnotationLayerAction,
+  SetAnnotationDescriptionAction,
 } from "viewer/model/actions/annotation_actions";
 import { setVersionRestoreVisibilityAction } from "viewer/model/actions/ui_actions";
 import type { Saga } from "viewer/model/sagas/effect-generators";
@@ -48,6 +31,7 @@ import { mayEditAnnotationProperties } from "../accessors/annotation_accessor";
 import { needsLocalHdf5Mapping } from "../accessors/volumetracing_accessor";
 import { pushSaveQueueTransaction } from "../actions/save_actions";
 import { ensureWkReady } from "./ready_sagas";
+import { acquireAnnotationMutexMaybe } from "./saving/save_mutex_saga";
 import { updateAnnotationLayerName, updateMetadataOfAnnotation } from "./volume/update_actions";
 
 /* Note that this must stay in sync with the back-end constant MaxMagForAgglomerateMapping
@@ -237,121 +221,6 @@ export function* watchAnnotationAsync(): Saga<void> {
   yield* takeLatest("EDIT_ANNOTATION_LAYER", pushAnnotationLayerUpdateAsync);
 }
 
-export function* acquireAnnotationMutexMaybe(): Saga<void> {
-  yield* call(ensureWkReady);
-  const allowUpdate = yield* select((state) => state.annotation.restrictions.allowUpdate);
-  const annotationId = yield* select((storeState) => storeState.annotation.annotationId);
-  if (!allowUpdate) {
-    return;
-  }
-  const othersMayEdit = yield* select((state) => state.annotation.othersMayEdit);
-  const activeUser = yield* select((state) => state.activeUser);
-  const acquireMutexInterval = 1000 * 60;
-  const RETRY_COUNT = 12;
-  const MUTEX_NOT_ACQUIRED_KEY = "MutexCouldNotBeAcquired";
-  const MUTEX_ACQUIRED_KEY = "AnnotationMutexAcquired";
-  let isInitialRequest = true;
-  let doesHaveMutexFromBeginning = false;
-  let doesHaveMutex = false;
-  let shallTryAcquireMutex = othersMayEdit;
-
-  function onMutexStateChanged(canEdit: boolean, blockedByUser: APIUserCompact | null | undefined) {
-    if (canEdit) {
-      Toast.close("MutexCouldNotBeAcquired");
-      if (!isInitialRequest) {
-        const message = (
-          <React.Fragment>
-            {messages["annotation.acquiringMutexSucceeded"]}{" "}
-            <Button onClick={() => location.reload()}>Reload the annotation</Button>
-          </React.Fragment>
-        );
-        Toast.success(message, { sticky: true, key: MUTEX_ACQUIRED_KEY });
-      }
-    } else {
-      Toast.close(MUTEX_ACQUIRED_KEY);
-      const message =
-        blockedByUser != null
-          ? messages["annotation.acquiringMutexFailed"]({
-              userName: `${blockedByUser.firstName} ${blockedByUser.lastName}`,
-            })
-          : messages["annotation.acquiringMutexFailed.noUser"];
-      Toast.warning(message, { sticky: true, key: MUTEX_NOT_ACQUIRED_KEY });
-    }
-  }
-
-  function* tryAcquireMutexContinuously(): Saga<void> {
-    while (shallTryAcquireMutex) {
-      if (isInitialRequest) {
-        yield* put(setAnnotationAllowUpdateAction(false));
-      }
-      try {
-        const { canEdit, blockedByUser } = yield* retry(
-          RETRY_COUNT,
-          acquireMutexInterval / RETRY_COUNT,
-          acquireAnnotationMutex,
-          annotationId,
-        );
-        if (isInitialRequest && canEdit) {
-          doesHaveMutexFromBeginning = true;
-          // Only set allow update to true in case the first try to get the mutex succeeded.
-          yield* put(setAnnotationAllowUpdateAction(true));
-        }
-        if (!canEdit || !doesHaveMutexFromBeginning) {
-          // If the mutex could not be acquired anymore or the user does not have it from the beginning, set allow update to false.
-          doesHaveMutexFromBeginning = false;
-          yield* put(setAnnotationAllowUpdateAction(false));
-        }
-        if (canEdit) {
-          yield* put(setBlockedByUserAction(activeUser));
-        } else {
-          yield* put(setBlockedByUserAction(blockedByUser));
-        }
-        if (canEdit !== doesHaveMutex || isInitialRequest) {
-          doesHaveMutex = canEdit;
-          onMutexStateChanged(canEdit, blockedByUser);
-        }
-      } catch (error) {
-        if (process.env.IS_TESTING) {
-          // In unit tests, that explicitly control this generator function,
-          // the console.error after the next yield won't be printed, because
-          // test assertions on the yield will already throw.
-          // Therefore, we also print the error in the test context.
-          console.error("Error while trying to acquire mutex:", error);
-        }
-        const wasCanceled = yield* cancelled();
-        if (!wasCanceled) {
-          console.error("Error while trying to acquire mutex.", error);
-          yield* put(setBlockedByUserAction(undefined));
-          yield* put(setAnnotationAllowUpdateAction(false));
-          doesHaveMutexFromBeginning = false;
-          if (doesHaveMutex || isInitialRequest) {
-            onMutexStateChanged(false, null);
-            doesHaveMutex = false;
-          }
-        }
-      }
-      isInitialRequest = false;
-      yield* call(delay, acquireMutexInterval);
-    }
-  }
-  let runningTryAcquireMutexContinuouslySaga = yield* fork(tryAcquireMutexContinuously);
-  function* reactToOthersMayEditChanges({
-    othersMayEdit,
-  }: SetOthersMayEditForAnnotationAction): Saga<void> {
-    shallTryAcquireMutex = othersMayEdit;
-    if (shallTryAcquireMutex) {
-      if (runningTryAcquireMutexContinuouslySaga != null) {
-        yield* cancel(runningTryAcquireMutexContinuouslySaga);
-      }
-      isInitialRequest = true;
-      runningTryAcquireMutexContinuouslySaga = yield* fork(tryAcquireMutexContinuously);
-    } else {
-      // othersMayEdit was turned off. The user editing it should be able to edit the annotation.
-      yield* put(setAnnotationAllowUpdateAction(true));
-    }
-  }
-  yield* takeEvery("SET_OTHERS_MAY_EDIT_FOR_ANNOTATION", reactToOthersMayEditChanges);
-}
 export default [
   warnAboutSegmentationZoom,
   watchAnnotationAsync,