let client send cmd data, the replicas should only work on the hash

5 files changed, 28 insertions, 34 deletions

diff --git a/include/hotstuff/client.h b/include/hotstuff/client.h
index d61d9e7..ca18062 100644
--- a/include/hotstuff/client.h
+++ b/include/hotstuff/client.h
@@ -12,25 +12,32 @@ struct MsgReqCmd {
     static const opcode_t opcode = 0x4;
     DataStream serialized;
     command_t cmd;
-    MsgReqCmd(const Command &cmd);
+    MsgReqCmd(const Command &cmd) { serialized << cmd; }
     MsgReqCmd(DataStream &&s): serialized(std::move(s)) {}
-    void postponed_parse(HotStuffCore *hsc);
 };
 
 struct MsgRespCmd {
     static const opcode_t opcode = 0x5;
     DataStream serialized;
+#if HOTSTUFF_CMD_RESPSIZE > 0
+    uint8_t payload[HOTSTUFF_CMD_RESPSIZE];
+#endif
     Finality fin;
-    MsgRespCmd(const Finality &fin);
-    MsgRespCmd(DataStream &&s);
+    MsgRespCmd(const Finality &fin) {
+        serialized << fin;
+#if HOTSTUFF_CMD_RESPSIZE > 0
+        serialized.put_data(payload, payload + HOTSTUFF_CMD_RESPSIZE);
+#endif
+    }
+    MsgRespCmd(DataStream &&s) { s >> fin; }
 };
 
 class CommandDummy: public Command {
     uint32_t cid;
     uint32_t n;
     uint256_t hash;
-#if HOTSTUFF_CMD_DMSIZE > 0
-    uint8_t payload[HOTSTUFF_CMD_DMSIZE];
+#if HOTSTUFF_CMD_REQSIZE > 0
+    uint8_t payload[HOTSTUFF_CMD_REQSIZE];
 #endif
     uint256_t compute_hash() {
         DataStream s;
@@ -47,17 +54,13 @@ class CommandDummy: public Command {
 
     void serialize(DataStream &s) const override {
         s << cid << n;
-#if HOTSTUFF_CMD_DMSIZE > 0
-        s.put_data(payload, payload + HOTSTUFF_CMD_DMSIZE);
+#if HOTSTUFF_CMD_REQSIZE > 0
+        s.put_data(payload, payload + HOTSTUFF_CMD_REQSIZE);
 #endif
     }
 
     void unserialize(DataStream &s) override {
         s >> cid >> n;
-#if HOTSTUFF_CMD_DMSIZE > 0
-        auto base = s.get_data_inplace(HOTSTUFF_CMD_DMSIZE);
-        memmove(payload, base, HOTSTUFF_CMD_DMSIZE);
-#endif
         hash = compute_hash();
     }
 
diff --git a/include/hotstuff/consensus.h b/include/hotstuff/consensus.h
index 9e2558c..e8f9765 100644
--- a/include/hotstuff/consensus.h
+++ b/include/hotstuff/consensus.h
@@ -84,7 +84,7 @@ class HotStuffCore {
     /** Call to submit new commands to be decided (executed). "Parents" must
      * contain at least one block, and the first block is the actual parent,
      * while the others are uncles/aunts */
-    void on_propose(const std::vector<command_t> &cmds,
+    void on_propose(const std::vector<uint256_t> &cmds,
                     const std::vector<block_t> &parents,
                     bytearray_t &&extra = bytearray_t());
 
@@ -118,7 +118,7 @@ class HotStuffCore {
     /** Create a quorum certificate from its serialized form. */
     virtual quorum_cert_bt parse_quorum_cert(DataStream &s) = 0;
     /** Create a command object from its serialized form. */
-    virtual command_t parse_cmd(DataStream &s) = 0;
+    //virtual command_t parse_cmd(DataStream &s) = 0;
 
     public:
     /** Add a replica to the current configuration. This should only be called
diff --git a/include/hotstuff/entity.h b/include/hotstuff/entity.h
index 6327dfe..f9e7bc8 100644
--- a/include/hotstuff/entity.h
+++ b/include/hotstuff/entity.h
@@ -79,7 +79,6 @@ using block_weak_t = salticidae::WeakObj<Block>;
 
 class Command: public Serializable {
     friend HotStuffCore;
-    block_weak_t container;
     public:
     virtual ~Command() = default;
     virtual const uint256_t &get_hash() const = 0;
@@ -105,7 +104,7 @@ get_hashes(const std::vector<Hashable> &plist) {
 class Block {
     friend HotStuffCore;
     std::vector<uint256_t> parent_hashes;
-    std::vector<command_t> cmds;
+    std::vector<uint256_t> cmds;
     quorum_cert_bt qc;
     bytearray_t extra;
 
@@ -135,7 +134,7 @@ class Block {
         delivered(delivered), decision(decision) {}
 
     Block(const std::vector<block_t> &parents,
-        const std::vector<command_t> &cmds,
+        const std::vector<uint256_t> &cmds,
         quorum_cert_bt &&qc,
         bytearray_t &&extra,
         uint32_t height,
@@ -158,7 +157,7 @@ class Block {
 
     void unserialize(DataStream &s, HotStuffCore *hsc);
 
-    const std::vector<command_t> &get_cmds() const {
+    const std::vector<uint256_t> &get_cmds() const {
         return cmds;
     }
 
@@ -174,19 +173,12 @@ class Block {
 
     bool verify(const ReplicaConfig &config) const {
         if (qc && !qc->verify(config)) return false;
-        for (auto cmd: cmds)
-            if (!cmd->verify()) return false;
         return true;
     }
 
     promise_t verify(const ReplicaConfig &config, VeriPool &vpool) const {
         return (qc ? qc->verify(config, vpool) :
-        promise_t([](promise_t &pm) { pm.resolve(true); })).then([this](bool result) {
-            if (!result) return false;
-            for (auto cmd: cmds)
-                if (!cmd->verify()) return false;
-            return true;
-        });
+        promise_t([](promise_t &pm) { pm.resolve(true); }));
     }
 
     int8_t get_decision() const { return decision; }
@@ -232,7 +224,7 @@ class EntityStorage {
         return blk_cache.count(blk_hash);
     }
 
-    block_t add_blk(Block &&_blk, const ReplicaConfig &config) {
+    block_t add_blk(Block &&_blk, const ReplicaConfig &/*config*/) {
         //if (!_blk.verify(config))
         //{
         //    HOTSTUFF_LOG_WARN("invalid %s", std::string(_blk).c_str());
@@ -288,8 +280,8 @@ class EntityStorage {
 #ifdef HOTSTUFF_PROTO_LOG
             HOTSTUFF_LOG_INFO("releasing blk %.10s", get_hex(blk_hash).c_str());
 #endif
-            for (const auto &cmd: blk->get_cmds())
-                try_release_cmd(cmd);
+//            for (const auto &cmd: blk->get_cmds())
+//                try_release_cmd(cmd);
             blk_cache.erase(blk_hash);
             return true;
         }
diff --git a/include/hotstuff/hotstuff.h b/include/hotstuff/hotstuff.h
index eeffaab..3d1c7b6 100644
--- a/include/hotstuff/hotstuff.h
+++ b/include/hotstuff/hotstuff.h
@@ -135,9 +135,8 @@ class HotStuffBase: public HotStuffCore {
     /* queues for async tasks */
     std::unordered_map<const uint256_t, BlockFetchContext> blk_fetch_waiting;
     std::unordered_map<const uint256_t, BlockDeliveryContext> blk_delivery_waiting;
-    std::unordered_map<const uint256_t, CmdFetchContext> cmd_fetch_waiting;
     std::unordered_map<const uint256_t, promise_t> decision_waiting;
-    std::queue<command_t> cmd_pending;
+    std::queue<uint256_t> cmd_pending;
 
     /* statistics */
     uint64_t fetched;
@@ -192,7 +191,7 @@ class HotStuffBase: public HotStuffCore {
     /* the API for HotStuffBase */
 
     /* Submit the command to be decided. */
-    promise_t exec_command(command_t cmd);
+    promise_t exec_command(uint256_t cmd);
     void add_replica(ReplicaID idx, const NetAddr &addr, pubkey_bt &&pub_key);
     void start(bool eb_loop = false);
 
diff --git a/include/hotstuff/liveness.h b/include/hotstuff/liveness.h
index 8c9c9ab..c88a0a1 100644
--- a/include/hotstuff/liveness.h
+++ b/include/hotstuff/liveness.h
@@ -330,7 +330,7 @@ class PMStickyProposer: virtual public PaceMaker {
         /* FIXME: should extra data be the voter's id? */
         s << hsc->get_id();
         /* propose a block for leader election */
-        hsc->on_propose(std::vector<command_t>{},
+        hsc->on_propose(std::vector<uint256_t>{},
                 get_parents(), std::move(s));
     }
 
@@ -580,7 +580,7 @@ class PMRoundRobinProposer: virtual public PaceMaker {
         /* FIXME: should extra data be the voter's id? */
         s << hsc->get_id();
         /* propose a block for leader election */
-        hsc->on_propose(std::vector<command_t>{},
+        hsc->on_propose(std::vector<uint256_t>{},
                 get_parents(), std::move(s));
     }