adding message request type

library/libsds.h

@@ -32,6 +32,12 @@ int CleanupReliabilityManager(void* ctx, SdsCallBack callback, void* userData);
 
 int ResetReliabilityManager(void* ctx, SdsCallBack callback, void* userData);
 
+int WrapOutgoingMessage(void* ctx,
+                    const char* message,
+                    const char* messageId,
+                    SdsCallBack callback,
+                    void* userData);
+
 
 #ifdef __cplusplus
 }

library/libsds.nim

@@ -13,7 +13,8 @@ import
   ./alloc,
   ./ffi_types,
   ./sds_thread/inter_thread_communication/sds_thread_request,
-  ./sds_thread/inter_thread_communication/requests/sds_lifecycle_request,
+  ./sds_thread/inter_thread_communication/requests/
+    [sds_lifecycle_request, sds_message_request],
   ../src/[reliability, reliability_utils, message]
 
 ################################################################################
@@ -175,5 +176,31 @@ proc ResetReliabilityManager(
     userData,
   )
 
+proc WrapOutgoingMessage(
+    ctx: ptr SdsContext,
+    message: cstring,
+    messageId: cstring,
+    callback: SdsCallBack,
+    userData: pointer,
+): cint {.dynlib, exportc.} =
+  initializeLibrary()
+  checkLibsdsParams(ctx, callback, userData)
+
+  let
+    msg = message.alloc()
+    msgId = messageId.alloc()
+
+  defer:
+    deallocShared(msg)
+    deallocShared(msgId)
+
+  handleRequest(
+    ctx,
+    RequestType.MESSAGE,
+    SdsMessageRequest.createShared(SdsMessageMsgType.WRAP_MESSAGE, msg, msgId),
+    callback,
+    userData,
+  )
+
 ### End of exported procs
 ################################################################################

library/sds_thread/inter_thread_communication/requests/sds_message_request.nim

@@ -0,0 +1,42 @@
+import std/[options, json, strutils, net]
+import chronos, chronicles, results, confutils, confutils/std/net
+
+import ../../../alloc
+import ../../../../src/[reliability_utils, reliability, message]
+
+type SdsMessageMsgType* = enum
+  WRAP_MESSAGE
+
+type SdsMessageRequest* = object
+  operation: SdsMessageMsgType
+  message: cstring
+  messageId: cstring
+
+proc createShared*(
+    T: type SdsMessageRequest,
+    op: SdsMessageMsgType,
+    message: cstring = "",
+    messageId: cstring = "",
+): ptr type T =
+  var ret = createShared(T)
+  ret[].operation = op
+  ret[].message = message.alloc()
+  ret[].messageId = messageId.alloc()
+  return ret
+
+proc destroyShared(self: ptr SdsMessageRequest) =
+  deallocShared(self[].message)
+  deallocShared(self[].messageId)
+  deallocShared(self)
+
+proc process*(
+    self: ptr SdsMessageRequest, rm: ptr ReliabilityManager
+): Future[Result[string, string]] {.async.} =
+  defer:
+    destroyShared(self)
+
+  case self.operation
+  of WRAP_MESSAGE:
+    echo "------- received wrap message request"
+
+  return ok("")

library/sds_thread/inter_thread_communication/sds_thread_request.nim

@@ -5,10 +5,13 @@
 import std/json, results
 import chronos, chronos/threadsync
 import
-  ../../ffi_types, ./requests/sds_lifecycle_request, ../../../src/[reliability_utils]
+  ../../ffi_types,
+  ./requests/[sds_lifecycle_request, sds_message_request],
+  ../../../src/[reliability_utils]
 
 type RequestType* {.pure.} = enum
   LIFECYCLE
+  MESSAGE
 
 type SdsThreadRequest* = object
   reqType: RequestType
@@ -63,6 +66,8 @@ proc process*(
     case request[].reqType
     of LIFECYCLE:
       cast[ptr SdsLifecycleRequest](request[].reqContent).process(rm)
+    of MESSAGE:
+      cast[ptr SdsMessageRequest](request[].reqContent).process(rm)
 
   handleRes(await retFut, request)