How to use listener.d example?

[Neia Neutuladh]

On Friday, 31 August 2018 at 07:38:54 UTC, Marcin wrote:
> https://github.com/dlang/dmd/blob/master/samples/listener.d
>
> Can some one add more comment to that example?
>
> I need to make code that connects to local application, very 
> similar to this.
>
> Assumptions:
> 1. Create an application that listens to arguments.
> 2. Create an application that will send arguments to the 
> application mentioned above.
> 3. The application will return the sine (argument) to the 
> client.
> 4. All communication must be realized via console.

Another, more structured way to do this is with an RPC framework 
like Apache Thrift. With Thrift, you'd write an interface 
description:

---
namespace d math.api
service Sine
{
   double sine(1: double value);
}
---

In your application, you'd have something like:

---
import vibe.d;
import vibethrift;
import math.api.Sine;

class SineImpl : Sine
{
   double sine(double value)
   {
     static import std.math;
     return std.math.sin(value);
   }
}
void main()
{
   serve!Sine(new SineImpl, "0.0.0.0", 5555);
   return runApplication();
}
---

Then you use the corresponding Thrift client to make requests 
against it.

You could also do this with Vibe and REST:

---
import vibe.d;
class Sine
{
   @path("/sine")
   string getSine(double value)
   {
     static import std.math;
     import std.conv : to;
     return std.math.sin(value).to!string;
   }
}
void main()
{
   auto settings = new HTTPServerSettings;
   settings.port = 5555;
   auto router = new URLRouter;
   router.registerWebInterface(new Sine);
   listenHTTP(settings, router);
   runApplication();
}
---

And then you can point your browser at 
http://localhost:5555/sine?value=1.5 and get back 0.997495. You 
can similarly use std.net.curl to make the request.

But let's say you want to do everything yourself.

That script is the server. Line 55 is the thing that handles the 
input. You need to put your code there.

The remote application might send input in multiple packets. That 
means you have to collect input somewhere and figure out where 
the end is. You can either pass a length as the first part 
(usually a 4-byte value in network byte order), or require a 
special character to terminate the commend (I recommend the ASCII 
Record Separator character, U+001E, or the like), or know enough 
about your input to figure out where it ends anyway.

Once you get the end of your input, you send it off somewhere to 
parse and process. It's up to you how you want to send numbers 
across. When you're done, you need to convert the output numbers 
back to bytes somehow and send them back with socket.send(), and 
then you close the connection.

Once you've got that working, you need to write a client that 
does pretty much the same thing, but Socket.connect instead of 
the bind/listen/accept business, and you can just use Socket.read 
for the response rather than dealing with a SocketSet.