diff --git a/README.md b/README.md index fc4990ef..b6f41867 100644 --- a/README.md +++ b/README.md @@ -23,30 +23,63 @@ let peerId2 = await Fluence.generatePeerId(); Establish connections to predefined nodes. ```typescript -let client1 = await Fluence.connect("12D3KooWBUJifCTgaxAUrcM9JysqCcS4CS8tiYH5hExbdWCAoNwb", "104.248.25.59", 9003, peerId1); -let client2 = await Fluence.connect("12D3KooWHk9BjDQBUqnavciRPhAYFvqKBe4ZiPPvde7vDaqgn5er", "104.248.25.59", 9002, peerId2); +let client1 = await Fluence.connect("/dns4/134.209.186.43/tcp/9003/ws/p2p/12D3KooWBUJifCTgaxAUrcM9JysqCcS4CS8tiYH5hExbdWCAoNwb", peerId1); +let client2 = await Fluence.connect("/ip4/134.209.186.43/tcp/9002/ws/p2p/12D3KooWHk9BjDQBUqnavciRPhAYFvqKBe4ZiPPvde7vDaqgn5er", peerId2); ``` -Create a new unique service by the first client that will calculate the sum of two numbers. -```typescript -let serviceId = "sum-calculator-" + genUUID(); +## Become a provider -await client1.registerService(serviceId, async (req) => { +Create a new unique name to provide by the first client that will calculate the sum of two numbers. +```typescript +let name = "sum-calculator-" + genUUID(); + +await cl1.provideName(name, async (req) => { let message = {msgId: req.arguments.msgId, result: req.arguments.one + req.arguments.two}; - await client1.sendCall(req.reply_to, message); + await cl1.sendCall(req.reply_to, message); }); ``` -Send a request by the second client and print a result. The predicate is required to match a request and a response by `msgId`. +## Become a provider + +To declare that you're available on some token (unique name), you can become a provider of that token. For example, below you become a provider of a name `sum-calculator-1234...` so you can share that name with other people, and they can call you by that. + ```typescript -let msgId = "calculate-it-for-me" + genUUID(); let req = {one: 12, two: 23, msgId: msgId}; -let predicate = (args: any) => args.msgId && args.msgId === msgId; - -let response = await client2.sendServiceCallWaitResponse(serviceId, req, predicate); +let response = await client2.callProvider(name, req); let result = response.result; console.log(`calculation result is: ${result}`); -``` \ No newline at end of file +``` + + + +## Register Service +Will register service that will combine multiple modules around one serviceId +``` +let serviceId = await cl2.createService(peerAddr, ["ipfs_node.wasm", "curl.wasm"]); +console.log(serviceId); +``` + +## Call Service + +``` +// peerAddr – address of the node that runs this service +// "get_address" – function to call +// { some_arg: "1" } – arguments passed to the function +// "ipfs_node.wasm" – name of the module to find function in + +let resp = await cl2.callService(peerAddr, serviceId, "ipfs_node.wasm", {some_arg: "1"}, "get_address") +console.log(resp) +``` + +## Discover Services + +``` +// get available modules on node (to get info about connected node should use the method without arguments) +let modules = cl1.getAvailableModules(peerAddr); + +// get interfaces of existing services +let interfaces = await cl2.getActiveInterfaces(peerAddr); +``` diff --git a/src/address.ts b/src/address.ts index 44fa58c6..8221770f 100644 --- a/src/address.ts +++ b/src/address.ts @@ -104,7 +104,7 @@ export async function createRelayAddress(relay: string, peerId: PeerId, withSig: } } -export function createServiceAddress(service: string, hash?: string): Address { +export function createProviderAddress(service: string, hash?: string): Address { let protocol = {protocol: ProtocolType.Providers, value: service}; diff --git a/src/fluence_client.ts b/src/fluence_client.ts index 61d0bb07..aeb865aa 100644 --- a/src/fluence_client.ts +++ b/src/fluence_client.ts @@ -14,7 +14,14 @@ * limitations under the License. */ -import {Address, createRelayAddress, ProtocolType} from "./address"; +import { + Address, + createPeerAddress, + createRelayAddress, + createProviderAddress, + ProtocolType, + addressToString +} from "./address"; import {callToString, FunctionCall, genUUID, makeFunctionCall,} from "./function_call"; import * as PeerId from "peer-id"; import {Services} from "./services"; @@ -23,9 +30,29 @@ import {Subscriptions} from "./subscriptions"; import * as PeerInfo from "peer-info"; import {FluenceConnection} from "./fluence_connection"; +/** + * @param target receiver + * @param args message in the call + * @param moduleId module name + * @param fname function name + * @param context list of modules to use with the request + * @param name common field for debug purposes + * @param msgId hash that will be added to replyTo address + */ +interface Call { + target: Address, + args: any, + moduleId?: string, + fname?: string, + msgId?: string, + context?: string[], + name?: string +} + export class FluenceClient { readonly selfPeerInfo: PeerInfo; readonly selfPeerIdStr: string; + private nodePeerIdStr: string; private connection: FluenceConnection; @@ -49,14 +76,23 @@ export class FluenceClient { * Waits a response that match the predicate. * * @param predicate will be applied to each incoming call until it matches + * @param ignoreErrors ignore an errors, wait for success response */ - waitResponse(predicate: (args: any, target: Address, replyTo: Address) => (boolean | undefined)): Promise { - return new Promise((resolve, _) => { + waitResponse(predicate: (args: any, target: Address, replyTo: Address) => (boolean | undefined), ignoreErrors: boolean): Promise { + return new Promise((resolve, reject) => { // subscribe for responses, to handle response // TODO if there's no conn, reject this.subscribe((args: any, target: Address, replyTo: Address) => { if (predicate(args, target, replyTo)) { - resolve(args); + if (args.reason) { + if (ignoreErrors) { + return false; + } else { + reject(new Error(args.reason)); + } + } else { + resolve(args); + } return true; } return false; @@ -65,7 +101,7 @@ export class FluenceClient { } private getPredicate(msgId: string): (args: any, target: Address) => (boolean | undefined) { - return (args: any, target: Address) => target.hash && target.hash === msgId && !args.reason; + return (args: any, target: Address) => target.hash && target.hash === msgId; } /** @@ -77,91 +113,76 @@ export class FluenceClient { * @param fname functin name */ async sendCallWaitResponse(target: Address, args: any, moduleId?: string, fname?: string): Promise { - let replyHash = genUUID(); - let predicate = this.getPredicate(replyHash); - await this.sendCall(target, args, true, moduleId, fname, replyHash, undefined); - return this.waitResponse(predicate); + let msgId = genUUID(); + let predicate = this.getPredicate(msgId); + await this.sendCall({target: target, args: args, moduleId: moduleId, fname: fname, msgId: msgId}); + return this.waitResponse(predicate, false); } + + /** * Send call and forget. * - * @param target receiver - * @param args message in the call - * @param reply add a `replyTo` field or not + */ + async sendCall(call: Call) { + if (this.connection && this.connection.isConnected()) { + await this.connection.sendFunctionCall(call.target, call.args, call.moduleId, call.fname, call.msgId, call.context, call.name); + } else { + throw Error("client is not connected") + } + } + + /** + * Send call to the provider and wait a response matches predicate. + * + * @param provider published name in dht + * @param args message to the service * @param moduleId module name * @param fname function name - * @param name common field for debug purposes - * @param replyHash hash that will be added to replyTo address + * @param name debug info */ - async sendCall(target: Address, args: any, reply?: boolean, moduleId?: string, fname?: string, replyHash?: string, name?: string) { - if (this.connection && this.connection.isConnected()) { - await this.connection.sendFunctionCall(target, args, reply, moduleId, fname, replyHash, name); - } else { - throw Error("client is not connected") - } - } - - /** - * Send call to the service. - * - * @param moduleId - * @param args message to the service - * @param fname function name - * @param name common field for debug purposes - * @param replyHash hash that will be added to replyTo address - */ - async sendServiceCall(moduleId: string, args: any, fname?: string, replyHash?: string, name?: string) { - if (this.connection && this.connection.isConnected()) { - await this.connection.sendServiceCall(moduleId, false, args, fname, replyHash, name); - } else { - throw Error("client is not connected") - } - } - - /** - * Send a call to the local service on a peer the client connected with. - * - * @param moduleId - * @param args message to the service - * @param fname function name - * @param name common field for debug purposes - * @param replyHash hash that will be added to replyTo address - */ - async sendServiceLocalCall(moduleId: string, args: any, fname?: string, replyHash?: string, name?: string) { - if (this.connection && this.connection.isConnected()) { - await this.connection.sendServiceCall(moduleId, true, args, fname, replyHash, name); - } else { - throw Error("client is not connected") - } - } - - /** - * Send call to the service and wait a response matches predicate. - * - * @param moduleId - * @param args message to the service - * @param fname function name - */ - async sendServiceCallWaitResponse(moduleId: string, args: any, fname?: string): Promise { - let replyHash = genUUID(); - let predicate = this.getPredicate(replyHash); - await this.sendServiceCall(moduleId, args, fname, replyHash, fname); - return await this.waitResponse(predicate); + async callProvider(provider: string, args: any, moduleId?: string, fname?: string, name?: string): Promise { + let msgId = genUUID(); + let predicate = this.getPredicate(msgId); + let address = createProviderAddress(provider); + await this.sendCall({target: address, args: args, moduleId: moduleId, fname: fname, msgId: msgId, name: name}); + return await this.waitResponse(predicate, true); } /** * Send a call to the local service and wait a response matches predicate on a peer the client connected with. * * @param moduleId + * @param addr node address * @param args message to the service * @param fname function name + * @param context + * @param name debug info */ - async sendServiceLocalCallWaitResponse(moduleId: string, args: any, fname?: string): Promise { - let replyHash = genUUID(); - let predicate = this.getPredicate(replyHash); - await this.sendServiceLocalCall(moduleId, args, fname, replyHash, undefined); - return await this.waitResponse(predicate); + async callPeer(moduleId: string, args: any, fname?: string, addr?: string, context?: string[], name?: string): Promise { + let msgId = genUUID(); + let predicate = this.getPredicate(msgId); + + let address; + if (addr) { + address = createPeerAddress(addr); + } else { + address = createPeerAddress(this.nodePeerIdStr); + } + + await this.sendCall({target: address, args: args, moduleId: moduleId, fname: fname, msgId: msgId, context: context, name: name}) + + return await this.waitResponse(predicate, false); + } + + async callService(peerId: string, serviceId: string, moduleId: string, args: any, fname?: string): Promise { + let target = createPeerAddress(peerId, serviceId); + let msgId = genUUID(); + let predicate = this.getPredicate(msgId); + + await this.sendCall({target: target, args: args, moduleId: moduleId, fname: fname, msgId: msgId}); + return await this.waitResponse(predicate, false); } /** @@ -246,12 +267,86 @@ export class FluenceClient { /** - * Sends a call to register the service_id. + * Become a name provider. Other network members could find and call one of the providers of this name by this name. */ - async registerService(moduleId: string, fn: (req: FunctionCall) => void) { - await this.connection.registerService(moduleId); + async provideName(name: string, fn: (req: FunctionCall) => void) { + let replyTo = this.connection.sender; + await this.callPeer("provide", {name: name, address: addressToString(replyTo)}) - this.services.addService(moduleId, fn) + this.services.addService(name, fn); + } + + /** + * Sends a call to create a service on remote node. + */ + async createService(peerId: string, context: string[]): Promise { + let resp = await this.callPeer("create", {}, undefined, peerId, context); + + if (resp.result && resp.result.service_id) { + return resp.result.service_id + } else { + console.error("Unknown response type on `createService`: ", resp) + throw new Error("Unknown response type on `createService`"); + } + } + + async getInterface(serviceId: string, peerId?: string): Promise { + let resp; + resp = await this.callPeer("get_interface", {service_id: serviceId}, undefined, peerId) + return resp.interface; + } + + async getActiveInterfaces(peerId?: string): Promise { + let resp; + if (peerId) { + resp = await this.sendCallWaitResponse(createPeerAddress(peerId), {}, "get_active_interfaces"); + } else { + resp = await this.callPeer("get_active_interfaces", {}, undefined, peerId); + } + return resp.active_interfaces; + } + + async getAvailableModules(peerId?: string): Promise { + let resp; + if (peerId) { + resp = await this.sendCallWaitResponse(createPeerAddress(peerId), {}, "get_available_modules"); + } else { + resp = await this.callPeer("get_available_modules", {}, undefined, peerId); + } + + return resp.available_modules; + } + + /** + * Add new WASM module to the node. + * + * @param bytes WASM in base64 + * @param name WASM identificator + * @param mem_pages_count memory amount for WASM + * @param envs environment variables + * @param mapped_dirs links to directories + * @param preopened_files files and directories that will be used in WASM + * @param peerId the node to add module + */ + async addModule(bytes: string, name: string, mem_pages_count: number, envs: string[], mapped_dirs: any, preopened_files: string[], peerId?: string): Promise { + let config: any = { + logger_enabled: true, + mem_pages_count: mem_pages_count, + name: name, + wasi: { + envs: envs, + mapped_dirs: mapped_dirs, + preopened_files: preopened_files + } + } + let resp; + if (peerId) { + resp = await this.sendCallWaitResponse(createPeerAddress(peerId), {bytes: bytes, config: config}, "add_module"); + } else { + resp = await this.callPeer("add_module", {bytes: bytes, config: config}, undefined, peerId); + } + + return resp.available_modules; } // subscribe new hook for every incoming call, to handle in-service responses and other different cases @@ -287,6 +382,7 @@ export class FluenceClient { multiaddr = Multiaddr(multiaddr); let nodePeerId = multiaddr.getPeerId(); + this.nodePeerIdStr = nodePeerId; if (!nodePeerId) { throw Error("'multiaddr' did not contain a valid peer id") @@ -309,7 +405,7 @@ export class FluenceClient { // if the client already had a connection, it will reregister all services after establishing a new connection. if (!firstConnection) { for (let service of this.services.getAllServices().keys()) { - await this.connection.registerService(service); + await this.connection.provideName(service); } } diff --git a/src/fluence_connection.ts b/src/fluence_connection.ts index 1f20d193..a28e6566 100644 --- a/src/fluence_connection.ts +++ b/src/fluence_connection.ts @@ -14,16 +14,13 @@ * limitations under the License. */ -import {Address, createPeerAddress, createServiceAddress} from "./address"; +import {Address, createPeerAddress} from "./address"; import { callToString, FunctionCall, genUUID, - makeCall, makeFunctionCall, - makePeerCall, - makeRegisterMessage, - makeRelayCall, + makeProvideMessage, parseFunctionCall } from "./function_call"; import * as PeerId from "peer-id"; @@ -50,7 +47,7 @@ export class FluenceConnection { readonly sender: Address; private node: LibP2p; private readonly address: Multiaddr; - private readonly nodePeerId: PeerId; + readonly nodePeerId: PeerId; private readonly selfPeerId: string; private readonly handleCall: (call: FunctionCall) => FunctionCall | undefined; @@ -63,10 +60,10 @@ export class FluenceConnection { this.sender = sender } - makeReplyTo(replyHash?: string): Address { - if (replyHash) { + makeReplyTo(reply?: string): Address { + if (reply) { let replyToWithHash = {...this.sender} - replyToWithHash.hash = replyHash; + if (typeof reply === "string") replyToWithHash.hash = reply; return replyToWithHash; } else { return this.sender; @@ -96,37 +93,6 @@ export class FluenceConnection { // connection status. If `Disconnected`, it cannot be reconnected private status: Status = Status.Initializing; - /** - * Sends remote service_id call. - */ - async sendServiceCall(moduleId: string, isLocal: boolean, args: any, fname?: string, replyHash?: string, name?: string) { - let target; - if (isLocal) { - target = createPeerAddress(this.nodePeerId.toB58String()); - } else { - target = createServiceAddress(moduleId); - } - - let regMsg = makeCall(moduleId, target, args, this.sender, this.makeReplyTo(replyHash), fname, name); - await this.sendCall(regMsg); - } - - /** - * Sends custom message to the peer. - */ - async sendPeerCall(peer: string, msg: any, name?: string) { - let regMsg = makePeerCall(PeerId.createFromB58String(peer), msg, this.sender, this.sender, name); - await this.sendCall(regMsg); - } - - /** - * Sends custom message to the peer through relay. - */ - async sendRelayCall(peer: string, relay: string, msg: any, name?: string) { - let regMsg = await makeRelayCall(PeerId.createFromB58String(peer), PeerId.createFromB58String(relay), msg, this.sender, this.sender, name); - await this.sendCall(regMsg); - } - private async startReceiving() { if (this.status === Status.Initializing) { await this.node.start(); @@ -193,24 +159,23 @@ export class FluenceConnection { ); } - /** * Send FunctionCall to the connected node. */ - async sendFunctionCall(target: Address, args: any, reply?: boolean, moduleId?: string, fname?: string, replyHash?: string, name?: string) { + async sendFunctionCall(target: Address, args: any, moduleId?: string, fname?: string, msgId?: string, context?: string[], name?: string) { this.checkConnectedOrThrow(); let replyTo; - if (reply) replyTo = this.makeReplyTo(replyHash); + if (msgId) replyTo = this.makeReplyTo(msgId); - let call = makeFunctionCall(genUUID(), target, this.sender, args, moduleId, fname, replyTo, name); + let call = makeFunctionCall(genUUID(), target, this.sender, args, moduleId, fname, replyTo, context, name); await this.sendCall(call); } - async registerService(serviceId: string) { + async provideName(name: string) { let target = createPeerAddress(this.nodePeerId.toB58String()) - let regMsg = await makeRegisterMessage(serviceId, target, this.sender); + let regMsg = await makeProvideMessage(name, target, this.sender); await this.sendCall(regMsg); } } diff --git a/src/function_call.ts b/src/function_call.ts index 9aeca5d0..df578e2d 100644 --- a/src/function_call.ts +++ b/src/function_call.ts @@ -17,7 +17,6 @@ import { createPeerAddress, createRelayAddress, - createServiceAddress, Address, addressToString, parseAddress } from "./address"; import * as PeerId from "peer-id"; @@ -30,6 +29,7 @@ export interface FunctionCall { "module"?: string, fname?: string, arguments: any, + context?: string[], name?: string, action: "FunctionCall" } @@ -47,7 +47,7 @@ export function callToString(call: FunctionCall) { return JSON.stringify(obj) } -export function makeFunctionCall(uuid: string, target: Address, sender: Address, args: object, moduleId?: string, fname?: string, replyTo?: Address, name?: string): FunctionCall { +export function makeFunctionCall(uuid: string, target: Address, sender: Address, args: object, moduleId?: string, fname?: string, replyTo?: Address, context?: string[], name?: string): FunctionCall { return { uuid: uuid, @@ -57,6 +57,7 @@ export function makeFunctionCall(uuid: string, target: Address, sender: Address, "module": moduleId, fname: fname, arguments: args, + context: context, name: name, action: "FunctionCall" } @@ -82,6 +83,7 @@ export function parseFunctionCall(str: string): FunctionCall { reply_to: replyTo, sender: sender, arguments: json.arguments, + context: json.context, "module": json.module, fname: json.fname, name: json.name, @@ -95,37 +97,10 @@ export function genUUID() { } /** - * Message to peer through relay + * Message to provide new name. */ -export async function makeRelayCall(client: PeerId, relay: PeerId, msg: any, sender: Address, replyTo?: Address, name?: string): Promise { - let relayAddress = await createRelayAddress(relay.toB58String(), client, false); - - return makeFunctionCall(genUUID(), relayAddress, sender, msg, undefined, undefined, replyTo, name); -} - -/** - * Message to peer - */ -export function makePeerCall(client: PeerId, msg: any, sender: Address, replyTo?: Address, name?: string): FunctionCall { - let peerAddress = createPeerAddress(client.toB58String()); - - return makeFunctionCall(genUUID(), peerAddress, sender, msg, undefined, undefined, replyTo, name); -} - -/** - * Message to call remote service - */ -export function makeCall(moduleId: string, target: Address, args: any, sender: Address, replyTo?: Address, fname?: string, name?: string): FunctionCall { - - - return makeFunctionCall(genUUID(), target, sender, args, moduleId, fname, replyTo, name); -} - -/** - * Message to register new service_id. - */ -export async function makeRegisterMessage(serviceId: string, target: Address, sender: Address): Promise { - return makeFunctionCall(genUUID(), target, sender, {service_id: serviceId}, "provide", undefined, sender, "provide service_id"); +export async function makeProvideMessage(name: string, target: Address, sender: Address): Promise { + return makeFunctionCall(genUUID(), target, sender, {name: name, address: addressToString(sender)}, "provide", undefined, sender, undefined, "provide service_id"); } // TODO uncomment when this will be implemented in Fluence network diff --git a/src/test/address.spec.ts b/src/test/address.spec.ts index f48b2cd7..63e703ea 100644 --- a/src/test/address.spec.ts +++ b/src/test/address.spec.ts @@ -1,14 +1,14 @@ import { createPeerAddress, createRelayAddress, - createServiceAddress, + createProviderAddress, addressToString, - parseAddress, Address + parseAddress } from "../address"; import {expect} from 'chai'; import 'mocha'; -import {decode, encode} from "bs58" +import {encode} from "bs58" import * as PeerId from "peer-id"; import {callToString, genUUID, makeFunctionCall, parseFunctionCall} from "../function_call"; import Fluence from "../fluence"; @@ -16,6 +16,7 @@ import {certificateFromString, certificateToString, issue} from "../trust/certif import {TrustGraph} from "../trust/trust_graph"; import {nodeRootCert} from "../trust/misc"; import {peerIdToSeed, seedToPeerId} from "../seed"; +import {greetingWASM} from "./greeting_wasm"; describe("Typescript usage suite", () => { @@ -24,7 +25,7 @@ describe("Typescript usage suite", () => { }); it("should be able to convert service_id address to and from string", () => { - let addr = createServiceAddress("service_id-1"); + let addr = createProviderAddress("service_id-1"); let str = addressToString(addr); let parsed = parseAddress(str); @@ -69,6 +70,7 @@ describe("Typescript usage suite", () => { "mm", "fff", addr, + undefined, "2444" ); @@ -124,10 +126,27 @@ describe("Typescript usage suite", () => { }); // delete `.skip` and run `npm run test` to check service's and certificate's api with Fluence nodes - it.skip("integration test", async function () { + it.skip("test provide", async function () { + this.timeout(15000); + await testProvide(); + }); + + // delete `.skip` and run `npm run test` to check service's and certificate's api with Fluence nodes + it.skip("test certs", async function () { this.timeout(15000); await testCerts(); - // await testCalculator(); + }); + + // delete `.skip` and run `npm run test` to check service's and certificate's api with Fluence nodes + it.skip("test upload wasm", async function () { + this.timeout(15000); + await testUploadWasm(); + }); + + // delete `.skip` and run `npm run test` to check service's and certificate's api with Fluence nodes + it.skip("test list of services and interfaces", async function () { + this.timeout(15000); + await testServicesAndInterfaces(); }); }); @@ -166,8 +185,53 @@ export async function testCerts() { expect(certs[0].chain[1].issuedAt).to.be.equal(extended.chain[1].issuedAt) } +export async function testUploadWasm() { + let key1 = await Fluence.generatePeerId(); + let cl1 = await Fluence.connect("/dns4/134.209.186.43/tcp/9100/ws/p2p/12D3KooWPnLxnY71JDxvB3zbjKu9k1BCYNthGZw6iGrLYsR1RnWM", key1); + + let moduleName = genUUID() + await cl1.addModule(greetingWASM, moduleName, 100, [], {}, []); + + let availableModules = await cl1.getAvailableModules(); + console.log(availableModules); + + let peerId1 = "12D3KooWPnLxnY71JDxvB3zbjKu9k1BCYNthGZw6iGrLYsR1RnWM" + + let serviceId = await cl1.createService(peerId1, [moduleName]); + + let argName = genUUID(); + let resp = await cl1.callService(peerId1, serviceId, moduleName, {name: argName}, "greeting") + + expect(resp.result).to.be.equal(`Hi, ${argName}`) +} + +export async function testServicesAndInterfaces() { + let key1 = await Fluence.generatePeerId(); + let key2 = await Fluence.generatePeerId(); + + // connect to two different nodes + let cl1 = await Fluence.connect("/dns4/134.209.186.43/tcp/9100/ws/p2p/12D3KooWPnLxnY71JDxvB3zbjKu9k1BCYNthGZw6iGrLYsR1RnWM", key1); + let cl2 = await Fluence.connect("/ip4/134.209.186.43/tcp/9002/ws/p2p/12D3KooWHk9BjDQBUqnavciRPhAYFvqKBe4ZiPPvde7vDaqgn5er", key2); + + let peerId1 = "12D3KooWPnLxnY71JDxvB3zbjKu9k1BCYNthGZw6iGrLYsR1RnWM" + + let serviceId = await cl2.createService(peerId1, ["ipfs_node.wasm"]); + + let resp = await cl2.callService(peerId1, serviceId, "ipfs_node.wasm", {}, "get_address") + console.log(resp) + + let interfaces = await cl1.getActiveInterfaces(); + let interfaceResp = await cl1.getInterface(serviceId, peerId1); + + console.log(interfaces); + console.log(interfaceResp); + + let availableModules = await cl1.getAvailableModules(peerId1); + console.log(availableModules); +} + // Shows how to register and call new service in Fluence network -export async function testCalculator() { +export async function testProvide() { let key1 = await Fluence.generatePeerId(); let key2 = await Fluence.generatePeerId(); @@ -177,10 +241,10 @@ export async function testCalculator() { let cl2 = await Fluence.connect("/ip4/134.209.186.43/tcp/9002/ws/p2p/12D3KooWHk9BjDQBUqnavciRPhAYFvqKBe4ZiPPvde7vDaqgn5er", key2); // service name that we will register with one connection and call with another - let serviceId = "sum-calculator-" + genUUID(); + let providerId = "sum-calculator-" + genUUID(); // register service that will add two numbers and send a response with calculation result - await cl1.registerService(serviceId, async (req) => { + await cl1.provideName(providerId, async (req) => { console.log("message received"); console.log(req); @@ -188,27 +252,30 @@ export async function testCalculator() { let message = {msgId: req.arguments.msgId, result: req.arguments.one + req.arguments.two}; - await cl1.sendCall(req.reply_to, message); + + await cl1.sendCall({target: req.reply_to, args: message}); }); let req = {one: 12, two: 23}; // send call to `sum-calculator` service with two numbers - let response = await cl2.sendServiceCallWaitResponse(serviceId, req); + let response = await cl2.callProvider(providerId, req, providerId); let result = response.result; - console.log(`calculation result is: ${result}`); + expect(result).to.be.equal(35) await cl1.connect("/dns4/relay02.fluence.dev/tcp/19001/wss/p2p/12D3KooWEXNUbCXooUwHrHBbrmjsrpHXoEphPwbjQXEGyzbqKnE9"); await delay(1000); // send call to `sum-calculator` service with two numbers - await cl2.sendServiceCall(serviceId, req, "calculator request"); + await cl2.callProvider(providerId, req, providerId, undefined, "calculator request"); - let response2 = await cl2.sendServiceCallWaitResponse(serviceId, req); + let response2 = await cl2.callProvider(providerId, req, providerId); let result2 = await response2.result; - console.log(`calculation result AFTER RECONNECT is: ${result2}`); + console.log("RESULT:"); + console.log(response2); + expect(result2).to.be.equal(35) } diff --git a/src/test/greeting_wasm.ts b/src/test/greeting_wasm.ts new file mode 100644 index 00000000..9ab7e51a --- /dev/null +++ b/src/test/greeting_wasm.ts @@ -0,0 +1 @@ +export const greetingWASM = "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" \ No newline at end of file diff --git a/src/trust/trust_graph.ts b/src/trust/trust_graph.ts index e5dc3565..fddb9f6a 100644 --- a/src/trust/trust_graph.ts +++ b/src/trust/trust_graph.ts @@ -16,7 +16,6 @@ import {FluenceClient} from "../fluence_client"; import {Certificate, certificateFromString, certificateToString} from "./certificate"; -import {genUUID} from "../function_call"; // The client to interact with the Fluence trust graph API export class TrustGraph { @@ -34,7 +33,7 @@ export class TrustGraph { certsStr.push(await certificateToString(cert)); } - let response = await this.client.sendServiceLocalCallWaitResponse("add_certificates", { + let response = await this.client.callPeer("add_certificates", { certificates: certsStr, peer_id: peerId }); @@ -50,7 +49,7 @@ export class TrustGraph { // Get certificates that stores in Kademlia neighbourhood by `peerId` key. async getCertificates(peerId: string): Promise { - let resp = await this.client.sendServiceLocalCallWaitResponse("certificates", { + let resp = await this.client.callPeer("certificates", { peer_id: peerId });