Description

This application provides ability to validate log file against particular FIX dictionary. Please follow instructions in the configuration file to configure the application.

Directory Contents

Usage

• Run the sample:
  • win: DictionaryValidator.bat
  • linux: DictionaryValidator.sh
• Clean everything:
  • win: clean.bat
  • linux: clean.sh

Source Code

import biz.onixs.fix.dictionary.Version;
import biz.onixs.fix.engine.Engine;
import biz.onixs.fix.parser.Message;
import biz.onixs.fix.parser.MessageValidationFlags;
import biz.onixs.util.settings.PropertyBasedSettings;
import biz.onixs.util.settings.Settings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;

public class DictionaryValidator {
    public static final String VALIDATE_VERSION_KEY = "ValidateVersion";
    public static final String LOG_FILE_TO_VALIDATE_KEY = "LogFileToValidate";
    public static final String VALIDATE_FLAGS_KEY = "ValidateFlags";

    private static final String SETTINGS_RESOURCE = "sample/DictionaryValidator.properties";
    private static final Logger LOG = LoggerFactory.getLogger(DictionaryValidator.class);
    private static Settings settings = null;

    public static class CannotParseLogFileException extends Exception {
        public CannotParseLogFileException(String message) {
            super(message);
        }

        public CannotParseLogFileException(){}
    }

    public static void main(final String[] args) {
        LOG.info("Loading settings from: {}", SETTINGS_RESOURCE);
        settings = new PropertyBasedSettings(SETTINGS_RESOURCE);

        try {
            final Engine engine = Engine.init(settings);

            final String versionName = settings.isDefined(VALIDATE_VERSION_KEY)
                    ? settings.getString(VALIDATE_VERSION_KEY)
                    : null;

            if (versionName == null) {
                LOG.info("Validate messages using suitable version");
            } else {
                LOG.info("Validate against '" + versionName  + "' version");
            }

            Version version = versionName == null
                                        ? null
                                        : Version.getById(versionName);

            if (versionName != null && version == Version.UNKNOWN) {
                throw new IllegalArgumentException("Version '" + versionName + "' is unknown");
            }

            int validationFlags = getValidationFlags(settings.getString(VALIDATE_FLAGS_KEY, ""));

            int numberOfProcessedMessages = parseLogFile(settings.getString(LOG_FILE_TO_VALIDATE_KEY), version, validationFlags);

            System.out.println("Validated " + numberOfProcessedMessages + " message(s)");

        } catch(Exception e) {
            LOG.error(e.getMessage());
        }
    }

    private static int parseLogFile(String logFileToValidate, Version version, int validationFlags) throws Exception {
        int lineCounter = 0;
        Path path = Paths.get(logFileToValidate);
        LOG.info("Validating file '" + path.toFile().getAbsolutePath() + "'");
        try(Stream<String> stream = Files.lines(path)) {
            for(String line : (Iterable<String>) stream::iterator) {
                ++lineCounter;

                if (0 == line.length()) {
                    continue;
                }

                String fixMessage = getFixMessage(logFileToValidate, line, lineCounter);

                try
                {
                    Message message = null;

                    if (null == version)
                    {
                        message = new Message(fixMessage);
                    }
                    else
                    {
                        message = new Message(version, fixMessage);
                    }

                    message.validate(validationFlags);
                }
                catch (Exception e)
                {
                    LOG.error(line);
                    throw e;
                }
            }
        }
        return lineCounter;
    }

    private static int getValidationFlags(String s) throws Exception {
        LOG.info("Use validation flags: " + s);

        if ("".equals(s)) {
            return 0;
        }

        Field[] fields = MessageValidationFlags.class.getDeclaredFields();
        Map<String, Integer> fieldsMap = new HashMap<>();

        for(Field field: fields) {
            if (Modifier.isStatic(field.getModifiers())) {
                fieldsMap.put(field.getName(), (Integer)field.get(MessageValidationFlags.class));
            }
        }

        String names[] = s.split("\\|");

        int result = 0;
        for(String flagName : names) {
            if (fieldsMap.containsKey(flagName)) {
                result |= fieldsMap.get(flagName);
            } else {
                throw new IllegalArgumentException("Unknown flag name: '" + flagName + "'");
            }
        }

        LOG.info("Validation flags numeric value: " + result);
        return result;
    }

    private static String getFixMessage(String logFileToValidate, String line, int lineCounter) throws CannotParseLogFileException {
        int startOfFixMsgIndex = line.indexOf("8=FIX");

        if (-1 == startOfFixMsgIndex) {
            throw new CannotParseLogFileException("Cannot find the start of the FIX message (8=FIX) in line # "
                    + lineCounter
                    + " of " + logFileToValidate);
        }

        String CheckSumTagStr = "10";
        char DelimChar = '\u0001';
        char TagValueSepChar = '=';
        int CheckSumValueLength = 6;

        int startOfCheckSumTag = line.indexOf(DelimChar+CheckSumTagStr+TagValueSepChar, startOfFixMsgIndex);
        if (-1 == startOfCheckSumTag) {
            throw new CannotParseLogFileException("Cannot find the checksum of the FIX message (10=***) in line # "
                    + lineCounter
                    + " of " + logFileToValidate);
        }

        String fixMessage = line.substring(startOfFixMsgIndex, startOfCheckSumTag + CheckSumValueLength + 2);

        return fixMessage;
    }
}