fix(statemachine): do not raise from state.run (#1115)

* fix(statemachine): do not raise from state.run

* fix rebase

* fix exception handling in SaleProvingSimulated.prove

- re-raise CancelledError
- don't return State on CatchableError
- expect the Proofs_InvalidProof custom error instead of checking a string

* asyncSpawn salesagent.onCancelled

This was swallowing a KeyError in one of the tests (fixed in the previous commit)

* remove error handling states in asyncstatemachine

* revert unneeded changes

* formatting

* PR feedback, logging updates

codex/purchasing/states/cancelled.nim

@@ -1,25 +1,35 @@
 import pkg/metrics
 
 import ../../logutils
+import ../../utils/exceptions
 import ../statemachine
-import ./errorhandling
+import ./error
 
 declareCounter(codex_purchases_cancelled, "codex purchases cancelled")
 
 logScope:
   topics = "marketplace purchases cancelled"
 
-type PurchaseCancelled* = ref object of ErrorHandlingState
+type PurchaseCancelled* = ref object of PurchaseState
 
 method `$`*(state: PurchaseCancelled): string =
   "cancelled"
 
-method run*(state: PurchaseCancelled, machine: Machine): Future[?State] {.async.} =
+method run*(
+    state: PurchaseCancelled, machine: Machine
+): Future[?State] {.async: (raises: []).} =
   codex_purchases_cancelled.inc()
   let purchase = Purchase(machine)
 
-  warn "Request cancelled, withdrawing remaining funds", requestId = purchase.requestId
-  await purchase.market.withdrawFunds(purchase.requestId)
-
-  let error = newException(Timeout, "Purchase cancelled due to timeout")
-  purchase.future.fail(error)
+  try:
+    warn "Request cancelled, withdrawing remaining funds",
+      requestId = purchase.requestId
+    await purchase.market.withdrawFunds(purchase.requestId)
+
+    let error = newException(Timeout, "Purchase cancelled due to timeout")
+    purchase.future.fail(error)
+  except CancelledError as e:
+    trace "PurchaseCancelled.run was cancelled", error = e.msgDetail
+  except CatchableError as e:
+    error "Error during PurchaseCancelled.run", error = e.msgDetail
+    return some State(PurchaseErrored(error: e))

codex/purchasing/states/error.nim

@@ -14,7 +14,9 @@ type PurchaseErrored* = ref object of PurchaseState
 method `$`*(state: PurchaseErrored): string =
   "errored"
 
-method run*(state: PurchaseErrored, machine: Machine): Future[?State] {.async.} =
+method run*(
+    state: PurchaseErrored, machine: Machine
+): Future[?State] {.async: (raises: []).} =
   codex_purchases_error.inc()
   let purchase = Purchase(machine)
 

codex/purchasing/states/failed.nim

@@ -1,6 +1,7 @@
 import pkg/metrics
 import ../statemachine
 import ../../logutils
+import ../../utils/exceptions
 import ./error
 
 declareCounter(codex_purchases_failed, "codex purchases failed")
@@ -10,11 +11,20 @@ type PurchaseFailed* = ref object of PurchaseState
 method `$`*(state: PurchaseFailed): string =
   "failed"
 
-method run*(state: PurchaseFailed, machine: Machine): Future[?State] {.async.} =
+method run*(
+    state: PurchaseFailed, machine: Machine
+): Future[?State] {.async: (raises: []).} =
   codex_purchases_failed.inc()
   let purchase = Purchase(machine)
-  warn "Request failed, withdrawing remaining funds", requestId = purchase.requestId
-  await purchase.market.withdrawFunds(purchase.requestId)
+
+  try:
+    warn "Request failed, withdrawing remaining funds", requestId = purchase.requestId
+    await purchase.market.withdrawFunds(purchase.requestId)
+  except CancelledError as e:
+    trace "PurchaseFailed.run was cancelled", error = e.msgDetail
+  except CatchableError as e:
+    error "Error during PurchaseFailed.run", error = e.msgDetail
+    return some State(PurchaseErrored(error: e))
 
   let error = newException(PurchaseError, "Purchase failed")
   return some State(PurchaseErrored(error: error))

codex/purchasing/states/finished.nim

@@ -1,7 +1,9 @@
 import pkg/metrics
 
 import ../statemachine
+import ../../utils/exceptions
 import ../../logutils
+import ./error
 
 declareCounter(codex_purchases_finished, "codex purchases finished")
 
@@ -13,10 +15,19 @@ type PurchaseFinished* = ref object of PurchaseState
 method `$`*(state: PurchaseFinished): string =
   "finished"
 
-method run*(state: PurchaseFinished, machine: Machine): Future[?State] {.async.} =
+method run*(
+    state: PurchaseFinished, machine: Machine
+): Future[?State] {.async: (raises: []).} =
   codex_purchases_finished.inc()
   let purchase = Purchase(machine)
-  info "Purchase finished, withdrawing remaining funds", requestId = purchase.requestId
-  await purchase.market.withdrawFunds(purchase.requestId)
+  try:
+    info "Purchase finished, withdrawing remaining funds",
+      requestId = purchase.requestId
+    await purchase.market.withdrawFunds(purchase.requestId)
 
-  purchase.future.complete()
+    purchase.future.complete()
+  except CancelledError as e:
+    trace "PurchaseFinished.run was cancelled", error = e.msgDetail
+  except CatchableError as e:
+    error "Error during PurchaseFinished.run", error = e.msgDetail
+    return some State(PurchaseErrored(error: e))

codex/purchasing/states/pending.nim

@@ -1,18 +1,28 @@
 import pkg/metrics
+import ../../logutils
+import ../../utils/exceptions
 import ../statemachine
-import ./errorhandling
 import ./submitted
+import ./error
 
 declareCounter(codex_purchases_pending, "codex purchases pending")
 
-type PurchasePending* = ref object of ErrorHandlingState
+type PurchasePending* = ref object of PurchaseState
 
 method `$`*(state: PurchasePending): string =
   "pending"
 
-method run*(state: PurchasePending, machine: Machine): Future[?State] {.async.} =
+method run*(
+    state: PurchasePending, machine: Machine
+): Future[?State] {.async: (raises: []).} =
   codex_purchases_pending.inc()
   let purchase = Purchase(machine)
-  let request = !purchase.request
-  await purchase.market.requestStorage(request)
-  return some State(PurchaseSubmitted())
+  try:
+    let request = !purchase.request
+    await purchase.market.requestStorage(request)
+    return some State(PurchaseSubmitted())
+  except CancelledError as e:
+    trace "PurchasePending.run was cancelled", error = e.msgDetail
+  except CatchableError as e:
+    error "Error during PurchasePending.run", error = e.msgDetail
+    return some State(PurchaseErrored(error: e))

codex/purchasing/states/started.nim

@@ -1,22 +1,25 @@
 import pkg/metrics
 
 import ../../logutils
+import ../../utils/exceptions
 import ../statemachine
-import ./errorhandling
 import ./finished
 import ./failed
+import ./error
 
 declareCounter(codex_purchases_started, "codex purchases started")
 
 logScope:
   topics = "marketplace purchases started"
 
-type PurchaseStarted* = ref object of ErrorHandlingState
+type PurchaseStarted* = ref object of PurchaseState
 
 method `$`*(state: PurchaseStarted): string =
   "started"
 
-method run*(state: PurchaseStarted, machine: Machine): Future[?State] {.async.} =
+method run*(
+    state: PurchaseStarted, machine: Machine
+): Future[?State] {.async: (raises: []).} =
   codex_purchases_started.inc()
   let purchase = Purchase(machine)
 
@@ -28,15 +31,24 @@ method run*(state: PurchaseStarted, machine: Machine): Future[?State] {.async.}
   proc callback(_: RequestId) =
     failed.complete()
 
-  let subscription = await market.subscribeRequestFailed(purchase.requestId, callback)
-
-  # Ensure that we're past the request end by waiting an additional second
-  let ended = clock.waitUntil((await market.getRequestEnd(purchase.requestId)) + 1)
-  let fut = await one(ended, failed)
-  await subscription.unsubscribe()
-  if fut.id == failed.id:
+  var ended: Future[void]
+  try:
+    let subscription = await market.subscribeRequestFailed(purchase.requestId, callback)
+
+    # Ensure that we're past the request end by waiting an additional second
+    ended = clock.waitUntil((await market.getRequestEnd(purchase.requestId)) + 1)
+    let fut = await one(ended, failed)
+    await subscription.unsubscribe()
+    if fut.id == failed.id:
+      ended.cancelSoon()
+      return some State(PurchaseFailed())
+    else:
+      failed.cancelSoon()
+      return some State(PurchaseFinished())
+  except CancelledError as e:
     ended.cancelSoon()
-    return some State(PurchaseFailed())
-  else:
     failed.cancelSoon()
-    return some State(PurchaseFinished())
+    trace "PurchaseStarted.run was cancelled", error = e.msgDetail
+  except CatchableError as e:
+    error "Error during PurchaseStarted.run", error = e.msgDetail
+    return some State(PurchaseErrored(error: e))

codex/purchasing/states/submitted.nim

@@ -1,22 +1,25 @@
 import pkg/metrics
 
 import ../../logutils
+import ../../utils/exceptions
 import ../statemachine
-import ./errorhandling
 import ./started
 import ./cancelled
+import ./error
 
 logScope:
   topics = "marketplace purchases submitted"
 
 declareCounter(codex_purchases_submitted, "codex purchases submitted")
 
-type PurchaseSubmitted* = ref object of ErrorHandlingState
+type PurchaseSubmitted* = ref object of PurchaseState
 
 method `$`*(state: PurchaseSubmitted): string =
   "submitted"
 
-method run*(state: PurchaseSubmitted, machine: Machine): Future[?State] {.async.} =
+method run*(
+    state: PurchaseSubmitted, machine: Machine
+): Future[?State] {.async: (raises: []).} =
   codex_purchases_submitted.inc()
   let purchase = Purchase(machine)
   let request = !purchase.request
@@ -44,5 +47,10 @@ method run*(state: PurchaseSubmitted, machine: Machine): Future[?State] {.async.
     await wait().withTimeout()
   except Timeout:
     return some State(PurchaseCancelled())
+  except CancelledError as e:
+    trace "PurchaseSubmitted.run was cancelled", error = e.msgDetail
+  except CatchableError as e:
+    error "Error during PurchaseSubmitted.run", error = e.msgDetail
+    return some State(PurchaseErrored(error: e))
 
   return some State(PurchaseStarted())

codex/purchasing/states/unknown.nim

@@ -1,34 +1,44 @@
 import pkg/metrics
+import ../../utils/exceptions
+import ../../logutils
 import ../statemachine
-import ./errorhandling
 import ./submitted
 import ./started
 import ./cancelled
 import ./finished
 import ./failed
+import ./error
 
 declareCounter(codex_purchases_unknown, "codex purchases unknown")
 
-type PurchaseUnknown* = ref object of ErrorHandlingState
+type PurchaseUnknown* = ref object of PurchaseState
 
 method `$`*(state: PurchaseUnknown): string =
   "unknown"
 
-method run*(state: PurchaseUnknown, machine: Machine): Future[?State] {.async.} =
-  codex_purchases_unknown.inc()
-  let purchase = Purchase(machine)
-  if (request =? await purchase.market.getRequest(purchase.requestId)) and
-      (requestState =? await purchase.market.requestState(purchase.requestId)):
-    purchase.request = some request
+method run*(
+    state: PurchaseUnknown, machine: Machine
+): Future[?State] {.async: (raises: []).} =
+  try:
+    codex_purchases_unknown.inc()
+    let purchase = Purchase(machine)
+    if (request =? await purchase.market.getRequest(purchase.requestId)) and
+        (requestState =? await purchase.market.requestState(purchase.requestId)):
+      purchase.request = some request
 
-    case requestState
-    of RequestState.New:
-      return some State(PurchaseSubmitted())
-    of RequestState.Started:
-      return some State(PurchaseStarted())
-    of RequestState.Cancelled:
-      return some State(PurchaseCancelled())
-    of RequestState.Finished:
-      return some State(PurchaseFinished())
-    of RequestState.Failed:
-      return some State(PurchaseFailed())
+      case requestState
+      of RequestState.New:
+        return some State(PurchaseSubmitted())
+      of RequestState.Started:
+        return some State(PurchaseStarted())
+      of RequestState.Cancelled:
+        return some State(PurchaseCancelled())
+      of RequestState.Finished:
+        return some State(PurchaseFinished())
+      of RequestState.Failed:
+        return some State(PurchaseFailed())
+  except CancelledError as e:
+    trace "PurchaseUnknown.run was cancelled", error = e.msgDetail
+  except CatchableError as e:
+    error "Error during PurchaseUnknown.run", error = e.msgDetail
+    return some State(PurchaseErrored(error: e))