141 lines
3.5 KiB
TypeScript
141 lines
3.5 KiB
TypeScript
import { Multihash } from "./multihash.js";
|
|
import NodeId from "./nodeId.js";
|
|
import { Logger, S5Config, S5NodeConfig, S5Services } from "./types.js";
|
|
import Unpacker from "./serialization/unpack.js";
|
|
import Packer from "./serialization/pack.js";
|
|
import StorageLocation from "./storage.js";
|
|
import KeyPairEd25519 from "#ed25519.js";
|
|
import { AbstractLevel } from "abstract-level";
|
|
import { P2PService } from "#service/p2p.js";
|
|
import { RegistryService } from "#service/registry.js";
|
|
const DEFAULT_LOGGER = {
|
|
info(s: any) {
|
|
console.info(s);
|
|
},
|
|
verbose(s: any) {
|
|
console.log(s);
|
|
},
|
|
warn(s: any) {
|
|
console.warn(s);
|
|
},
|
|
error(s: any) {
|
|
console.error(s);
|
|
},
|
|
catched(e: any, context?: string | null) {
|
|
console.error(e, context);
|
|
},
|
|
};
|
|
|
|
export class S5Node {
|
|
private _nodeConfig: S5NodeConfig;
|
|
|
|
constructor(config: S5NodeConfig) {
|
|
this._nodeConfig = config;
|
|
}
|
|
|
|
private _config?: S5Config;
|
|
|
|
get config() {
|
|
return this._config as S5Config;
|
|
}
|
|
|
|
get services() {
|
|
return this._config?.services as S5Services;
|
|
}
|
|
|
|
get db() {
|
|
return this._config?.db as AbstractLevel<Uint8Array, string, Uint8Array>;
|
|
}
|
|
|
|
get logger() {
|
|
return this._config?.logger as Logger;
|
|
}
|
|
|
|
public async start() {
|
|
this._config = {
|
|
keyPair: this._nodeConfig.keyPair,
|
|
db: this._nodeConfig.db,
|
|
logger: this._nodeConfig.logger ?? DEFAULT_LOGGER,
|
|
cacheDb: this._nodeConfig.db.sublevel("s5-object-cache", {}),
|
|
services: {} as any,
|
|
p2p: this._nodeConfig.p2p,
|
|
};
|
|
|
|
const p2p = new P2PService(this);
|
|
const registry = new RegistryService(this);
|
|
|
|
await p2p.init();
|
|
await registry.init();
|
|
await p2p.start();
|
|
}
|
|
|
|
async readStorageLocationsFromDB(
|
|
hash: Multihash,
|
|
): Promise<Map<number, Map<string, Map<number, any>>>> {
|
|
const map = new Map<number, Map<string, Map<number, any>>>();
|
|
const bytes = await this.db.get(stringifyHash(hash));
|
|
if (bytes === null) {
|
|
return map;
|
|
}
|
|
const unpacker = Unpacker.fromPacked(bytes);
|
|
const mapLength = unpacker.unpackMapLength();
|
|
for (let i = 0; i < mapLength; i++) {
|
|
const type = unpacker.unpackInt() as number;
|
|
const innerMap = new Map<string, Map<number, any>>();
|
|
map.set(type, innerMap);
|
|
const innerMapLength = unpacker.unpackMapLength();
|
|
for (let j = 0; j < innerMapLength; j++) {
|
|
const nodeId = new NodeId(unpacker.unpackBinary());
|
|
innerMap.set(
|
|
nodeId.toString(),
|
|
new Map(unpacker.unpackMap() as [number, any][]),
|
|
);
|
|
}
|
|
}
|
|
return map;
|
|
}
|
|
|
|
async addStorageLocation({
|
|
hash,
|
|
nodeId,
|
|
location,
|
|
message,
|
|
config,
|
|
}: {
|
|
hash: Multihash;
|
|
nodeId: NodeId;
|
|
location: StorageLocation;
|
|
message?: Uint8Array;
|
|
config: S5Config;
|
|
}) {
|
|
const map = await this.readStorageLocationsFromDB(hash);
|
|
const innerMap =
|
|
map.get(location.type) || new Map<string, Map<number, any>>();
|
|
map.set(location.type, innerMap);
|
|
|
|
const locationMap = new Map<number, any>([
|
|
[1, location.parts],
|
|
// [2, location.binaryParts],
|
|
[3, location.expiry],
|
|
[4, message],
|
|
]);
|
|
|
|
innerMap.set(nodeId.toString(), locationMap);
|
|
await config.cacheDb.put(
|
|
stringifyHash(hash),
|
|
new Packer().pack(map).takeBytes(),
|
|
);
|
|
}
|
|
}
|
|
|
|
export function stringifyBytes(data: Uint8Array) {
|
|
return String.fromCharCode(...data);
|
|
}
|
|
|
|
function stringifyHash(hash: Multihash) {
|
|
return stringifyBytes(hash.fullBytes);
|
|
}
|
|
export function stringifyNode(node: NodeId) {
|
|
return stringifyBytes(node.bytes);
|
|
}
|