mirror of
https://github.com/logos-storage/logos-storage-nim.git
synced 2026-01-02 13:33:10 +00:00
4a70312ee9
Implement blockstore manager which executes block storage operations on its block stores, in the order to which they were added to the manager, typically in the order of most local (fastest, eg cache) to least local (slowest, eg filesystem or perhaps a network filesystem). As an example, given a `BlockStoreManager` instantiated with a `@[MemoryStore, FSStore]`, retrieving a block would first attempt to get from the `MemoryStore`, and if not found, attempt to get from the `FSStore`. Remove all dependencies on `BlockStores` (typically in the shape of `localstore`) and instead depend on `BlockStoreManager` via the `BlockExcEngine`. Modify the role of the `BlockExcEngine` to make a “local vs remote” decision on block access/storage. For all operations other than retrieving blocks, this means simply going to the `BlockStoreManager`. For retrieving blocks, however, this means going first to the `BlockStoreManager`, and then if not found, going to the Dagger network (via pending block and want/have lists). Remove `NetworkStore` as its two purposes were to defer block retrieval from a local store first, then go to the block exchange to requeest a block from the Dagger network. `BlockStoreManager` takes care of going to local storage first, and the block exchange engine handles going to Dagger network if retrieval from the store manager fails. ### Notes 1. Future work may want to consider breaking up `BlockExcEngine` further in to three modules: - `BlockExcEngine` (depends on `WantHave`, `DHT`) - `WantHave` - `DHT` (work is in progress) Co-authored-by: Michael Bradley <michaelsbradleyjr@gmail.com>
57 lines
1.6 KiB
Nim
57 lines
1.6 KiB
Nim
import std/random
|
|
import std/sequtils
|
|
import pkg/libp2p
|
|
import pkg/nitro
|
|
import pkg/dagger/blockexchange
|
|
import pkg/dagger/rng
|
|
import pkg/dagger/stores
|
|
import pkg/dagger/blocktype as bt
|
|
|
|
proc example*(_: type EthAddress): EthAddress =
|
|
EthPrivateKey.random().toPublicKey.toAddress
|
|
|
|
proc example*(_: type UInt256): UInt256 =
|
|
var bytes: array[32, byte]
|
|
for b in bytes.mitems:
|
|
b = rand(byte)
|
|
UInt256.fromBytes(bytes)
|
|
|
|
proc example*(_: type UInt48): UInt48 =
|
|
# workaround for https://github.com/nim-lang/Nim/issues/17670
|
|
uint64.rand mod (UInt48.high + 1)
|
|
|
|
proc example*(_: type Wallet): Wallet =
|
|
Wallet.init(EthPrivateKey.random())
|
|
|
|
proc example*(_: type WalletRef): WalletRef =
|
|
WalletRef.new(EthPrivateKey.random())
|
|
|
|
proc example*(_: type SignedState): SignedState =
|
|
var wallet = Wallet.example
|
|
let hub, asset, receiver = EthAddress.example
|
|
let chainId, amount = UInt256.example
|
|
let nonce = UInt48.example
|
|
let channel = wallet.openLedgerChannel(hub, chainId, nonce, asset, amount).get
|
|
wallet.pay(channel, asset, receiver, amount).get
|
|
|
|
proc example*(_: type Pricing): Pricing =
|
|
Pricing(
|
|
address: EthAddress.example,
|
|
price: uint32.rand.u256
|
|
)
|
|
|
|
proc example*(_: type bt.Block): bt.Block =
|
|
let length = rand(4096)
|
|
let bytes = newSeqWith(length, rand(uint8))
|
|
Block.init(bytes).tryGet()
|
|
|
|
proc example*(_: type PeerId): PeerID =
|
|
let key = PrivateKey.random(Rng.instance[]).get
|
|
PeerId.init(key.getPublicKey().get).get
|
|
|
|
proc example*(_: type BlockExcPeerCtx): BlockExcPeerCtx =
|
|
BlockExcPeerCtx(id: PeerID.example)
|
|
|
|
proc example*(_: type Cid): Cid =
|
|
Block.example.cid
|