JSON and Sockets - Revision history

Michael Leuschel: /* Client-Server Example Machines */

2025-06-18T15:39:36Z

Client-Server Example Machines

← Older revision		Revision as of 15:39, 18 June 2025
Line 141:		Line 141:
	END;		END;
	b <-- SendNotImplemented(Method) = SELECT request /= JsonNull & Method:STRING &		b <-- SendNotImplemented(Method) = SELECT request /= JsonNull & Method:STRING &
	"method"\|->JsonString(Method) : JsonObject~(request) THEN		"method"\|->JsonString(Method) : JsonObject~(request) &
			Method /: {"ping", "halt", "prob_statistics"} THEN
	b := SOCKET_RPC_REPLY(Port,RpcError(```Not Implemented: ${Method}```))		b := SOCKET_RPC_REPLY(Port,RpcError(```Not Implemented: ${Method}```))
	\|\|		\|\|

David Geleßus: Link to complete cf-srv now that it is public, instead of including just the B machine inline

2025-06-18T10:17:56Z

Link to complete cf-srv now that it is public, instead of including just the B machine inline

Show changes

David Geleßus: Use consistent terminology for plain TCP sockets and clarify that they use the NDJSON protocol

2025-06-18T10:03:39Z

Use consistent terminology for plain TCP sockets and clarify that they use the NDJSON protocol

David Geleßus: /* JSON-RPC Library */

2025-06-18T09:46:46Z

JSON-RPC Library

David Geleßus at 09:43, 18 June 2025

2025-06-18T09:43:27Z

← Older revision		Revision as of 09:43, 18 June 2025
Line 34:		Line 34:
	** Type Signature: <tt>STRING --> JsonValue</tt>		** Type Signature: <tt>STRING --> JsonValue</tt>
	** Parses the given JSON text into the freetype representation.		** Parses the given JSON text into the freetype representation.
	* <tt>WRITE_JSON (json, file)</tt>		* <tt>WRITE_JSON(json, file)</tt>
	** Type Signature: <tt>JsonValue * STRING</tt> (predicate, always returns <tt>true</tt>)		** Type Signature: <tt>JsonValue * STRING</tt> (predicate, always returns <tt>true</tt>)
	** Converts the given JSON data from the freetype representation into text and writes it to the given file path.		** Converts the given JSON data from the freetype representation into text and writes it to the given file path.
