mirror of
https://github.com/codex-storage/nim-codex.git
synced 2025-01-24 19:59:51 +00:00
4c51dca299
* convert EthersError to MarketError * change `canReserveSlot` and `reserveSlot` parameters Parameters for `canReserveSlot` and `reserveSlot` were changed from `SlotId` to `RequestId` and `UInt256 slotIndex`. * Add SaleSlotReserving Adds a new state, SaleSlotReserving, that attempts to reserve a slot before downloading. If the slot cannot be reserved, the state moves to SaleIgnored. On error, the state moves to SaleErrored. SaleIgnored is also updated to pass in `reprocessSlot` and `returnBytes`, controlling the behaviour in the Sales module after the slot is ignored. This is because previously it was assumed that SaleIgnored was only reached when there was no Availability. This is no longer the case, since SaleIgnored can now be reached when a slot cannot be reserved. * Update SalePreparing Specify `reprocessSlot` and `returnBytes` when moving to `SaleIgnored` from `SalePreparing`. Update tests to include test for a raised CatchableError. * Fix unit test * Modify `canReserveSlot` and `reverseSlot` params after rebase * Update MockMarket with new `canReserveSlot` and `reserveSlot` params * fix after rebase also bump codex-contracts-eth to master
99 lines
3.3 KiB
Nim
99 lines
3.3 KiB
Nim
import pkg/questionable
|
|
import pkg/questionable/results
|
|
import pkg/metrics
|
|
|
|
import ../../logutils
|
|
import ../../market
|
|
import ../salesagent
|
|
import ../statemachine
|
|
import ./errorhandling
|
|
import ./cancelled
|
|
import ./failed
|
|
import ./filled
|
|
import ./ignored
|
|
import ./slotreserving
|
|
import ./errored
|
|
|
|
declareCounter(codex_reservations_availability_mismatch, "codex reservations availability_mismatch")
|
|
|
|
type
|
|
SalePreparing* = ref object of ErrorHandlingState
|
|
|
|
logScope:
|
|
topics = "marketplace sales preparing"
|
|
|
|
method `$`*(state: SalePreparing): string = "SalePreparing"
|
|
|
|
method onCancelled*(state: SalePreparing, request: StorageRequest): ?State =
|
|
return some State(SaleCancelled())
|
|
|
|
method onFailed*(state: SalePreparing, request: StorageRequest): ?State =
|
|
return some State(SaleFailed())
|
|
|
|
method onSlotFilled*(state: SalePreparing, requestId: RequestId,
|
|
slotIndex: UInt256): ?State =
|
|
return some State(SaleFilled())
|
|
|
|
method run*(state: SalePreparing, machine: Machine): Future[?State] {.async.} =
|
|
let agent = SalesAgent(machine)
|
|
let data = agent.data
|
|
let context = agent.context
|
|
let market = context.market
|
|
let reservations = context.reservations
|
|
|
|
await agent.retrieveRequest()
|
|
await agent.subscribe()
|
|
|
|
without request =? data.request:
|
|
raiseAssert "no sale request"
|
|
|
|
let slotId = slotId(data.requestId, data.slotIndex)
|
|
let state = await market.slotState(slotId)
|
|
if state != SlotState.Free:
|
|
return some State(SaleIgnored(reprocessSlot: false, returnBytes: false))
|
|
|
|
# TODO: Once implemented, check to ensure the host is allowed to fill the slot,
|
|
# due to the [sliding window mechanism](https://github.com/codex-storage/codex-research/blob/master/design/marketplace.md#dispersal)
|
|
|
|
logScope:
|
|
slotIndex = data.slotIndex
|
|
slotSize = request.ask.slotSize
|
|
duration = request.ask.duration
|
|
pricePerSlot = request.ask.pricePerSlot
|
|
|
|
# availability was checked for this slot when it entered the queue, however
|
|
# check to the ensure that there is still availability as they may have
|
|
# changed since being added (other slots may have been processed in that time)
|
|
without availability =? await reservations.findAvailability(
|
|
request.ask.slotSize,
|
|
request.ask.duration,
|
|
request.ask.pricePerSlot,
|
|
request.ask.collateral):
|
|
debug "No availability found for request, ignoring"
|
|
|
|
return some State(SaleIgnored(reprocessSlot: true))
|
|
|
|
info "Availability found for request, creating reservation"
|
|
|
|
without reservation =? await reservations.createReservation(
|
|
availability.id,
|
|
request.ask.slotSize,
|
|
request.id,
|
|
data.slotIndex
|
|
), error:
|
|
trace "Creation of reservation failed"
|
|
# Race condition:
|
|
# reservations.findAvailability (line 64) is no guarantee. You can never know for certain that the reservation can be created until after you have it.
|
|
# Should createReservation fail because there's no space, we proceed to SaleIgnored.
|
|
if error of BytesOutOfBoundsError:
|
|
# Lets monitor how often this happen and if it is often we can make it more inteligent to handle it
|
|
codex_reservations_availability_mismatch.inc()
|
|
return some State(SaleIgnored(reprocessSlot: true))
|
|
|
|
return some State(SaleErrored(error: error))
|
|
|
|
trace "Reservation created succesfully"
|
|
|
|
data.reservation = some reservation
|
|
return some State(SaleSlotReserving())
|