Merge pull request quickfixgo#387 from ackleymi/master

Adds LogoutTimeout and LogonTimeout as config parameters

Author: cbusbey

config/configuration.go

@@ -42,6 +42,8 @@ const (
 	ResetOnLogout                string = "ResetOnLogout"
 	ResetOnDisconnect            string = "ResetOnDisconnect"
 	ReconnectInterval            string = "ReconnectInterval"
+	LogoutTimeout                string = "LogoutTimeout"
+	LogonTimeout                 string = "LogonTimeout"
 	HeartBtInt                   string = "HeartBtInt"
 	FileLogPath                  string = "FileLogPath"
 	FileStorePath                string = "FileStorePath"

config/doc.go

@@ -230,6 +230,18 @@ Time between reconnection attempts in seconds. Only used for initiators.    Valu
 
 Defaults to 30
 
+LogoutTimeout
+
+Session setting for logout timeout in seconds. Only used for initiators. Value must be positive integer.
+
+Defaults to 2
+
+LogonTimeout
+
+Session setting for logon timeout in seconds. Only used for initiators. Value must be positive integer.
+
+Defaults to 10
+
 HeartBtInt
 
 Heartbeat interval in seconds. Only used for initiators.	Value must be positive integer.

internal/session_settings.go

@@ -22,5 +22,7 @@ type SessionSettings struct {
 
 	//specific to initiators
 	ReconnectInterval    time.Duration
+	LogoutTimeout        time.Duration
+	LogonTimeout         time.Duration
 	SocketConnectAddress []string
 }

session.go

@@ -465,8 +465,7 @@ func (s *session) initiateLogoutInReplyTo(reason string, inReplyTo *Message) (er
 		return
 	}
 	s.log.OnEvent("Inititated logout request")
-	time.AfterFunc(time.Duration(2)*time.Second, func() { s.sessionEvent <- internal.LogoutTimeout })
-
+	time.AfterFunc(s.LogoutTimeout, func() { s.sessionEvent <- internal.LogoutTimeout })
 	return
 }
 

session_factory.go

@@ -331,6 +331,36 @@ func (f sessionFactory) buildInitiatorSettings(session *session, settings *Sessi
 		session.ReconnectInterval = time.Duration(interval) * time.Second
 	}
 
+	session.LogoutTimeout = 2 * time.Second
+	if settings.HasSetting(config.LogoutTimeout) {
+
+		timeout, err := settings.IntSetting(config.LogoutTimeout)
+		if err != nil {
+			return err
+		}
+
+		if timeout <= 0 {
+			return errors.New("LogoutTimeout must be greater than zero")
+		}
+
+		session.LogoutTimeout = time.Duration(timeout) * time.Second
+	}
+
+	session.LogonTimeout = 10 * time.Second
+	if settings.HasSetting(config.LogonTimeout) {
+
+		timeout, err := settings.IntSetting(config.LogonTimeout)
+		if err != nil {
+			return err
+		}
+
+		if timeout <= 0 {
+			return errors.New("LogonTimeout must be greater than zero")
+		}
+
+		session.LogonTimeout = time.Duration(timeout) * time.Second
+	}
+
 	return f.configureSocketConnectAddress(session, settings)
 }
 

session_factory_test.go

@@ -353,6 +353,8 @@ func (s *SessionFactorySuite) TestNewSessionBuildInitiators() {
 	s.True(session.InitiateLogon)
 	s.Equal(34*time.Second, session.HeartBtInt)
 	s.Equal(30*time.Second, session.ReconnectInterval)
+	s.Equal(10*time.Second, session.LogonTimeout)
+	s.Equal(2*time.Second, session.LogoutTimeout)
 	s.Equal("127.0.0.1:5000", session.SocketConnectAddress[0])
 }
 
@@ -399,6 +401,54 @@ func (s *SessionFactorySuite) TestNewSessionBuildInitiatorsValidReconnectInterva
 	s.NotNil(err, "ReconnectInterval must be greater than zero")
 }
 
