[clsi] remove locking from docker actions (#32373)

* [clsi] remove locking from docker actions

Start:
- We have an in-memory lock on the compile request

Destroy:
- as part of run: see above
- as part of cleanup: we check the last access time now, so it cannot
  happen concurrent to compiling anymore.

Co-authored-by: Anna Claire Fields <anna.fields@overleaf.com>

* [clsi] update comment

---------

Co-authored-by: Anna Claire Fields <anna.fields@overleaf.com>
GitOrigin-RevId: a58df45416ae31c0b38d5efec7f9371d747303df

services/clsi/app/js/DockerLockManager.js

@@ -1,110 +0,0 @@
-// TODO: This file was created by bulk-decaffeinate.
-// Fix any style issues and re-enable lint.
-/*
- * decaffeinate suggestions:
- * DS101: Remove unnecessary use of Array.from
- * DS102: Remove unnecessary code created because of implicit returns
- * DS207: Consider shorter variations of null checks
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-import logger from '@overleaf/logger'
-let LockManager
-
-const LockState = {} // locks for docker container operations, by container name
-
-export default LockManager = {
-  MAX_LOCK_HOLD_TIME: 15000, // how long we can keep a lock
-  MAX_LOCK_WAIT_TIME: 10000, // how long we wait for a lock
-  LOCK_TEST_INTERVAL: 1000, // retry time
-
-  tryLock(key, callback) {
-    let lockValue
-    if (callback == null) {
-      callback = function () {}
-    }
-    const existingLock = LockState[key]
-    if (existingLock != null) {
-      // the lock is already taken, check how old it is
-      const lockAge = Date.now() - existingLock.created
-      if (lockAge < LockManager.MAX_LOCK_HOLD_TIME) {
-        return callback(null, false) // we didn't get the lock, bail out
-      } else {
-        logger.error(
-          { key, lock: existingLock, age: lockAge },
-          'taking old lock by force'
-        )
-      }
-    }
-    // take the lock
-    LockState[key] = lockValue = { created: Date.now() }
-    return callback(null, true, lockValue)
-  },
-
-  getLock(key, callback) {
-    let attempt
-    if (callback == null) {
-      callback = function () {}
-    }
-    const startTime = Date.now()
-    return (attempt = () =>
-      LockManager.tryLock(key, function (error, gotLock, lockValue) {
-        if (error != null) {
-          return callback(error)
-        }
-        if (gotLock) {
-          return callback(null, lockValue)
-        } else if (Date.now() - startTime > LockManager.MAX_LOCK_WAIT_TIME) {
-          const e = new Error('Lock timeout')
-          e.key = key
-          return callback(e)
-        } else {
-          return setTimeout(attempt, LockManager.LOCK_TEST_INTERVAL)
-        }
-      }))()
-  },
-
-  releaseLock(key, lockValue, callback) {
-    if (callback == null) {
-      callback = function () {}
-    }
-    const existingLock = LockState[key]
-    if (existingLock === lockValue) {
-      // lockValue is an object, so we can test by reference
-      delete LockState[key] // our lock, so we can free it
-      return callback()
-    } else if (existingLock != null) {
-      // lock exists but doesn't match ours
-      logger.error(
-        { key, lock: existingLock },
-        'tried to release lock taken by force'
-      )
-      return callback()
-    } else {
-      logger.error(
-        { key, lock: existingLock },
-        'tried to release lock that has gone'
-      )
-      return callback()
-    }
-  },
-
-  runWithLock(key, runner, callback) {
-    if (callback == null) {
-      callback = function () {}
-    }
-    return LockManager.getLock(key, function (error, lockValue) {
-      if (error != null) {
-        return callback(error)
-      }
-      return runner((error1, ...args) =>
-        LockManager.releaseLock(key, lockValue, function (error2) {
-          error = error1 || error2
-          if (error != null) {
-            return callback(error)
-          }
-          return callback(null, ...Array.from(args))
-        })
-      )
-    })
-  },
-}