refactoring

Signed-off-by: Daisuke Kanda <daisuke.kanda@datachain.jp>

Author: Daisuke Kanda

core/mock_chain_test.go

@@ -217,44 +217,44 @@ func (st *NaiveStrategy) ProcessTimeoutPackets(ctx context.Context, src, dst *Pr
 	)
 
 	if 0 < len(rp.Src) {
-		if h, err := dst.LatestHeight(context.TODO()); err != nil {
+		if h, err := dst.LatestHeight(ctx); err != nil {
 			logger.Error("fail to get dst.LatestHeight", err)
 			return nil, err
 		} else {
 			dstLatestHeight = h
 		}
 
-		if t, err := dst.Timestamp(context.TODO(), dstLatestHeight); err != nil {
-			logger.Error("fail to get dst.Timestamp", err)
+		if t, err := dst.Timestamp(ctx, dstLatestHeight); err != nil {
+			logger.Error("fail to get dst.Timestamp of latestHeight", err)
 			return nil, err
 		} else {
 			dstLatestTimestamp = uint64(t.UnixNano())
 		}
 
 		dstLatestFinalizedHeight = sh.GetLatestFinalizedHeader(dst.ChainID()).GetHeight()
-		if t, err := dst.Timestamp(context.TODO(), dstLatestFinalizedHeight); err != nil {
-			logger.Error("fail to get dst.Timestamp", err)
+		if t, err := dst.Timestamp(ctx, dstLatestFinalizedHeight); err != nil {
+			logger.Error("fail to get dst.Timestamp of latestFinalizedHeight", err)
 			return nil, err
 		} else {
 			dstLatestFinalizedTimestamp = uint64(t.UnixNano())
 		}
 	}
 	if 0 < len(rp.Dst) {
-		if h, err := src.LatestHeight(context.TODO()); err != nil {
+		if h, err := src.LatestHeight(ctx); err != nil {
 			logger.Error("fail to get src.LatestHeight", err)
 			return nil, err
 		} else {
 			srcLatestHeight = h
 		}
-		if t, err := src.Timestamp(context.TODO(), srcLatestHeight); err != nil {
+		if t, err := src.Timestamp(ctx, srcLatestHeight); err != nil {
 			logger.Error("fail to get src.Timestamp", err)
 			return nil, err
 		} else {
 			srcLatestTimestamp = uint64(t.UnixNano())
 		}
 
 		srcLatestFinalizedHeight = sh.GetLatestFinalizedHeader(src.ChainID()).GetHeight()
-		if t, err := src.Timestamp(context.TODO(), srcLatestFinalizedHeight); err != nil {
+		if t, err := src.Timestamp(ctx, srcLatestFinalizedHeight); err != nil {
 			logger.Error("fail to get src.Timestamp", err)
 			return nil, err
 		} else {
@@ -499,7 +499,6 @@ func (st *NaiveStrategy) UnrelayedAcknowledgements(ctx context.Context, src, dst
 	}, nil
 }
 
-// TODO add packet-timeout support
 func collectPackets(ctx QueryContext, chain *ProvableChain, packets PacketInfoList, signer sdk.AccAddress) ([]sdk.Msg, error) {
 	logger := GetChannelLogger(chain)
 

core/naive-strategy.go

@@ -119,7 +119,7 @@ func (srv *RelayService) Serve(ctx context.Context) error {
 		return err
 	}
 
-	pseqs2, err := srv.st.ProcessTimeoutPackets(ctx, srv.src, srv.dst, srv.sh, pseqs)
+	pseqs, err = srv.st.ProcessTimeoutPackets(ctx, srv.src, srv.dst, srv.sh, pseqs)
 	if err != nil {
 		logger.Error("failed to process timeout packets", err)
 		return err
@@ -134,7 +134,7 @@ func (srv *RelayService) Serve(ctx context.Context) error {
 
 	msgs := NewRelayMsgs()
 
-	doExecuteRelaySrc, doExecuteRelayDst := srv.shouldExecuteRelay(ctx, pseqs2)
+	doExecuteRelaySrc, doExecuteRelayDst := srv.shouldExecuteRelay(ctx, pseqs)
 	doExecuteAckSrc, doExecuteAckDst := srv.shouldExecuteRelay(ctx, aseqs)
 	// update clients
 	if m, err := srv.st.UpdateClients(ctx, srv.src, srv.dst, doExecuteRelaySrc, doExecuteRelayDst, doExecuteAckSrc, doExecuteAckDst, srv.sh, true); err != nil {
@@ -145,7 +145,7 @@ func (srv *RelayService) Serve(ctx context.Context) error {
 	}
 
 	// relay packets if unrelayed seqs exist
-	if m, err := srv.st.RelayPackets(ctx, srv.src, srv.dst, pseqs2, srv.sh, doExecuteRelaySrc, doExecuteRelayDst); err != nil {
+	if m, err := srv.st.RelayPackets(ctx, srv.src, srv.dst, pseqs, srv.sh, doExecuteRelaySrc, doExecuteRelayDst); err != nil {
 		logger.Error("failed to relay packets", err)
 		return err
 	} else {

core/service.go

@@ -314,15 +314,15 @@ func testServe(t *testing.T, tc testCase) {
 	srv := core.NewRelayService(st, src, dst, sh, time.Minute, forever, tc.optimizeCount, forever, tc.optimizeCount)
 
 	srv.Serve(context.TODO())
-	/* for debug
-	fmt.Printf("UnrelayedPackets: %v\n", st.UnrelayedPacketsOut)
-	fmt.Printf("UnrelayedAcknowledgementsOut: %v\n", st.UnrelayedAcknowledgementsOut)
-	fmt.Printf("RelayPacketsOut: %v\n", st.RelayPacketsOut)
-	fmt.Printf("RelayAcknowledgementsOut: %v\n", st.RelayAcknowledgementsOut)
-	fmt.Printf("UpdateClientsOut: %v\n", st.UpdateClientsOut)
-	fmt.Printf("Send.Src: %v\n", st.SendInSrc)
-	fmt.Printf("Send.Dst: %v\n", st.SendInDst)
-	*/
+
+	t.Logf("UnrelayedPackets: %v\n", st.UnrelayedPacketsOut)
+	t.Logf("UnrelayedAcknowledgementsOut: %v\n", st.UnrelayedAcknowledgementsOut)
+	t.Logf("RelayPacketsOut: %v\n", st.RelayPacketsOut)
+	t.Logf("RelayAcknowledgementsOut: %v\n", st.RelayAcknowledgementsOut)
+	t.Logf("UpdateClientsOut: %v\n", st.UpdateClientsOut)
+	t.Logf("Send.Src: %v\n", st.SendInSrc)
+	t.Logf("Send.Dst: %v\n", st.SendInDst)
+
 	assert.Equal(t, tc.ExpectSendSrc, st.SendInSrc, "Send.Src")
 	assert.Equal(t, tc.ExpectSendDst, st.SendInDst, "Send.Dst")
 }

core/service_test.go

@@ -24,7 +24,7 @@ type StrategyI interface {
 	// `includeRelayedButUnfinalized` decides if the result includes packets of which acknowledgePacket has been executed but not finalized
 	UnrelayedAcknowledgements(ctx context.Context, src, dst *ProvableChain, sh SyncHeaders, includeRelayedButUnfinalized bool) (*RelayPackets, error)
 
-	// ProcessTimeoutPackets process timeout packets in given RelayPackets and returns sorted RelayPackets. Note that input Packet object may be modified.
+	// ProcessTimeoutPackets processes timeout packets in given RelayPackets and returns sorted RelayPackets. Note that input Packet object may be modified.
 	ProcessTimeoutPackets(ctx context.Context, src, dst *ProvableChain, sh SyncHeaders, rp *RelayPackets) (*RelayPackets, error)
 
 	// RelayAcknowledgements executes AcknowledgePacket to the packets contained in `rp` on both chains (`src` and `dst`).