+func (s *SessionFactorySuite) TestNewSessionBuildInitiatorsValidLogoutTimeout() {
+	s.sessionFactory.BuildInitiators = true
+	s.SessionSettings.Set(config.HeartBtInt, "34")
+	s.SessionSettings.Set(config.SocketConnectHost, "127.0.0.1")
+	s.SessionSettings.Set(config.SocketConnectPort, "3000")
+
+	s.SessionSettings.Set(config.LogoutTimeout, "45")
+	session, err := s.newSession(s.SessionID, s.MessageStoreFactory, s.SessionSettings, s.LogFactory, s.App)
+	s.Nil(err)
+	s.Equal(45*time.Second, session.LogoutTimeout)
+
+	s.SessionSettings.Set(config.LogoutTimeout, "not a number")
+	_, err = s.newSession(s.SessionID, s.MessageStoreFactory, s.SessionSettings, s.LogFactory, s.App)
+	s.NotNil(err, "LogoutTimeout must be a number")
+
+	s.SessionSettings.Set(config.LogoutTimeout, "0")
+	_, err = s.newSession(s.SessionID, s.MessageStoreFactory, s.SessionSettings, s.LogFactory, s.App)
+	s.NotNil(err, "LogoutTimeout must be greater than zero")
+
+	s.SessionSettings.Set(config.LogoutTimeout, "-20")
+	_, err = s.newSession(s.SessionID, s.MessageStoreFactory, s.SessionSettings, s.LogFactory, s.App)
+	s.NotNil(err, "LogoutTimeout must be greater than zero")
+}
+
+func (s *SessionFactorySuite) TestNewSessionBuildInitiatorsValidLogonTimeout() {
+	s.sessionFactory.BuildInitiators = true
+	s.SessionSettings.Set(config.HeartBtInt, "34")
+	s.SessionSettings.Set(config.SocketConnectHost, "127.0.0.1")
+	s.SessionSettings.Set(config.SocketConnectPort, "3000")
+
+	s.SessionSettings.Set(config.LogonTimeout, "45")
+	session, err := s.newSession(s.SessionID, s.MessageStoreFactory, s.SessionSettings, s.LogFactory, s.App)
+	s.Nil(err)
+	s.Equal(45*time.Second, session.LogonTimeout)
+
+	s.SessionSettings.Set(config.LogonTimeout, "not a number")
+	_, err = s.newSession(s.SessionID, s.MessageStoreFactory, s.SessionSettings, s.LogFactory, s.App)
+	s.NotNil(err, "LogonTimeout must be a number")
+
+	s.SessionSettings.Set(config.LogonTimeout, "0")
+	_, err = s.newSession(s.SessionID, s.MessageStoreFactory, s.SessionSettings, s.LogFactory, s.App)
+	s.NotNil(err, "LogonTimeout must be greater than zero")
+
+	s.SessionSettings.Set(config.LogonTimeout, "-20")
+	_, err = s.newSession(s.SessionID, s.MessageStoreFactory, s.SessionSettings, s.LogFactory, s.App)
+	s.NotNil(err, "LogonTimeout must be greater than zero")
+}
+
 func (s *SessionFactorySuite) TestConfigureSocketConnectAddress() {
 	sess := new(session)
 	err := s.configureSocketConnectAddress(sess, s.SessionSettings)

session_state.go

@@ -28,22 +28,27 @@ func (sm *stateMachine) Connect(session *session) {
 		return
 	}
 
-	if session.InitiateLogon {
-		if session.RefreshOnLogon {
-			if err := session.store.Refresh(); err != nil {
-				session.logError(err)
-				return
-			}
-		}
+	// No special logon logic needed for FIX Acceptors.
+	if !session.InitiateLogon {
+		sm.setState(session, logonState{})
+		return
+	}
 
-		session.log.OnEvent("Sending logon request")
-		if err := session.sendLogon(); err != nil {
+	if session.RefreshOnLogon {
+		if err := session.store.Refresh(); err != nil {
 			session.logError(err)
 			return
 		}
 	}
+	session.log.OnEvent("Sending logon request")
+	if err := session.sendLogon(); err != nil {
+		session.logError(err)
+		return
+	}
 
 	sm.setState(session, logonState{})
+	// Fire logon timeout event after the pre-configured delay period.
+	time.AfterFunc(session.LogonTimeout, func() { session.sessionEvent <- internal.LogonTimeout })
 }
 
 func (sm *stateMachine) Stop(session *session) {