make mutex-acquisition ad-hoc when trying to save

Author: philippotto

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/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/sagas/saving/save_mutex_saga.tsx

@@ -3,7 +3,19 @@ import { Button } from "antd";
 import Toast from "libs/toast";
 import messages from "messages";
 import React from "react";
-import { call, cancel, cancelled, delay, fork, put, retry, takeEvery } from "typed-redux-saga";
+import {
+  call,
+  cancel,
+  cancelled,
+  delay,
+  type FixedTask,
+  fork,
+  put,
+  race,
+  retry,
+  take,
+  takeEvery,
+} from "typed-redux-saga";
 import {
   type SetIsMutexAcquiredAction,
   type SetOthersMayEditForAnnotationAction,
@@ -14,11 +26,15 @@ import {
 import type { Saga } from "viewer/model/sagas/effect-generators";
 import { select } from "viewer/model/sagas/effect-generators";
 import { ensureWkReady } from "../ready_sagas";
+import { EnsureMaySaveNowAction } from "viewer/model/actions/save_actions";
+
+// Also refer to application.conf where annotation.mutex.expiryTime is defined
+// (typically, 2 minutes).
 
 const MUTEX_NOT_ACQUIRED_KEY = "MutexCouldNotBeAcquired";
 const MUTEX_ACQUIRED_KEY = "AnnotationMutexAcquired";
-const RETRY_COUNT = 12;
 const ACQUIRE_MUTEX_INTERVAL = 1000 * 60;
+const RETRY_COUNT = 12; // 12 retries with 60/12=5 seconds backup delay
 
 // todop
 const DISABLE_EAGER_MUTEX_ACQUISITION = true;
@@ -32,27 +48,23 @@ function* getDoesHaveMutex(): Saga<boolean> {
 }
 
 export function* acquireAnnotationMutexMaybe(): Saga<void> {
-  if (DISABLE_EAGER_MUTEX_ACQUISITION) {
-    return;
-  }
+  yield* call(ensureWkReady);
   const initialAllowUpdate = yield* select(
     (state) => state.annotation.restrictions.initialAllowUpdate,
   );
   if (!initialAllowUpdate) {
-    // We are in an read-only annotation.
+    // We are in an read-only annotation. There's no point in acquiring mutexes.
+    console.log("exit mutex saga");
     return;
   }
   const mutexLogicState: MutexLogicState = {
     isInitialRequest: true,
   };
 
-  yield* call(ensureWkReady);
   yield* fork(watchMutexStateChangesForNotification, mutexLogicState);
 
-  let runningTryAcquireMutexContinuouslySaga = yield* fork(
-    tryAcquireMutexContinuously,
-    mutexLogicState,
-  );
+  let runningTryAcquireMutexContinuouslySaga: FixedTask<void> | null;
+
   function* reactToOthersMayEditChanges({
     othersMayEdit,
   }: SetOthersMayEditForAnnotationAction): Saga<void> {
@@ -65,8 +77,9 @@ export function* acquireAnnotationMutexMaybe(): Saga<void> {
         mutexLogicState,
       );
     } else {
-      // othersMayEdit was turned off. The user editing it should be able to edit the annotation.
-      // let's check that owner === activeUser, anyway.
+      // othersMayEdit was turned off by the activeUser. Since this is only
+      // allowed by the owner, they should be able to edit the annotation, too.
+      // Still, let's check that owner === activeUser to be extra safe.
       const owner = yield* select((storeState) => storeState.annotation.owner);
       const activeUser = yield* select((state) => state.activeUser);
       if (activeUser && owner?.id === activeUser?.id) {
@@ -75,16 +88,55 @@ export function* acquireAnnotationMutexMaybe(): Saga<void> {
     }
   }
   yield* takeEvery("SET_OTHERS_MAY_EDIT_FOR_ANNOTATION", reactToOthersMayEditChanges);
+
+  if (DISABLE_EAGER_MUTEX_ACQUISITION) {
+    console.log("listening to all ENSURE_MAY_SAVE_NOW");
+    yield* takeEvery("ENSURE_MAY_SAVE_NOW", resolveEnsureMaySaveNowActions);
+    while (true) {
+      console.log("taking ENSURE_MAY_SAVE_NOW");
+      yield* take("ENSURE_MAY_SAVE_NOW");
+      console.log("took ENSURE_MAY_SAVE_NOW");
+      const { doneSaving } = yield race({
+        tryAcquireMutexContinuously: fork(tryAcquireMutexContinuously, mutexLogicState),
+        doneSaving: take("DONE_SAVING"),
+      });
+      if (doneSaving) {
+        yield call(releaseMutex);
+      }
+    }
+  } else {
+    runningTryAcquireMutexContinuouslySaga = yield* fork(
+      tryAcquireMutexContinuously,
+      mutexLogicState,
+    );
+  }
 }
 
-function* tryAcquireMutexContinuously(mutexLogicState: MutexLogicState): Saga<void> {
+function* resolveEnsureMaySaveNowActions(action: EnsureMaySaveNowAction) {
+  /*
+   * For each EnsureMaySaveNowAction wait until, we have the mutex. Then call
+   * the callback.
+   */
+  while (true) {
+    const doesHaveMutex = yield* select(getDoesHaveMutex);
+    if (doesHaveMutex) {
+      action.callback();
+      return;
+    }
+    yield* take("SET_BLOCKED_BY_USER");
+  }
+}
+
+function* tryAcquireMutexContinuously(mutexLogicState: MutexLogicState): Saga<never> {
+  console.log("started tryAcquireMutexContinuously");
   const annotationId = yield* select((storeState) => storeState.annotation.annotationId);
   const activeUser = yield* select((state) => state.activeUser);
   mutexLogicState.isInitialRequest = true;
 
   // We can simply use an infinite loop here, because the saga will be cancelled by
   // reactToOthersMayEditChanges when othersMayEdit is set to false.
   while (true) {
+    console.log("tryAcquireMutexContinuously loop");
     const blockedByUser = yield* select((state) => state.annotation.blockedByUser);
     if (blockedByUser == null || blockedByUser.id !== activeUser?.id) {
       // If the annotation is currently not blocked by the active user,
@@ -114,7 +166,9 @@ function* tryAcquireMutexContinuously(mutexLogicState: MutexLogicState): Saga<vo
         // Therefore, we also print the error in the test context.
         console.error("Error while trying to acquire mutex:", error);
       }
+      // todop: I think this needs to happen in a finally block?
       const wasCanceled = yield* cancelled();
+      console.log("wasCanceled", wasCanceled);
       if (!wasCanceled) {
         console.error("Error while trying to acquire mutex.", error);
         yield* put(setBlockedByUserAction(undefined));
@@ -159,3 +213,15 @@ function* watchMutexStateChangesForNotification(mutexLogicState: MutexLogicState
     },
   );
 }
+
+function* releaseMutex() {
+  const annotationId = yield* select((storeState) => storeState.annotation.annotationId);
+  yield* retry(
+    RETRY_COUNT,
+    ACQUIRE_MUTEX_INTERVAL / RETRY_COUNT,
+    acquireAnnotationMutex,
+    annotationId,
+  );
+  yield* put(setAnnotationAllowUpdateAction(true));
+  yield* put(setBlockedByUserAction(null));
+}

frontend/javascripts/viewer/model/sagas/saving/save_queue_draining.ts

@@ -14,6 +14,8 @@ import { call, delay, put, race, take } from "typed-redux-saga";
 import { ControlModeEnum } from "viewer/constants";
 import { getMagInfo } from "viewer/model/accessors/dataset_accessor";
 import {
+  dispatchEnsureMaySaveNowAsync,
+  doneSavingAction,
   setLastSaveTimestampAction,
   setSaveBusyAction,
   setVersionNumberAction,
@@ -30,11 +32,9 @@ import {
   PUSH_THROTTLE_TIME,
   SAVE_RETRY_WAITING_TIME,
 } from "viewer/model/sagas/saving/save_saga_constants";
-import { Model } from "viewer/singletons";
+import { Model, Store } from "viewer/singletons";
 import type { SaveQueueEntry } from "viewer/store";
 
-const ONE_YEAR_MS = 365 * 24 * 3600 * 1000;
-
 export function* pushSaveQueueAsync(): Saga<never> {
   yield* call(ensureWkReady);
 
@@ -65,6 +65,9 @@ export function* pushSaveQueueAsync(): Saga<never> {
     });
     yield* put(setSaveBusyAction(true));
 
+    // Wait until we may save
+    yield* call(dispatchEnsureMaySaveNowAsync, Store.dispatch);
+
     // Send (parts of) the save queue to the server.
     // There are two main cases:
     // 1) forcePush is true
@@ -96,6 +99,7 @@ export function* pushSaveQueueAsync(): Saga<never> {
         break;
       }
     }
+    yield* put(doneSavingAction());
     yield* put(setSaveBusyAction(false));
   }
 }

frontend/javascripts/viewer/model/sagas/volume/mapping_saga.ts

@@ -477,6 +477,7 @@ export function* updateLocalHdf5Mapping(
     intersection: mutableRemainingEntries,
   } = fastDiffSetAndMap(segmentIds as Set<NumberLike>, previousMapping);
 
+  // todop: does this crash wk if the request fails?
   const newEntries =
     editableMapping != null
       ? yield* call(

frontend/javascripts/viewer/model/sagas/volume/proofread_saga.ts

@@ -1,11 +1,9 @@
 import {
   type NeighborInfo,
-  acquireAnnotationMutex,
   getAgglomeratesForSegmentsFromTracingstore,
   getEdgesForAgglomerateMinCut,
   getNeighborsForAgglomerateNode,
   getPositionForSegmentInAgglomerate,
-  releaseAnnotationMutex,
 } from "admin/rest_api";
 import { V3 } from "libs/mjs";
 import Toast from "libs/toast";
@@ -444,7 +442,8 @@ function* handleSkeletonProofreadingAction(action: Action): Saga<void> {
 
   yield* put(pushSaveQueueTransaction(items));
   yield* call([Model, Model.ensureSavedState]);
-  yield* call(releaseAnnotationMutex, annotationId);
+  // todop
+  // yield* call(releaseAnnotationMutex, annotationId);
 
   if (action.type === "MIN_CUT_AGGLOMERATE_WITH_NODE_IDS" || action.type === "DELETE_EDGE") {
     if (sourceAgglomerateId !== targetAgglomerateId) {
@@ -780,7 +779,8 @@ function* handleProofreadMergeOrMinCut(action: Action) {
 
   yield* put(pushSaveQueueTransaction(items));
   yield* call([Model, Model.ensureSavedState]);
-  yield* call(releaseAnnotationMutex, annotationId);
+  // todop
+  // yield* call(releaseAnnotationMutex, annotationId);
 
   if (action.type === "MIN_CUT_AGGLOMERATE") {
     console.log("start updating the mapping after a min-cut");
@@ -940,7 +940,8 @@ function* handleProofreadCutFromNeighbors(action: Action) {
 
   yield* put(pushSaveQueueTransaction(items));
   yield* call([Model, Model.ensureSavedState]);
-  yield* call(releaseAnnotationMutex, annotationId);
+  // todop
+  // yield* call(releaseAnnotationMutex, annotationId);
 
   // Now that the changes are saved, we can split the mapping locally (because it requires
   // communication with the back-end).
@@ -1124,12 +1125,13 @@ function* prepareSplitOrMerge(isSkeletonProofreading: boolean): Saga<Preparation
     return null;
   }
 
-  const annotationId = yield* select((state) => state.annotation.annotationId);
-  const { canEdit } = yield* call(acquireAnnotationMutex, annotationId);
-  if (!canEdit) {
-    Toast.error("Could not acquire mutex. Somebody else is proofreading at the moment.");
-    return null;
-  }
+  // todop
+  // const annotationId = yield* select((state) => state.annotation.annotationId);
+  // const { canEdit } = yield* call(acquireAnnotationMutex, annotationId);
+  // if (!canEdit) {
+  //   Toast.error("Could not acquire mutex. Somebody else is proofreading at the moment.");
+  //   return null;
+  // }
 
   return {
     agglomerateFileMag,