tweak defaults

Author: shikokuchuo

NEWS.md

@@ -4,17 +4,18 @@
 
 * New `stream()` interface exposes low-level byte stream functionality in the NNG library, intended for communicating with non-NNG endpoints, including but not limited to websocket servers.
 * `ncurl()` adds an 'async' option to perform HTTP requests asynchronously, returning immediately with a 'recvAio'. Also adds explicit arguments for HTTP method, headers (which takes a named list or character vector) and request data.
-* New `messenger()` function implements a multi-threaded console-based messaging system using NNG's scalability protocols.
+* New `messenger()` function implements a multi-threaded console-based messaging system using NNG's scalability protocols (currently as proof of concept).
 * New `nano_init()` function intended to be called immediately after package load to set global options.
 
 #### Updates
 
 * Behavioural change: messages have been upgraded to warnings across the package to allow for enhanced reporting of the originating call e.g. via `warnings()` and flexibility in handling via setting `options()`.
+* Returned NNG error codes are now all classed as 'errorValue' across the package.
 * Unified `send()` and `recv()` functions, and their asynchronous counterparts `send_aio()` and `recv_aio()`, are now S3 generics and can be used across Sockets, Contexts and Streams.
-* Revised 'block' argument for `send()` and `recv()` now allows an integer value for setting a timeout.
+* Revised 'block' argument for `send()` and `recv()` now allows an integer value for setting a timeout (under the hood this wraps an asynchronous send/recv followed by a wait to make it a synchronous function).
 * `send_ctx()` and `recv_ctx()` are deprecated and will be removed in a future package version - the methods for `send()` and `recv()` should be used instead.
 * To allow for more flexible practices, logging is now deprecated and being phased out. Logging can still be set via 'NANONEXT_LOG' prior to package load but `logging()` can no longer be used. Logging will be removed entirely in the next package version.
-* Returned NNG error codes are now all classed as 'errorValue' across the package.
+* Internal performance optimisations.
 
 # nanonext 0.3.0
 

R/aio.R

@@ -7,8 +7,9 @@
 #' Send data asynchronously over a connection (Socket, Context or Stream).
 #'
 #' @inheritParams send
-#' @param timeout (optional) integer value in milliseconds. If unspecified, a
-#'     socket-specific default timeout will be used.
+#' @param timeout (optional) integer value in milliseconds. If unspecified, the
+#'     default of -2L uses a socket-specific default, which is usually the same
+#'     as no timeout.
 #'
 #' @return A 'sendAio' (object of class 'sendAio').
 #'
@@ -40,24 +41,23 @@
 #' @rdname send_aio
 #' @export
 #'
-send_aio <- function(con, data, mode = c("serial", "raw"), timeout) UseMethod("send_aio")
+send_aio <- function(con, data, mode = c("serial", "raw"), timeout = -2L) UseMethod("send_aio")
 
 #' @rdname send_aio
 #' @method send_aio nanoSocket
 #' @export
 #'
