mirror of
https://github.com/logos-storage/logos-storage-nim.git
synced 2026-06-26 12:29:30 +00:00
137 lines
4.1 KiB
Nim
137 lines
4.1 KiB
Nim
import std/importutils
|
|
|
|
import pkg/questionable
|
|
import pkg/libp2p
|
|
import pkg/libp2p_mix
|
|
import pkg/libp2p_mix/curve25519
|
|
import pkg/codexdht/discv5/node as dn
|
|
import pkg/codexdht/discv5/routing_table as rt
|
|
import ../node
|
|
import ../conf
|
|
import ../utils/json
|
|
import ../manifest
|
|
import ../units
|
|
|
|
export json
|
|
|
|
type
|
|
RestContent* = object
|
|
cid* {.serialize.}: Cid
|
|
manifest* {.serialize.}: Manifest
|
|
|
|
RestContentList* = object
|
|
content* {.serialize.}: seq[RestContent]
|
|
|
|
RestNode* = object
|
|
nodeId* {.serialize.}: RestNodeId
|
|
peerId* {.serialize.}: PeerId
|
|
record* {.serialize.}: SignedPeerRecord
|
|
address* {.serialize.}: Option[dn.Address]
|
|
seen* {.serialize.}: bool
|
|
|
|
RestRoutingTable* = object
|
|
localNode* {.serialize.}: RestNode
|
|
nodes* {.serialize.}: seq[RestNode]
|
|
|
|
RestPeerRecord* = object
|
|
peerId* {.serialize.}: PeerId
|
|
seqNo* {.serialize.}: uint64
|
|
addresses* {.serialize.}: seq[AddressInfo]
|
|
|
|
RestNodeId* = object
|
|
id*: NodeId
|
|
|
|
RestRepoStore* = object
|
|
totalBlocks* {.serialize.}: Natural
|
|
quotaMaxBytes* {.serialize.}: NBytes
|
|
quotaUsedBytes* {.serialize.}: NBytes
|
|
quotaReservedBytes* {.serialize.}: NBytes
|
|
|
|
VersionInfo* = object
|
|
version* {.serialize.}: string
|
|
revision* {.serialize.}: string
|
|
|
|
DebugInfo* = object # Peer's ID
|
|
id* {.serialize.}: PeerId
|
|
# peer addresses known by the libp2p switch
|
|
addrs* {.serialize.}: seq[MultiAddress]
|
|
# signed peer record (URI form)
|
|
spr* {.serialize.}: Option[SignedPeerRecord]
|
|
# provider record (the one we announce for content we provide)
|
|
providerRecord* {.serialize.}: Option[SignedPeerRecord]
|
|
# addresses contained in the provider record
|
|
announceAddresses* {.serialize.}: seq[MultiAddress]
|
|
# libp2p public key
|
|
libp2pPubKey* {.serialize.}: string
|
|
# mix public key (for nodes that support mix)
|
|
mixPubKey* {.serialize.}: Option[FieldElement]
|
|
table* {.serialize.}: RestRoutingTable
|
|
storage* {.serialize.}: VersionInfo
|
|
|
|
proc init*(_: type RestContentList, content: seq[RestContent]): RestContentList =
|
|
RestContentList(content: content)
|
|
|
|
proc init*(_: type RestContent, cid: Cid, manifest: Manifest): RestContent =
|
|
RestContent(cid: cid, manifest: manifest)
|
|
|
|
proc init*(_: type RestNode, node: dn.Node): RestNode =
|
|
RestNode(
|
|
nodeId: RestNodeId.init(node.id),
|
|
peerId: node.record.data.peerId,
|
|
record: node.record,
|
|
address: node.address,
|
|
seen: node.seen > 0.5,
|
|
)
|
|
|
|
proc init*(_: type RestRoutingTable, routingTable: rt.RoutingTable): RestRoutingTable =
|
|
var nodes: seq[RestNode] = @[]
|
|
for bucket in routingTable.buckets:
|
|
for node in bucket.nodes:
|
|
nodes.add(RestNode.init(node))
|
|
|
|
RestRoutingTable(localNode: RestNode.init(routingTable.localNode), nodes: nodes)
|
|
|
|
proc init*(_: type RestPeerRecord, peerRecord: PeerRecord): RestPeerRecord =
|
|
RestPeerRecord(
|
|
peerId: peerRecord.peerId, seqNo: peerRecord.seqNo, addresses: peerRecord.addresses
|
|
)
|
|
|
|
proc init*(_: type RestNodeId, id: NodeId): RestNodeId =
|
|
RestNodeId(id: id)
|
|
|
|
proc `%`*(obj: RestNodeId): JsonNode =
|
|
% $obj.id
|
|
|
|
proc init*(_: type DebugInfo, node: StorageNodeRef): DebugInfo =
|
|
let
|
|
peerInfo = node.switch.peerInfo
|
|
peerId = peerInfo.peerId
|
|
libp2pPubKeyBytes = peerInfo.publicKey.getBytes()
|
|
|
|
# Cause there's no cannonical way to get your own key from MixProtocol
|
|
# that I'm aware of.
|
|
privateAccess(MixProtocol)
|
|
|
|
DebugInfo(
|
|
id: peerId,
|
|
addrs: peerInfo.addrs,
|
|
spr: node.discovery.dhtRecord,
|
|
providerRecord: node.discovery.providerRecord,
|
|
announceAddresses: node.discovery.announceAddrs,
|
|
table: RestRoutingTable.init(node.discovery.protocol.routingTable),
|
|
storage: VersionInfo(version: $storageVersion, revision: $storageRevision),
|
|
# Serialization has no error contract in nim-serde, so we need to
|
|
# handle this here.
|
|
libp2pPubKey:
|
|
if libp2pPubKeyBytes.isErr:
|
|
$libp2pPubKeyBytes.error
|
|
else:
|
|
byteutils.toHex(libp2pPubKeyBytes.get),
|
|
mixPubKey:
|
|
if node.discovery.mixProto.isNil():
|
|
none(FieldElement)
|
|
else:
|
|
# It's a bug if we don't have the peer in the pool, so let it throw an exception.
|
|
some(node.discovery.mixProto.mixNodeInfo.mixPubKey),
|
|
)
|