Fluence Labs Hands-on p2p network choreography. Workshop, 5 Mar 2021

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: How to build a simple Curl service

Description

Building a simple effectful service in rust: curl adapter

Workshop, at Hack the System hackathon
Speaker: Alexey Pyshnenko
Engineer at Fluence Labs

----
Source https://youtu.be/om038Mnzj_w
Workshop requirements & flow https://www.notion.so/fluencenetwork/Fluence-Workshop-hands-on-2-network-choreography-83beddecd2194a4789039406a85224df
Hack the System hackathon challenges https://medium.com/encode-club/hack-the-system-announcing-fluence-87fa8dae59
Get started with Fluence https://fluence.dev/docs
Protocol Paper https://github.com/fluencelabs/rfcs/blob/main/0-overview.md
Developer Hub https://dash.fluence.dev/
Github https://github.com/fluencelabs
Fluence Home https://fluence.network/

A

um We already saw the requirements if you want to follow, follow me.

A

If you don't want it's okay, if you want install this, please.

A

So, what's the plan for the workshop, um we will build a simple service in rust. It's I say here that it's effective service. What it means is that you will be able to call network.

A

Where to get this text.

A

A

Great, so um then we will configure that service we will deploy. We will connect it with a front-end application. We will use cli to the flgs here to inspect the server that service and run scripts from cli. We can run scripts from front-end. We can run scripts from cli or you can use your own environment that you like.

A

Then we will extend that service to be able to write data to disk, and I will also explain how to link several modules together and finally, we will go to advanced part that we have time hopefully, and we will talk about authorization, that's done through chatroclax. We have this term I'll talk about.

A

So, let's go to our first first little example: here we imagine we want to implement the duckduckgo command that we that I was mentioning in the chat api right. So what I want to have is a separate service, so others can reuse it, and I want to be able to call network to call duckduckgo from that service. But there is a problem with wasm advisor. They do not provide network socket api yet, but how do we work around that? We can reuse existing software.

A

I, like reusing stuff, and here we will use curl, not as a library but as a binary. That's already that's running that that exists on the node. So if you want to do that to call duckduckgo in the clip you can just do that comment. Copy, copied and paste to your.

A

To your terminal- and you will have some answer- the condensed milk is a cow's, milk blah blah. We will do almost the same, but we will have it as a webassembly service. That's calling the external binary curl and return the result for us to use in other services.

A

This is a basic building block that you can use to call any external network api, any websocket or whatever, and if you ever need to have not a curl about some other binary, you can run your own node and put any binary there, and you can will be able to call that binary from your node.

A

How to do that and what api I want to have. I want to have a simple request: function. That's that will be callable from air script.

A

It will take a single argument, url and return a string result either success or.

A

And the whole implementation of that request and the point now that request function is here in a single line. It calls external binary curl, like a simple raster like an ordinary rust function. It passes a single argument, that's an array of a single argument for a single element to as an argument to the curl. So it basically does this.

A

You can also keep those parameters, but then, instead of having just.

A

A

You will do like this.

A

It's a simple rust, nothing specific to fluence. uh The only specific thing is to is that we allow to call external binaries as simple rust functions, so you can have as many arguments as you wish. Okay,.

A

But how fluence knows where this binary is, we surely shouldn't trust or use path variable, so we specify the path to the curl binary in the module conflict.

A

So that means that there are module conflicts. We you didn't know about that, I presume so. Every module every was module has to have a configuration file.

A

If it doesn't need access to file system or network, it will be just a single field name, nothing else, but here we need an access to external binary curl and that's why we have to have uh these field mounted binaries that says that mounted binary curl is expected to be on this path. On the node.

A

So, let's go to the project actually and review the structure, the structure of the project. Here we have several things. First, we have backend folder that contains rust project. We have a frontend folder, which contains react project. We have a script to deploy the back-ends.

A

We have a script air script to call those back-ends and we have this configuration file that allows you to try the service lock. I will talk about so. Let's first review, let's first review the back end right, as I said, it's a simple rust project that has a single dependency influence.

A

That's fluence trust sdk,.

A

