spep::SPEP* spep::SPEP::initializeServer( spep::ConfigurationReader &configurationReader, std::vector<saml2::Handler*> handlers )
{
spep::SPEP *spep = new spep::SPEP;
spep->_mode = SPEP_MODE_SERVER;
spep->_isStarted = false;
spep->_logger = new saml2::Logger();
for( std::vector<saml2::Handler*>::iterator handlerIterator = handlers.begin();
handlerIterator != handlers.end(); ++handlerIterator )
{
spep->_logger->registerHandler( *handlerIterator );
}
saml2::LocalLogger localLogger(spep->_logger, "spep::SPEP");
localLogger.debug() << "Beginning to initialize server-side SPEP components.";
spep->_configuration = new ConfigurationImpl( configurationReader );
spep->_spepConfigData = new SPEPConfigData( spep->_configuration->getSPEPConfigData() );
int allowedTimeSkew = configurationReader.getIntegerValue( CONFIGURATION_ALLOWEDTIMESKEW );
int metadataInterval = configurationReader.getIntegerValue( CONFIGURATION_METADATAINTERVAL );
int attributeConsumingServiceIndex = configurationReader.getIntegerValue( CONFIGURATION_ATTRIBUTECONSUMINGSERVICEINDEX );
int assertionConsumerServiceIndex = configurationReader.getIntegerValue( CONFIGURATION_ASSERTIONCONSUMERSERVICEINDEX );
int authzCacheIndex = configurationReader.getIntegerValue( CONFIGURATION_AUTHZCACHEINDEX );
int startupRetryInterval = configurationReader.getIntegerValue( CONFIGURATION_STARTUPRETRYINTERVAL );
int sessionCacheInterval = configurationReader.getIntegerValue( CONFIGURATION_SESSIONCACHEINTERVAL );
int sessionCacheTimeout = configurationReader.getIntegerValue( CONFIGURATION_SESSIONCACHETIMEOUT );
std::string nodeID( configurationReader.getStringValue( CONFIGURATION_NODEIDENTIFIER ) );
std::string caBundle( configurationReader.getStringValue( CONFIGURATION_CABUNDLE, std::string() ) );
Decision defaultPolicyDecision( configurationReader.getStringValue( CONFIGURATION_DEFAULTPOLICYDECISION ) );
std::string schemaPath( configurationReader.getStringValue( CONFIGURATION_SCHEMAPATH ) );
std::wstring spepIdentifier( UnicodeStringConversion::toWString( configurationReader.getStringValue( CONFIGURATION_SPEPIDENTIFIER ) ) );
std::wstring esoeIdentifier( UnicodeStringConversion::toWString( configurationReader.getStringValue( CONFIGURATION_ESOEIDENTIFIER ) ) );
std::string metadataURL( configurationReader.getStringValue( CONFIGURATION_METADATAURL ) );
spep->_identifierCache = new saml2::IdentifierCache();
spep->_identifierGenerator = new saml2::IdentifierGenerator( spep->_identifierCache );
spep->_samlValidator = new saml2::SAMLValidator( spep->_identifierCache, allowedTimeSkew );
spep->_metadata = new MetadataImpl( spep->_logger, schemaPath, spepIdentifier, esoeIdentifier, metadataURL, caBundle, spep->_spepConfigData->getKeyResolver(), assertionConsumerServiceIndex, metadataInterval );
spep->_soapUtil = new SOAPUtil( spep->_logger, schemaPath );
spep->_wsClient = new WSClient( spep->_logger, caBundle, spep->_soapUtil );
spep->_attributeProcessor = new AttributeProcessor( spep->_logger, spep->_metadata, spep->_spepConfigData->getKeyResolver(), spep->_identifierGenerator, spep->_wsClient, spep->_samlValidator, schemaPath, spep->_spepConfigData->getAttributeRenameMap() );
spep->_sessionCache = new SessionCacheImpl( spep->_logger );
spep->_sessionCacheThread = new SessionCacheThread( spep->_logger, spep->_sessionCache, sessionCacheTimeout, sessionCacheInterval );
spep->_authnProcessor = new AuthnProcessor( spep->_logger, spep->_attributeProcessor, spep->_metadata, spep->_sessionCache, spep->_samlValidator, spep->_identifierGenerator, spep->_spepConfigData->getKeyResolver(), spepIdentifier, spep->_spepConfigData->getSSORedirect(), spep->_spepConfigData->getServiceHost(), schemaPath, attributeConsumingServiceIndex, assertionConsumerServiceIndex );
spep->_sessionGroupCache = new SessionGroupCacheImpl( spep->_logger, defaultPolicyDecision );
spep->_policyEnforcementProcessor = new PolicyEnforcementProcessor( spep->_logger, spep->_wsClient, spep->_sessionGroupCache, spep->_sessionCache, spep->_metadata, spep->_identifierGenerator, spep->_samlValidator, spep->_spepConfigData->getKeyResolver(), schemaPath );
spep->_startupProcessor = new StartupProcessorImpl( spep->_logger, spep->_wsClient, spep->_metadata, spep->_spepConfigData->getKeyResolver(), spep->_identifierGenerator, spep->_samlValidator, schemaPath, spepIdentifier, spep->_spepConfigData->getIPAddresses(), nodeID, authzCacheIndex, startupRetryInterval );
spep->_wsProcessor = new WSProcessor( spep->_logger, spep->_authnProcessor, spep->_policyEnforcementProcessor, spep->_soapUtil );
return spep;
}
spep::SPEP* spep::SPEP::initializeStandalone( spep::ConfigurationReader& configReader, std::vector<saml2::Handler*> handlers )
{
SPEP* spep = SPEP::initializeServer( configReader, handlers );
saml2::LocalLogger localLogger(spep->_logger, "spep::SPEP");
localLogger.debug() << "Server-side SPEP components initialized. Switching to standalone mode.";
spep->_mode = SPEP_MODE_STANDALONE;
return spep;
}
TEST_F(LoggerTest, LogWithLocalLogger)
{
Logger localLogger(appender);
localLogger.setLogLevel(LL_ALL);
testing::InSequence seq;
EXPECT_CALL(appender, logMessage(testing::Property(&LogMessage::getLogLevel, LL_TRACE)));
EXPECT_CALL(appender, logMessage(testing::Property(&LogMessage::getLogLevel, LL_DEBUG)));
EXPECT_CALL(appender, logMessage(testing::Property(&LogMessage::getLogLevel, LL_INFO)));
EXPECT_CALL(appender, logMessage(testing::Property(&LogMessage::getLogLevel, LL_WARN)));
EXPECT_CALL(appender, logMessage(testing::Property(&LogMessage::getLogLevel, LL_ERROR)));
EXPECT_CALL(appender, logMessage(testing::Property(&LogMessage::getLogLevel, LL_FATAL)));
logWithLocalLogger(localLogger);
}
spep::SPEP* spep::SPEP::initializeClient( int spepDaemonPort )
{
spep::SPEP *spep = new spep::SPEP;
spep->_mode = SPEP_MODE_CLIENT;
spep->_isStarted = false;
#ifdef WIN32
spep->_socketPool = new spep::ipc::ClientSocketPool( spepDaemonPort, 20 );
#else //!WIN32
#ifdef SPEP_CLIENT_THREADS
spep->_socketPool = new spep::ipc::ClientSocketPool( spepDaemonPort, SPEP_CLIENT_THREADS );
#else //!SPEP_CLIENT_THREADS
spep->_socketPool = new spep::ipc::ClientSocketPool( spepDaemonPort, 1 );
#endif //SPEP_CLIENT_THREADS
#endif //WIN32
spep->_logger = new spep::ipc::LoggerProxy(spep->_socketPool);
saml2::LocalLogger localLogger(spep->_logger, "spep::SPEP");
spep->_startupProcessor = new spep::ipc::StartupProcessorProxy( spep->_socketPool );
spep->_identifierCache = new spep::ipc::IdentifierCacheProxy( spep->_socketPool );
spep->_identifierGenerator = new saml2::IdentifierGenerator( spep->_identifierCache );
spep->_metadata = new spep::ipc::MetadataProxy( spep->_socketPool );
spep->_sessionCache = new spep::ipc::SessionCacheProxy( spep->_socketPool );
spep->_sessionGroupCache = new spep::ipc::SessionGroupCacheProxy( spep->_socketPool );
try {
spep->reinitializeClient();
// This will get the background thread firing to let the SPEP startup request occur.
if( !spep->_spepConfigData->disableSPEPStartup() )
spep->_startupProcessor->allowProcessing();
spep->_serviceID = spep->_socketPool->getServiceID();
} catch (spep::ipc::SocketException& e) {
// There's not much we can do with it. Just stop the caller from dying.
}
return spep;
}
