Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.apache.camel.component.quickfixj.QuickfixjEngine Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.camel.component.quickfixj;
import java.io.InputStream;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import javax.management.JMException;
import javax.management.ObjectName;
import org.apache.camel.CamelContext;
import org.apache.camel.support.ResourceHelper;
import org.apache.camel.support.service.ServiceSupport;
import org.apache.camel.util.URISupport;
import org.quickfixj.jmx.JmxExporter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import quickfix.Acceptor;
import quickfix.Application;
import quickfix.ConfigError;
import quickfix.DefaultMessageFactory;
import quickfix.DoNotSend;
import quickfix.FieldConvertError;
import quickfix.FieldNotFound;
import quickfix.FileLogFactory;
import quickfix.FileStoreFactory;
import quickfix.IncorrectDataFormat;
import quickfix.IncorrectTagValue;
import quickfix.Initiator;
import quickfix.JdbcLogFactory;
import quickfix.JdbcSetting;
import quickfix.JdbcStoreFactory;
import quickfix.LogFactory;
import quickfix.MemoryStoreFactory;
import quickfix.Message;
import quickfix.MessageFactory;
import quickfix.MessageStoreFactory;
import quickfix.RejectLogon;
import quickfix.SLF4JLogFactory;
import quickfix.ScreenLogFactory;
import quickfix.Session;
import quickfix.SessionFactory;
import quickfix.SessionID;
import quickfix.SessionSettings;
import quickfix.SleepycatStoreFactory;
import quickfix.SocketAcceptor;
import quickfix.SocketInitiator;
import quickfix.ThreadedSocketAcceptor;
import quickfix.ThreadedSocketInitiator;
import quickfix.UnsupportedMessageType;
/**
* This is a wrapper class that provided QuickFIX/J initialization capabilities beyond those supported in the core
* QuickFIX/J distribution.
*
* Specifically, it infers dependencies on specific implementations of message stores and logs. It also supports
* extended QuickFIX/J settings properties to specify threading models, custom store and log implementations, etc.
*
* The wrapper will create an initiator or acceptor or both depending on the roles of sessions described in the settings
* file.
*/
public class QuickfixjEngine extends ServiceSupport {
public static final String DEFAULT_START_TIME = "00:00:00";
public static final String DEFAULT_END_TIME = "00:00:00";
public static final long DEFAULT_HEARTBTINT = 30;
public static final String SETTING_THREAD_MODEL = "ThreadModel";
public static final String SETTING_USE_JMX = "UseJmx";
private static final Logger LOG = LoggerFactory.getLogger(QuickfixjEngine.class);
private Acceptor acceptor;
private Initiator initiator;
private JmxExporter jmxExporter;
private MessageStoreFactory messageStoreFactory;
private LogFactory sessionLogFactory;
private MessageFactory messageFactory;
private final MessageCorrelator messageCorrelator = new MessageCorrelator();
private final List eventListeners = new CopyOnWriteArrayList<>();
private final String uri;
private ObjectName acceptorObjectName;
private ObjectName initiatorObjectName;
private final SessionSettings settings;
private final AtomicBoolean initialized = new AtomicBoolean();
private final boolean lazy;
private final AtomicInteger refCount = new AtomicInteger();
public enum ThreadModel {
ThreadPerConnector,
ThreadPerSession;
}
public QuickfixjEngine(CamelContext camelContext, String uri, String settingsResourceName) throws Exception {
this(camelContext, uri, settingsResourceName, null, null, null);
}
public QuickfixjEngine(CamelContext camelContext, String uri, String settingsResourceName,
MessageStoreFactory messageStoreFactoryOverride,
LogFactory sessionLogFactoryOverride,
MessageFactory messageFactoryOverride) throws Exception {
this(uri, loadSettings(camelContext, settingsResourceName), messageStoreFactoryOverride,
sessionLogFactoryOverride,
messageFactoryOverride);
}
public QuickfixjEngine(String uri, SessionSettings settings,
MessageStoreFactory messageStoreFactoryOverride,
LogFactory sessionLogFactoryOverride,
MessageFactory messageFactoryOverride) throws Exception {
this(uri, settings, messageStoreFactoryOverride, sessionLogFactoryOverride, messageFactoryOverride,
false);
}
public QuickfixjEngine(String uri, SessionSettings settings,
MessageStoreFactory messageStoreFactoryOverride,
LogFactory sessionLogFactoryOverride,
MessageFactory messageFactoryOverride,
boolean lazy) throws Exception {
addEventListener(messageCorrelator);
this.uri = URISupport.sanitizeUri(uri);
this.lazy = lazy;
this.settings = settings;
// overrides
if (messageFactoryOverride != null) {
messageFactory = messageFactoryOverride;
}
if (sessionLogFactoryOverride != null) {
sessionLogFactory = sessionLogFactoryOverride;
}
if (messageStoreFactoryOverride != null) {
messageStoreFactory = messageStoreFactoryOverride;
}
if (!lazy) {
initializeEngine();
}
}
public int incRefCount() {
return refCount.incrementAndGet();
}
public int decRefCount() {
return refCount.decrementAndGet();
}
/**
* Initializes the engine on demand. May be called immediately in constructor or when needed. If initializing later,
* it should be started afterwards.
*/
void initializeEngine()
throws ConfigError,
FieldConvertError, JMException {
LOG.debug("Initializing QuickFIX/J Engine: {}", uri);
if (messageFactory == null) {
messageFactory = new DefaultMessageFactory();
}
if (sessionLogFactory == null) {
sessionLogFactory = inferLogFactory(settings);
}
if (messageStoreFactory == null) {
messageStoreFactory = inferMessageStoreFactory(settings);
}
// Set default session schedule if not specified in configuration
if (!settings.isSetting(Session.SETTING_START_TIME)) {
settings.setString(Session.SETTING_START_TIME, DEFAULT_START_TIME);
}
if (!settings.isSetting(Session.SETTING_END_TIME)) {
settings.setString(Session.SETTING_END_TIME, DEFAULT_END_TIME);
}
// Default heartbeat interval
if (!settings.isSetting(Session.SETTING_HEARTBTINT)) {
settings.setLong(Session.SETTING_HEARTBTINT, DEFAULT_HEARTBTINT);
}
// Allow specification of the QFJ threading model
ThreadModel threadModel = ThreadModel.ThreadPerConnector;
if (settings.isSetting(SETTING_THREAD_MODEL)) {
threadModel = ThreadModel.valueOf(settings.getString(SETTING_THREAD_MODEL));
}
if (settings.isSetting(SETTING_USE_JMX) && settings.getBool(SETTING_USE_JMX)) {
LOG.info("Enabling JMX for QuickFIX/J");
jmxExporter = new JmxExporter();
} else {
jmxExporter = null;
}
// From original component implementation...
// To avoid this exception in OSGi platform
// java.lang.NoClassDefFoundError: quickfix/fix41/MessageFactory
ClassLoader ccl = Thread.currentThread().getContextClassLoader();
try {
Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
if (isConnectorRole(settings, SessionFactory.ACCEPTOR_CONNECTION_TYPE)) {
acceptor = createAcceptor(new Dispatcher(), settings, messageStoreFactory,
sessionLogFactory, messageFactory, threadModel);
} else {
acceptor = null;
}
if (isConnectorRole(settings, SessionFactory.INITIATOR_CONNECTION_TYPE)) {
initiator = createInitiator(new Dispatcher(), settings, messageStoreFactory,
sessionLogFactory, messageFactory, threadModel);
} else {
initiator = null;
}
if (acceptor == null && initiator == null) {
throw new ConfigError("No connector role");
}
} finally {
Thread.currentThread().setContextClassLoader(ccl);
}
LOG.debug("Initialized QuickFIX/J Engine: {}", uri);
initialized.set(true);
}
protected static SessionSettings loadSettings(CamelContext camelContext, String settingsResourceName) throws Exception {
InputStream inputStream = ResourceHelper.resolveMandatoryResourceAsInputStream(camelContext, settingsResourceName);
return new SessionSettings(inputStream);
}
@Override
protected void doInit() throws Exception {
initializeEngine();
}
@Override
protected void doStart() throws Exception {
LOG.debug("Starting QuickFIX/J Engine: {}", uri);
if (acceptor != null) {
acceptor.start();
if (jmxExporter != null) {
acceptorObjectName = jmxExporter.register(acceptor);
}
}
if (initiator != null) {
initiator.start();
if (jmxExporter != null) {
initiatorObjectName = jmxExporter.register(initiator);
}
}
}
@Override
protected void doStop() throws Exception {
LOG.debug("Stopping QuickFIX/J Engine: {}", uri);
if (acceptor != null) {
acceptor.stop();
if (jmxExporter != null && acceptorObjectName != null) {
jmxExporter.getMBeanServer().unregisterMBean(acceptorObjectName);
}
}
if (initiator != null) {
initiator.stop();
if (jmxExporter != null && initiatorObjectName != null) {
jmxExporter.getMBeanServer().unregisterMBean(initiatorObjectName);
}
}
}
@Override
protected void doShutdown() throws Exception {
// also clear event listeners
eventListeners.clear();
}
private Initiator createInitiator(
Application application, SessionSettings settings,
MessageStoreFactory messageStoreFactory, LogFactory sessionLogFactory,
MessageFactory messageFactory, ThreadModel threadModel)
throws ConfigError {
Initiator initiator;
if (threadModel == ThreadModel.ThreadPerSession) {
initiator = new ThreadedSocketInitiator(
application, messageStoreFactory, settings, sessionLogFactory, messageFactory);
} else if (threadModel == ThreadModel.ThreadPerConnector) {
initiator = new SocketInitiator(application, messageStoreFactory, settings, sessionLogFactory, messageFactory);
} else {
throw new ConfigError("Unknown thread mode: " + threadModel);
}
return initiator;
}
private Acceptor createAcceptor(
Application application, SessionSettings settings,
MessageStoreFactory messageStoreFactory, LogFactory sessionLogFactory,
MessageFactory messageFactory, ThreadModel threadModel)
throws ConfigError {
Acceptor acceptor;
if (threadModel == ThreadModel.ThreadPerSession) {
acceptor = new ThreadedSocketAcceptor(
application, messageStoreFactory, settings, sessionLogFactory, messageFactory);
} else if (threadModel == ThreadModel.ThreadPerConnector) {
acceptor = new SocketAcceptor(application, messageStoreFactory, settings, sessionLogFactory, messageFactory);
} else {
throw new ConfigError("Unknown thread mode: " + threadModel);
}
return acceptor;
}
private MessageStoreFactory inferMessageStoreFactory(SessionSettings settings) throws ConfigError {
Set impliedMessageStoreFactories = new HashSet<>();
isJdbcStore(settings, impliedMessageStoreFactories);
isFileStore(settings, impliedMessageStoreFactories);
isSleepycatStore(settings, impliedMessageStoreFactories);
if (impliedMessageStoreFactories.size() > 1) {
throw new ConfigError("Ambiguous message store implied in configuration.");
}
MessageStoreFactory messageStoreFactory;
if (impliedMessageStoreFactories.size() == 1) {
messageStoreFactory = impliedMessageStoreFactories.iterator().next();
} else {
messageStoreFactory = new MemoryStoreFactory();
}
LOG.info("Inferring message store factory: {}", messageStoreFactory.getClass().getName());
return messageStoreFactory;
}
private void isSleepycatStore(SessionSettings settings, Set impliedMessageStoreFactories) {
if (settings.isSetting(SleepycatStoreFactory.SETTING_SLEEPYCAT_DATABASE_DIR)) {
impliedMessageStoreFactories.add(new SleepycatStoreFactory(settings));
}
}
private void isFileStore(SessionSettings settings, Set impliedMessageStoreFactories) {
if (settings.isSetting(FileStoreFactory.SETTING_FILE_STORE_PATH)) {
impliedMessageStoreFactories.add(new FileStoreFactory(settings));
}
}
private void isJdbcStore(SessionSettings settings, Set impliedMessageStoreFactories) {
if (settings.isSetting(JdbcSetting.SETTING_JDBC_DRIVER) || settings.isSetting(JdbcSetting.SETTING_JDBC_DS_NAME)) {
impliedMessageStoreFactories.add(new JdbcStoreFactory(settings));
}
}
private LogFactory inferLogFactory(SessionSettings settings) throws ConfigError {
Set impliedLogFactories = new HashSet<>();
isFileLog(settings, impliedLogFactories);
isScreenLog(settings, impliedLogFactories);
isSL4JLog(settings, impliedLogFactories);
isJdbcLog(settings, impliedLogFactories);
if (impliedLogFactories.size() > 1) {
throw new ConfigError("Ambiguous log factory implied in configuration");
}
LogFactory sessionLogFactory;
if (impliedLogFactories.size() == 1) {
sessionLogFactory = impliedLogFactories.iterator().next();
} else {
// Default
sessionLogFactory = new ScreenLogFactory(settings);
}
LOG.info("Inferring log factory: {}", sessionLogFactory.getClass().getName());
return sessionLogFactory;
}
private void isScreenLog(SessionSettings settings, Set impliedLogFactories) {
if (settings.isSetting(ScreenLogFactory.SETTING_LOG_EVENTS)
|| settings.isSetting(ScreenLogFactory.SETTING_LOG_INCOMING)
|| settings.isSetting(ScreenLogFactory.SETTING_LOG_OUTGOING)) {
impliedLogFactories.add(new ScreenLogFactory(settings));
}
}
private void isFileLog(SessionSettings settings, Set impliedLogFactories) {
if (settings.isSetting(FileLogFactory.SETTING_FILE_LOG_PATH)) {
impliedLogFactories.add(new FileLogFactory(settings));
}
}
private void isJdbcLog(SessionSettings settings, Set impliedLogFactories) {
if ((settings.isSetting(JdbcSetting.SETTING_JDBC_DRIVER) || settings.isSetting(JdbcSetting.SETTING_JDBC_DS_NAME))
&& settings.isSetting(JdbcSetting.SETTING_LOG_EVENT_TABLE)) {
impliedLogFactories.add(new JdbcLogFactory(settings));
}
}
private void isSL4JLog(SessionSettings settings, Set impliedLogFactories) {
for (Object key : settings.getDefaultProperties().keySet()) {
if (key.toString().startsWith("SLF4J")) {
impliedLogFactories.add(new SLF4JLogFactory(settings));
return;
}
}
}
private boolean isConnectorRole(SessionSettings settings, String connectorRole) throws ConfigError {
boolean hasRole = false;
Iterator sessionIdItr = settings.sectionIterator();
while (sessionIdItr.hasNext()) {
if (connectorRole.equals(settings.getString(sessionIdItr.next(), SessionFactory.SETTING_CONNECTION_TYPE))) {
hasRole = true;
break;
}
}
return hasRole;
}
public void addEventListener(QuickfixjEventListener listener) {
eventListeners.add(listener);
}
public void removeEventListener(QuickfixjEventListener listener) {
eventListeners.remove(listener);
}
private class Dispatcher implements Application {
@Override
public void fromAdmin(Message message, SessionID sessionID)
throws FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon {
try {
dispatch(QuickfixjEventCategory.AdminMessageReceived, sessionID, message);
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
rethrowIfType(e, FieldNotFound.class);
rethrowIfType(e, IncorrectDataFormat.class);
rethrowIfType(e, IncorrectTagValue.class);
rethrowIfType(e, RejectLogon.class);
throw new DispatcherException(e);
}
}
@Override
public void fromApp(Message message, SessionID sessionID)
throws FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType {
try {
dispatch(QuickfixjEventCategory.AppMessageReceived, sessionID, message);
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
rethrowIfType(e, FieldNotFound.class);
rethrowIfType(e, IncorrectDataFormat.class);
rethrowIfType(e, IncorrectTagValue.class);
rethrowIfType(e, UnsupportedMessageType.class);
throw new DispatcherException(e);
}
}
@Override
public void onCreate(SessionID sessionID) {
try {
dispatch(QuickfixjEventCategory.SessionCreated, sessionID, null);
} catch (Exception e) {
throw new DispatcherException(e);
}
}
@Override
public void onLogon(SessionID sessionID) {
try {
dispatch(QuickfixjEventCategory.SessionLogon, sessionID, null);
} catch (Exception e) {
throw new DispatcherException(e);
}
}
@Override
public void onLogout(SessionID sessionID) {
try {
dispatch(QuickfixjEventCategory.SessionLogoff, sessionID, null);
} catch (Exception e) {
throw new DispatcherException(e);
}
}
@Override
public void toAdmin(Message message, SessionID sessionID) {
try {
dispatch(QuickfixjEventCategory.AdminMessageSent, sessionID, message);
} catch (Exception e) {
throw new DispatcherException(e);
}
}
@Override
public void toApp(Message message, SessionID sessionID) throws DoNotSend {
try {
dispatch(QuickfixjEventCategory.AppMessageSent, sessionID, message);
} catch (Exception e) {
throw new DispatcherException(e);
}
}
private void rethrowIfType(Exception e, Class exceptionClass) throws T {
if (e.getClass() == exceptionClass) {
throw exceptionClass.cast(e);
}
}
private void dispatch(QuickfixjEventCategory quickfixjEventCategory, SessionID sessionID, Message message)
throws Exception {
LOG.debug("FIX event dispatched: {} {}", quickfixjEventCategory, message != null ? message : "");
for (QuickfixjEventListener listener : eventListeners) {
// Exceptions propagate back to the FIX engine so sequence numbers can be adjusted
listener.onEvent(quickfixjEventCategory, sessionID, message);
}
}
private class DispatcherException extends RuntimeException {
private static final long serialVersionUID = 1L;
DispatcherException(Throwable cause) {
super(cause);
}
}
}
public String getUri() {
return uri;
}
public MessageCorrelator getMessageCorrelator() {
return messageCorrelator;
}
public boolean isInitialized() {
return this.initialized.get();
}
public boolean isLazy() {
return this.lazy;
}
// For Testing
Initiator getInitiator() {
return initiator;
}
// For Testing
Acceptor getAcceptor() {
return acceptor;
}
// For Testing
MessageStoreFactory getMessageStoreFactory() {
return messageStoreFactory;
}
// For Testing
LogFactory getLogFactory() {
return sessionLogFactory;
}
// For Testing
MessageFactory getMessageFactory() {
return messageFactory;
}
}
