add logic to block messages when a rResend Request is active

Author: hlibman-connamara

in_session.go

@@ -210,6 +210,7 @@ func (state inSession) handleResendRequest(session *session, msg *Message) (next
 	if err := state.resendMessages(session, int(beginSeqNo), endSeqNo, *msg); err != nil {
 		return handleStateError(session, err)
 	}
+	session.isResendRequestActive = false
 
 	if err := session.checkTargetTooLow(msg); err != nil {
 		return state
@@ -281,6 +282,7 @@ func (state inSession) resendMessages(session *session, beginSeqNo, endSeqNo int
 }
 
 func (state inSession) processReject(session *session, msg *Message, rej MessageRejectError) sessionState {
+	session.isResendRequestActive = false
 	switch TypedError := rej.(type) {
 	case targetTooHigh:
 

in_session_test.go

@@ -373,6 +373,26 @@ func (s *InSessionTestSuite) TestFIXMsgInResendRequestDoNotSendApp() {
 	s.State(inSession{})
 }
 
+func (s *InSessionTestSuite) TestIsResendRequestActive() {
+	s.MockApp.On("FromAdmin").Return(nil)
+	s.MockApp.On("ToApp").Return(nil)
+	s.MockApp.On("ToAdmin")
+	s.sendResendRequest(5, 10)
+	s.True(s.isResendRequestActive)
+
+	nos := s.NewOrderSingle()
+	err := s.session.sendInReplyTo(nos, nil)
+
+	s.Error(err)
+	s.EqualError(err, "cannot send message while resend request is active")
+	s.fixMsgIn(s.session, s.ResendRequest(5))
+	s.False(s.isResendRequestActive)
+
+	err = s.session.sendInReplyTo(nos, nil)
+
+	s.NoError(err)
+}
+
 func (s *InSessionTestSuite) TestFIXMsgInTargetTooLow() {
 	s.IncrNextTargetMsgSeqNum()
 

session.go

@@ -52,6 +52,8 @@ type session struct {
 	sentReset  bool
 	stopOnce   sync.Once
 
+	isResendRequestActive bool
+
 	targetDefaultApplVerID string
 
 	admin chan interface{}
@@ -305,6 +307,12 @@ func (s *session) sendInReplyTo(msg *Message, inReplyTo *Message) error {
 	s.sendMutex.Lock()
 	defer s.sendMutex.Unlock()
 
+	if blocked, err := s.isResendRequestBlocking(msg); err != nil {
+		return err
+	} else if blocked {
+		return nil
+	}
+
 	msgBytes, err := s.prepMessageForSend(msg, inReplyTo)
 	if err != nil {
 		return err
@@ -316,6 +324,20 @@ func (s *session) sendInReplyTo(msg *Message, inReplyTo *Message) error {
 	return nil
 }
 
+func (s *session) isResendRequestBlocking(msg *Message) (bool, error) {
+	msgType, err := msg.Header.GetBytes(tagMsgType)
+	if err != nil {
+		return false, err
+	}
+
+	if s.isResendRequestActive && !bytes.Equal(msgType, msgTypeResendRequest) {
+		s.log.OnEvent("Message blocked: resend request in progress")
+		return true, errors.New("cannot send message while resend request is active")
+	}
+
+	return false, nil
+}
+
 // dropAndReset will drop the send queue and reset the message store.
 func (s *session) dropAndReset() error {
 	s.sendMutex.Lock()
@@ -477,6 +499,7 @@ func (s *session) sendResendRequest(beginSeq, endSeq int) (nextState resendState
 		return
 	}
 	s.log.OnEventf("Sent ResendRequest FROM: %v TO: %v", beginSeq, endSeqNo)
+	s.isResendRequestActive = true
 
 	return
 }