Log* FileLogFactory::create()
{ QF_STACK_PUSH(FileLogFactory::create)
m_globalLogCount++;
if( m_globalLogCount > 1 ) return m_globalLog;
try
{
if ( m_path.size() ) return new FileLog( m_path );
std::string path;
std::string backupPath;
Dictionary settings = m_settings.get();
path = settings.getString( FILE_LOG_PATH );
backupPath = path;
if( settings.has( FILE_LOG_BACKUP_PATH ) )
backupPath = settings.getString( FILE_LOG_BACKUP_PATH );
return m_globalLog = new FileLog( path );
}
catch( ConfigError& )
{
m_globalLogCount--;
throw;
}
QF_STACK_POP
}
void SocketInitiator::onDisconnect( SocketConnector&, int s )
{ QF_STACK_PUSH(SocketInitiator::onDisconnect)
SocketConnections::iterator i = m_connections.find( s );
SocketConnections::iterator j = m_pendingConnections.find( s );
SocketConnection* pSocketConnection = 0;
if( i != m_connections.end() )
pSocketConnection = i->second;
if( j != m_pendingConnections.end() )
pSocketConnection = j->second;
if( !pSocketConnection )
return;
setDisconnected( pSocketConnection->getSession()->getSessionID() );
Session* pSession = pSocketConnection->getSession();
if ( pSession )
{
pSession->disconnect();
setDisconnected( pSession->getSessionID() );
}
delete pSocketConnection;
m_connections.erase( s );
m_pendingConnections.erase( s );
QF_STACK_POP
}
void SessionFactory::processFixtDataDictionaries(const SessionID& sessionID,
const Dictionary& settings,
DataDictionaryProvider& provider) throw(ConfigError)
{ QF_STACK_PUSH(SessionFactory::processFixtDataDictionaries)
DataDictionary dataDictionary = createDataDictionary(sessionID, settings, TRANSPORT_DATA_DICTIONARY);
provider.addTransportDataDictionary(sessionID.getBeginString(), dataDictionary);
for(Dictionary::const_iterator data = settings.begin(); data != settings.end(); ++data)
{
const std::string& key = data->first;
const std::string frontKey = key.substr(0, strlen(APP_DATA_DICTIONARY));
if( frontKey == string_toUpper(APP_DATA_DICTIONARY) )
{
if( key == string_toUpper(APP_DATA_DICTIONARY) )
{
DataDictionary dataDictionary = createDataDictionary(sessionID, settings, APP_DATA_DICTIONARY);
provider.addApplicationDataDictionary(Message::toApplVerID(settings.getString(DEFAULT_APPLVERID)), dataDictionary);
}
else
{
std::string::size_type offset = key.find('.');
if( offset == std::string::npos )
throw ConfigError(std::string("Malformed ") + APP_DATA_DICTIONARY + ": " + key);
std::string beginStringQualifier = key.substr(offset+1);
DataDictionary dataDictionary = createDataDictionary(sessionID, settings, key);
provider.addApplicationDataDictionary(Message::toApplVerID(beginStringQualifier), dataDictionary);
}
}
}
QF_STACK_POP
}
void onWrite( SocketMonitor&, int socket )
{ QF_STACK_PUSH(ConnectorWrapper::onWrite)
m_strategy.onWrite( m_connector, socket );
QF_STACK_POP
}
bool SocketConnection::processQueue()
{ QF_STACK_PUSH(SocketConnection::processQueue)
Locker l( m_mutex );
if( !m_sendQueue.size() ) return true;
struct timeval timeout = { 0, 0 };
fd_set writeset = m_fds;
if( select( 1 + m_socket, 0, &writeset, 0, &timeout ) <= 0 )
return false;
const std::string& msg = m_sendQueue.front();
int result = socket_send
( m_socket, msg.c_str() + m_sendLength, msg.length() - m_sendLength );
if( result > 0 )
m_sendLength += result;
if( m_sendLength == msg.length() )
{
m_sendLength = 0;
m_sendQueue.pop_front();
}
return !m_sendQueue.size();
QF_STACK_POP
}
void NullStore::get( int begin, int end,
std::vector < std::string > & messages ) const
throw( IOException )
{ QF_STACK_PUSH(NullStore::get)
messages.clear();
QF_STACK_POP
}
void HttpMessage::setString( const std::string& string )
throw( InvalidMessage )
{ QF_STACK_PUSH(HttpMessage::setString)
clear();
std::string::size_type eolPos = string.find( "\r\n" );
if( eolPos == std::string::npos ) throw InvalidMessage();
std::string line = string.substr( 0, eolPos );
std::string::size_type getPos = line.find( "GET " );
if( getPos != 0 ) throw InvalidMessage();
std::string::size_type httpPos = line.rfind( "HTTP", std::string::npos );
if( httpPos == std::string::npos ) throw InvalidMessage();
m_root = line.substr( getPos + 4, httpPos - 5 );
std::string::size_type paramPos = m_root.find_first_of( '?' );
if( paramPos == std::string::npos ) return;
std::string parameters = m_root.substr( paramPos, m_root.size() - paramPos );
m_root = m_root.substr( 0, paramPos );
paramPos = 0;
while( paramPos != std::string::npos )
{
std::string::size_type sepPos = parameters.find_first_of( "=", paramPos );
if( sepPos == std::string::npos ) break;
std::string::size_type tempPos = paramPos;
paramPos = parameters.find_first_of( "&", paramPos + 1 );
std::string key = parameters.substr(tempPos + 1, sepPos - tempPos - 1);
std::string value = parameters.substr(sepPos + 1, paramPos - sepPos - 1);
m_parameters[key] = value;
}
QF_STACK_POP
}
void OdbcLogFactory::destroy( Log* pLog )
{ QF_STACK_PUSH(OdbcLogFactory::destroy)
delete pLog;
QF_STACK_POP
}
void OdbcLogFactory::init( const Dictionary& settings,
std::string& user,
std::string& password,
std::string& connectionString )
{ QF_STACK_PUSH(OdbcLogFactory::init)
user = DEFAULT_USER;
password = DEFAULT_PASSWORD;
connectionString = DEFAULT_CONNECTION_STRING;
if( m_useSettings )
{
try { user = settings.getString( ODBC_LOG_USER ); }
catch( ConfigError& ) {}
try { password = settings.getString( ODBC_LOG_PASSWORD ); }
catch( ConfigError& ) {}
try { connectionString = settings.getString( ODBC_LOG_CONNECTION_STRING ); }
catch( ConfigError& ) {}
}
else
{
user = m_user;
password = m_password;
connectionString = m_connectionString;
}
QF_STACK_POP
}
void onError( SocketMonitor&, int socket )
{ QF_STACK_PUSH(ConnectorWrapper::onError)
m_strategy.onDisconnect( m_connector, socket );
QF_STACK_POP
}
std::string HttpMessage::toString() const
{ QF_STACK_PUSH(HttpMessage::toString)
std::string str;
return toString( str );
QF_STACK_POP
}
bool FieldMap::hasGroup( int field ) const
{ QF_STACK_PUSH(FieldMap::hasGroup)
Groups::const_iterator i = m_groups.find( field );
return i != m_groups.end();
QF_STACK_POP
}
std::string& HttpMessage::toString( std::string& str ) const
{ QF_STACK_PUSH(HttpMessage::toString)
str = m_root + getParameterString();
return str;
QF_STACK_POP
}
void ThreadedSocketConnection::disconnect()
{ QF_STACK_PUSH(ThreadedSocketConnection::disconnect)
m_disconnect = true;
socket_close( m_socket );
QF_STACK_POP
}
void FieldMap::removeField( int field )
{ QF_STACK_PUSH(FieldMap::removeField)
Fields::iterator i = m_fields.find( field );
if ( i != m_fields.end() )
m_fields.erase( i );
QF_STACK_POP
}
bool SocketInitiator::onData( SocketConnector& connector, int s )
{ QF_STACK_PUSH(SocketInitiator::onData)
SocketConnections::iterator i = m_connections.find( s );
if ( i == m_connections.end() ) return false;
SocketConnection* pSocketConnection = i->second;
return pSocketConnection->read( connector );
QF_STACK_POP
}
std::string Message::toString( int beginStringField,
int bodyLengthField,
int checkSumField ) const
{ QF_STACK_PUSH(Message::toString)
std::string str;
return toString( str, beginStringField, bodyLengthField, checkSumField );
QF_STACK_POP
}
int FieldMap::groupCount( int field ) const
{ QF_STACK_PUSH(FieldMap::groupCount)
Groups::const_iterator i = m_groups.find( field );
if( i == m_groups.end() )
return 0;
return i->second.size();
QF_STACK_POP
}
void Acceptor::block() throw ( ConfigError, RuntimeError )
{ QF_STACK_PUSH( Acceptor::start )
m_stop = false;
onConfigure( m_settings );
onInitialize( m_settings );
startThread(this);
QF_STACK_POP
}
void SessionFactory::processFixDataDictionary(const SessionID& sessionID,
const Dictionary& settings,
DataDictionaryProvider& provider) throw(ConfigError)
{ QF_STACK_PUSH(SessionFactory::processFixDataDictionary)
DataDictionary dataDictionary = createDataDictionary(sessionID, settings, DATA_DICTIONARY);
provider.addTransportDataDictionary(sessionID.getBeginString(), dataDictionary);
provider.addApplicationDataDictionary(Message::toApplVerID(sessionID.getBeginString()), dataDictionary);
QF_STACK_POP
}
void FieldMap::replaceGroup( int num, int field, FieldMap& group )
{ QF_STACK_PUSH(FieldMap::replaceGroup)
Groups::const_iterator i = m_groups.find( field );
if ( i == m_groups.end() ) return;
if ( num <= 0 ) return;
if ( i->second.size() < ( unsigned ) num ) return;
*( *( i->second.begin() + ( num - 1 ) ) ) = group;
QF_STACK_POP
}
void SocketInitiator::onWrite( SocketConnector& connector, int s )
{ QF_STACK_PUSH(SocketInitiator::onWrite)
SocketConnections::iterator i = m_connections.find( s );
if ( i == m_connections.end() ) return ;
SocketConnection* pSocketConnection = i->second;
if( pSocketConnection->processQueue() )
pSocketConnection->unsignal();
QF_STACK_POP
}
Session* Acceptor::getSession( const SessionID& sessionID ) const
{ QF_STACK_PUSH(Initiator::getSession)
Sessions::const_iterator i = m_sessions.find( sessionID );
if( i != m_sessions.end() )
return i->second;
else
return 0;
QF_STACK_POP
}
void FieldMap::addGroup( int field, const FieldMap& group, bool setCount )
{ QF_STACK_PUSH(FieldMap::addGroup)
FieldMap * pGroup = new FieldMap( group.m_fields.key_comp() );
*pGroup = group;
m_groups[ field ].push_back( pGroup );
Groups::iterator i = m_groups.find( field );
if( setCount )
setField( IntField( field, i->second.size() ) );
QF_STACK_POP
}
bool SocketMonitor::addRead( int s )
{ QF_STACK_PUSH(SocketMonitor::addRead)
socket_setnonblock( s );
Sockets::iterator i = m_readSockets.find( s );
if( i != m_readSockets.end() ) return false;
m_readSockets.insert( s );
return true;
QF_STACK_POP
}
FieldMap& FieldMap::getGroup( int num, int field, FieldMap& group ) const
throw( FieldNotFound )
{ QF_STACK_PUSH(FieldMap::getGroup)
Groups::const_iterator i = m_groups.find( field );
if ( i == m_groups.end() ) throw FieldNotFound( field );
if ( num <= 0 ) throw FieldNotFound( field );
if ( i->second.size() < ( unsigned ) num ) throw FieldNotFound( field );
group = *( *( i->second.begin() + ( num - 1 ) ) );
return group;
QF_STACK_POP
}
Log* OdbcLogFactory::create()
{ QF_STACK_PUSH(OdbcLogFactory::create)
std::string database;
std::string user;
std::string connectionString;
init( m_settings.get(), database, user, connectionString );
OdbcLog* result = new OdbcLog( database, user, connectionString );
initLog( m_settings.get(), *result );
return result;
QF_STACK_POP
}
void SocketInitiator::onConnect( SocketConnector&, int s )
{ QF_STACK_PUSH(SocketInitiator::onConnect)
SocketConnections::iterator i = m_pendingConnections.find( s );
if( i == m_pendingConnections.end() ) return;
SocketConnection* pSocketConnection = i->second;
m_connections[s] = pSocketConnection;
m_pendingConnections.erase( i );
setConnected( pSocketConnection->getSession()->getSessionID() );
pSocketConnection->onTimeout();
QF_STACK_POP
}
void Acceptor::start() throw ( ConfigError, RuntimeError )
{ QF_STACK_PUSH( Acceptor::start )
m_stop = false;
onConfigure( m_settings );
onInitialize( m_settings );
HttpServer::startGlobal( m_settings );
if( !thread_spawn( &startThread, this, m_threadid ) )
throw RuntimeError("Unable to spawn thread");
QF_STACK_POP
}
void FieldMap::clear()
{ QF_STACK_PUSH(FieldMap::clear)
m_fields.clear();
Groups::iterator i;
for ( i = m_groups.begin(); i != m_groups.end(); ++i )
{
std::vector < FieldMap* > ::iterator j;
for ( j = i->second.begin(); j != i->second.end(); ++j )
delete *j;
}
m_groups.clear();
QF_STACK_POP
}
