feat(serialize): Add serializer for send mam message

Author: Yu Wei Wu

accelerator/BUILD

@@ -28,7 +28,6 @@ cc_library(
         ":ta_errors",
         "//serializer",
         "@entangled//common/trinary:trit_tryte",
-        "@entangled//common/trinary:tryte_ascii",
         "@entangled//mam/api",
     ],
 )

response/ta_send_mam.c

@@ -2,58 +2,36 @@
 
 send_mam_res_t* send_mam_res_new() {
   send_mam_res_t* res = (send_mam_res_t*)malloc(sizeof(send_mam_res_t));
-  if (res) {
-    res->bundle_hash = NULL;
-    res->channel_id = NULL;
-  }
 
   return res;
 }
 
 status_t send_mam_res_set_bundle_hash(send_mam_res_t* res,
                                       const tryte_t* bundle_hash) {
-  if (res->bundle_hash || !bundle_hash) {
+  if (!bundle_hash || !res) {
     return SC_RES_NULL;
   }
 
-  size_t bundle_hash_size = NUM_TRYTES_ADDRESS * sizeof(char);
-  res->bundle_hash = (char*)malloc(bundle_hash_size);
-  if (!res->bundle_hash) {
-    return SC_RES_OOM;
-  }
-
-  memcpy(res->bundle_hash, bundle_hash, bundle_hash_size);
+  memcpy(res->bundle_hash, bundle_hash, NUM_TRYTES_HASH);
+  res->bundle_hash[NUM_TRYTES_HASH] = '\0';
   return SC_OK;
 }
 
 status_t send_mam_res_set_channel_id(send_mam_res_t* res,
                                      const tryte_t* channel_id) {
-  if (res->channel_id || !channel_id) {
+  if (!channel_id || !res) {
     return SC_RES_NULL;
   }
 
-  size_t channel_id_size = NUM_TRYTES_ADDRESS * sizeof(char);
-  res->channel_id = (char*)malloc(channel_id_size);
-  if (!res->channel_id) {
-    return SC_RES_OOM;
-  }
-
-  memcpy(res->channel_id, channel_id, channel_id_size);
+  memcpy(res->channel_id, channel_id, NUM_TRYTES_HASH);
+  res->channel_id[NUM_TRYTES_HASH] = '\0';
   return SC_OK;
 }
 
 void send_mam_res_free(send_mam_res_t** res) {
   if (!res || !(*res)) {
     return;
   }
-  if ((*res)->bundle_hash) {
-    free((*res)->bundle_hash);
-    (*res)->bundle_hash = NULL;
-  }
-  if ((*res)->channel_id) {
-    free((*res)->channel_id);
-    (*res)->channel_id = NULL;
-  }
 
   free(*res);
   *res = NULL;

response/ta_send_mam.h

@@ -15,9 +15,9 @@ extern "C" {
 /** struct of ta_send_mam_res_t */
 typedef struct send_mam_res_s {
   /** ascii string bundle hash */
-  char* bundle_hash;
+  char bundle_hash[NUM_TRYTES_HASH + 1];
   /** ascii string channel id */
-  char* channel_id;
+  char channel_id[NUM_TRYTES_HASH + 1];
 } send_mam_res_t;
 
 /**

serializer/BUILD

@@ -11,5 +11,6 @@ cc_library(
         "//response",
         "@cJSON",
         "@entangled//cclient/types",
+        "@entangled//common/trinary:tryte_ascii",
     ],
 )

serializer/serializer.c

@@ -407,3 +407,56 @@ status_t receive_mam_message_serialize(char** obj, const char** res) {
   cJSON_Delete(json_root);
   return ret;
 }
+
+status_t send_mam_res_serialize(char** obj, const send_mam_res_t* const res) {
+  status_t ret = SC_OK;
+  cJSON* json_root = cJSON_CreateObject();
+  if (json_root == NULL) {
+    ret = SC_SERIALIZER_JSON_CREATE;
+    goto done;
+  }
+
+  cJSON_AddStringToObject(json_root, "channel", res->channel_id);
+
+  cJSON_AddStringToObject(json_root, "bundle_hash", res->bundle_hash);
+
+  *obj = cJSON_PrintUnformatted(json_root);
+  if (*obj == NULL) {
+    ret = SC_SERIALIZER_JSON_PARSE;
+    goto done;
+  }
+
+done:
+  cJSON_Delete(json_root);
+  return ret;
+}
+
+status_t send_mam_req_deserialize(const char* const obj, send_mam_req_t* req) {
+  if (obj == NULL) {
+    return SC_SERIALIZER_NULL;
+  }
+  cJSON* json_obj = cJSON_Parse(obj);
+  cJSON* json_result = NULL;
+  status_t ret = SC_OK;
+
+  if (json_obj == NULL) {
+    ret = SC_SERIALIZER_JSON_PARSE;
+    goto done;
+  }
+
+  json_result = cJSON_GetObjectItemCaseSensitive(json_obj, "message");
+  if (json_result != NULL) {
+    size_t payload_size = strlen(json_result->valuestring) * 2;
+    tryte_t* payload_trytes = (tryte_t*)malloc(payload_size * sizeof(tryte_t));
+    ascii_to_trytes(json_result->valuestring, payload_trytes);
+
+    req->payload_trytes = payload_trytes;
+    req->payload_trytes_size = payload_size;
+  } else {
+    ret = SC_SERIALIZER_NULL;
+  }
+
+done:
+  cJSON_Delete(json_obj);
+  return ret;
+}

serializer/serializer.h

@@ -6,6 +6,7 @@
 #include "accelerator/errors.h"
 #include "cJSON.h"
 #include "cclient/types/types.h"
+#include "common/trinary/tryte_ascii.h"
 #include "request/request.h"
 #include "response/response.h"
 
@@ -122,6 +123,30 @@ status_t ta_find_transactions_obj_res_serialize(
  * - non-zero on error
  */
 status_t receive_mam_message_serialize(char** obj, const char** res);
+
+/**
+ * @brief Serialze type of send_mam_res_t to JSON string
+ *
+ * @param[out] obj send mam response object in JSON
+ * @param[in] res Response data in type of send_mam_res_t
+ *
+ * @return
+ * - SC_OK on success
+ * - non-zero on error
+ */
+status_t send_mam_res_serialize(char** obj, const send_mam_res_t* const res);
+
+/**
+ * @brief Deserialze JSON string to type of send_mam_req_t
+ *
+ * @param[in] obj Input values in JSON
+ * @param[out] req Request data in type of send_mam_req_t
+ *
+ * @return
+ * - SC_OK on success
+ * - non-zero on error
+ */
+status_t send_mam_req_deserialize(const char* const obj, send_mam_req_t* req);
 #ifdef __cplusplus
 }
 #endif

tests/driver.c

@@ -149,30 +149,16 @@ void test_find_transactions_obj_by_tag(void) {
 
 void test_send_mam_message(void) {
   double sum = 0;
-
-  char* bundle_hash_result;
-  char* channel_id_result;
+  const char* json = "{\"message\":\"" TEST_PAYLOAD "\"}";
+  char* json_result;
 
   for (size_t count = 0; count < TEST_COUNT; count++) {
     test_time_start(&start_time);
     TEST_ASSERT_EQUAL_INT32(
-        SC_OK,
-        api_mam_send_message(&ta_core.tangle, &ta_core.service, TEST_PAYLOAD,
-                             &bundle_hash_result, &channel_id_result));
+        SC_OK, api_mam_send_message(&ta_core.tangle, &ta_core.service, json,
+                                    &json_result));
     test_time_end(&start_time, &end_time, &sum);
-
-    for (size_t i = 0; i < FLEX_TRIT_SIZE_243; i++) {
-      printf("%c", channel_id_result[i]);
-    }
-    printf("\n");
-    printf("Bundle: ");
-    for (size_t i = 0; i < FLEX_TRIT_SIZE_243; i++) {
-      printf("%c", bundle_hash_result[i]);
-    }
-    printf("\n");
-
-    free(bundle_hash_result);
-    free(channel_id_result);
+    free(json_result);
   }
   printf("Average time of receive_mam_message: %lf\n", sum / TEST_COUNT);
 }

tests/test_serializer.c

@@ -251,6 +251,41 @@ void test_serialize_ta_find_transactions_obj_by_tag(void) {
   transaction_free(txn);
   free(json_result);
 }
+
+void test_serialize_send_mam_message(void) {
+  const char* json = "{\"channel\":\"" TRYTES_81_1
+                     "\","
+                     "\"bundle_hash\":\"" TRYTES_81_2 "\"}";
+  char* json_result;
+  send_mam_res_t* res = send_mam_res_new();
+
+  send_mam_res_set_bundle_hash(res, (tryte_t*)TRYTES_81_2);
+  send_mam_res_set_channel_id(res, (tryte_t*)TRYTES_81_1);
+
+  send_mam_res_serialize(&json_result, res);
+  TEST_ASSERT_EQUAL_STRING(json, json_result);
+
+  free(json_result);
+  send_mam_res_free(&res);
+}
+
+void test_deserialize_send_mam_message(void) {
+  const char* json = "{\"message\":\"" TEST_PAYLOAD "\"}";
+  send_mam_req_t* req = send_mam_req_new();
+
+  send_mam_req_deserialize(json, req);
+
+  size_t payload_size = strlen(TEST_PAYLOAD) * 2;
+  tryte_t* payload_trytes = (tryte_t*)malloc(payload_size * sizeof(tryte_t));
+  ascii_to_trytes(TEST_PAYLOAD, payload_trytes);
+
+  TEST_ASSERT_EQUAL_UINT(payload_size, req->payload_trytes_size);
+  TEST_ASSERT_EQUAL_MEMORY(payload_trytes, req->payload_trytes, payload_size);
+
+  free(payload_trytes);
+  send_mam_req_free(&req);
+}
+
 int main(void) {
   UNITY_BEGIN();
 
@@ -260,5 +295,7 @@ int main(void) {
   RUN_TEST(test_serialize_ta_get_transaction_object);
   RUN_TEST(test_serialize_ta_find_transactions_by_tag);
   RUN_TEST(test_serialize_ta_find_transactions_obj_by_tag);
+  RUN_TEST(test_serialize_send_mam_message);
+  RUN_TEST(test_deserialize_send_mam_message);
   return UNITY_END();
 }