implement src/dst-noack mode using StrategyCfg to set the flags

Signed-off-by: Masanori Yoshida <[email protected]>
hyperledger-labs · Aug 16, 2023 · 58c7c29 · 58c7c29
1 parent 30449b9
commit 58c7c29
Show file tree

Hide file tree

Showing 3 changed files with 78 additions and 52 deletions.
diff --git a/core/naive-strategy.go b/core/naive-strategy.go
@@ -16,12 +16,17 @@ type NaiveStrategy struct {
 	Ordered      bool
 	MaxTxSize    uint64 // maximum permitted size of the msgs in a bundled relay transaction
 	MaxMsgLength uint64 // maximum amount of messages in a bundled relay transaction
+	srcNoAck     bool
+	dstNoAck     bool
 }
 
 var _ StrategyI = (*NaiveStrategy)(nil)
 
-func NewNaiveStrategy() *NaiveStrategy {
-	return &NaiveStrategy{}
+func NewNaiveStrategy(srcNoAck, dstNoAck bool) *NaiveStrategy {
+	return &NaiveStrategy{
+		srcNoAck: srcNoAck,
+		dstNoAck: dstNoAck,
+	}
 }
 
 // GetType implements Strategy
@@ -220,27 +225,31 @@ func (st NaiveStrategy) UnrelayedAcknowledgements(src, dst *ProvableChain, sh Sy
 		return nil, err
 	}
 
-	eg.Go(func() error {
-		return retry.Do(func() error {
-			var err error
-			srcAcks, err = src.QueryUnfinalizedRelayAcknowledgements(srcCtx, dst)
-			return err
-		}, rtyAtt, rtyDel, rtyErr, retry.OnRetry(func(n uint, err error) {
-			log.Printf("- [%s]@{%d} - try(%d/%d) query packet acknowledgements: %s", src.ChainID(), srcCtx.Height().GetRevisionHeight(), n+1, rtyAttNum, err)
-			sh.Updates(src, dst)
-		}))
-	})
+	if !st.dstNoAck {
+		eg.Go(func() error {
+			return retry.Do(func() error {
+				var err error
+				srcAcks, err = src.QueryUnfinalizedRelayAcknowledgements(srcCtx, dst)
+				return err
+			}, rtyAtt, rtyDel, rtyErr, retry.OnRetry(func(n uint, err error) {
+				log.Printf("- [%s]@{%d} - try(%d/%d) query packet acknowledgements: %s", src.ChainID(), srcCtx.Height().GetRevisionHeight(), n+1, rtyAttNum, err)
+				sh.Updates(src, dst)
+			}))
+		})
+	}
 
-	eg.Go(func() error {
-		return retry.Do(func() error {
-			var err error
-			dstAcks, err = dst.QueryUnfinalizedRelayAcknowledgements(dstCtx, src)
-			return err
-		}, rtyAtt, rtyDel, rtyErr, retry.OnRetry(func(n uint, err error) {
-			log.Printf("- [%s]@{%d} - try(%d/%d) query packet acknowledgements: %s", dst.ChainID(), dstCtx.Height().GetRevisionHeight(), n+1, rtyAttNum, err)
-			sh.Updates(src, dst)
-		}))
-	})
+	if !st.srcNoAck {
+		eg.Go(func() error {
+			return retry.Do(func() error {
+				var err error
+				dstAcks, err = dst.QueryUnfinalizedRelayAcknowledgements(dstCtx, src)
+				return err
+			}, rtyAtt, rtyDel, rtyErr, retry.OnRetry(func(n uint, err error) {
+				log.Printf("- [%s]@{%d} - try(%d/%d) query packet acknowledgements: %s", dst.ChainID(), dstCtx.Height().GetRevisionHeight(), n+1, rtyAttNum, err)
+				sh.Updates(src, dst)
+			}))
+		})
+	}
 
 	if err := eg.Wait(); err != nil {
 		return nil, err
@@ -259,23 +268,27 @@ func (st NaiveStrategy) UnrelayedAcknowledgements(src, dst *ProvableChain, sh Sy
 			return nil, err
 		}
 
-		eg.Go(func() error {
-			seqs, err := dst.QueryUnreceivedAcknowledgements(dstCtx, srcAcks.ExtractSequenceList())
-			if err != nil {
-				return err
-			}
-			srcAcks = srcAcks.Filter(seqs)
-			return nil
-		})
+		if !st.dstNoAck {
+			eg.Go(func() error {
+				seqs, err := dst.QueryUnreceivedAcknowledgements(dstCtx, srcAcks.ExtractSequenceList())
+				if err != nil {
+					return err
+				}
+				srcAcks = srcAcks.Filter(seqs)
+				return nil
+			})
+		}
 
-		eg.Go(func() error {
-			seqs, err := src.QueryUnreceivedAcknowledgements(srcCtx, dstAcks.ExtractSequenceList())
-			if err != nil {
-				return err
-			}
-			dstAcks = dstAcks.Filter(seqs)
-			return nil
-		})
+		if !st.srcNoAck {
+			eg.Go(func() error {
+				seqs, err := src.QueryUnreceivedAcknowledgements(srcCtx, dstAcks.ExtractSequenceList())
+				if err != nil {
+					return err
+				}
+				dstAcks = dstAcks.Filter(seqs)
+				return nil
+			})
+		}
 
 		if err := eg.Wait(); err != nil {
 			return nil, err
@@ -330,7 +343,7 @@ func (st NaiveStrategy) RelayAcknowledgements(src, dst *ProvableChain, rp *Relay
 		return err
 	}
 
-	if len(rp.Src) > 0 {
+	if !st.dstNoAck && len(rp.Src) > 0 {
 		hs, err := sh.SetupHeadersForUpdate(src, dst)
 		if err != nil {
 			return err
@@ -340,7 +353,7 @@ func (st NaiveStrategy) RelayAcknowledgements(src, dst *ProvableChain, rp *Relay
 		}
 	}
 
-	if len(rp.Dst) > 0 {
+	if !st.srcNoAck && len(rp.Dst) > 0 {
 		hs, err := sh.SetupHeadersForUpdate(dst, src)
 		if err != nil {
 			return err
@@ -350,13 +363,18 @@ func (st NaiveStrategy) RelayAcknowledgements(src, dst *ProvableChain, rp *Relay
 		}
 	}
 
-	acksForDst, err := collectAcks(srcCtx, src, rp.Src, dstAddress)
-	if err != nil {
-		return err
+	var acksForSrc, acksForDst []sdk.Msg
+	if !st.dstNoAck {
+		acksForDst, err = collectAcks(srcCtx, src, rp.Src, dstAddress)
+		if err != nil {
+			return err
+		}
 	}
-	acksForSrc, err := collectAcks(dstCtx, dst, rp.Dst, srcAddress)
-	if err != nil {
-		return err
+	if !st.srcNoAck {
+		acksForSrc, err = collectAcks(dstCtx, dst, rp.Dst, srcAddress)
+		if err != nil {
+			return err
+		}
 	}
 
 	if len(acksForDst) == 0 && len(acksForSrc) == 0 {

diff --git a/core/path.go b/core/path.go
@@ -141,7 +141,7 @@ func (p *Path) Validate() (err error) {
 	if err = p.Dst.Validate(); err != nil {
 		return err
 	}
-	if _, err = p.GetStrategy(); err != nil {
+	if err = p.ValidateStrategy(); err != nil {
 		return err
 	}
 	if p.Src.Order != p.Dst.Order {

diff --git a/core/strategies.go b/core/strategies.go
@@ -31,23 +31,31 @@ type StrategyI interface {
 // StrategyCfg defines which relaying strategy to take for a given path
 type StrategyCfg struct {
 	Type string `json:"type" yaml:"type"`
+
+	// If set, executions of acknowledgePacket are always skipped on the src chain.
+	// Also `UnrelayedAcknowledgements` returns zero packets for the src chain.
+	SrcNoack bool `json:"src-noack" yaml:"src-noack"`
+
+	// If set, executions of acknowledgePacket are always skipped on the dst chain
+	// Also `UnrelayedAcknowledgements` returns zero packets for the dst chain.
+	DstNoack bool `json:"dst-noack" yaml:"dst-noack"`
 }
 
 func GetStrategy(cfg StrategyCfg) (StrategyI, error) {
 	switch cfg.Type {
 	case "naive":
-		return NewNaiveStrategy(), nil
+		return NewNaiveStrategy(cfg.SrcNoack, cfg.DstNoack), nil
 	default:
 		return nil, fmt.Errorf("unknown strategy type '%v'", cfg.Type)
 	}
 }
 
-// GetStrategy the strategy defined in the relay messages
-func (p *Path) GetStrategy() (StrategyI, error) {
+// ValidateStrategy validates that the strategy of path `p` is valid
+func (p *Path) ValidateStrategy() error {
 	switch p.Strategy.Type {
 	case (&NaiveStrategy{}).GetType():
-		return &NaiveStrategy{}, nil
+		return nil
 	default:
-		return nil, fmt.Errorf("invalid strategy: %s", p.Strategy.Type)
+		return fmt.Errorf("invalid strategy: %s", p.Strategy.Type)
 	}
 }