And here, and when you compile that project you in result will have a webassembly file, so you will have something like uh curl template dot wasn't somewhere in the target directory. We'll do that. We will see so here. What's in the what are the sources of the project? They are pretty simple, as was imagined uh presented on the pictures here I passed two arguments, the url and the options to make it less verbose.

A

Cool by default is pretty verbose so that that will make it quiet but still show errors, and we have this block that says that we have a mount binary, that's available to be called as a rust function.

A

So, anytime, you want to call some mounted binary, some external binary. You will have to do it that way. You will have to have external c around it. So it's so rust knows it's an ffi frame function. Interface. You will have to have this link that points last member module to host. So runtime knows that you mean running those functions on the host and you will need to have this macro fce that converts all this and converts underlying types. So you can't have just string and webassembly. You can have just result in web assembly.

A

You need to manage pointers and raw memory too, for this to work so that what that small, free electric micro does inside a lot of complex logic that you don't have to worry about. You just have to have this marker here and to describe your public api. You define uh function and mark it with fc macro too, so it converts it makes public. It makes it available for scripts to call and it converts complex structures to webassembly.

A

Okay, so how is it deployed? What how to deploy the service to the influence? It's pretty simple. The first thing is this, and the second thing is this: all everything else is just a fancy uh scripting stuff that we don't really care about.

A

So you to compile the webassembly file, you have to go to the backend folder and run fc view minus minus release. That's why you need fc uh installed, so I am in current template. I go to backhand, I put a release and I have my web assembly. I guess it's too small. This is too small and I have my webassembly file there.

A

Okay, so you can instead of doing this that may enable you you can use, deploy sage script, you can run, it will build and then it will that's two okay and it will deploy service and once the service is deployed, you will have service id as a result.

A

So we deployed service. Let's try to call it, and here uh yeah and I'll show you where the wasm file is in the target folder. So we can check it there, it's there and then discrete the deploy, sh script. It uses flgs2 to create a service, so you basically specify a list of modules as a pairs of semicolon configuration file in here configuration file. We already seen here on the image. It's it's. You have a link here to follow.

A

If you want so that already happened, let's try to call our service, but before that, let's review.

A

Yeah here is a smaller, more smaller version of that script. That shows only in the main parts.

A

um Let's call that service, but first, let's review the script so to call service, you use a photist, run air command and you specify a path to air script and you specify variables really for variables that I use inside that script, what it means variables inside script. So let's take a look at the request. Air file here we have a simple script that goes to a service goes to a node uh which id is resolved through variable uh named service. That's why we have here.

A

I will switch tab, that's why we have here this uh variable that holds a service id so yeah. It holds a service id uh here, so it's so we can use it.

A

We go to the node relay uh here. It's also variable, but run air already gives you to where that variable uh to use. So we don't have to specify it all the time. If you switch to another relay, it will automatically change. So here we go to relay where we deployed our service. We call the service by the id specified as a variable. We call the function request, as was specified in the last code. We pass the this request there, the url go that search for homotopy.

A

What hamataki means it's magic, mathematical object and stuff. We will see and we have the result of the curl execution of the call of the curl binary put into well variable named result. And, finally, we go to the init peer id, which is our the client's address, and we run this thing. uh This is a specific to run air command. So when we we do, authorities run air, we have two variables available for us. First, one is a relay and second one is return service. That way, you can always return a result to the client.

A

By calling this this service return service and function run, it will be just displayed on the in the console. Let's see how it works in action, so here you can see that it it's a different service id then from what I created, because it was with me, it's a little smaller. It's too big hope it's okay. Now, um so we take the service id. We just deployed, we put it here.

A

Hopefully it works yeah and we get the result.

A

uh We have uh the following structure. As a result, we have a structure with field error or a return code, stdr and stdl. Since curl didn't fail, we have an std out output and it's a json, as was returned by data, go api so yeah.

A

Now we know that uh homotherapy, it's uh churn from topology branch, mathematics, landlord okay. So it works. This second argument, so you have here two things. This first one is the result of the curl. Second, one is the theatre plot that says where this result came from. That's how security works. I will talk about it. I will elaborate on it later, but in sure you have this thing. That's called tetraplaque white tetraplate because there are four meaningful fields. There are four fields uh from what node.

