filecoin-project · turuslan · Nov 22, 2021 · Nov 19, 2021 · Nov 22, 2021
diff --git a/core/api/full_node/make.cpp b/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;

diff --git a/core/api/full_node/node_api.hpp b/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);

diff --git a/core/vm/actor/cgo/actors.cpp b/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
diff --git a/core/vm/actor/cgo/actors.hpp b/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
diff --git a/core/vm/actor/cgo/c_actors.h b/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
 }

diff --git a/core/vm/actor/cgo/cgo.go b/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 {

diff --git a/core/vm/actor/cgo/go_actors.go b/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)

diff --git a/test/core/sector_storage/zerocomm/zerocomm_test.cpp b/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,

diff --git a/test/core/storage/mpool/message_pool_test.cpp b/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
diff --git a/test/core/storage/unixfs/unixfs_test.cpp b/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(

diff --git a/test/core/test_vectors/test.cpp b/test/core/test_vectors/test.cpp
@@ -271,10 +271,7 @@ struct TestVectors : testing::TestWithParam<MessageVector> {
     OUTCOME_EXCEPT(params,
                    ProofParamProvider::readJson(
                        "/var/tmp/filecoin-proof-parameters/parameters.json"));
-    RegisteredSealProof seal_proof_type =
-        RegisteredSealProof::kStackedDrg2KiBV1;
-    OUTCOME_EXCEPT(sector_size, getSectorSize(seal_proof_type));
-    OUTCOME_EXCEPT(ProofParamProvider::getParams(params, sector_size));
+    OUTCOME_EXCEPT(ProofParamProvider::getParams(params, 0));
   }
 };
 
@@ -404,7 +401,7 @@ TEST_P(TestVectors, Vector) {
   }
 }
 
-INSTANTIATE_TEST_CASE_P(Vectors,
-                        TestVectors,
-                        testing::ValuesIn(search()),
-                        [](auto &&p) { return testName(p.param.path); });
+INSTANTIATE_TEST_SUITE_P(Vectors,
+                         TestVectors,
+                         testing::ValuesIn(search()),
+                         [](auto &&p) { return testName(p.param.path); });
diff --git a/test/core/vm/actor/builtin/types/miner/deadline_assignment_test.cpp b/test/core/vm/actor/builtin/types/miner/deadline_assignment_test.cpp
@@ -130,7 +130,7 @@ namespace fc::vm::actor::builtin::types::miner {
     }
   }
 
-  INSTANTIATE_TEST_CASE_P(
+  INSTANTIATE_TEST_SUITE_P(
       P,
       DeadlineAssignmentTestP,
       ::testing::ValuesIn(DeadlineAssignmentTestP::initTestCases()));

diff --git a/test/core/vm/actor/builtin/v0/reward/reward_actor_calculus_v0_test.cpp b/test/core/vm/actor/builtin/v0/reward/reward_actor_calculus_v0_test.cpp
@@ -133,23 +133,23 @@ namespace fc::vm::actor::builtin::types::reward {
     ASSERT_LT(err, err_bound);
   }
 
-  INSTANTIATE_TEST_CASE_P(RewardActorCalculusV0Cases,
-                          RewardActorCalculusV0,
-                          ::testing::Values(
-                              // 1 byte
-                              Params{StoragePower{1}, BigFloat{1}},
-                              // GiB
-                              Params{StoragePower{1} << 30, BigFloat{1e-3}},
-                              // TiB
-                              Params{StoragePower{1} << 40, BigFloat{1e-6}},
-                              // PiB
-                              Params{StoragePower{1} << 50, BigFloat{1e-8}},
-                              // EiB
-                              Params{kBaselineInitialValueV0, BigFloat{1e-8}},
-                              // ZiB
-                              Params{StoragePower{1} << 70, BigFloat{1e-8}},
-                              // non power of 2 ~ 1 EiB
-                              Params{StoragePower{"513633559722596517"},
-                                     BigFloat{1e-8}}));
+  INSTANTIATE_TEST_SUITE_P(RewardActorCalculusV0Cases,
+                           RewardActorCalculusV0,
+                           ::testing::Values(
+                               // 1 byte
+                               Params{StoragePower{1}, BigFloat{1}},
+                               // GiB
+                               Params{StoragePower{1} << 30, BigFloat{1e-3}},
+                               // TiB
+                               Params{StoragePower{1} << 40, BigFloat{1e-6}},
+                               // PiB
+                               Params{StoragePower{1} << 50, BigFloat{1e-8}},
+                               // EiB
+                               Params{kBaselineInitialValueV0, BigFloat{1e-8}},
+                               // ZiB
+                               Params{StoragePower{1} << 70, BigFloat{1e-8}},
+                               // non power of 2 ~ 1 EiB
+                               Params{StoragePower{"513633559722596517"},
+                                      BigFloat{1e-8}}));
 
 }  // namespace fc::vm::actor::builtin::types::reward
diff --git a/test/core/vm/actor/builtin/v2/miner/miner_actor_v2_test.cpp b/test/core/vm/actor/builtin/v2/miner/miner_actor_v2_test.cpp
@@ -310,7 +310,7 @@ namespace fc::vm::actor::builtin::v2::miner {
     EXPECT_OUTCOME_TRUE_1(Construct::call(runtime, params));
   }
 
-  INSTANTIATE_TEST_CASE_P(
+  INSTANTIATE_TEST_SUITE_P(
       ConstructSuccesssMinerActorTestCases,
       ConstructSuccesssMinerActorTest,
       ::testing::Values(
@@ -333,7 +333,7 @@ namespace fc::vm::actor::builtin::v2::miner {
       : public MinerActorTest,
         public ::testing::WithParamInterface<ConstructParams> {};
 
-  INSTANTIATE_TEST_CASE_P(
+  INSTANTIATE_TEST_SUITE_P(
       ConstructFailureMinerActorTestCases,
       ConstructFailureMinerActorTest,
       ::testing::Values(