Merge pull request #139 from wusyong/send_mam_serialize

howjmay · web-flow · commit 894f4d7494b6 · 2019-04-10T18:37:18.000+08:00
feat(serializer): Add send_mam_message (de)serializer
diff --git a/accelerator/BUILD b/accelerator/BUILD
@@ -28,7 +28,6 @@ cc_library(
         ":ta_errors",
         "//serializer",
         "@entangled//common/trinary:trit_tryte",
-        "@entangled//common/trinary:tryte_ascii",
         "@entangled//mam/api",
     ],
 )
diff --git a/accelerator/apis.c b/accelerator/apis.c
@@ -223,9 +223,7 @@ status_t api_receive_mam_message(const iota_client_service_t* const service,
 
 status_t api_mam_send_message(const iota_config_t* const tangle,
                               const iota_client_service_t* const service,
-                              char const* const payload,
-                              char** bundle_hash_result,
-                              char** channel_id_result) {
+                              char const* const payload, char** json_result) {
   status_t ret = SC_OK;
   mam_api_t mam;
   const bool last_packet = true;
@@ -234,24 +232,12 @@ status_t api_mam_send_message(const iota_config_t* const tangle,
   bundle_transactions_new(&bundle);
   tryte_t channel_id[MAM_CHANNEL_ID_SIZE];
   trit_t msg_id[MAM_MSG_ID_SIZE];
+  send_mam_req_t* req = send_mam_req_new();
+  send_mam_res_t* res = send_mam_res_new();
 
-  size_t payload_size = strlen(payload) * 2;
-  if ((payload_size == 0) || ((payload_size * 3) > SIZE_MAX)) {
-    return SC_MAM_OOM;
-  }
-  tryte_t* payload_trytes = (tryte_t*)malloc(payload_size * sizeof(tryte_t));
-  if (!payload_trytes) {
-    return SC_MAM_OOM;
-  }
-  ascii_to_trytes(payload, payload_trytes);
-
-  *bundle_hash_result = (tryte_t*)malloc(sizeof(tryte_t) * NUM_TRYTES_ADDRESS);
-  if (!(*bundle_hash_result)) {
-    return SC_MAM_OOM;
-  }
-  *channel_id_result = (tryte_t*)malloc(sizeof(tryte_t) * NUM_TRYTES_ADDRESS);
-  if (!(*channel_id_result)) {
-    return SC_MAM_OOM;
+  ret = send_mam_req_deserialize(payload, req);
+  if (ret) {
+    goto done;
   }
 
   // Creating MAM API
@@ -281,21 +267,23 @@ status_t api_mam_send_message(const iota_config_t* const tangle,
     ret = SC_MAM_FAILED_WRITE;
     goto done;
   }
-  if (mam_api_bundle_write_packet(&mam, msg_id, payload_trytes, payload_size, 0,
-                                  last_packet, bundle) != RC_OK) {
+  if (mam_api_bundle_write_packet(&mam, msg_id, req->payload_trytes,
+                                  req->payload_trytes_size, 0, last_packet,
+                                  bundle) != RC_OK) {
     ret = SC_MAM_FAILED_WRITE;
     goto done;
   }
-  memcpy(*channel_id_result, channel_id, sizeof(tryte_t) * NUM_TRYTES_ADDRESS);
+  send_mam_res_set_channel_id(res, channel_id);
 
   // Sending bundle
   if (ta_send_bundle(tangle, service, bundle) != SC_OK) {
     ret = SC_MAM_FAILED_RESPONSE;
     goto done;
   }
-  memcpy(*bundle_hash_result,
-         ((iota_transaction_t*)utarray_front(bundle))->essence.bundle,
-         sizeof(tryte_t) * NUM_TRYTES_ADDRESS);
+  send_mam_res_set_bundle_hash(
+      res, transaction_bundle((iota_transaction_t*)utarray_front(bundle)));
+
+  ret = send_mam_res_serialize(json_result, res);
 
 done:
   // Destroying MAM API
@@ -304,9 +292,10 @@ status_t api_mam_send_message(const iota_config_t* const tangle,
       ret = SC_MAM_FAILED_DESTROYED;
     }
   }
-  free(payload_trytes);
   mam_psk_t_set_free(&psks);
   bundle_transactions_free(&bundle);
+  send_mam_req_free(&req);
+  send_mam_res_free(&res);
   return ret;
 }
 
diff --git a/accelerator/apis.h b/accelerator/apis.h
@@ -5,7 +5,6 @@
 #include "accelerator/errors.h"
 #include "cclient/types/types.h"
 #include "common/trinary/trit_tryte.h"
-#include "common/trinary/tryte_ascii.h"
 #include "mam/api/api.h"
 #include "mam/mam/mam_channel_t_set.h"
 #include "serializer/serializer.h"
@@ -102,18 +101,15 @@ status_t api_receive_mam_message(const iota_client_service_t* const service,
  * @param[in] tangle IOTA API parameter configurations
  * @param[in] service IRI node end point service
  * @param[in] payload message to send undecoded ascii string.
- * @param[out] bundle_hashes_result the bundle hash of sent message
- * @param[out] channel_id_result the channel id the sent message to
+ * @param[out] json_result Result containing channel id and bundle hash
  *
  * @return
  * - SC_OK on success
  * - non-zero on error
  */
 status_t api_mam_send_message(const iota_config_t* const tangle,
                               const iota_client_service_t* const service,
-                              char const* const payload,
-                              char** bundle_hash_result,
-                              char** channel_id_result);
+                              char const* const payload, char** json_result);
 
 /**
  * @brief Send transfer to tangle.
diff --git a/accelerator/server.cc b/accelerator/server.cc
@@ -87,7 +87,6 @@ int main(int, char const**) {
       .post([&](served::response& res, const served::request& req) {
         status_t ret = SC_OK;
         char* json_result;
-        char* chid_result;
 
         if (req.header("content-type").find("application/json") ==
             std::string::npos) {
@@ -100,7 +99,7 @@ int main(int, char const**) {
           cJSON_Delete(json_obj);
         } else {
           api_mam_send_message(&ta_core.tangle, &ta_core.service,
-                               req.body().c_str(), &json_result, &chid_result);
+                               req.body().c_str(), &json_result);
           ret = set_response_content(ret, &json_result);
           res.set_status(ret);
         }
diff --git a/request/BUILD b/request/BUILD
@@ -9,7 +9,7 @@ cc_library(
     include_prefix = "request",
     visibility = ["//visibility:public"],
     deps = [
-        "@entangled//cclient/types",
         "//accelerator:ta_errors",
+        "@entangled//cclient/types",
     ],
 )
diff --git a/request/request.h b/request/request.h
@@ -1,7 +1,7 @@
 #ifndef REQUEST_REQUEST_H_
 #define REQUEST_REQUEST_H_
 
-#include "request/ta_send_mam_req.h"
+#include "request/ta_send_mam.h"
 #include "request/ta_send_transfer.h"
 
 /**
diff --git a/request/ta_send_mam.c b/request/ta_send_mam.c
@@ -1,4 +1,4 @@
-#include "ta_send_mam_req.h"
+#include "ta_send_mam.h"
 
 send_mam_req_t* send_mam_req_new() {
   send_mam_req_t* req = (send_mam_req_t*)malloc(sizeof(send_mam_req_t));
diff --git a/request/ta_send_mam.h b/request/ta_send_mam.h
@@ -1,5 +1,5 @@
-#ifndef REQUEST_TA_SEND_MAM_REQ_H_
-#define REQUEST_TA_SEND_MAM_REQ_H_
+#ifndef REQUEST_TA_SEND_MAM_H_
+#define REQUEST_TA_SEND_MAM_H_
 
 #include "accelerator/errors.h"
 #include "cclient/types/types.h"
@@ -21,4 +21,4 @@ void send_mam_req_free(send_mam_req_t** req);
 }
 #endif
 
-#endif  // REQUEST_TA_SEND_MAM_REQ_H_
+#endif  // REQUEST_TA_SEND_MAM_H_
diff --git a/response/BUILD b/response/BUILD
@@ -9,8 +9,8 @@ cc_library(
     include_prefix = "response",
     visibility = ["//visibility:public"],
     deps = [
+        "//accelerator:ta_errors",
         "@entangled//cclient/types",
         "@entangled//common/model:transaction",
-        "//accelerator:ta_errors",
     ],
 )
diff --git a/response/response.h b/response/response.h
@@ -6,7 +6,7 @@
 #include "response/ta_generate_address.h"
 #include "response/ta_get_tips.h"
 #include "response/ta_get_transaction_object.h"
-#include "response/ta_send_mam_res.h"
+#include "response/ta_send_mam.h"
 #include "response/ta_send_transfer.h"
 
 /**
diff --git a/response/ta_send_mam.c b/response/ta_send_mam.c
@@ -0,0 +1,38 @@
+#include "ta_send_mam.h"
+
+send_mam_res_t* send_mam_res_new() {
+  send_mam_res_t* res = (send_mam_res_t*)malloc(sizeof(send_mam_res_t));
+
+  return res;
+}
+
+status_t send_mam_res_set_bundle_hash(send_mam_res_t* res,
+                                      const tryte_t* bundle_hash) {
+  if (!bundle_hash || !res) {
+    return SC_RES_NULL;
+  }
+
+  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 (!channel_id || !res) {
+    return SC_RES_NULL;
+  }
+
+  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;
+  }
+
+  free(*res);
+  *res = NULL;
+}
diff --git a/response/ta_send_mam.h b/response/ta_send_mam.h
@@ -1,5 +1,5 @@
-#ifndef RESPONSE_TA_SEND_MAM_RES_H_
-#define RESPONSE_TA_SEND_MAM_RES_H_
+#ifndef RESPONSE_TA_SEND_MAM_H_
+#define RESPONSE_TA_SEND_MAM_H_
 
 #include "accelerator/errors.h"
 #include "common/model/transaction.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;
 
 /**
@@ -76,4 +76,4 @@ void send_mam_res_free(send_mam_res_t** res);
 }
 #endif
 
-#endif  // RESPONSE_TA_SEND_MAM_RES_H_
+#endif  // RESPONSE_TA_SEND_MAM_H_
diff --git a/response/ta_send_mam_res.c b/response/ta_send_mam_res.c
diff --git a/serializer/BUILD b/serializer/BUILD
@@ -11,5 +11,6 @@ cc_library(
         "//response",
         "@cJSON",
         "@entangled//cclient/types",
+        "@entangled//common/trinary:tryte_ascii",
     ],
 )
diff --git a/serializer/serializer.c b/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;
+}
diff --git a/serializer/serializer.h b/serializer/serializer.h
diff --git a/tests/driver.c b/tests/driver.c
diff --git a/tests/test_serializer.c b/tests/test_serializer.c

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,6 @@ cc_library(`
`28`	`28`	`":ta_errors",`
`29`	`29`	`"//serializer",`
`30`	`30`	`"@entangled//common/trinary:trit_tryte",`
`31`		`- "@entangled//common/trinary:tryte_ascii",`
`32`	`31`	`"@entangled//mam/api",`
`33`	`32`	`],`
`34`	`33`	`)`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ cc_library(`
`9`	`9`	`include_prefix = "request",`
`10`	`10`	`visibility = ["//visibility:public"],`
`11`	`11`	`deps = [`
`12`		`- "@entangled//cclient/types",`
`13`	`12`	`"//accelerator:ta_errors",`
	`13`	`+ "@entangled//cclient/types",`
`14`	`14`	`],`
`15`	`15`	`)`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#include "ta_send_mam_req.h"`
	`1`	`+#include "ta_send_mam.h"`
`2`	`2`
`3`	`3`	`send_mam_req_t* send_mam_req_new() {`
`4`	`4`	`send_mam_req_t* req = (send_mam_req_t*)malloc(sizeof(send_mam_req_t));`