ChainGetPath (#529)

Signed-off-by: turuslan <turuslan.devbox@gmail.com>

Author: turuslan

core/api/full_node/make.cpp

@@ -68,6 +68,7 @@ namespace fc::api {
   using primitives::kChainEpochUndefined;
   using primitives::block::MsgMeta;
   using primitives::sector::getPreferredSealProofTypeFromWindowPoStType;
+  using primitives::tipset::HeadChangeType;
   using primitives::tipset::Tipset;
   using storage::ipld::kAllSelector;
   using vm::isVMExitCode;
@@ -84,6 +85,7 @@ namespace fc::api {
   using vm::actor::builtin::states::RewardActorStatePtr;
   using vm::actor::builtin::states::VerifiedRegistryActorStatePtr;
   using vm::actor::builtin::types::market::DealState;
+  using vm::actor::builtin::types::miner::kChainFinality;
   using vm::actor::builtin::types::storage_power::kConsensusMinerMinPower;
   using vm::interpreter::InterpreterCache;
   using vm::runtime::Env;
@@ -293,6 +295,27 @@ namespace fc::api {
       OUTCOME_TRY(cbor, ipld->get(cid));
       return UnsignedMessage::decode(cbor);
     };
+    api->ChainGetPath = [=](const TipsetKey &from_key, const TipsetKey &to_key)
+        -> outcome::result<std::vector<HeadChange>> {
+      std::vector<HeadChange> revert;
+      std::vector<HeadChange> apply;
+      OUTCOME_TRY(from, ts_load->load(from_key));
+      OUTCOME_TRY(to, ts_load->load(to_key));
+      while (from->key != to->key) {
+        if (revert.size() > kChainFinality || apply.size() > kChainFinality) {
+          return ERROR_TEXT("ChainGetPath finality limit");
+        }
+        if (from->height() > to->height()) {
+          revert.emplace_back(HeadChange{HeadChangeType::REVERT, from});
+          OUTCOME_TRYA(from, ts_load->load(from->getParents()));
+        } else {
+          apply.emplace_back(HeadChange{HeadChangeType::APPLY, to});
+          OUTCOME_TRYA(to, ts_load->load(to->getParents()));
+        }
+      }
+      revert.insert(revert.end(), apply.rbegin(), apply.rend());
+      return std::move(revert);
+    };
     api->ChainGetParentMessages =
         [=](auto &block_cid) -> outcome::result<std::vector<CidMessage>> {
       std::vector<CidMessage> messages;

core/api/full_node/node_api.hpp

@@ -315,6 +315,11 @@ namespace fc::api {
                jwt::kReadPermission,
                UnsignedMessage,
                const CID &)
+    API_METHOD(ChainGetPath,
+               jwt::kReadPermission,
+               std::vector<HeadChange>,
+               const TipsetKey &,
+               const TipsetKey &)
     API_METHOD(ChainGetParentMessages,
                jwt::kReadPermission,
                std::vector<CidMessage>,
@@ -813,6 +818,7 @@ namespace fc::api {
     f(a.ChainGetGenesis);
     f(a.ChainGetMessage);
     f(a.ChainGetNode);
+    f(a.ChainGetPath);
     f(a.ChainGetParentMessages);
     f(a.ChainGetParentReceipts);
     f(a.ChainGetRandomnessFromBeacon);

core/vm/actor/cgo/actors.cpp

@@ -55,6 +55,12 @@ namespace fc::vm::actor::cgo {
     cgoCall<cgoActorsConfigParams>(arg);
   }
 
+  void logLevel(LogLevel level) {
+    CborEncodeStream arg;
+    arg << level;
+    cgoCall<cgoActorsSetLogLevel>(arg);
+  }
+
   constexpr auto kFatal{VMExitCode::kFatal};
   constexpr auto kOk{VMExitCode::kOk};
 
@@ -394,4 +400,9 @@ namespace fc::vm::actor::cgo {
       ret << VMExitCode::kErrIllegalState;
     }
   }
+
+  RUNTIME_METHOD(gocRtLog) {
+    spdlog::info("cgoActorsInvoke log: {}", arg.get<std::string>());
+    ret << kOk;
+  }
 }  // namespace fc::vm::actor::cgo

core/vm/actor/cgo/actors.hpp

@@ -18,6 +18,14 @@ namespace fc::vm::actor::cgo {
    */
   void configParams();
 
+  enum class LogLevel {
+    kDebug = -1,
+    kInfo,
+    kWarn,
+    kError,
+  };
+  void logLevel(LogLevel level);
+
   outcome::result<Bytes> invoke(const CID &code,
                                 const std::shared_ptr<Runtime> &runtime);
 }  // namespace fc::vm::actor::cgo

core/vm/actor/cgo/c_actors.h

@@ -33,6 +33,7 @@ Raw gocRtStateGet(Raw);
 Raw gocRtStateCommit(Raw);
 Raw gocRtDeleteActor(Raw);
 Raw gocRtCirc(Raw);
+Raw gocRtLog(Raw);
 
 #ifdef __cplusplus
 }

core/vm/actor/cgo/cgo.go

@@ -157,6 +157,14 @@ func (out *cborOut) bytes(b []byte) *cborOut {
 	return out
 }
 
+func (out *cborOut) str(s string) *cborOut {
+	e := typegen.CborWriteHeader(out.w, typegen.MajTextString, uint64(len(s)))
+	cgoAsserte(e)
+	_, e = out.w.Write([]byte(s))
+	cgoAsserte(e)
+	return out
+}
+
 func (out *cborOut) int(i int64) *cborOut {
 	t := typegen.MajUnsignedInt
 	if i < 0 {

core/vm/actor/cgo/go_actors.go

@@ -275,7 +275,21 @@ func (rt *rt) ChargeGas(_ string, gas int64, _ int64) {
 	rt.gocRet(C.gocRtCharge(rt.gocArg().int(gas).arg()))
 }
 
-func (rt *rt) Log(rtt.LogLevel, string, ...interface{}) {
+var log_level rtt.LogLevel = rtt.WARN
+var log_levels = []string{"DEBUG", "INFO", "WARN", "ERROR"}
+
+func (rt *rt) Log(level rtt.LogLevel, format string, args ...interface{}) {
+	if level < rtt.DEBUG {
+		return
+	}
+	if level > rtt.ERROR {
+		level = rtt.ERROR
+	}
+	if level < log_level {
+		return
+	}
+	msg := fmt.Sprintf("%s %s", log_levels[level+1], fmt.Sprintf(format, args...))
+	rt.gocRet(C.gocRtLog(rt.gocArg().str(msg).arg()))
 }
 
 var _ rt1.StateHandle = &rt{}
@@ -844,6 +858,13 @@ func cgoActorsConfigParams(raw C.Raw) C.Raw {
 	return cgoRet(nil)
 }
 
+//export cgoActorsSetLogLevel
+func cgoActorsSetLogLevel(raw C.Raw) C.Raw {
+	arg := cgoArgCbor(raw)
+	log_level = rtt.LogLevel(arg.int())
+	return cgoRet(nil)
+}
+
 func init() {
 	for k, v := range _actors {
 		actors[k] = export(v)

test/core/sector_storage/zerocomm/zerocomm_test.cpp

@@ -29,7 +29,7 @@ namespace fc::sector_storage::zerocomm {
                       params.expected)
   }
 
-  INSTANTIATE_TEST_CASE_P(
+  INSTANTIATE_TEST_SUITE_P(
       ZerocommTestCases,
       ZerocommTest,
       ::testing::Values(Params{1016,

test/core/storage/mpool/message_pool_test.cpp

@@ -134,7 +134,7 @@ namespace fc::storage::mpool {
     EXPECT_FALSE(testMpoolSelectRevert(fix, ticket_quality).empty());
   }
 
-  INSTANTIATE_TEST_CASE_P(MpoolSelectQualityTest,
-                          MpoolSelectQualityTest,
-                          ::testing::Values(0.8, 0.9));
+  INSTANTIATE_TEST_SUITE_P(MpoolSelectQualityTest,
+                           MpoolSelectQualityTest,
+                           ::testing::Values(0.8, 0.9));
 }  // namespace fc::storage::mpool

test/core/storage/unixfs/unixfs_test.cpp

@@ -27,7 +27,7 @@ TEST_P(UnixfsTest, MatchGo) {
   EXPECT_EQ(unwrapped.str(), data);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     UnixfsTestCases,
     UnixfsTest,
     ::testing::Values(