A

This data came from, what service from what function and from what jsonpath and which json path was used to transform the data. So you know that the data wasn't forged in any way. Okay, oops.

A

So any questions so far, let me check no.

A

So yeah here is the image of the of the script.

A

We can also use uh flgs get interface to take a look at the service. Let me copy it.

A

Okay, service id is this and we will have a json json structure that describes that this service has the following functions. It's a single function called request with a single argument: url of type string, it outputs string, result, structure and that structure string result is defined here in record types. So we know that it has those fields, red code, error, std out and stdr, all of them strings, except the return code, which is an integer, and it will also show us who is the owner or who created that service.

A

uh That's the tier id that was after automatically generated here. Let me show it yeah this yeah. Was it yeah it's time to ready, that's the one that was used to create the service and it's and it's the same. So every service knows who created it and it can be checked in the service function. That's another primitive! You can use for after research.

A

So there was a question.

A

A

So uh yeah uh it's recorded, but I will elaborate anyway. I will hope to make it clear that um backend is vast. It's not like what we can do is connected to us. We have has this code here. It says this is our back. This is the backend code right, and this is the api of the back-end this code. It was compiled to webassembly module and deployed to melody.

A

So it was a really simple deployment process and you can have it programmed in different complex way. You can deploy different services to different nodes, different backends, to different nodes in a dynamic way. However, you choose to do, but here it was simple that we have this code. This is whole code wire back no more.

A

We compiled it to webassembly module, deployed it and then called this function which, uh in its order, called the external binary curl and returned the string result structure which has four fields: okay, oh it I made it clear now.

A

So if you, it's really uh kind of annoying to deploy all the time and with resources, uh so if you don't want to deploy your service all the time, you can use fc repo to develop it and test it locally here how it works good. Just put so I was a little ahead of.

A

Let me explain so here we have uh a simple tomo config that describes describes for fc repo, how to run that service locker. Here we have a specification for a module. It's almost the same as you have seen json right, it's almost almost the same as a configuration for this module.

A

Just this is in json, and this is in town. It specifies where to look for the module. It specifies the name of the module yeah, so we had the we had our module and then this folder right under this name.

A

That's exactly what it says uh what it says, and here we specify the same amount of binaries. So we tell that we should. The fc rebel should look for the curl on my system. Now now it is running locally uh under this path. So, let's run to run to run vfc repo. You have to specify path to the configuration file you run it it app service is creates, is created immediately and you can call it. Let's see, how can we how we can call it?

A

So it's really simple you just basically it's almost the same as in the airscript. You call you the the different things that you specify here, not the service but the module name, and you specify function name in the argument. Let's do that yep and here we have the same output.

A

Well, not the same this time, it's about condensed milk not attractive, but still we have the output. We have this object that contains the fields that were the same in the previous call, and we have the result uh from from go forward it here to our to my console.

A

Okay, so it works nice, that's how you can experiment with your services locally and you can have in this configuration file. You can have different modules. I mean several modules, different modules linked together and we'll see in a moment how to do that.

A

Okay, so, but first, let's take a look on how to connect the front end application to the coral background.

A

Let's go to the go and see if it works, I'm going to the front-end directory. I already done- and I uninstalled, but let's do that again. Maybe I shouldn't have because it takes time- and I don't have much of it too bad anyway, um let's review package.json for now, while it installs so package.json.

A

I hope you know that it well. It allows you to specify dependencies for your project here. There are two main dependencies uh for using fluent. First one is fluence jcdk. Second, one is a library that allows you to switch between different environments of the frames network. Okay, it's done. Let's start it hope it works.

A

Would you like another? Yes, oh I guess I already have it anyway. I already have it running somewhere.

A

So here we have a really simple web application that has yes, that has the field to enter the url and the button to issue a request to issue a call function to the service. We will go through the source of the front end application in a moment here you can see that we sent a request to go and receive the same response. So if I put here another string, we will have apple apple, disobligation definition text apple daily. Well, it's not that good.

