framework:1.fix record time error 2.add qosdepth param

framework/python/cybertron/cybertron.py

@@ -173,7 +173,7 @@ class Node(object):
         desc_str = proto.SerializeToString()
         _CYBER_NODE.PyNode_register_message(self.node, desc_str)
 
-    def create_writer(self, name, data_type):
+    def create_writer(self, name, data_type, qos_depth=1):
         """
         create a topic writer for send message to topic.
         @param self
@@ -182,7 +182,8 @@ class Node(object):
         """
         self.register_message(data_type.DESCRIPTOR.file)
         datatype = data_type.DESCRIPTOR.full_name
-        writer = _CYBER_NODE.PyNode_create_writer(self.node, name, datatype)
+        writer = _CYBER_NODE.PyNode_create_writer(self.node, name,
+            datatype, qos_depth)
         self.list_writer.append(writer)
         return Writer(name, writer, datatype)
 

framework/python/examples/talker.py

@@ -37,7 +37,7 @@ def test_talker_class():
     g_count = 1
 
     writer = test_node.create_writer("channel/chatter",
-        chatter_pb2.Chatter)
+        chatter_pb2.Chatter, 6)
     while not cybertron.is_shutdown():
         time.sleep(1)
         g_count = g_count + 1

framework/python/test/test_node.py

@@ -56,7 +56,7 @@ class TestNode(unittest.TestCase):
 
         self.assertTrue(cybertron.ok())
         test_node = cybertron.Node("node_name1")
-        writer = test_node.create_writer("channel/chatter", chatter_pb2.Chatter)
+        writer = test_node.create_writer("channel/chatter", chatter_pb2.Chatter, 7)
         self.assertEqual(writer.name, "channel/chatter")
         self.assertEqual(writer.data_type, "apollo.cybertron.proto.Chatter")
         self.assertTrue(writer.write(msg))

framework/python/wrapper/cyber_node_wrap.cpp

