/**
* Cache an array of resources into the given cache
* @param array $resources
* @return void
*/
public function cacheResources(array $resources)
{
$cache = new ConfigCache($this->getCacheFileLocation(), $this->debug);
$content = sprintf('<?php return %s;', var_export($resources, true));
$cache->write($content);
$this->logger->debug('Writing translation resources to cache file.');
}
/**
* indexAction action.
*/
public function indexAction(Request $request, $_format)
{
$session = $request->getSession();
if ($request->hasPreviousSession() && $session->getFlashBag() instanceof AutoExpireFlashBag) {
// keep current flashes for one more request if using AutoExpireFlashBag
$session->getFlashBag()->setAll($session->getFlashBag()->peekAll());
}
$cache = new ConfigCache($this->exposedRoutesExtractor->getCachePath($request->getLocale()), $this->debug);
if (!$cache->isFresh()) {
$exposedRoutes = $this->exposedRoutesExtractor->getRoutes();
$serializedRoutes = $this->serializer->serialize($exposedRoutes, 'json');
$cache->write($serializedRoutes, $this->exposedRoutesExtractor->getResources());
} else {
$serializedRoutes = file_get_contents((string) $cache);
$exposedRoutes = $this->serializer->deserialize($serializedRoutes, 'Symfony\\Component\\Routing\\RouteCollection', 'json');
}
$routesResponse = new RoutesResponse($this->exposedRoutesExtractor->getBaseUrl(), $exposedRoutes, $this->exposedRoutesExtractor->getPrefix($request->getLocale()), $this->exposedRoutesExtractor->getHost(), $this->exposedRoutesExtractor->getScheme(), $request->getLocale());
$content = $this->serializer->serialize($routesResponse, 'json');
if (null !== ($callback = $request->query->get('callback'))) {
$validator = new \JsonpCallbackValidator();
if (!$validator->validate($callback)) {
throw new HttpException(400, 'Invalid JSONP callback value');
}
$content = $callback . '(' . $content . ');';
}
$response = new Response($content, 200, array('Content-Type' => $request->getMimeType($_format)));
$this->cacheControlConfig->apply($response);
return $response;
}
public function process(ContainerBuilder $container)
{
$filename = $container->getParameter('kernel.cache_dir') . '/daemons.php';
$cache = new ConfigCache($filename, $container->getParameter('kernel.debug'));
if ($cache->isFresh()) {
return;
}
$resources = array();
$this->container = $container;
foreach ($this->findFiles($container) as $serviceWrapper) {
$has = false;
$backgroundGenerator = new BackgroundGenerator();
foreach ($serviceWrapper->getMethods() as $method) {
if ($method->isPrivate()) {
continue;
}
$this->configureDaemonsIfAny($method, $backgroundGenerator, $serviceWrapper, $has);
}
if (!$has) {
continue;
}
$resources[] = $serviceWrapper->getResource();
$proxy = $container->get('jms_aop.proxy_matcher')->getEnhanced($serviceWrapper->getDefinition());
$proxy->addGenerator($backgroundGenerator);
$serviceWrapper->getDefinition()->addMethodCall('__setMessagingAdapter', array(new Reference('nfx_async.messaging.adapter')))->addMethodCall('__setDefaultTransform', array(new Reference('nfx_async.messaging.transform')));
}
$cache->write("<?php return unserialize('" . serialize($this->daemons) . "');", $resources);
}
/**
* Get the list of all "autoregistered" bundles
*
* @return array List ob bundle objects
*/
public function registerBundles(array $blackList = [])
{
if (!empty($blackList)) {
$blackList = array_flip($blackList);
$blackList = array_change_key_case($blackList, CASE_LOWER);
}
// clear state of CumulativeResourceManager
CumulativeResourceManager::getInstance()->clear();
$bundles = [];
if (!$this->getCacheDir()) {
foreach ($this->collectBundles($blackList) as $class => $params) {
$bundles[] = $params['kernel'] ? new $class($this) : new $class();
}
} else {
$file = $this->getCacheDir() . '/bundles.php';
$cache = new ConfigCache($file, $this->debug);
if (!$cache->isFresh($file)) {
$bundles = $this->collectBundles($blackList);
$dumper = new PhpBundlesDumper($bundles);
$metaData = [];
foreach ($bundles as $bundle) {
$metaData[] = new FileResource($bundle['file']);
}
$metaData[] = new FileResource($this->rootDir . '/../composer.lock');
//a composer update might add bundles
$metaData[] = new DirectoryResource($this->rootDir . '/../src/', '/.*Bundle.php$/');
//all bundle.php files
$cache->write($dumper->dump(), $metaData);
}
// require instead of require_once used to correctly handle sub-requests
$bundles = (require $cache instanceof ConfigCacheInterface ? $cache->getPath() : $cache);
}
return $bundles;
}
/**
* indexAction action.
*/
public function indexAction(Request $request, $_format)
{
if (version_compare(Kernel::VERSION, '2.1.0-dev', '<')) {
if (null !== ($session = $request->getSession())) {
// keep current flashes for one more request
$session->setFlashes($session->getFlashes());
}
} else {
$session = $request->getSession();
if (null !== $session && $session->getFlashBag() instanceof AutoExpireFlashBag) {
// keep current flashes for one more request if using AutoExpireFlashBag
$session->getFlashBag()->setAll($session->getFlashBag()->peekAll());
}
}
$cache = new ConfigCache($this->cacheDir . '/fosJsRouting.json', $this->debug);
if (!$cache->isFresh()) {
$content = $this->serializer->serialize(new RoutesResponse($this->exposedRoutesExtractor->getBaseUrl(), $this->exposedRoutesExtractor->getRoutes()), 'json');
$cache->write($content, $this->exposedRoutesExtractor->getResources());
}
$content = file_get_contents((string) $cache);
if ($callback = $request->query->get('callback')) {
$content = $callback . '(' . $content . ');';
}
return new Response($content, 200, array('Content-Type' => $request->getMimeType($_format)));
}
public function testCacheIsFreshAfterCacheClearedWithWarmup()
{
$input = new ArrayInput(array('cache:clear'));
$application = new Application($this->kernel);
$application->setCatchExceptions(false);
$application->doRun($input, new NullOutput());
// Ensure that all *.meta files are fresh
$finder = new Finder();
$metaFiles = $finder->files()->in($this->kernel->getCacheDir())->name('*.php.meta');
// simply check that cache is warmed up
$this->assertGreaterThanOrEqual(1, count($metaFiles));
foreach ($metaFiles as $file) {
$configCache = new ConfigCache(substr($file, 0, -5), true);
$this->assertTrue($configCache->isFresh(), sprintf('Meta file "%s" is not fresh', (string) $file));
}
// check that app kernel file present in meta file of container's cache
$containerRef = new \ReflectionObject($this->kernel->getContainer());
$containerFile = $containerRef->getFileName();
$containerMetaFile = $containerFile . '.meta';
$kernelRef = new \ReflectionObject($this->kernel);
$kernelFile = $kernelRef->getFileName();
/** @var ResourceInterface[] $meta */
$meta = unserialize(file_get_contents($containerMetaFile));
$found = false;
foreach ($meta as $resource) {
if ((string) $resource === $kernelFile) {
$found = true;
break;
}
}
$this->assertTrue($found, 'Kernel file should present as resource');
}
/**
* Builds the container.
* @param array $parameters
*/
public function build($parameters = array())
{
// sort array by key to generate the container name
ksort($parameters);
// needed for new packages installed
$composerClass = array_filter(get_declared_classes(), function ($item) {
if (0 === strpos($item, 'ComposerAutoloaderInit')) {
return true;
}
});
$composerClass = array_pop($composerClass);
// generate hash
$parametersHash = md5(serialize($parameters) . $composerClass);
$containerClass = 'Container' . $parametersHash;
$isDebug = true;
$file = sprintf('%s/ladybug_cache/%s.php', sys_get_temp_dir(), $parametersHash);
$containerConfigCache = new ConfigCache($file, $isDebug);
if (!$containerConfigCache->isFresh()) {
$this->initializeContainer();
$this->loadServices();
$this->loadThemes();
$this->loadPlugins();
$this->setParameters($parameters);
$this->container->compile();
$dumper = new PhpDumper($this->container);
$containerConfigCache->write($dumper->dump(array('class' => $containerClass)), $this->container->getResources());
} else {
require_once $file;
$this->container = new $containerClass();
}
}
/**
* @param DnaConfiguration $dna
*
* @return \Nucleus\IService\DependencyInjection\IServiceContainer
*/
protected function loadServiceContainer($dna)
{
$cachePath = $dna->freezeCachePath()->getCachePath();
$class = 'ServiceContainer' . md5($cachePath);
$file = $cachePath . '/serviceContainer/' . $class . '.php';
$containerConfigCache = new ConfigCache($file, $dna->getDebug());
$isNew = false;
if (!class_exists($class)) {
if (!$containerConfigCache->isFresh()) {
$container = new ContainerBuilder();
$nucleusCompilerPass = new NucleusCompilerPass($dna);
$container->addCompilerPass($nucleusCompilerPass);
$container->compile();
$dumper = new PhpDumper($container);
$containerConfigCache->write($dumper->dump(array('class' => $class, 'nucleus' => $nucleusCompilerPass->getConfiguration())), $container->getResources());
$isNew = true;
}
require $file;
}
$serviceContainer = new $class();
/* @var $serviceContainer \Nucleus\DependencyInjection\BaseServiceContainer */
$serviceContainer->initialize();
if ($isNew) {
$serviceContainer->getServiceByName(IEventDispatcherService::NUCLEUS_SERVICE_NAME)->dispatch('ServiceContainer.postDump', $serviceContainer, array('containerBuilder' => $container, 'dnaConfiguration' => $dna));
}
return $serviceContainer;
}
protected function coreTest(array $arguments)
{
$input = new ArrayInput($arguments);
$application = new Application(static::$kernel);
$application->setCatchExceptions(false);
$application->doRun($input, new NullOutput());
// Ensure that all *.meta files are fresh
$finder = new Finder();
$metaFiles = $finder->files()->in(static::$kernel->getCacheDir())->name('*.php.meta');
// simply check that cache is warmed up
$this->assertGreaterThanOrEqual(1, count($metaFiles));
foreach ($metaFiles as $file) {
$configCache = new ConfigCache(substr($file, 0, -5), true);
$this->assertTrue($configCache->isFresh(), sprintf('Meta file "%s" is not fresh', (string) $file));
}
// check that app kernel file present in meta file of container's cache
$containerRef = new \ReflectionObject(static::$kernel->getContainer());
$containerFile = $containerRef->getFileName();
$containerMetaFile = $containerFile . '.meta';
$kernelRef = new \ReflectionObject(static::$kernel);
$kernelFile = $kernelRef->getFileName();
/** @var ResourceInterface[] $meta */
$meta = unserialize(file_get_contents($containerMetaFile));
$found = false;
foreach ($meta as $resource) {
if ((string) $resource === $kernelFile) {
$found = true;
break;
}
}
$this->assertTrue($found, 'Kernel file should present as resource');
$this->assertRegExp(sprintf('/\'kernel.name\'\\s*=>\\s*\'%s\'/', static::$kernel->getName()), file_get_contents($containerFile), 'kernel.name is properly set on the dumped container');
$this->assertEquals(ini_get('memory_limit'), '1024M');
}
/**
*
* @param string $configDirectories
* @param string $configFiles
* @param string $cachePath
* @param bool $debug
*/
public function __construct($configDirectories, $configFiles, $cachePath, $debug = false)
{
$this->configDirectories = (array) $configDirectories;
$this->configFiles = (array) $configFiles;
$this->cachePath = $cachePath . '/faker_config.php';
$configCache = new ConfigCache($this->cachePath, $debug);
if (!$configCache->isFresh()) {
$locator = new FileLocator($this->configDirectories);
$loaderResolver = new LoaderResolver([new YamlLoader($locator)]);
$delegatingLoader = new DelegatingLoader($loaderResolver);
$resources = [];
$config = [];
foreach ($this->configFiles as $configFile) {
$path = $locator->locate($configFile);
$config = array_merge($config, $delegatingLoader->load($path));
$resources[] = new FileResource($path);
}
$exportConfig = var_export($this->parseRawConfig(isset($config['faker']) ? $config['faker'] : []), true);
$code = <<<PHP
<?php
return {$exportConfig};
PHP;
$configCache->write($code, $resources);
}
if (file_exists($this->cachePath)) {
$this->config = (include $this->cachePath);
}
}
/**
* Loads a container and returns it.
*
* If the cache file for the service container exists and is current, it
* will be loaded and returned. Otherwise, a new container will be built
* using the configuration file and the provided optional builder. The
* builder will be used to make changes to the service container before
* it is compiled and cached.
*
* It may be important to note that debug mode for the `ConfigCache` class
* is enabled by default. This will ensure that cached configuration files
* are updated whenever they are changed.
*
* @param string $containerCacheFilePath The container cache file path.
* @param callable $containerBuilderCallable The new container builder callable.
* @param string $compiledContainerClassName The compiled container class name.
* @param boolean $debug Is debugging mode enabled?
*
* @return Jarvis The loaded application.
*/
public static function create($containerCacheFilePath, callable $containerBuilderCallable = null, $compiledContainerClassName = 'AppCachedContainer', $debug = true)
{
$cacheManager = new ConfigCache($containerCacheFilePath, $debug);
if (!$cacheManager->isFresh()) {
$container = static::createContainer();
if (null !== $containerBuilderCallable) {
$containerBuilderCallable($container);
}
if ($debug) {
$filename = pathinfo($containerCacheFilePath, PATHINFO_DIRNAME) . '/' . pathinfo($containerCacheFilePath, PATHINFO_FILENAME) . '.xml';
$container->setParameter('debug.container.dump', $filename);
}
$container->compile();
$dumper = new PhpDumper($container);
$cacheManager->write($dumper->dump(array('class' => $compiledContainerClassName)), $container->getResources());
if ($debug) {
$filename = $container->getParameter('debug.container.dump');
$dumper = new XmlDumper($container);
$filesystem = new Filesystem();
$filesystem->dumpFile($filename, $dumper->dump(), null);
try {
$filesystem->chmod($filename, 0666, umask());
} catch (IOException $e) {
// discard chmod failure (some filesystem may not support it)
}
}
}
if (!class_exists($compiledContainerClassName)) {
/** @noinspection PhpIncludeInspection */
require $containerCacheFilePath;
}
return new Jarvis(new $compiledContainerClassName());
}
/**
* {@inheritDoc}
*/
public function getStructureMetadata($type, $structureType = null)
{
$cacheKey = $type . $structureType;
if (isset($this->cache[$cacheKey])) {
return $this->cache[$cacheKey];
}
$this->assertExists($type);
if (!$structureType) {
$structureType = $this->getDefaultStructureType($type);
}
if (!is_string($structureType)) {
throw new \InvalidArgumentException(sprintf('Expected string for structureType, got: %s', is_object($structureType) ? get_class($structureType) : gettype($structureType)));
}
$cachePath = sprintf('%s/%s%s', $this->cachePath, Inflector::camelize($type), Inflector::camelize($structureType));
$cache = new ConfigCache($cachePath, $this->debug);
if ($this->debug || !$cache->isFresh()) {
$paths = $this->getPaths($type);
// reverse paths, so that the last path overrides previous ones
$fileLocator = new FileLocator(array_reverse($paths));
try {
$filePath = $fileLocator->locate(sprintf('%s.xml', $structureType));
} catch (\InvalidArgumentException $e) {
throw new Exception\StructureTypeNotFoundException(sprintf('Could not load structure type "%s" for document type "%s", looked in "%s"', $structureType, $type, implode('", "', $paths)), null, $e);
}
$metadata = $this->loader->load($filePath, $type);
$resources = [new FileResource($filePath)];
$cache->write(sprintf('<?php $metadata = \'%s\';', serialize($metadata)), $resources);
}
require $cachePath;
$structure = unserialize($metadata);
$this->cache[$cacheKey] = $structure;
return $structure;
}
/**
* @return RamlDoc $doc
* @return self
*/
public function keep(RamlDoc $doc)
{
$code = var_export($doc, TRUE);
$code = "<?php return {$code};";
$this->configCache->write($code);
return $this;
}
/**
* @return array $map
* @return self
*/
public function keep(array $map)
{
$code = var_export($map, TRUE);
$code = "<?php return {$code};";
$this->configCache->write($code);
return $this;
}
/**
* Dumps the service container to PHP code in the cache.
*
* @param ConfigCache $cache The config cache
* @param ContainerBuilder $container The service container
* @param string $class The name of the class to generate
* @param string $baseClass The name of the container's base class
*/
protected function dumpContainer(ConfigCache $cache, ContainerBuilder $container, $class, $baseClass)
{
// cache the container
$dumper = new PhpDumper($container);
$content = $dumper->dump(array('class' => $class, 'base_class' => $baseClass, 'optimize_strings' => false));
$cache->write($content, $container->getResources());
}
/**
* @param AdminInterface $admin
*
* @return mixed
* @throws \RuntimeException
*/
public function load(AdminInterface $admin)
{
$filename = $this->cacheFolder . '/route_' . md5($admin->getCode());
$cache = new ConfigCache($filename, $this->debug);
if (!$cache->isFresh()) {
$resources = array();
$routes = array();
$reflection = new \ReflectionObject($admin);
$resources[] = new FileResource($reflection->getFileName());
if (!$admin->getRoutes()) {
throw new \RuntimeException('Invalid data type, Admin::getRoutes must return a RouteCollection');
}
foreach ($admin->getRoutes()->getElements() as $code => $route) {
$routes[$code] = $route->getDefault('_sonata_name');
}
if (!is_array($admin->getExtensions())) {
throw new \RuntimeException('extensions must be an array');
}
foreach ($admin->getExtensions() as $extension) {
$reflection = new \ReflectionObject($extension);
$resources[] = new FileResource($reflection->getFileName());
}
$cache->write(serialize($routes), $resources);
}
return unserialize(file_get_contents($filename));
}
public function testStaleResourceInDebug()
{
$staleResource = new ResourceStub();
$staleResource->setFresh(false);
$cache = new ConfigCache($this->cacheFile, true);
$cache->write('', array($staleResource));
$this->assertFalse($cache->isFresh());
}
function it_uses_config_cache_to_create_the_cache(Filesystem $filesystem, ContainerDumperFactory $dumperFactory, ContainerBuilder $containerBuilder, PhpDumper $dumper, ConfigCache $configCache)
{
$dumper->dump()->willReturn('file contents');
$dumperFactory->create($containerBuilder)->willReturn($dumper);
$containerBuilder->getResources()->willReturn([]);
$this->dump($containerBuilder);
$configCache->write('file contents', [])->shouldHaveBeenCalled();
}
/**
* @param SymfonyRequest $symfonyRequest
* @param string $filePath
*/
private function dumpContainer(SymfonyRequest $symfonyRequest, $filePath)
{
$containerConfigCache = new ConfigCache($filePath, $this->appMode === ApplicationMode::DEVELOPMENT);
if (!$containerConfigCache->isFresh()) {
$containerBuilder = ServiceContainerBuilder::create($this->appPath, $symfonyRequest, $this->appMode);
$dumper = new PhpDumper($containerBuilder);
$containerConfigCache->write($dumper->dump(['class' => 'ACP3ServiceContainer']), $containerBuilder->getResources());
}
}
/**
* {@inheritdoc}
*/
public function warmUp($cacheDir)
{
$filename = $cacheDir . '/padam87/attribute_bundle/Entity.cache.php';
$cache = new ConfigCache($filename, $this->debug);
if (!$cache->isFresh()) {
$content = '<?php return ' . var_export($this->getEntities(), true) . ';';
$cache->write($content, $this->getResources());
}
}
public function getWsdlFile($endpoint = null)
{
$id = $endpoint !== null ? '.' . md5($endpoint) : '';
$file = sprintf('%s/%s.wsdl', $this->options['cache_dir'], $this->options['name'] . $id);
$cache = new ConfigCache($file, true);
if (!$cache->isFresh()) {
$cache->write($this->wsdlFileDumper->dumpServiceDefinition($this->getServiceDefinition(), array('endpoint' => $endpoint)));
}
return $file;
}
/**
* Loads document proxy class into cache.
*
* @param \ReflectionClass $reflectionClass
*
* @return string Proxy document path.
*/
public function load(\ReflectionClass $reflectionClass)
{
$cacheBundleDir = $this->getCacheDir($reflectionClass->getName());
$cache = new ConfigCache($cacheBundleDir . DIRECTORY_SEPARATOR . md5(strtolower($reflectionClass->getShortName())) . '.php', $this->debug);
if (!$cache->isFresh()) {
$code = ProxyFactory::generate($reflectionClass);
$cache->write($code, [new FileResource($reflectionClass->getFileName())]);
}
return $cache->getPath();
}
protected function dumpContainer(ConfigCache $cache, ContainerBuilder $container, $class, $baseClass)
{
$dumper = new PhpDumper($container);
$namespace = null;
if (($p = strrpos($class, "\\")) !== false) {
$namespace = substr($class, 0, $p);
$class = substr($class, $p + 1);
}
$content = $dumper->dump(["namespace" => $namespace, "class" => $class, "base_class" => $baseClass]);
$cache->write($content, $container->getResources());
}
public function load(NestedRoute $nestedRoute)
{
$filename = $this->cacheFolder . '/route_' . md5($nestedRoute->getId());
$cache = new ConfigCache($filename, $this->debug);
if (!$cache->isFresh()) {
$resources = array();
$reflection = new ReflectionObject($nestedRoute);
$resources[] = new FileResource($reflection->getFileName());
$cache->write(serialize($this->flattenRouteFactory->getFlattenRoutes($nestedRoute)), $resources);
}
return unserialize(file_get_contents($filename));
}
/**
* Returns json string with WebUI config.
*
* @param boolean $useRequirejsRc Is use file .requirejsrc.
* @param string $jsonFilePath Path to parse json file with WebUI config.
* @param array $options Required options eg. resources, translations.
* @param array $extend Additional params.
*
* @return string
*/
public function startApp($useRequirejsRc, $jsonFilePath, array $options, array $extend = [])
{
$path = $this->getCacheFileName($jsonFilePath);
$cache = new ConfigCache($path, $this->env === 'dev');
if (!$cache->isFresh()) {
$resource = new FileResource($this->getSrcFileName($jsonFilePath));
$resourceRc = new FileResource($this->getRequirejsRcFile());
$content = $this->generateConfig($useRequirejsRc, $jsonFilePath, $options, $extend);
$cache->write($content, [$resource, $resourceRc]);
}
return file_get_contents($path);
}
private function regenerateUrlMatcher()
{
/** @var Router $router */
$router = $this->router;
$class = $router->getOption('matcher_cache_class');
$cache = new ConfigCache($router->getOption('cache_dir') . '/' . $class . '.php', $router->getOption('debug'));
$dumperClass = $router->getOption('matcher_dumper_class');
/** @var PhpMatcherDumper $dumper */
$dumper = new $dumperClass($router->getRouteCollection());
$options = array('class' => $class, 'base_class' => $router->getOption('matcher_base_class'));
$cache->write($dumper->dump($options), $router->getRouteCollection()->getResources());
}
public function getPageControllers()
{
if ($this->pageControllers === null) {
$cache = new ConfigCache($this->cacheFile, $this->debug);
if ($cache->isFresh()) {
$this->pageControllers = unserialize(require $cache->getPath());
} else {
$this->loadPageControllers();
$cache->write(sprintf('<?php return %s;', var_export(serialize($this->pageControllers), true)));
}
}
return $this->pageControllers;
}
/**
* indexAction action.
*/
public function indexAction(Request $request, $_format)
{
$cache = new ConfigCache($this->cacheDir . '/fosJsRouting.json', $this->debug);
if (!$cache->isFresh()) {
$content = $this->serializer->serialize(new RoutesResponse($this->exposedRoutesExtractor->getBaseUrl(), $this->exposedRoutesExtractor->getRoutes()), 'json');
$cache->write($content, $this->exposedRoutesExtractor->getResources());
}
$content = file_get_contents((string) $cache);
if ($callback = $request->query->get('callback')) {
$content = $callback . '(' . $content . ')';
}
return new Response($content, 200, array('Content-Type' => $request->getMimeType($_format)));
}
/**
* @return ContainerInterface
*/
protected function getContainerBuilderCached($contextFile, $cacheDir, $isDebug, $loaderFactory)
{
$contextFile = realpath($contextFile);
$className = "c" . Base32Hex::encode($contextFile);
$file = $cacheDir . '/' . $className;
$containerConfigCache = new ConfigCache($file, $isDebug);
if (!$containerConfigCache->isFresh()) {
$containerBuilder = $this->buildContainer($contextFile, $loaderFactory);
$dumper = new PhpDumper($containerBuilder);
$containerConfigCache->write($dumper->dump(array('class' => $className)), $containerBuilder->getResources());
}
require_once $file;
return new $className();
}
public function load($resource, $type = null)
{
$cache = new ConfigCache(sprintf('%s/%s.php', $this->cacheDir, crc32($resource)), $this->debug);
if (!$cache->isFresh()) {
$parameters = $this->loader->load($resource);
}
if ($this->cacheDir && isset($parameters)) {
$cache->write('<?php $parameters = ' . var_export($parameters, true) . ';', $this->resources->all());
}
if (!isset($parameters)) {
require (string) $cache;
}
return $parameters;
}
