Merge branch 'master' into fix-erasure-tests

Signed-off-by: Dmitriy Ryajov <[email protected]>

codex/contracts/requests.nim

@@ -54,6 +54,7 @@ type
     Finished
     Failed
     Paid
+    Cancelled
 
 proc `==`*(x, y: Nonce): bool {.borrow.}
 proc `==`*(x, y: RequestId): bool {.borrow.}

codex/purchasing/states/cancelled.nim

@@ -22,4 +22,4 @@ method run*(state: PurchaseCancelled, machine: Machine): Future[?State] {.async.
   await purchase.market.withdrawFunds(purchase.requestId)
 
   let error = newException(Timeout, "Purchase cancelled due to timeout")
-  return some State(PurchaseErrored(error: error))
+  purchase.future.fail(error)

codex/purchasing/states/submitted.nim

@@ -33,7 +33,7 @@ method run*(state: PurchaseSubmitted, machine: Machine): Future[?State] {.async.
     await subscription.unsubscribe()
 
   proc withTimeout(future: Future[void]) {.async.} =
-    let expiry = request.expiry.truncate(int64)
+    let expiry = request.expiry.truncate(int64) + 1
     await future.withTimeout(clock, expiry)
 
   try:

codex/sales/salesagent.nim

@@ -54,6 +54,11 @@ proc retrieveRequest*(agent: SalesAgent) {.async.} =
   if data.request.isNone:
     data.request = await market.getRequest(data.requestId)
 
+proc retrieveRequestState*(agent: SalesAgent): Future[?RequestState] {.async.} =
+  let data = agent.data
+  let market = agent.context.market
+  return await market.requestState(data.requestId)
+
 proc subscribeCancellation(agent: SalesAgent) {.async.} =
   let data = agent.data
   let clock = agent.context.clock
@@ -62,8 +67,20 @@ proc subscribeCancellation(agent: SalesAgent) {.async.} =
     without request =? data.request:
       return
 
-    await clock.waitUntil(request.expiry.truncate(int64))
-    agent.schedule(cancelledEvent(request))
+    while true:
+      let deadline = max(clock.now, request.expiry.truncate(int64)) + 1
+      trace "Waiting for request to be cancelled", now=clock.now, expiry=deadline
+      await clock.waitUntil(deadline)
+
+      without state =? await agent.retrieveRequestState():
+        error "Uknown request", requestId = data.requestId
+        return
+
+      if state == RequestState.Cancelled:
+        agent.schedule(cancelledEvent(request))
+        break
+
+      debug "The request is not yet canceled, even though it should be. Waiting for some more time.", currentState = state, now=clock.now
 
   data.cancelled = onCancelled()
 

codex/sales/states/cancelled.nim

@@ -1,4 +1,5 @@
 import pkg/chronicles
+import ../salesagent
 import ../statemachine
 import ./errorhandling
 import ./errored
@@ -8,11 +9,30 @@ logScope:
 
 type
   SaleCancelled* = ref object of ErrorHandlingState
-  SaleCancelledError* = object of CatchableError
-  SaleTimeoutError* = object of SaleCancelledError
 
 method `$`*(state: SaleCancelled): string = "SaleCancelled"
 
 method run*(state: SaleCancelled, machine: Machine): Future[?State] {.async.} =
-  let error = newException(SaleTimeoutError, "Sale cancelled due to timeout")
-  return some State(SaleErrored(error: error))
+  let agent = SalesAgent(machine)
+  let data = agent.data
+  let market = agent.context.market
+
+  without request =? data.request:
+    raiseAssert "no sale request"
+
+  without slotIndex =? data.slotIndex:
+    raiseAssert("no slot index assigned")
+
+  let slot = Slot(request: request, slotIndex: slotIndex)
+  debug "Collecting collateral and partial payout",  requestId = $data.requestId, slotIndex
+  await market.freeSlot(slot.id)
+
+  if onClear =? agent.context.onClear and
+      request =? data.request and
+      slotIndex =? data.slotIndex:
+    onClear(request, slotIndex)
+
+  if onCleanUp =? agent.onCleanUp:
+    await onCleanUp()
+
+  warn "Sale cancelled due to timeout",  requestId = $data.requestId, slotIndex

codex/sales/states/failed.nim

@@ -1,4 +1,5 @@
 import pkg/chronicles
+import ../salesagent
 import ../statemachine
 import ./errorhandling
 import ./errored
@@ -13,5 +14,18 @@ type
 method `$`*(state: SaleFailed): string = "SaleFailed"
 
 method run*(state: SaleFailed, machine: Machine): Future[?State] {.async.} =
+  let data = SalesAgent(machine).data
+  let market = SalesAgent(machine).context.market
+
+  without request =? data.request:
+    raiseAssert "no sale request"
+
+  without slotIndex =? data.slotIndex:
+    raiseAssert("no slot index assigned")
+
+  let slot = Slot(request: request, slotIndex: slotIndex)
+  debug "Removing slot from mySlots",  requestId = $data.requestId, slotIndex
+  await market.freeSlot(slot.id)
+
   let error = newException(SaleFailedError, "Sale failed")
   return some State(SaleErrored(error: error))

codex/sales/states/unknown.nim

@@ -54,3 +54,5 @@ method run*(state: SaleUnknown, machine: Machine): Future[?State] {.async.} =
     return some State(SaleFinished())
   of SlotState.Failed:
     return some State(SaleFailed())
+  of SlotState.Cancelled:
+    return some State(SaleCancelled())