update logic to fix failing tests

Author: hlibman-connamara

in_session.go

@@ -208,6 +208,7 @@ func (state inSession) handleResendRequest(session *session, msg *Message) (next
 	}
 
 	if err := state.resendMessages(session, int(beginSeqNo), endSeqNo, *msg); err != nil {
+		session.isResendRequestActive = false
 		return handleStateError(session, err)
 	}
 	session.isResendRequestActive = false
@@ -282,7 +283,6 @@ 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:
 
@@ -293,7 +293,7 @@ func (state inSession) processReject(session *session, msg *Message, rej Message
 			nextState = currentState
 		default:
 			var err error
-			if nextState, err = session.doTargetTooHigh(TypedError); err != nil {
+			if nextState, err = session.doTargetTooHigh(TypedError, true); err != nil {
 				return handleStateError(session, err)
 			}
 		}

in_session_test.go

@@ -377,18 +377,18 @@ 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.sendResendRequest(5, 10, false)
 	s.True(s.isResendRequestActive)
 
 	nos := s.NewOrderSingle()
-	err := s.session.sendInReplyTo(nos, nil)
+	err := s.session.send(nos)
 
 	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)
+	err = s.session.send(nos)
 
 	s.NoError(err)
 }

logon_state.go

@@ -46,7 +46,7 @@ func (s logonState) FixMsgIn(session *session, msg *Message) (nextState sessionS
 
 		case targetTooHigh:
 			var tooHighErr error
-			if nextState, tooHighErr = session.doTargetTooHigh(err); tooHighErr != nil {
+			if nextState, tooHighErr = session.doTargetTooHigh(err, false); tooHighErr != nil {
 				return shutdownWithReason(session, msg, false, tooHighErr.Error())
 			}
 

resend_state.go

@@ -48,7 +48,7 @@ func (s resendState) FixMsgIn(session *session, msg *Message) (nextState session
 	}
 
 	if s.currentResendRangeEnd != 0 && s.currentResendRangeEnd < session.store.NextTargetMsgSeqNum() {
-		nextResendState, err := session.sendResendRequest(session.store.NextTargetMsgSeqNum(), s.resendRangeEnd)
+		nextResendState, err := session.sendResendRequest(session.store.NextTargetMsgSeqNum(), s.resendRangeEnd, false)
 		if err != nil {
 			return handleStateError(session, err)
 		}
@@ -64,7 +64,7 @@ func (s resendState) FixMsgIn(session *session, msg *Message) (nextState session
 	}
 
 	if bool(gapFillFlag) && s.currentResendRangeEnd != 0 && s.currentResendRangeEnd == session.store.NextTargetMsgSeqNum() {
-		nextResendState, err := session.sendResendRequest(session.store.NextTargetMsgSeqNum(), s.resendRangeEnd)
+		nextResendState, err := session.sendResendRequest(session.store.NextTargetMsgSeqNum(), s.resendRangeEnd, false)
 		if err != nil {
 			return handleStateError(session, err)
 		}

session.go

@@ -297,6 +297,10 @@ func (s *session) notifyMessageOut() {
 
 // send will validate, persist, queue the message. If the session is logged on, send all messages in the queue.
 func (s *session) send(msg *Message) error {
+	if err := s.isResendRequestBlocking(msg); err != nil {
+		return err
+	}
+
 	return s.sendInReplyTo(msg, nil)
 }
 func (s *session) sendInReplyTo(msg *Message, inReplyTo *Message) error {
@@ -307,12 +311,6 @@ 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
@@ -324,18 +322,18 @@ func (s *session) sendInReplyTo(msg *Message, inReplyTo *Message) error {
 	return nil
 }
 
-func (s *session) isResendRequestBlocking(msg *Message) (bool, error) {
+func (s *session) isResendRequestBlocking(msg *Message) error {
 	msgType, err := msg.Header.GetBytes(tagMsgType)
 	if err != nil {
-		return false, err
+		return 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 errors.New("cannot send message while resend request is active")
 	}
 
-	return false, nil
+	return nil
 }
 
 // dropAndReset will drop the send queue and reset the message store.
@@ -465,12 +463,12 @@ func (s *session) sendBytes(msg []byte, blockUntilSent bool) bool {
 	}
 }
 
-func (s *session) doTargetTooHigh(reject targetTooHigh) (nextState resendState, err error) {
+func (s *session) doTargetTooHigh(reject targetTooHigh, isReject bool) (nextState resendState, err error) {
 	s.log.OnEventf("MsgSeqNum too high, expecting %v but received %v", reject.ExpectedTarget, reject.ReceivedTarget)
-	return s.sendResendRequest(reject.ExpectedTarget, reject.ReceivedTarget-1)
+	return s.sendResendRequest(reject.ExpectedTarget, reject.ReceivedTarget-1, isReject)
 }
 
-func (s *session) sendResendRequest(beginSeq, endSeq int) (nextState resendState, err error) {
+func (s *session) sendResendRequest(beginSeq, endSeq int, isReject bool) (nextState resendState, err error) {
 	nextState.resendRangeEnd = endSeq
 
 	resend := NewMessage()
@@ -499,7 +497,9 @@ func (s *session) sendResendRequest(beginSeq, endSeq int) (nextState resendState
 		return
 	}
 	s.log.OnEventf("Sent ResendRequest FROM: %v TO: %v", beginSeq, endSeqNo)
-	s.isResendRequestActive = true
+	if !isReject {
+		s.isResendRequestActive = true
+	}
 
 	return
 }