/**
* Handle an event.
*
* @param \League\Event\EventInterface $event The triggering event
*
* @return void
* @see \League\Event\ListenerInterface::handle()
*/
public function handle(EventInterface $event)
{
try {
// load the application server, naming directory and system configuration instance
/** @var \AppserverIo\Appserver\Core\Interfaces\ApplicationServerInterface $applicationServer */
$applicationServer = $this->getApplicationServer();
/** @var \AppserverIo\Psr\Naming\NamingDirectoryInterface $namingDirectory */
$namingDirectory = $applicationServer->getNamingDirectory();
/** @var \AppserverIo\Appserver\Core\Interfaces\SystemConfigurationInterface $systemConfiguration */
$systemConfiguration = $applicationServer->getSystemConfiguration();
// initialize the loggers
$loggers = array();
foreach ($systemConfiguration->getLoggers() as $loggerNode) {
$loggers[$loggerNode->getName()] = LoggerFactory::factory($loggerNode);
}
// register the logger callbacks in the naming directory
foreach ($loggers as $name => $logger) {
$namingDirectory->bind(sprintf('php:global/log/%s', $name), $logger);
}
// set the initialized loggers finally
$applicationServer->setLoggers($loggers);
} catch (\Exception $e) {
$applicationServer->getSystemLogger()->error($e->__toString());
}
}
/**
* Visitor method that registers the application in the container.
*
* @param \AppserverIo\Appserver\Core\Interfaces\ContainerInterface $container The container instance bind the application to
* @param \AppserverIo\Appserver\Core\Api\Node\ContextNode $context The application configuration
*
* @return void
*/
public static function visit(ContainerInterface $container, ContextNode $context)
{
// load the applications base directory
$webappPath = $context->getWebappPath();
// declare META-INF and WEB-INF directory
$webInfDir = $webappPath . DIRECTORY_SEPARATOR . 'WEB-INF';
$metaInfDir = $webappPath . DIRECTORY_SEPARATOR . 'META-INF';
// check if we've a directory containing a valid application,
// at least a WEB-INF or META-INF folder has to be available
if (!is_dir($webInfDir) && !is_dir($metaInfDir)) {
return;
}
// load the naming directory + initial context
$initialContext = $container->getInitialContext();
$namingDirectory = $container->getNamingDirectory();
// load the application service
$appService = $container->newService('AppserverIo\\Appserver\\Core\\Api\\AppService');
// load the application type
$contextType = $context->getType();
$containerName = $container->getName();
$environmentName = $context->getEnvironmentName();
$applicationName = $context->getName();
$containerRunlevel = $container->getRunlevel();
// create a new application instance
/** @var \AppserverIo\Appserver\Application\Application $application */
$application = new $contextType();
// initialize the storage for managers, virtual hosts an class loaders
$loggers = new GenericStackable();
$managers = new GenericStackable();
$provisioners = new GenericStackable();
$classLoaders = new GenericStackable();
// initialize the generic instances and information
$application->injectLoggers($loggers);
$application->injectManagers($managers);
$application->injectName($applicationName);
$application->injectEnvironmentName($environmentName);
$application->injectProvisioners($provisioners);
$application->injectClassLoaders($classLoaders);
$application->injectContainerName($containerName);
$application->injectInitialContext($initialContext);
$application->injectNamingDirectory($namingDirectory);
$application->injectContainerRunlevel($containerRunlevel);
// prepare the application instance
$application->prepare($container, $context);
// create the applications temporary folders and cleans the folders up
/** @var \AppserverIo\Appserver\Core\Api\AppService $appService */
PermissionHelper::sudo(array($appService, 'createTmpFolders'), array($application));
$appService->cleanUpFolders($application);
// add the configured loggers
/** @var \AppserverIo\Appserver\Core\Api\Node\LoggerNode $loggerNode */
foreach ($context->getLoggers() as $loggerNode) {
$application->addLogger(LoggerFactory::factory($loggerNode), $loggerNode);
}
// add the configured class loaders
/** @var \AppserverIo\Appserver\Core\Api\Node\ClassLoaderNode $classLoader */
foreach ($context->getClassLoaders() as $classLoader) {
/** @var \AppserverIo\Appserver\Core\Interfaces\ClassLoaderFactoryInterface $classLoaderFactory */
if ($classLoaderFactory = $classLoader->getFactory()) {
// use the factory if available
$classLoaderFactory::visit($application, $classLoader);
} else {
// if not, try to instanciate the class loader directly
$classLoaderType = $classLoader->getType();
$application->addClassLoader(new $classLoaderType($classLoader), $classLoader);
}
}
// add the configured managers
/** @var \AppserverIo\Appserver\Core\Api\Node\ManagerNode $manager */
foreach ($context->getManagers() as $manager) {
/** @var \AppserverIo\Appserver\Core\Interfaces\ManagerFactoryInterface $managerFactory */
if ($managerFactory = $manager->getFactory()) {
// use the factory if available
$managerFactory::visit($application, $manager);
} else {
// if not, try to instanciate the manager directly
$managerType = $manager->getType();
$application->addManager(new $managerType($manager), $manager);
}
}
// add the configured provisioners
/** @var \AppserverIo\Appserver\Core\Api\Node\ProvisionerNode $provisioner */
foreach ($context->getProvisioners() as $provisioner) {
/** @var \AppserverIo\Appserver\Provisioning\StandardProvisionerFactory $provisionerFactory */
if ($provisionerFactory = $provisioner->getFactory()) {
// use the factory if available
$provisionerFactory::visit($application, $provisioner);
} else {
// if not, try to instanciate the provisioner directly
$provisionerType = $provisioner->getType();
$application->addProvisioner(new $provisionerType($provisioner), $provisioner);
}
}
// add the application to the container
$container->addApplication($application);
}