@@ -61,11 +61,12 @@ T PyObjectToPtr(PyObject *pyobj, const std::string &type_ptr) {
 PyObject *cyber_new_PyWriter(PyObject *self, PyObject *args) {
   char *channel_name = nullptr;
   char *data_type = nullptr;
+  uint32_t qos_depth = 1;
   apollo::cybertron::Node *node = nullptr;
 
   PyObject *node_pyobj = nullptr;
-  if (!PyArg_ParseTuple(args, const_cast<char *>("ssO:new_PyWriter"),
-                        &channel_name, &data_type, &node_pyobj)) {
+  if (!PyArg_ParseTuple(args, const_cast<char *>("ssIO:new_PyWriter"),
+                        &channel_name, &data_type, &qos_depth, &node_pyobj)) {
     return Py_None;
   }
 
@@ -76,9 +77,9 @@ PyObject *cyber_new_PyWriter(PyObject *self, PyObject *args) {
     return Py_None;
   }
 
-  apollo::cybertron::PyWriter *writer =
-      new apollo::cybertron::PyWriter((std::string const &)*channel_name,
-                                      (std::string const &)*data_type, node);
+  apollo::cybertron::PyWriter *writer = new apollo::cybertron::PyWriter(
+      (std::string const &)*channel_name, (std::string const &)*data_type,
+      qos_depth, node);
   PyObject *pyobj_writer =
       PyCapsule_New(writer, "apollo_cybertron_pywriter", NULL);
   return pyobj_writer;
@@ -419,12 +420,13 @@ PyObject *cyber_delete_PyNode(PyObject *self, PyObject *args) {
 }
 
 PyObject *cyber_PyNode_create_writer(PyObject *self, PyObject *args) {
+  PyObject *pyobj_node = nullptr;
   char *channel_name = nullptr;
   char *type_name = nullptr;
-  PyObject *pyobj_node = nullptr;
+  int qos_depth = 1;
 
-  if (!PyArg_ParseTuple(args, const_cast<char *>("Oss:PyNode_create_writer"),
-                        &pyobj_node, &channel_name, &type_name)) {
+  if (!PyArg_ParseTuple(args, const_cast<char *>("OssI:PyNode_create_writer"),
+                        &pyobj_node, &channel_name, &type_name, &qos_depth)) {
     AINFO << "cyber_PyNode_create_writer:PyArg_ParseTuple failed!";
     return Py_None;
   }
@@ -438,7 +440,8 @@ PyObject *cyber_PyNode_create_writer(PyObject *self, PyObject *args) {
 
   apollo::cybertron::PyWriter *writer =
       (apollo::cybertron::PyWriter *)(node->create_writer(
-          (std::string const &)channel_name, (std::string const &)type_name));
+          (std::string const &)channel_name, (std::string const &)type_name,
+          qos_depth));
 
   PyObject *pyobj_writer =
       PyCapsule_New(writer, "apollo_cybertron_pywriter", NULL);

framework/python/wrapper/cyber_record_wrap.cpp

@@ -405,7 +405,7 @@ PyObject *cyber_PyRecordWriter_WriteMessage(PyObject *self, PyObject *args) {
   Py_ssize_t len = 0;
   uint64_t time = 0;
   if (!PyArg_ParseTuple(
-          args, const_cast<char *>("Oss#i:cyber_PyRecordWriter_WriteMessage"),
+          args, const_cast<char *>("Oss#K:cyber_PyRecordWriter_WriteMessage"),
           &pyobj_rec_writer, &channel_name, &rawmessage, &len, &time)) {
     AINFO << "cyber_PyRecordWriter_WriteMessage parsetuple failed!";
     Py_RETURN_FALSE;

framework/python/wrapper/py_node.h

@@ -63,8 +63,11 @@ bool py_OK() { return apollo::cybertron::OK(); }
 class PyWriter {
  public:
   PyWriter(const std::string &channel, const std::string &type,
-           apollo::cybertron::Node *node)
-      : channel_name_(channel), data_type_(type), node_(node) {
+           uint32_t qos_depth, apollo::cybertron::Node *node)
+      : channel_name_(channel),
+        data_type_(type),
+        qos_depth_(qos_depth),
+        node_(node) {
     std::string proto_desc("");
     message::ProtobufFactory::Instance()->GetDescriptorString(type,
                                                               &proto_desc);
@@ -76,6 +79,8 @@ class PyWriter {
     role_attr.set_channel_name(channel_name_);
     role_attr.set_message_type(data_type_);
     role_attr.set_proto_desc(proto_desc);
+    auto qos_profile = role_attr.mutable_qos_profile();
+    qos_profile->set_depth(qos_depth_);
     writer_ = node_->CreateWriter<apollo::cybertron::message::PyMessageWrap>(
         role_attr);
   }
@@ -93,6 +98,7 @@ class PyWriter {
   apollo::cybertron::Node *node_;
   std::string channel_name_;
   std::string data_type_;
+  uint32_t qos_depth_;
   std::shared_ptr<
       apollo::cybertron::Writer<apollo::cybertron::message::PyMessageWrap>>
       writer_;
@@ -282,9 +288,10 @@ class PyNode {
     AINFO << "PyNode " << node_name_ << " exit.";
   }
 
-  PyWriter *create_writer(const std::string &channel, const std::string &type) {
+  PyWriter *create_writer(const std::string &channel, const std::string &type,
+                          uint32_t qos_depth = 1) {
     if (node_) {
-      return new PyWriter(channel, type, node_.get());
+      return new PyWriter(channel, type, qos_depth, node_.get());
     }
     AINFO << "Py_Node: node_ is null, new PyWriter failed!";
     return nullptr;

framework/python/wrapper/test/test_node.cpp

@@ -50,7 +50,7 @@ TEST(CyberNodeTest, create_writer) {
   auto msgChat = std::make_shared<apollo::cybertron::proto::Chatter>();
   apollo::cybertron::PyNode node("talker");
   apollo::cybertron::PyWriter *pw =
-      node.create_writer("channel/chatter", msgChat->GetTypeName());
+      node.create_writer("channel/chatter", msgChat->GetTypeName(), 10);
   EXPECT_TRUE(pw != nullptr);
 
   EXPECT_TRUE(apollo::cybertron::OK());