From 58c7c29b663b0eb3d61befa50b3a4565ec66d83f Mon Sep 17 00:00:00 2001 From: Masanori Yoshida Date: Wed, 9 Aug 2023 10:31:59 +0900 Subject: [PATCH] implement src/dst-noack mode using `StrategyCfg` to set the flags Signed-off-by: Masanori Yoshida --- core/naive-strategy.go | 110 ++++++++++++++++++++++++----------------- core/path.go | 2 +- core/strategies.go | 18 +++++-- 3 files changed, 78 insertions(+), 52 deletions(-) diff --git a/core/naive-strategy.go b/core/naive-strategy.go index b455bdb5..551e1004 100644 --- 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 index 536aa29e..c9460b00 100644 --- 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 index c76bb5e6..4b8312c0 100644 --- 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) } }