Line 46:		Line 46:
	== JSON-RPC Library ==		== JSON-RPC Library ==

	Implements the [~~http~~://jsonrpc.org/~~spec~~ JSON RPC] protocol.		Implements the [https://www.jsonrpc.org/specification JSON-RPC 2.0] protocol.

	Despite their names the <tt>LibraryZMQ_RPC</tt> libraries can use both [https://zeromq.org/ ZeroMQ] library and native sockets.		Despite their names the <tt>LibraryZMQ_RPC</tt> libraries can use both [https://zeromq.org/ ZeroMQ] library and native sockets.

Michael Leuschel: /* Client-Server Example Machines */

2025-06-18T07:46:27Z

Client-Server Example Machines

← Older revision		Revision as of 07:46, 18 June 2025
Line 186:		Line 186:


			Here is a sample log when running the server:
			<pre>
			$ probcli Simple_RPC_JSON_Server.mch
			% unused_constants(3,[JsonArray,JsonBoolean,RpcResult])
			% Runtime for SOLUTION for SETUP_CONSTANTS: 1 ms (walltime: 1 ms)
			Opened RPC-JSON socket (for ndjson, UTF8 streams) on port 9999
			Client connected: 127.0.0.1
			Received request line: {"jsonrpc":"2.0","method":"prob_statistics","params":{"name":"prolog-walltime"},"id":1}
			Prolog: [jsonrpc=string(2.0),method=string(prob_statistics),params=json([name=string(prolog-walltime)]),id=number(1)]

			Received request: JsonObject({("id"\|->JsonNumber(1.0)),("jsonrpc"\|->JsonString("2.0")),("method"\|->JsonString("prob_statistics")),("params"\|->JsonObject({("name"\|->JsonString("prolog-walltime"))}))})
			Response for request 1 >>> {"jsonrpc":"2.0","result":3667.0,"id":1}

			...

			Received request: JsonObject({("id"\|->JsonNumber(5.0)),("jsonrpc"\|->JsonString("2.0")),("method"\|->JsonString("halt")),("params"\|->JsonObject({}))})
			Response for request 5 >>> {"jsonrpc":"2.0","result":null,"id":5}
			Deadlock reached after 12 steps (after SendSuccessAnswer).
			VARIABLES (use -v to see constants or -silent to suppress output):
			( request=JsonNull &
			terminated=TRUE )
			% Runtime for -execute: 5 ms (with gc: 5 ms, walltime: 3144 ms); since start: 3 sec 671 ms
			</pre>


			Here is a sample log when running the client (starting it after the above server):
			<pre>
			$ probcli Simple_RPC_JSON_Client.mch -p MAXINT 5
			% unused_constants(10,[JsonArray,JsonBoolean,JsonNull,JsonNumber,JsonObject,JsonValue,Port,RpcError,RpcResult,RpcSuccess])
			% Runtime for SOLUTION for SETUP_CONSTANTS: 0 ms (walltime: 0 ms)

			Sending PROB_STATISTICS request on socket -1 (4 left)
			Result = RpcSuccess(JsonNumber(3667.0))

			Sending PING request on socket -1 (3 left)
			Result = RpcSuccess(JsonNull)

			Sending PROB_STATISTICS request on socket -1 (2 left)
			Result = RpcSuccess(JsonNumber(3669.0))

			Sending PING request on socket -1 (1 left)
			Result = RpcSuccess(JsonNull)

			ZMQ_RPC_DESTROY (-1)
			Deadlock reached after 7 steps (after Terminate).
			VARIABLES (use -v to see constants or -silent to suppress output):
			( count=0 &
			socket=-1 )
			% Runtime for -execute: 2 ms (with gc: 2 ms, walltime: 70 ms); since start: 0 sec 431 ms
			</pre>

	== Drone Example Machine ==		== Drone Example Machine ==

Michael Leuschel: /* Example Machine */

2025-06-18T07:44:29Z

Example Machine

@@ Line 87: / Line 87: @@
 You need to include <b>all</b> of <tt>LibraryJson.mch</tt>, <tt>LibraryZMQ_RPC.def</tt> and <tt>LibraryZMQ_RPC.mch</tt> to interact with JSON-RPC, because the freetype definitions have to be separate from the external function definitions.
-== Example Machine ==
+== Client-Server Example Machines ==
 This is an excerpt from the B machine used to communicate with the Crazyflie drone.
 Parallel to this a Python script is running, which implements all the JSON-RPC methods and uses [https://pypi.org/project/cflib/ <tt>cflib</tt>] to communicate with the drone over radio.

Vella: /* Example Machine */

2025-04-04T12:09:48Z

Example Machine

← Older revision		Revision as of 12:09, 4 April 2025
Line 89:		Line 89:
	== Example Machine ==		== Example Machine ==
	This is an excerpt from the B machine used to communicate with the Crazyflie drone.		This is an excerpt from the B machine used to communicate with the Crazyflie drone.
			Parallel to this a Python script is running, which implements all the JSON-RPC methods and uses [https://pypi.org/project/cflib/ <tt>cflib</tt>] to communicate with the drone over radio.
	<pre>		<pre>
	MACHINE DroneCommunicator USES LibraryJSON, LibraryZMQ_RPC		MACHINE DroneCommunicator USES LibraryJSON, LibraryZMQ_RPC

Vella at 12:05, 4 April 2025

2025-04-04T12:05:49Z

← Older revision		Revision as of 12:05, 4 April 2025
Line 86:		Line 86:

	You need to include <b>all</b> of <tt>LibraryJson.mch</tt>, <tt>LibraryZMQ_RPC.def</tt> and <tt>LibraryZMQ_RPC.mch</tt> to interact with JSON-RPC, because the freetype definitions have to be separate from the external function definitions.		You need to include <b>all</b> of <tt>LibraryJson.mch</tt>, <tt>LibraryZMQ_RPC.def</tt> and <tt>LibraryZMQ_RPC.mch</tt> to interact with JSON-RPC, because the freetype definitions have to be separate from the external function definitions.

			== Example Machine ==
			This is an excerpt from the B machine used to communicate with the Crazyflie drone.
			<pre>
			MACHINE DroneCommunicator USES LibraryJSON, LibraryZMQ_RPC
			DEFINITIONS
			"LibraryZMQ_RPC.def";
			"LibraryReals.def";
			SET_PREF_MAX_OPERATIONS == 0;
			CONSTANTS DRONE_URL
			PROPERTIES DRONE_URL:STRING & DRONE_URL = "radio://0/80/2M/5700B500F7"
			VARIABLES init, socket, cycle
			INVARIANT
			init:BOOL &
			socket:SOCKET &
			cycle:INTEGER
			INITIALISATION
			init := FALSE;
			socket := 0;
			cycle := 1

			OPERATIONS
			Init =
			SELECT init = FALSE THEN
			socket := ZMQ_RPC_INIT("tcp://localhost:22272");
			init := TRUE
			END;

			Destroy =
			SELECT init = TRUE THEN
			ZMQ_RPC_DESTROY(socket);
			init := FALSE
			END;

			register_sensors =
			SELECT init = TRUE THEN
			VAR res IN
			res := RpcSuccess~(ZMQ_RPC_SEND(socket, "register_log", {
			("url" \|-> JsonString(DRONE_URL)),
			("name" \|-> JsonString("Telemetry")),
			("variables" \|-> JsonArray([
			JsonString("stateEstimate.x"),
			JsonString("stateEstimate.y"),
			JsonString("stateEstimate.z"),
			JsonString("stateEstimate.roll"),
			JsonString("stateEstimate.pitch"),
			JsonString("stateEstimate.yaw")
			]))}));
			END
			END;

			Drone_Takeoff =
			SELECT init = TRUE THEN
			VAR res IN
			res := RpcSuccess~(ZMQ_RPC_SEND(socket, "takeoff", {("url" \|-> JsonString(DRONE_URL))}))
			END
			END;

			Drone_Land =
			SELECT init = TRUE THEN
			VAR res IN
			res := RpcSuccess~(ZMQ_RPC_SEND(socket, "land", {("url" \|-> JsonString(DRONE_URL))}))
			END
			END;

			Drone_Left(dist) =
			SELECT
			init = TRUE &
			dist : 0..2000
			THEN
			VAR res IN
			res := RpcSuccess~(ZMQ_RPC_SEND(socket, "left", {("url" \|-> JsonString(DRONE_URL)), ("distance" \|-> JsonNumber(RDIV(real(dist), real(1000))))}))
			END
			END;

			Drone_Right(dist) =
			SELECT
			init = TRUE &
			dist : 0..2000
			THEN
			VAR res IN
			res := RpcSuccess~(ZMQ_RPC_SEND(socket, "right", {("url" \|-> JsonString(DRONE_URL)), ("distance" \|-> JsonNumber(RDIV(real(dist), real(1000))))}))
			END
			END;

			Drone_Up(dist) =
			SELECT
			init = TRUE &
			dist : 0..2000
			THEN
			VAR res IN
			res := RpcSuccess~(ZMQ_RPC_SEND(socket, "up", {("url" \|-> JsonString(DRONE_URL)), ("distance" \|-> JsonNumber(RDIV(real(dist), real(1000))))}))
			END
			END;

			Drone_Down(dist) =
			SELECT
			init = TRUE &
			dist : 0..2000
			THEN
			VAR res IN
			res := RpcSuccess~(ZMQ_RPC_SEND(socket, "down", {("url" \|-> JsonString(DRONE_URL)), ("distance" \|-> JsonNumber(RDIV(real(dist), real(1000))))}))
			END
			END;

			Drone_Forward(dist) =
			SELECT
			init = TRUE &
			dist : 0..2000
			THEN
			VAR res IN
			res := RpcSuccess~(ZMQ_RPC_SEND(socket, "forward", {("url" \|-> JsonString(DRONE_URL)), ("distance" \|-> JsonNumber(RDIV(real(dist), real(1000))))}))
			END
			END;

			Drone_Backward(dist) =
			SELECT
			init = TRUE &
			dist : 0..2000
			THEN
			VAR res IN
			res := RpcSuccess~(ZMQ_RPC_SEND(socket, "backward", {("url" \|-> JsonString(DRONE_URL)), ("distance" \|-> JsonNumber(RDIV(real(dist), real(1000))))}))
			END
			END;

			out <-- Drone_GetX =
			SELECT init = TRUE THEN
			out := floor(1000.0 * JsonNumber~(RpcSuccess~(ZMQ_RPC_SEND(socket, "get_log_var", {("url" \|-> JsonString(DRONE_URL)), ("name" \|-> JsonString("stateEstimate.x"))}))));
			cycle := cycle + 1
			END
			END
			</pre>

Vella at 11:48, 4 April 2025

2025-04-04T11:48:54Z

@@ Line 1: / Line 1: @@
-ProB contains external functions to read and write JSON data and to communicate via sockets using JSON:
+== Introduction ==
 * <tt>LibraryJSON.def</tt> and <tt>LibraryJSON.mch</tt> providing the functions <tt>READ_JSON</tt>, <tt>READ_JSON_FROM_STRING</tt>, <tt>WRITE_JSON</tt>, <tt>WRITE_JSON_TO_STRING</tt> and the freetype <tt>JsonValue</tt> to read and write JSON data.
-* <tt>LibraryZMQ_RPC.def</tt> and <tt>LibraryZMQ_RPC.mch</tt>: providing access to a JSON RPC (Remote Procedure Call) library either over regular sockets or ZMQ sockets.
+* <tt>LibraryZMQ_RPC.def</tt> and <tt>LibraryZMQ_RPC.mch</tt>: providing access to a JSON-RPC (Remote Procedure Call) protocol implementation either over regular sockets or ZMQ sockets.
-<tt>LibraryJSON.mch</tt> defines a FREETYPE to represent JSON data in a type-safe way:
+<tt>LibraryJSON.mch</tt> defines a FREETYPE to represent [https://json.org/ JSON] data in a type-safe way:
 <pre>
    JsonValue = JsonNull,
@@ Line 18: / Line 24: @@
 They are not standard B, but stem from Z and Rodin's theory plug-in.
-<tt> LibraryZMQ_RPC.mch </tt> defines a FREETYPE to represent RPC in a type-safe way:
+<tt>LibraryZMQ_RPC.mch</tt> defines a FREETYPE to represent JSON-RPC response object in a type-safe way:
 <pre>
   RpcResult = RpcSuccess(JsonValue), RpcError(STRING)
 </pre>
-We have used this library to control Crazyflie drones via ProB:
+<tt>LibraryZMQ_RPC.def</tt> contains the definitions for the the external functions to interact with JSON RPC as a client or server:
-[[File:prob_drone.jpeg||800px]]
+* <tt>ZMQ_RPC_INIT(endpoint)</tt>

← Older revision		Revision as of 10:03, 18 June 2025
Line 5:		Line 5:
	* <tt>LibraryJSON.def</tt> and <tt>LibraryJSON.mch</tt> providing the functions <tt>READ_JSON</tt>, <tt>READ_JSON_FROM_STRING</tt>, <tt>WRITE_JSON</tt>, <tt>WRITE_JSON_TO_STRING</tt> and the freetype <tt>JsonValue</tt> to read and write JSON data.		* <tt>LibraryJSON.def</tt> and <tt>LibraryJSON.mch</tt> providing the functions <tt>READ_JSON</tt>, <tt>READ_JSON_FROM_STRING</tt>, <tt>WRITE_JSON</tt>, <tt>WRITE_JSON_TO_STRING</tt> and the freetype <tt>JsonValue</tt> to read and write JSON data.

	* <tt>LibraryZMQ_RPC.def</tt> and <tt>LibraryZMQ_RPC.mch</tt>: providing access to a JSON-RPC (Remote Procedure Call) protocol implementation either ~~over regular~~ sockets or ~~ZMQ~~ sockets.		* <tt>LibraryZMQ_RPC.def</tt> and <tt>LibraryZMQ_RPC.mch</tt>: providing access to a JSON-RPC (Remote Procedure Call) protocol implementation over either TCP sockets using [[wikipedia:NDJSON\|NDJSON]] or over [https://zeromq.org/ ZeroMQ] sockets.

	We have used this library to control Crazyflie drones via ProB:		We have used this library to control Crazyflie drones via ProB:
Line 48:		Line 48:
	Implements the [https://www.jsonrpc.org/specification JSON-RPC 2.0] protocol.		Implements the [https://www.jsonrpc.org/specification JSON-RPC 2.0] protocol.

	Despite their names the <tt>LibraryZMQ_RPC</tt> libraries ~~can use both [https://zeromq.org/~~ ZeroMQ~~] library and native sockets~~.		Despite their names, the <tt>LibraryZMQ_RPC</tt> libraries also support using NDJSON instead of ZeroMQ.

	<tt>LibraryZMQ_RPC.mch</tt> defines a FREETYPE to represent JSON-RPC response object in a type-safe way:		<tt>LibraryZMQ_RPC.mch</tt> defines a FREETYPE to represent JSON-RPC response object in a type-safe way:
Line 61:		Line 61:
	* <tt>ZMQ_RPC_INIT(endpoint)</tt>		* <tt>ZMQ_RPC_INIT(endpoint)</tt>
	** Type Signature: <tt>STRING --> SOCKET</tt>		** Type Signature: <tt>STRING --> SOCKET</tt>
	** Creates a ~~ZMQ~~ socket for RPC ~~with the ZMQ library~~ and binds it to the given endpoint.		** Creates a ZeroMQ client socket for JSON-RPC requests and binds it to the given ZeroMQ endpoint.
	* <tt>SOCKET_RPC_INIT(port)</tt>		* <tt>SOCKET_RPC_INIT(port)</tt>
	** Type Signature: <tt>INTEGER --> SOCKET</tt>		** Type Signature: <tt>INTEGER --> SOCKET</tt>
	** Creates a ~~native~~ socket for RPC and binds it to the given port.		** Creates a plain TCP client socket for JSON-RPC over NDJSON and binds it to the given port.
	* <tt>ZMQ_RPC_DESTROY(socket)</tt>		* <tt>ZMQ_RPC_DESTROY(socket)</tt>
	** Type Signature: <tt>SOCKET</tt> (substitution, no return value)		** Type Signature: <tt>SOCKET</tt> (substitution, no return value)
	** Closes the given ~~ZMQ~~ or ~~native~~ socket.		** Closes the given ZeroMQ or plain TCP socket.
	** <i>Note: despite its name this function works with both ~~ZMQ~~ and ~~native~~ sockets</i>		** <i>Note: despite its name this function works with both ZeroMQ and plain TCP sockets</i>
	* <tt>ZMQ_RPC_SEND(socket, name, args)</tt>		* <tt>ZMQ_RPC_SEND(socket, name, args)</tt>
	** Type Signature: <tt>(SOCKETSTRING(STRING+->JsonValue)) --> RpcResult</tt>		** Type Signature: <tt>(SOCKETSTRING(STRING+->JsonValue)) --> RpcResult</tt>
	** Sends a JSON-RPC request object over the given ~~ZMQ~~ or ~~native~~ socket.		** Sends a JSON-RPC request object over the given ZeroMQ or plain TCP socket.
	** <i>Note: despite its name this function works with both ~~ZMQ~~ and ~~native~~ sockets</i>		** <i>Note: despite its name this function works with both ZeroMQ and plain TCP sockets</i>
	* <tt>SOCKET_RPC_ACCEPT(port)</tt>		* <tt>SOCKET_RPC_ACCEPT(port)</tt>
	** Type Signature: <tt>INTEGER --> JsonValue</tt>		** Type Signature: <tt>INTEGER --> JsonValue</tt>
	** Open a ~~native~~ server socket, wait for a client to connect, receive a JSON-RPC request object and return it.		** Open a plain TCP server socket, wait for a client to connect, receive a JSON-RPC request object over NDJSON and return it.
	* <tt>SOCKET_RPC_REPLY(port,rpcresult)</tt>		* <tt>SOCKET_RPC_REPLY(port,rpcresult)</tt>
	** Type Signature: <tt>(INTEGER * RpcResult) --> BOOL</tt>		** Type Signature: <tt>(INTEGER * RpcResult) --> BOOL</tt>
Line 86:		Line 86:
	== Client-Server Example Machines ==		== Client-Server Example Machines ==

	Here is a small example of a server that listens on a ~~classical~~ (non-~~ZMQ~~) socket.		Here is a small example of a server that listens for NDJSON JSON-RPC messages on a plain (non-ZeroMQ) TCP socket.
	You can run the server by calling <tt>probcli Simple_RPC_JSON_Server.mch</tt>.		You can run the server by calling <tt>probcli Simple_RPC_JSON_Server.mch</tt>.
	<pre>		<pre>

← Older revision		Revision as of 09:46, 18 June 2025
Line 55:		Line 55:
	</pre>		</pre>

	<tt>LibraryZMQ_RPC.def</tt> contains the definitions for the the external functions to interact with JSON RPC as a client or server:		<tt>LibraryZMQ_RPC.def</tt> contains the definitions for the the external functions to interact with JSON RPC as a client or server.

			''Warning: '''all''' of the following functions/predicates/substitutions perform external IO and should be guarded by a <tt>MAX_OPERATIONS == 0</tt> definition.''

	* <tt>ZMQ_RPC_INIT(endpoint)</tt>		* <tt>ZMQ_RPC_INIT(endpoint)</tt>
	** Type Signature: <tt>STRING --> SOCKET</tt>		** Type Signature: <tt>STRING --> SOCKET</tt>
	** Creates a ZMQ socket for RPC with the ZMQ library and binds it to the given endpoint.		** Creates a ZMQ socket for RPC with the ZMQ library and binds it to the given endpoint.
	** <i>Warning: this function does external IO and should be guarded by a <tt>MAX_OPERATIONS == 0</tt> definition</i>
	* <tt>SOCKET_RPC_INIT(port)</tt>		* <tt>SOCKET_RPC_INIT(port)</tt>
	** Type Signature: <tt>INTEGER --> SOCKET</tt>		** Type Signature: <tt>INTEGER --> SOCKET</tt>
	** Creates a native socket for RPC and binds it to the given port.		** Creates a native socket for RPC and binds it to the given port.
	** <i>Warning: this function does external IO and should be guarded by a <tt>MAX_OPERATIONS == 0</tt> definition</i>
	* <tt>ZMQ_RPC_DESTROY(socket)</tt>		* <tt>ZMQ_RPC_DESTROY(socket)</tt>
	** Type Signature: <tt>SOCKET</tt> (substitution, no return value)		** Type Signature: <tt>SOCKET</tt> (substitution, no return value)
	** Closes the given ZMQ or native socket.		** Closes the given ZMQ or native socket.
	** <i>Note: despite its name this function works with both ZMQ and native sockets</i>		** <i>Note: despite its name this function works with both ZMQ and native sockets</i>
	** <i>Warning: this substitution does external IO and should be guarded by a <tt>MAX_OPERATIONS == 0</tt> definition</i>
	* <tt>ZMQ_RPC_SEND(socket, name, args)</tt>		* <tt>ZMQ_RPC_SEND(socket, name, args)</tt>
	** Type Signature: <tt>(SOCKETSTRING(STRING+->JsonValue)) --> RpcResult</tt>		** Type Signature: <tt>(SOCKETSTRING(STRING+->JsonValue)) --> RpcResult</tt>
	** Sends a JSON-RPC request object over the given ZMQ or native socket.		** Sends a JSON-RPC request object over the given ZMQ or native socket.
	** <i>Note: despite its name this function works with both ZMQ and native sockets</i>		** <i>Note: despite its name this function works with both ZMQ and native sockets</i>
	** <i>Warning: this function does external IO and should be guarded by a <tt>MAX_OPERATIONS == 0</tt> definition</i>
	* <tt>SOCKET_RPC_ACCEPT(port)</tt>		* <tt>SOCKET_RPC_ACCEPT(port)</tt>
	** Type Signature: <tt>INTEGER --> JsonValue</tt>		** Type Signature: <tt>INTEGER --> JsonValue</tt>
	** Open a native server socket, wait for a client to connect, receive a JSON-RPC request object and return it.		** Open a native server socket, wait for a client to connect, receive a JSON-RPC request object and return it.
	** <i>Warning: this function does external IO and should be guarded by a <tt>MAX_OPERATIONS == 0</tt> definition</i>
	* <tt>SOCKET_RPC_REPLY(port,rpcresult)</tt>		* <tt>SOCKET_RPC_REPLY(port,rpcresult)</tt>
	** Type Signature: <tt>(INTEGER * RpcResult) --> BOOL</tt>		** Type Signature: <tt>(INTEGER * RpcResult) --> BOOL</tt>
	** Respond to a previously received JSON-RPC request object with the given JSON-RPC response object. Will always return <tt>TRUE</tt>.		** Respond to a previously received JSON-RPC request object with the given JSON-RPC response object. Will always return <tt>TRUE</tt>.
	** <i>Note: must be called right after <tt>SOCKET_RPC_ACCEPT</tt></i>		** <i>Note: must be called right after <tt>SOCKET_RPC_ACCEPT</tt></i>
	** <i>Warning: this function does external IO and should be guarded by a <tt>MAX_OPERATIONS == 0</tt> definition</i>
	<tt>LibraryZMQ_RPC.def</tt> will transitively include <tt>LibraryJson.def</tt>.		<tt>LibraryZMQ_RPC.def</tt> will transitively include <tt>LibraryJson.def</tt>.