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; }