/** * Expands GLOB resource patterns. * * @param string $resource Resource name. * @param string $type Type of the resource. * @return array */ public function expand($resource, $type) { list($moduleName, $subDir, $filePattern) = $this->parseResourceName($resource); $resourceLocation = $moduleName . ':' . $subDir . ':'; // read from application dir $appDir = rtrim($this->_application->getApplicationDir(), DS) . DS . 'Resources' . DS; // if a module name was specified then point to a subfolder with the module name if (!empty($moduleName)) { // check for module existence in the first place if (!$this->_application->hasModule($moduleName)) { throw new ResourceNotFoundException('There is no module "' . $moduleName . '" registered, so cannot find its resource.'); } $appDir = $appDir . $moduleName . DS; } $appDir = $this->buildResourcePath($appDir, $type, $subDir, ''); $appFiles = FilesystemUtils::glob($appDir . $filePattern, FilesystemUtils::GLOB_ROOTFIRST | GLOB_BRACE); $resources = array(); foreach ($appFiles as $file) { $resources[] = $resourceLocation . substr($file, mb_strlen($appDir)); } // now take care of the module dir if ($moduleName) { $module = $this->_application->getModule($moduleName); $moduleDir = rtrim($module->getModuleDir(), DS) . DS . 'Resources' . DS; $moduleDir = $this->buildResourcePath($moduleDir, $type, $subDir, ''); $moduleFiles = FilesystemUtils::glob($moduleDir . $filePattern, GLOB_BRACE); foreach ($moduleFiles as $file) { $resources[] = $resourceLocation . substr($file, mb_strlen($moduleDir)); } } $resources = array_unique($resources); return ArrayUtils::sortPaths($resources, true); }
/** * Constructor. * * @param Application $application Application for this router. * @param CacheInterface $cache Cache in which routes definitions will be stored. * @param boolean $cacheEnabled [optional] Whether or not the cache is enabled. Default: `true`. * @param string $host [optional] Host to use when generating full URL's. Default: `localhost`. * @param string $protocol [optional] Protocol to use when generating full URL's. Default: `http://`. * @param int $port [optional] Port to use when generating full URL's. Default: `80`. */ public function __construct(AbstractApplication $application, CacheInterface $cache, $cacheEnabled = true, $host = 'localhost', $protocol = 'http://', $port = 80) { $this->cache = $cache; $this->cache->setEnabled($cacheEnabled); $this->setHost($host); $this->setProtocol($protocol); $this->setPort($port); // read all routes from cache and if there aren't any then read them from application modules and write to cache $router = $this; $this->routes = $this->cache->get('routes', 0, function () use($router, $application) { foreach ($application->getModules() as $module) { $router->readModuleRoutes($module); } return $router->getRoutes(); }); }
/** * Configure the application. */ public function configure() { parent::configure(); // copy config values to the container $config = $this->getConfig(); $this->container->setParameter('log_error_file', $config->get('log_error_file')); }
/** * Executes a command by parsing all the input options and arguments and passing them to the command. * * @param string $name Name of the command to call. * @param InputInterface $input Input. * @param OutputInterface $ouput Output. */ public function exec($name, InputInterface $input, OutputInterface $output) { if (!isset($this->commands[$name])) { throw new NotFoundException('The command "' . $name . '" was not found in the list of registered commands.'); } $commandInfo = $this->commands[$name]; $commandClass = $commandInfo['class']; $consoleCommand = $commandInfo['command']; // instantiate the command with appropriate DI $command = new $commandClass($this->application->getContainer(), $input, $output, $consoleCommand->getHelperSet()); // parse options $command->setOptions($input->getOptions()); // parse arguments $arguments = array(); foreach ($input->getArguments() as $key => $argument) { // if key is command then ignore it if ($key === 'command') { continue; } $arguments[] = $argument; } // call! call_user_func_array(array($command, 'execute'), $arguments); }
/** * Runs the application. */ public function run() { if ($this->container->getParameter('mode') !== Framework::MODE_CONSOLE) { throw new \RuntimeException('Genry can only be run in console!'); } parent::run(); }
/** * This method is called by Splot Framework during the run phase, so right before it will * handle a request or a CLI command. * * This is a place where all services from all modules have been registered and the whole app * is fully bootstrapped and fully configured so you can add some global application-wide * logic or behavior here. */ public function run() { parent::run(); }
/** * Runs the application in context of the given mode and using the given runner function. * * The last argument is a callback that will be invoked by this method and it should contain * execution logic specific to the given mode. * * Returns whatever the runner returns (which should be a result of running the application). * * @param AbstractApplication $application Application to be ran. * @param int $mode Mode in which the application should be ran. * One of the `Framework::MODE_*` constants. * @param callable $runner Closure that is responsible for actually running * the application in appropriate mode. * @return mixed */ protected function doRunApplication(AbstractApplication $application, $mode, $runner) { $timer = new Timer(); $container = $application->getContainer(); // container can now know in what mode its running $container->setParameter('mode', $mode); // run modules and the app foreach ($application->getModules() as $module) { $module->run(); } $application->run(); // run using the passed runner $result = call_user_func($runner); // log benchmark data $time = $timer->stop(); $memory = $timer->getMemoryUsage(); $container->get('splot.logger')->debug('Application run phase in mode "{mode}" finished in {time} ms and used {memory} memory.', array('mode' => self::modeName($mode), 'env' => $container->getParameter('env'), 'debug' => $container->getParameter('debug'), 'time' => $time, 'memory' => StringUtils::bytesToString($memory), '@stat' => 'splot.run.' . self::modeName($mode), '@time' => $time, '@memory' => $memory)); return $result; }