-send_aio.nanoSocket <- function(con, data, mode = c("serial", "raw"), timeout) {
+send_aio.nanoSocket <- function(con, data, mode = c("serial", "raw"), timeout = -2L) {
 
   mode <- match.arg2(mode, c("serial", "raw"))
   force(data)
   data <- encode(data = data, mode = mode)
-  if (missing(timeout)) timeout <- -2L
   aio <- .Call(rnng_send_aio, con, data, timeout)
   is.integer(aio) && return(invisible(aio))
 
-  env <- new.env(hash = FALSE)
-  result <- NULL
+  result <- data <- con <- NULL
   unresolv <- TRUE
+  env <- new.env(hash = FALSE)
   makeActiveBinding(sym = "result", fun = function(x) {
     if (unresolv) {
       res <- .Call(rnng_aio_result, aio)
@@ -76,18 +76,17 @@ send_aio.nanoSocket <- function(con, data, mode = c("serial", "raw"), timeout) {
 #' @method send_aio nanoContext
 #' @export
 #'
-send_aio.nanoContext <- function(con, data, mode = c("serial", "raw"), timeout) {
+send_aio.nanoContext <- function(con, data, mode = c("serial", "raw"), timeout = -2L) {
 
   mode <- match.arg2(mode, c("serial", "raw"))
   force(data)
   data <- encode(data = data, mode = mode)
-  if (missing(timeout)) timeout <- -2L
   aio <- .Call(rnng_ctx_send_aio, con, data, timeout)
   is.integer(aio) && return(invisible(aio))
 
-  env <- new.env(hash = FALSE)
-  result <- NULL
+  result <- data <- con <- NULL
   unresolv <- TRUE
+  env <- new.env(hash = FALSE)
   makeActiveBinding(sym = "result", fun = function(x) {
     if (unresolv) {
       res <- .Call(rnng_aio_result, aio)
@@ -106,17 +105,16 @@ send_aio.nanoContext <- function(con, data, mode = c("serial", "raw"), timeout)
 #' @method send_aio nanoStream
 #' @export
 #'
-send_aio.nanoStream <- function(con, data, mode = "raw", timeout) {
+send_aio.nanoStream <- function(con, data, mode = "raw", timeout = -2L) {
 
   force(data)
   data <- encode(data = data, mode = 2L)
-  if (missing(timeout)) timeout <- -2L
   aio <- .Call(rnng_stream_send_aio, con, data, timeout)
   is.integer(aio) && return(invisible(aio))
 
-  env <- new.env(hash = FALSE)
-  result <- NULL
+  result <- data <- con <- NULL
   unresolv <- TRUE
+  env <- new.env(hash = FALSE)
   makeActiveBinding(sym = "result", fun = function(x) {
     if (unresolv) {
       res <- .Call(rnng_aio_result, aio)
@@ -190,10 +188,10 @@ send_aio.nanoStream <- function(con, data, mode = "raw", timeout) {
 recv_aio <- function(con,
                      mode = c("serial", "character", "complex", "double",
                               "integer", "logical", "numeric", "raw"),
-                     timeout,
+                     timeout = -2L,
                      keep.raw = TRUE,
                      ...,
-                     n) UseMethod("recv_aio")
+                     n = 100000L) UseMethod("recv_aio")
 
 #' @rdname recv_aio
 #' @method recv_aio nanoSocket
@@ -202,20 +200,19 @@ recv_aio <- function(con,
 recv_aio.nanoSocket <- function(con,
                                 mode = c("serial", "character", "complex", "double",
                                          "integer", "logical", "numeric", "raw"),
-                                timeout,
+                                timeout = -2L,
                                 keep.raw = TRUE,
                                 ...) {
 
   mode <- match.arg2(mode, c("serial", "character", "complex", "double",
                              "integer", "logical", "numeric", "raw"))
-  if (missing(timeout)) timeout <- -2L
   aio <- .Call(rnng_recv_aio, con, timeout)
   is.integer(aio) && return(invisible(aio))
 
   keep.raw <- missing(keep.raw) || isTRUE(keep.raw)
-  env <- new.env(hash = FALSE)
-  data <- raw <- NULL
+  data <- raw <- con <- NULL
   unresolv <- TRUE
+  env <- new.env(hash = FALSE)
   if (keep.raw) {
     makeActiveBinding(sym = "raw", fun = function(x) {
       if (unresolv) {
@@ -279,20 +276,19 @@ recv_aio.nanoSocket <- function(con,
 recv_aio.nanoContext <- function(con,
                                  mode = c("serial", "character", "complex", "double",
                                           "integer", "logical", "numeric", "raw"),
-                                 timeout,
+                                 timeout = -2L,
                                  keep.raw = TRUE,
                                  ...) {
 
   mode <- match.arg2(mode, c("serial", "character", "complex", "double",
                              "integer", "logical", "numeric", "raw"))
-  if (missing(timeout)) timeout <- -2L
   aio <- .Call(rnng_ctx_recv_aio, con, timeout)
   is.integer(aio) && return(invisible(aio))
 
   keep.raw <- missing(keep.raw) || isTRUE(keep.raw)
-  env <- new.env(hash = FALSE)
-  data <- raw <- NULL
+  data <- raw <- con <- NULL
   unresolv <- TRUE
+  env <- new.env(hash = FALSE)
   if (keep.raw) {
     makeActiveBinding(sym = "raw", fun = function(x) {
       if (unresolv) {
@@ -356,21 +352,20 @@ recv_aio.nanoContext <- function(con,
 recv_aio.nanoStream <- function(con,
                                 mode = c("character", "complex", "double", "integer",
                                          "logical", "numeric", "raw"),
-                                timeout,
+                                timeout = -2L,
                                 keep.raw = TRUE,
-                                n = 10000,
+                                n = 100000L,
                                 ...) {
 
   mode <- match.arg2(mode, c("character", "complex", "double", "integer",
                              "logical", "numeric", "raw")) + 1L
-  if (missing(timeout)) timeout <- -2L
   aio <- .Call(rnng_stream_recv_aio, con, n, timeout)
   is.integer(aio) && return(invisible(aio))
 
   keep.raw <- missing(keep.raw) || isTRUE(keep.raw)
-  env <- new.env(hash = FALSE)
-  data <- raw <- NULL
+  data <- raw <- con <- NULL
   unresolv <- TRUE
+  env <- new.env(hash = FALSE)
   if (keep.raw) {
     makeActiveBinding(sym = "raw", fun = function(x) {
       if (unresolv) {

R/context.R

@@ -67,9 +67,10 @@ context <- function(socket) {
 #'     'character', 'complex', 'double', 'integer', 'logical', 'numeric', or 'raw'.
 #'     The default 'serial' means a serialised R object, for the other modes,
 #'     the raw vector received will be converted into the respective mode.
-#' @param timeout in ms. If unspecified, a socket-specific default timeout will
-#'     be used. Note that this applies to receiving the request. The total elapsed
-#'     time would also include the time for performing 'execute' on the received
+#' @param timeout (optional) integer value in milliseconds. If unspecified, the
+#'     default of -2L uses a socket-specific default, which is usually the same
+#'     as no timeout. Note that this applies to receiving the request. The total
+#'     elapsed time would also include performing 'execute' on the received
 #'     data. The timeout then also applies to sending the result (in the event
 #'     that the requestor has become unavailable since sending the request).
 #' @param ... additional arguments passed to the function specified by 'execute'.
@@ -111,13 +112,12 @@ reply <- function(context,
                   recv_mode = c("serial", "character", "complex", "double",
                                 "integer", "logical", "numeric", "raw"),
                   send_mode = c("serial", "raw"),
-                  timeout,
+                  timeout = -2L,
                   ...) {
 
   recv_mode <- match.arg2(recv_mode, c("serial", "character", "complex", "double",
                                        "integer", "logical", "numeric", "raw"))
   send_mode <- match.arg2(send_mode, c("serial", "raw"))
-  if (missing(timeout)) timeout <- -2L
   res <- .Call(rnng_ctx_recv, context, timeout)
   is.integer(res) && return(invisible(res))
   on.exit(expr = send_aio(context, as.raw(0L), mode = send_mode))
@@ -140,8 +140,9 @@ reply <- function(context,
 #' @inheritParams reply
 #' @inheritParams recv
 #' @param data an object (if send_mode = 'raw', a vector).
-#' @param timeout in ms. If unspecified, a socket-specific default timeout will
-#'     be used. Note that this applies to receiving the result.
+#' @param timeout (optional) integer value in milliseconds. If unspecified, the
+#'     default of -2L uses a socket-specific default, which is usually the same
+#'     as no timeout. Note that this applies to receiving the result.
 #'
 #' @return A 'recvAio' (object of class 'recvAio').
 #'
@@ -182,7 +183,7 @@ request <- function(context,
                     send_mode = c("serial", "raw"),
                     recv_mode = c("serial", "character", "complex", "double",
                                   "integer", "logical", "numeric", "raw"),
-                    timeout,
+                    timeout = -2L,
                     keep.raw = TRUE) {
 
   send_mode <- match.arg2(send_mode, c("serial", "raw"))
@@ -193,14 +194,13 @@ request <- function(context,
   res <- .Call(rnng_ctx_send_aio, context, data, -2L)
   is.integer(res) && return(invisible(res))
 
-  if (missing(timeout)) timeout <- -2L
   aio <- .Call(rnng_ctx_recv_aio, context, timeout)
   is.integer(aio) && return(invisible(aio))
 
   keep.raw <- missing(keep.raw) || isTRUE(keep.raw)
-  env <- new.env(hash = FALSE)
-  data <- raw <- NULL
+  data <- raw <- context <- res <- NULL
   unresolv <- TRUE
+  env <- new.env(hash = FALSE)
   if (keep.raw) {
     makeActiveBinding(sym = "raw", fun = function(x) {
       if (unresolv) {
@@ -278,10 +278,9 @@ request <- function(context,
 #' @keywords internal
 #' @export
 #'
-send_ctx <- function(context, data, mode = c("serial", "raw"), timeout, echo = TRUE) {
+send_ctx <- function(context, data, mode = c("serial", "raw"), timeout = -2L, echo = TRUE) {
 
   mode <- match.arg2(mode, c("serial", "raw"))
-  if (missing(timeout)) timeout <- -2L
   force(data)
   data <- encode(data = data, mode = mode)
   res <- .Call(rnng_ctx_send, context, data, timeout)
@@ -320,12 +319,11 @@ send_ctx <- function(context, data, mode = c("serial", "raw"), timeout, echo = T
 recv_ctx <- function(context,
                      mode = c("serial", "character", "complex", "double",
                               "integer", "logical", "numeric", "raw"),
-                     timeout,
+                     timeout = -2L,
                      keep.raw = TRUE) {
 
   mode <- match.arg2(mode, c("serial", "character", "complex", "double",
                              "integer", "logical", "numeric", "raw"))
-  if (missing(timeout)) timeout <- -2L
   res <- .Call(rnng_ctx_recv, context, timeout)
   is.integer(res) && return(invisible(res))
   on.exit(expr = return(res))

R/ncurl.R

@@ -67,9 +67,9 @@ ncurl <- function(url, async = FALSE, method = NULL, headers = NULL, data = NULL
     aio <- .Call(rnng_ncurl_aio, url, method, headers, data)
     is.integer(aio) && return(invisible(aio))
 
-    env <- new.env(hash = FALSE)
     data <- raw <- NULL
     unresolv <- TRUE
+    env <- new.env(hash = FALSE)
     makeActiveBinding(sym = "raw", fun = function(x) {
       if (unresolv) {
         res <- .Call(rnng_aio_http, aio)

R/sendrecv.R

@@ -142,7 +142,7 @@ send.nanoStream <- function(con,
 #' @param keep.raw [default TRUE] logical flag whether to keep the received raw
 #'     vector (useful for verification e.g. via hashing). If FALSE, will return
 #'     the converted data only.
-#' @param n <Streams> [default 10000L] the maximum number of bytes to receive.
+#' @param n <Streams> [default 100000L] the maximum number of bytes to receive.
 #'     Can be an over-estimate, but note that a buffer of this size is reserved.
 #' @param ... currently unused.
 #'
@@ -212,7 +212,7 @@ recv <- function(con,
                  block,
                  keep.raw = TRUE,
                  ...,
-                 n) UseMethod("recv")
+                 n = 100000L) UseMethod("recv")
 
 #' @rdname recv
 #' @method recv nanoSocket
@@ -269,7 +269,7 @@ recv.nanoStream <- function(con,
                                      "logical", "numeric", "raw"),
                             block = TRUE,
                             keep.raw = TRUE,
-                            n = 10000L,
+                            n = 100000L,
                             ...) {
 
   mode <- match.arg2(mode, c("character", "complex", "double", "integer",