How to read incomming messages using svSocket Server in R

I am using svSocket package in R to create a socket server. I have successfully created server using startSocketServer(...). I am able to connect my application to the server and send data from server to the application. But I am struggeling with reading of messages sent by application. I couldn't find any example for that on internet. I found only processSocket(...) example in documentation of vsSocket (see below) which describes the function that processes a command coming from the socket. But I want only read socket messages comming to the server in repeat block and print them on the screen for testing.

## Not run: 
# ## A simple REPL (R eval/process loop) using basic features of processSocket()
# repl <- function ()
# {
#   pars <- parSocket("repl", "", bare = FALSE)  # Parameterize the loop
#   cat("Enter R code, hit <CTRL-C> or <ESC> to exit\n> ")   # First prompt
#   repeat {
#       entry <- readLines(n = 1)                # Read a line of entry
#       if (entry == "") entry <- "<<<esc>>>"    # Exit from multiline mode
#       cat(processSocket(entry, "repl", ""))    # Process the entry
#   }
# }
# repl()
# ## End(Not run)

Thx for your input.

EDIT:

Here more specific example of socket server creation and sending message:

require(svSocket)

#start server
svSocket::startSocketServer(
  port = 9999,
  server.name = "test_server",
  procfun = processSocket,
  secure = FALSE,
  local = FALSE
)

#test calls
svSocket::getSocketClients(port = 9999) #ip and port of client connected
svSocket::getSocketClientsNames(port = 9999) #name of client connected
svSocket::getSocketServerName(port = 9999) #name of socket server given during creation
svSocket::getSocketServers() #server name and port

#send message to client
svSocket::sendSocketClients(
  text = "send this message to the client",
  sockets = svSocket::getSocketClientsNames(port = 9999),
  serverport = 9999
)

... and response of the code above is:

> require(svSocket)
> 
> #start server
> svSocket::startSocketServer(
+   port = 9999,
+   server.name = "test_server",
+   procfun = processSocket,
+   secure = FALSE,
+   local = FALSE
+ )
[1] TRUE
> 
> #test calls
> svSocket::getSocketClients(port = 9999) #ip and port of client connected
sock0000000005C576B0 
 "192.168.2.1:55427" 
> svSocket::getSocketClientsNames(port = 9999) #name of client connected
[1] "sock0000000005C576B0"
> svSocket::getSocketServerName(port = 9999) #name of socket server given during creation
[1] "test_server"
> svSocket::getSocketServers() #server name and port
test_server 
       9999 
> 
> #send message to client
> svSocket::sendSocketClients(
+   text = "send this message to the client",
+   sockets = svSocket::getSocketClientsNames(port = 9999),
+   serverport = 9999
+ )
>

What you can see is:

successfull creation of socket server
successfull connection of external client sock0000000005C576B0 (192.168.2.1:55427) to the server
successfull sending of message to the client (here no explizit output is provided in console, but the client reacts as awaited
what I am still not able to implement is to fetch client messages sent to the server. Could somebody provide me an example on that?

Solution

For interaction with the server from the client side, see ?evalServer.

Otherwise, it is your processSocket() function (either the default one, or a custom function you provide) that is the entry point triggered when the server got some data from one connected client. From there, you have two possibilities:

The simplest one is just to use the default processSocket() function. Besides some special code between <<<>>>, which is interpreted as special commands, the default version will evaluate R code on the server side. So, just call the function you want on the server. For instance, define f <- function(txt) paste("Fake process ", txt) on the server, and call evalServer(con, "f('some text')") on the client. Your custom f() function is executed on the server. Just take care that you need to double quote expressions that contain text here.
An alternate solution is to define your own processSocket() function to capture messages sent by the client to the server earlier. This is safer for a server that needs to process a limited number of message types without parsing and evaluating R code received from the client.

Now, the server is asynchronous, meaning that you still got the prompt available on the server, while it is listening to client(s) and processing their requests.