A

As for gamma homotyping, but still it's uh we, we have called, go and receive the response. It's a really simple application, as you can see, there's no unix there, so how that application works anyway. uh It has three main files that you I care about for right now.

A

The first one is package.json that specifies the dependencies on fluency.js sdk, but that we already looked through the second one is fluence.ts: it's a typescript file. Yeah, all it does. It gives you a single function to call it's called request.

A

It accepts friends, client as a connection to the node url to call and ttl meaning that if this request hasn't been executed in this number of seconds, then it should fail, and here we have the script.

A

It's really easy, almost the same as we use it. If we run air, um but since we don't have relay variable provided here by default, we have to provide it our own, so it does the almost the same. We go to the relay. We go to the node that hosts service. It's the same thing in our case, but still you can tell it different. You can have work with different nodes through same relay and we call service.

A

We call the function request there we put url, we get result and we finally send a result back to ourselves right here. We could use init peer id in person science, but we decided not to for no apparent reason with just the matter of taste. However, you like it, you can write, and here you can see that results return to the client through relay, so it's expressed in this way. It says that sequentially go to relay.

A

Do nothing there or identity just nothing that does just nothing and after relay, go to client and call callback function. Callback service with callback function and callback is defined. Here.

A

It's done to resemble gate we, so you can see that callback id is generated on each request. That way, you can differentiate.

A

Between different responses to different requests, it's all up to you how to do that now you can express any business logic or any logic of any application with that.

A

So what we have in result is a curl function that returns some result here by sending discrete give that data to the network, script and data they are wrapped in a structure called particle particle is a network packet that contains well script and data and the timeout and once and network will start executing the script line by line, and once it goes to that line, the particle will be sent will be sent from the relay to the local client and will be executed in the local webassembly runtime. So this front-end application this one internally.

A

It runs webassembly module to interpret that script, and once it receives the script, it sees that all those instructions already executed, and this instruction belongs to the local client. So it calls the callback.

A

And the last meaningful file that glues this all together. It's a simple react application, I'm no front-end developer, but this is simple even for me who doesn't who has no experience whatsoever?

A

So what happens here? um First, we connect the client to the node. We have relay node defined in the fringe ts file. It's let me show you so relay. Node is the third node from test net environment and the environment comes from fluence network, environment library.

A

You should use testnet environment always, but this index you can switch. You can use several nodes, you can use all of them. I think there are like 10 of them right now. You can use any other or you can stick with this one. It's the most used node we have. I will show you that also uh so we have really node. We connect there through korean, create client function that we take from fluence.js, sdk and well.

A

We basically set the client to use it later, so it's really obvious and then we get the we execute curl request once this request function is executed on on the button. So we have this button and on click, it just executes request function that, in its turn, executes cruel requests that which, in its turn, sends script to the node and uh it returns a promise. So we wait for it. And finally, we set the data to be displayed here.

A

You can see that we accessed std out field, so the data this structure returned from the rust right. So we had this, we have we had anyway. We had the structure returned from rust. It had some fields and those fields, they are deserialized to javascript objects to json objects, and you can access their fields in a single way later. It will all be smoothed out.

A

With I mean it will be, all uh will all have types proper types, so you couldn't use a wrong field, but currently you have to be careful about that, but I think that's the nature of the javascript and typescript that you. You know that this is this argina dynamic type link dynamically typed languages, so you have to be careful about fields of the structures anyway, okay, so front end works.

A

We have our first. We just had our first uh back-end implemented and we made a front-end dot for it and it can implement these slash, go comment of our chat and you can start from right from there. You can start developing your up right from there and uh give a few customizations. You can already uh hit those bounties. The first two just don't just be sure to customize your apps to do something different, uh not copy paste, the existing code.

A

Okay, any questions so far.

A

Seems like I hope there are still people watching me, but anyway this all will be recorded, so you will be able to watch that on youtube, I hope or somewhere.

A

So you will be able to use that video as a kind of help through the workshop, and we have documentation also to assist you so I'll talk about that. Okay,.