Event as Request from JSON Rpc Server

[juaal12]

Good afternoon!

I am using your package for implementing a json rpc client which connects to a json rpc server (json rpc server is provided by an external client). I am using your package for connecting to the server an executing the methods it provides. So far so good it works like a charm for simple calls.

However, the server has a special functionality where he sends a response when an event is raised inside him. I cannot subscribe to this response and I neither can use NotifyAsync method since this method is not a valid method to call in my server methods. This response looks like this:

{
   "jsonrpc" :  "2.0" ,
   "method" :  "Event.eventOccurred" ,
   "params" : { ... }
   }
}

For managing this special use case I am using a method provided by your package like follows:

jsonRpc.AddLocalRpcMethod("Event.eventOccurred", "Here I will have an async delegate");

As I understand this AddLocalRpcMethod will create a local method to execute when called. I do not know if maybe I am missunderstanding the method or maybe my implementation is not correct but this method seems to never be called which means my async delegate is not executed and my flow cannot continue.

• Am I doing a proper approach using AddLocalRpcMethod for my use case?
• Should I do this in a different way? If yes... How can I manage this?
• Is it possible to receive messages throught the socket without asking for them pointing to an "endpoint" (this would be this case if I am not wrong)?

Thanks in advance!

[AArnott]

This response looks like this:

I'm confused by your terminology. The JSON object you share is not a response. It is a notification. Responses do not include method names.

I neither can use NotifyAsync method since this method is not a valid method to call in my server methods.

I don't understand this either, because in fact RPC server methods can call NotifyAsync just fine. But as you don't implement the party you are calling a server, and that remote party is the one I believe is sending the notification, I don't know why the party receiving the notification would ever have need to call NotifyAsync.

jsonRpc.AddLocalRpcMethod ought to work, provided the signature of the delegate you provide matches the shape of the params property per the JSON-RPC spec. If it doesn't match, it'll just drop the notification without invoking your delegate. Turning on logging via JsonRpc.TraceSource would allow you to see if such an error is happening.

Another option is to declare a method on a class, and pass an instance of that class is a local target object. That will let the remote party invoke public methods on your locally defined class. Since the method name on this notification isn't a valid C# method name, you can apply the [JsonRpcMethod("Event.eventOccurred")] attribute to the method so that it will be invoked as expected. But again, the same method signature requirement applies, and the logs can help you diagnose this.

[juaal12]

Good morning!

I am sorry for my bad explanation, I wanted to explain it as clear as possible but without copy and pasting code is a bit hard to be honest (I can not copy internal code here due to company policies).

Then returning to the topic... Explaining a bit the big picture I have a PLC, then I have a server using JSON rpc protocol and lately I have my application. When a value in the PLC changes, in my application, I will get the notification I attached in my first question, through the Server.

What I am doing right now in my application is creating a local rpc method with JsonRpc.AddLocalRpcMethod. This local rpc method as endpoint has the Event.eventOccurred endpoint and as a delegate an async delegate which parameters match the shape of the params property in the JSON-RPC spec. So reading your response this approach should work.

I will activate the JsonRpc.TraceSource on JsonRpc side and I will check this. Do I need something else to get my logs on my log file through NLog? May I change my appsettings.json to get the JsonRpc logs?

Thanks for the response!

[juaal12]

Good afternoon @AArnott ,

I have followed your advices but it still not working. My local method still not being executed by the remote party.
If I understood well, my application has to act as client for my remote party but also as server for the remote party. I am creating the JsonRpc client as:

  public void Initialize(WebSocketMessageHandler webSocketMessageHandler)
  {
    JsonRpc = new JsonRpc(webSocketMessageHandler)
    {
      AllowModificationWhileListening = true
    };

    CreateLocalRpcEndpoint();

    JsonRpc.StartListening();
  }

And CreateLocalRpcEnpoint looks like this:

  private void CreateLocalRpcEndpoint()
  {
    try
    {
      AddLocalRpcMethod(EventRegistrationEndpoint,
        new Func<EventOccurredRequest, Task>(async request =>
          await _eventContext.ExecuteCallbackAsync(request.RegistrationId!).ConfigureAwait(false)));

      _logger.LogInformation("{MethodName}: Local endpoint created on {EventRegistrationEndpoint}.",
        nameof(CreateLocalRpcEndpoint), EventRegistrationEndpoint);
    }
...

Here => private const string EventRegistrationEndpoint = "Event.eventOccurred";

internal class EventOccurredRequest
{
  [JsonPropertyName("registrationId")]
  public string? RegistrationId { get; set; }

  [JsonPropertyName("event")]
  public EventData? Event { get; set; }
}

internal class EventData
{
  [JsonPropertyName("uniqueMscName")]
  public string? UniqueMscName { get; set; }

  [JsonPropertyName("objectIdentifier")]
  public string? ObjectIdentifier { get; set; }

  [JsonPropertyName("uniqueMachineName")]
  public string? UniqueMachineName { get; set; }

  [JsonPropertyName("creationDate")]
  public string? CreationDate { get; set; }

  [JsonPropertyName("sequenceNumber")]
  public string? SequenceNumber { get; set; }

  [JsonPropertyName("$type")]
  public string? Type { get; set; }
}

The remote party after some rpc request sent from our side executes some jobs by its side. After a small period the request I am receiving tested out from a different application is:

{
	"jsonrpc": "2.0",
	"method": "Event.eventOccurred",
	"params": {
		"registrationId": "9123d80b-930e-4ec4-bd15-920b571dc9fb",
		"event": {
			"uniqueMscName": "MODULE_20",
			"objectIdentifier": "PartLabelFromMOMProc",
			"uniqueMachineName": "M0815",
			"creationDate": "2023-11-09T10:48:33.177+01:00",
			"sequenceNumber": null,
			"$type": "server.bc.object.event.rmi.ObjectValueChangedDtoEventV1"
		}
	}
}

My local endpoint is not being executed so the workflow can not continue. I have tried to also implement your second option but it seems not not work neither. Any further guidance or steps you could give me here?

If I understood correctly and driven by my needs, I should act as client for the remote party, but also as a server. The first part is completly achieved but the second one is not working yet or I do not understand the steps for making it work.

Thanks in advance!

[juaal12]

Good morning @AArnott,

Activating the jsonrpc log traces I have noticed I get this message: "Invocation of "Event.eventOccurred" cannot occur because arguments do not match any registred target methods"

As far I understand, and seeing all the information I posted it should match right?

Thanks in advance!

[AArnott]

This seems virtually identical to a request made over on gitter.im.
The short answer is no, this notification has two arguments, which doesn't fit the .NET EventHandler delegate signature (which takes only one parameter, ignoring the sender which doesn't apply over RPC). You'll have to handle this notification as a regular method, invoked on a client-side RPC target as I describe on the forum I linked to.