simplifies settings error handling

Author: Chris Busbey

errors.go

@@ -145,8 +145,3 @@ func compIDProblem() MessageRejectError {
 func sendingTimeAccuracyProblem() MessageRejectError {
 	return NewMessageRejectError("SendingTime accuracy problem", rejectReasonSendingTimeAccuracyProblem, nil)
 }
-
-//requiredConfigurationMissing indicates a missing required conditional configuration option.
-func requiredConfigurationMissing(setting string) error {
-	return fmt.Errorf("missing configuration: %v", setting)
-}

file_log.go

@@ -42,15 +42,15 @@ func NewFileLogFactory(settings *Settings) (LogFactory, error) {
 
 	var err error
 	if logFactory.globalLogPath, err = settings.GlobalSettings().Setting(config.FileLogPath); err != nil {
-		return logFactory, requiredConfigurationMissing(config.FileLogPath)
+		return logFactory, err
 	}
 
 	logFactory.sessionLogPaths = make(map[SessionID]string)
 
 	for sid, sessionSettings := range settings.SessionSettings() {
 		logPath, err := sessionSettings.Setting(config.FileLogPath)
 		if err != nil {
-			return logFactory, requiredConfigurationMissing(config.FileLogPath)
+			return logFactory, err
 		}
 		logFactory.sessionLogPaths[sid] = logPath
 	}

filestore.go

@@ -49,7 +49,7 @@ func (f fileStoreFactory) Create(sessionID SessionID) (msgStore MessageStore, er
 	}
 	dirname, err := sessionSettings.Setting(config.FileStorePath)
 	if err != nil {
-		return nil, requiredConfigurationMissing(config.FileStorePath)
+		return nil, err
 	}
 	return newFileStore(sessionID, dirname)
 }

initiator.go

@@ -91,16 +91,16 @@ func NewInitiator(app Application, storeFactory MessageStoreFactory, appSettings
 	for sessionID, s := range i.sessionSettings {
 
 		//fail fast
-		if ok := s.HasSetting(config.SocketConnectHost); !ok {
-			return nil, requiredConfigurationMissing(config.SocketConnectHost)
+		if _, err := s.Setting(config.SocketConnectHost); err != nil {
+			return nil, err
 		}
 
-		if ok := s.HasSetting(config.SocketConnectPort); !ok {
-			return nil, requiredConfigurationMissing(config.SocketConnectPort)
+		if _, err := s.Setting(config.SocketConnectPort); err != nil {
+			return nil, err
 		}
 
-		if ok := s.HasSetting(config.HeartBtInt); !ok {
-			return nil, requiredConfigurationMissing(config.HeartBtInt)
+		if _, err := s.IntSetting(config.HeartBtInt); err != nil {
+			return nil, err
 		}
 
 		session, err := createSession(sessionID, storeFactory, s, logFactory, app)

session.go

@@ -102,34 +102,36 @@ func newSession(sessionID SessionID, storeFactory MessageStoreFactory, settings
 
 	if sessionID.IsFIXT() {
 		if session.defaultApplVerID, err = settings.Setting(config.DefaultApplVerID); err != nil {
-			return session, requiredConfigurationMissing(config.DefaultApplVerID)
+			return session, err
 		}
 
 		if applVerID, ok := applVerIDLookup[session.defaultApplVerID]; ok {
 			session.defaultApplVerID = applVerID
 		}
 
 		//If the transport or app data dictionary setting is set, the other also needs to be set.
-		hasTransportDataDictionary := settings.HasSetting(config.TransportDataDictionary)
-		hasAppDataDictionary := settings.HasSetting(config.AppDataDictionary)
-		if hasTransportDataDictionary && hasAppDataDictionary {
-			transportDataDictionaryPath, _ := settings.Setting(config.TransportDataDictionary)
+		if settings.HasSetting(config.TransportDataDictionary) || settings.HasSetting(config.AppDataDictionary) {
+			transportDataDictionaryPath, err := settings.Setting(config.TransportDataDictionary)
+			if err != nil {
+				return session, err
+			}
+
 			transportDataDictionary, err := datadictionary.Parse(transportDataDictionaryPath)
 			if err != nil {
 				return session, err
 			}
 
-			appDataDictionaryPath, _ := settings.Setting(config.AppDataDictionary)
+			appDataDictionaryPath, err := settings.Setting(config.AppDataDictionary)
+			if err != nil {
+				return session, err
+			}
+
 			appDataDictionary, err := datadictionary.Parse(appDataDictionaryPath)
 			if err != nil {
 				return session, err
 			}
 
 			session.validator = &fixtValidator{transportDataDictionary, appDataDictionary, validatorSettings}
-		} else if hasTransportDataDictionary {
-			return session, requiredConfigurationMissing(config.AppDataDictionary)
-		} else if hasAppDataDictionary {
-			return session, requiredConfigurationMissing(config.TransportDataDictionary)
 		}
 	} else {
 		var dataDictionary *datadictionary.DataDictionary
@@ -170,10 +172,7 @@ func newSession(sessionID SessionID, storeFactory MessageStoreFactory, settings
 		}
 	}
 
-	switch {
-	case !settings.HasSetting(config.StartTime) && !settings.HasSetting(config.EndTime):
-	//no session times
-	case settings.HasSetting(config.StartTime) && settings.HasSetting(config.EndTime):
+	if settings.HasSetting(config.StartTime) || settings.HasSetting(config.EndTime) {
 		var startTimeStr, endTimeStr string
 		if startTimeStr, err = settings.Setting(config.StartTime); err != nil {
 			return session, err
@@ -185,12 +184,12 @@ func newSession(sessionID SessionID, storeFactory MessageStoreFactory, settings
 
 		start, err := internal.ParseTimeOfDay(startTimeStr)
 		if err != nil {
-			return session, err
+			return session, IncorrectFormatForSetting{Setting: config.StartTime, Value: startTimeStr, Err: err}
 		}
 
 		end, err := internal.ParseTimeOfDay(endTimeStr)
 		if err != nil {
-			return session, err
+			return session, IncorrectFormatForSetting{Setting: config.EndTime, Value: endTimeStr, Err: err}
 		}
 
 		loc := time.UTC
@@ -202,15 +201,13 @@ func newSession(sessionID SessionID, storeFactory MessageStoreFactory, settings
 
 			loc, err = time.LoadLocation(locStr)
 			if err != nil {
-				return session, err
+				return session, IncorrectFormatForSetting{Setting: config.TimeZone, Value: locStr, Err: err}
 			}
 		}
 
-		switch {
-		case !settings.HasSetting(config.StartDay) && !settings.HasSetting(config.EndDay):
+		if !settings.HasSetting(config.StartDay) && !settings.HasSetting(config.EndDay) {
 			session.sessionTime = internal.NewTimeRangeInLocation(start, end, loc)
-
-		case settings.HasSetting(config.StartDay) && settings.HasSetting(config.EndDay):
+		} else {
 			var startDayStr, endDayStr string
 			if startDayStr, err = settings.Setting(config.StartDay); err != nil {
 				return session, err
@@ -220,35 +217,26 @@ func newSession(sessionID SessionID, storeFactory MessageStoreFactory, settings
 				return session, err
 			}
 
-			parseDay := func(dayStr string) (day time.Weekday, err error) {
+			parseDay := func(setting, dayStr string) (day time.Weekday, err error) {
 				day, ok := dayLookup[dayStr]
 				if !ok {
-					err = fmt.Errorf("Cannot parse %v", dayStr)
+					return day, IncorrectFormatForSetting{Setting: setting, Value: dayStr}
 				}
 				return
 			}
 
-			startDay, err := parseDay(startDayStr)
+			startDay, err := parseDay(config.StartDay, startDayStr)
 			if err != nil {
 				return session, err
 			}
 
-			endDay, err := parseDay(endDayStr)
+			endDay, err := parseDay(config.EndDay, endDayStr)
 			if err != nil {
 				return session, err
 			}
 
 			session.sessionTime = internal.NewWeekRangeInLocation(start, end, startDay, endDay, loc)
-		case settings.HasSetting(config.StartDay):
-			return session, requiredConfigurationMissing(config.EndDay)
-		case settings.HasSetting(config.EndDay):
-			return session, requiredConfigurationMissing(config.StartDay)
 		}
-
-	case settings.HasSetting(config.StartTime):
-		return session, requiredConfigurationMissing(config.EndTime)
-	case settings.HasSetting(config.EndTime):
-		return session, requiredConfigurationMissing(config.StartTime)
 	}
 
 	if session.log, err = logFactory.CreateSessionLog(session.sessionID); err != nil {

session_settings.go

@@ -1,7 +1,6 @@
 package quickfix
 
 import (
-	"errors"
 	"fmt"
 	"strconv"
 	"time"
@@ -12,6 +11,25 @@ type SessionSettings struct {
 	settings map[string]string
 }
 
+//ConditionallyRequiredSetting indicates a missing setting
+type ConditionallyRequiredSetting struct {
+	Setting string
+}
+
+func (e ConditionallyRequiredSetting) Error() string {
+	return fmt.Sprintf("Conditionally Required Setting: %v", e.Setting)
+}
+
+//IncorrectFormatForSetting indicates a setting that is incorrectly formatted
+type IncorrectFormatForSetting struct {
+	Setting, Value string
+	Err            error
+}
+
+func (e IncorrectFormatForSetting) Error() string {
+	return fmt.Sprintf("%q is invalid for %s", e.Value, e.Setting)
+}
+
 //Init initializes or resets SessionSettings
 func (s *SessionSettings) Init() {
 	s.settings = make(map[string]string)
@@ -45,32 +63,41 @@ func (s *SessionSettings) HasSetting(setting string) bool {
 func (s *SessionSettings) Setting(setting string) (string, error) {
 	val, ok := s.settings[setting]
 	if !ok {
-		return val, errors.New("setting not found")
+		return val, ConditionallyRequiredSetting{setting}
 	}
 
 	return val, nil
 }
 
 //IntSetting returns the requested setting parsed as an int.  Returns an errror if the setting is not set or cannot be parsed as an int.
-func (s *SessionSettings) IntSetting(setting string) (int, error) {
+func (s *SessionSettings) IntSetting(setting string) (val int, err error) {
 	stringVal, err := s.Setting(setting)
 
 	if err != nil {
-		return 0, err
+		return
+	}
+
+	if val, err = strconv.Atoi(stringVal); err != nil {
+		return val, IncorrectFormatForSetting{Setting: setting, Value: stringVal, Err: err}
 	}
 
-	return strconv.Atoi(stringVal)
+	return
 }
 
-//DurationSetting returns the requested setting parsed as a time.Duration.  Returns an error if the setting is not set or cannot be parsed as a time.Duration.
+//DurationSetting returns the requested setting parsed as a time.Duration.
+//Returns an error if the setting is not set or cannot be parsed as a time.Duration.
 func (s *SessionSettings) DurationSetting(setting string) (val time.Duration, err error) {
 	stringVal, err := s.Setting(setting)
 
 	if err != nil {
 		return
 	}
 
-	return time.ParseDuration(stringVal)
+	if val, err = time.ParseDuration(stringVal); err != nil {
+		return val, IncorrectFormatForSetting{Setting: setting, Value: stringVal, Err: err}
+	}
+
+	return
 }
 
 //BoolSetting returns the requested setting parsed as a boolean.  Returns an errror if the setting is not set or cannot be parsed as a bool.
@@ -81,15 +108,14 @@ func (s SessionSettings) BoolSetting(setting string) (bool, error) {
 		return false, err
 	}
 
-	if stringVal == "Y" || stringVal == "y" {
+	switch stringVal {
+	case "Y", "y":
 		return true, nil
-	}
-
-	if stringVal == "N" || stringVal == "n" {
+	case "N", "n":
 		return false, nil
 	}
 
-	return false, fmt.Errorf("%v cannot be parsed as a bool", stringVal)
+	return false, IncorrectFormatForSetting{Setting: setting, Value: stringVal}
 }
 
 func (s *SessionSettings) overlay(overlay *SessionSettings) {