/**
* @param string $key
* @return mixed|null
*/
public function get($key)
{
if (!$this->cache->contains($key)) {
$this->loadSettings();
}
return $this->cache->fetch($key);
}
/**
* @param string $packageName
* @return string
*/
public function getVersion($packageName = OroPlatformBundle::PACKAGE_NAME)
{
// Get package version from local cache if any
if (isset($this->packageVersions[$packageName])) {
return $this->packageVersions[$packageName];
}
// Try to get package version from persistent cache
if ($this->cache && $this->cache->contains($packageName)) {
$version = $this->cache->fetch($packageName);
} else {
// Get package version from composer repository
$packages = $this->factory->getLocalRepository()->findPackages($packageName);
if ($package = current($packages)) {
/** @var PackageInterface $package */
$version = $package->getPrettyVersion();
} else {
$version = self::UNDEFINED_VERSION;
}
//Save package version to persistent cache
if ($this->cache) {
$this->cache->save($packageName, $version);
}
}
// Save package version to local cache
$this->packageVersions[$packageName] = $version;
return $version;
}
/**
* Gets the timestamp of the last update of database translations for the given locale
*
* @param string $locale
* @return int|bool timestamp or false if the timestamp is not cached yet
*/
public function getTimestamp($locale)
{
if (!isset($this->localCache[$locale])) {
$this->localCache[$locale] = $this->cacheImpl->fetch($locale);
}
return $this->localCache[$locale];
}
/**
* Build menu.
*
* @param string $alias
* @param array $options
* @return ItemInterface
*/
public function get($alias, array $options = [])
{
$this->assertAlias($alias);
if (!array_key_exists($alias, $this->menus)) {
if ($this->cache && $this->cache->contains($alias)) {
$menuData = $this->cache->fetch($alias);
$this->menus[$alias] = $this->factory->createFromArray($menuData);
} else {
$menu = $this->factory->createItem($alias);
/** @var BuilderInterface $builder */
// try to find builder for the specified menu alias
if (array_key_exists($alias, $this->builders)) {
foreach ($this->builders[$alias] as $builder) {
$builder->build($menu, $options, $alias);
}
}
// In any case we must run common builder
if (array_key_exists(self::COMMON_BUILDER_ALIAS, $this->builders)) {
foreach ($this->builders[self::COMMON_BUILDER_ALIAS] as $builder) {
$builder->build($menu, $options, $alias);
}
}
$this->menus[$alias] = $menu;
$this->eventDispatcher->dispatch(ConfigureMenuEvent::getEventName($alias), new ConfigureMenuEvent($this->factory, $menu));
$this->sort($menu);
if ($this->cache) {
$this->cache->save($alias, $menu->toArray());
}
}
}
return $this->menus[$alias];
}
/**
* @return \Heyday\Redirects\Redirect[]
*/
public function get()
{
$key = $this->dataSource->getKey();
if (!($result = $this->cache->fetch($key))) {
$this->cache->save($key, $result = $this->dataSource->get());
}
return $result;
}
/**
* @param string $packageName
*
* @return int
*/
protected function getCachedAssetVersion($packageName)
{
if (!array_key_exists($packageName, $this->localCache)) {
$version = $this->cache->fetch($packageName);
$this->localCache[$packageName] = false !== $version ? $version : 0;
}
return $this->localCache[$packageName];
}
/**
* (non-PHPdoc)
* @see Generator/Admingenerator\GeneratorBundle\Generator.GeneratorInterface::build()
*/
public function build()
{
if ($this->cacheProvider->fetch($this->getCacheKey())) {
return;
}
$this->doBuild();
$this->cacheProvider->save($this->getCacheKey(), true);
}
/**
* @param DocumentFinder $finder For finding documents.
* @param DocumentParser $parser For reading document annotations.
* @param CacheProvider $cache Cache provider to store the meta data for later use.
*/
public function __construct($finder, $parser, $cache = null)
{
$this->finder = $finder;
$this->parser = $parser;
$this->cache = $cache;
if ($this->cache) {
$this->mappings = $this->cache->fetch('ongr.metadata.mappings');
}
}
/**
* Get an item.
*
* @param string $cacheId
* @param bool $success
*
* @return mixed Data on success, null on failure
*/
public function getItem($cacheId, &$success = null)
{
if (!$this->hasItem($cacheId)) {
$success = false;
return null;
}
$cacheId = $this->normalizeKey($cacheId);
$success = true;
return unserialize($this->cache->fetch($cacheId));
}
/**
* {@inheritdoc}
*/
public function get(RequesterInterface $requester, ResourceInterface $resource)
{
$cacheId = $this->getCacheId($requester, $resource);
$permission = $this->cacheProvider->fetch($cacheId);
if ($permission instanceof PermissionInterface) {
return $permission;
}
$this->cacheProvider->delete($cacheId);
return;
}
/**
* {@inheritdoc}
*/
public function canReblog($post)
{
$cacheKey = $this->makeCacheKey($post);
$cached = $this->cache->fetch($cacheKey);
if ($cached) {
return false;
}
$this->cache->save($cacheKey, '1', $this->term);
return true;
}
/**
* Returns the data for the given key.
*
* @param string $key The key to search for.
* @param mixed $default Default value to return if there is no data.
*
* @return mixed The cached data, default value or null, if no cache entry exists for the given id.
*/
public function get($key, $default = false)
{
$data = $this->cacheProvider->fetch($key);
if ($data === false && $default !== false) {
return $default;
} elseif ($data === false) {
return null;
}
return $data;
}
/**
* @param EventInterface $event
*/
public function preFind(EventInterface $event)
{
if (!preg_match('/\\d$/', $this->cacheId)) {
return;
//The current route is a POST, do not cache new resources with this cache ID
}
if ($this->cache->contains($this->cacheId)) {
$event->stopPropagation(true);
return $this->cache->fetch($this->cacheId);
}
}
/**
* @param \Doctrine\Common\Cache\CacheProvider $cacheDriver
*/
public function __construct($cacheDriver = null)
{
if (!is_null($cacheDriver) && class_exists('\\Doctrine\\Common\\Cache\\CacheProvider')) {
if ($cacheDriver instanceof \Doctrine\Common\Cache\CacheProvider) {
$this->cacheDriver = $cacheDriver;
if ($this->cacheDriver->contains($this->cacheKey)) {
$this->data = $this->cacheDriver->fetch($this->cacheKey);
}
}
}
}
public function saveCollectInformation($id, $information)
{
$this->cache->save($id, $information);
$indexArray = $this->cache->fetch('index');
if (empty($indexArray)) {
$indexArray = [];
}
$indexArray[$id] = array_merge($information['request'], $information['response']);
$this->cache->save('index', $indexArray);
return $id;
}
/**
* @return array
*/
public function loadSourceData()
{
if (null === $this->cache) {
return $this->formatDataLoader->load($this->getUrl());
}
$key = $this->getObjectKey();
if (!$this->cache->contains($key)) {
$this->cache->save($key, $this->formatDataLoader->load($this->getUrl()), $this->getTtl());
}
return $this->cache->fetch($key);
}
/**
* Gets a flag indicates whether an entity or entity field is configurable or not.
*
* @param string $className
* @param string|null $fieldName
* @return bool|null true if an entity or entity field is configurable;
* false if not;
* null if unknown (it means that "is configurable" flag was not set yet)
*/
public function getConfigurable($className, $fieldName = null)
{
$flag = $this->modelCache->fetch($this->buildModelCacheKey($className, $fieldName));
if ($flag === false) {
// no cache entry exists
$flag = null;
} elseif ($flag === null) {
// no cache entry exists and it say that an entity or entity field is not configurable
$flag = false;
}
return $flag;
}
/**
* {@inheritdoc}
*/
public function getItem($key)
{
if (isset($this->deferred[$key])) {
return $this->deferred[$key];
}
if (false === $this->provider->contains($key)) {
return new CacheItem($key);
}
$item = $this->provider->fetch($key);
$item->setHit(true);
return $item;
}
/**
* Finds first available image for listing purposes
*
* @param Content $content
*
* @return string
*/
public function getCoverImage(Content $content)
{
$key = $content->getCoverImageCacheKey();
if (!($image = $this->cache->fetch($key))) {
$image = $content->getCoverImage();
if ($image) {
$image = $this->imageCacheManager->getBrowserPath($image, 'medialibrary');
}
$this->cache->save($key, $image, 86400);
}
return $image;
}
public function call()
{
if (!in_array($this->app->request()->getMethod(), ['GET', 'HEAD'])) {
return $this->next->call();
}
$cacheKey = $this->app->request()->getPathInfo();
if ($this->cache->contains($cacheKey)) {
$resource = $this->cache->fetch($cacheKey);
$lastModified = strtotime($resource['last_updated_at']);
$this->app->lastModified($lastModified);
}
$this->next->call();
}
/**
* @return string
*/
public function get()
{
$key = 'feed';
if ($this->cache->contains($key)) {
return $this->cache->fetch($key);
}
$articles = $this->articleRepository->findPublishedOrderedByPublishDate();
$feed = $this->feedManager->get('article');
$feed->addFromArray($articles);
$renderedFeed = $feed->render('rss');
$this->cache->save($key, $renderedFeed);
return $renderedFeed;
}
/**
* Fetches piece of JS-code with require.js main config from cache
* or if it was not there - generates and put into a cache
*
* @return string
*/
public function getMainConfig()
{
$config = null;
if ($this->cache) {
$config = $this->cache->fetch(self::REQUIREJS_CONFIG_CACHE_KEY);
}
if (empty($config)) {
$config = $this->generateMainConfig();
if ($this->cache) {
$this->cache->save(self::REQUIREJS_CONFIG_CACHE_KEY, $config);
}
}
return $config;
}
/**
* Makes sure that metadata are loaded and cached
*/
protected function ensureMetadataLoaded()
{
if ($this->localCache === null) {
$data = null;
if ($this->cache) {
$data = $this->cache->fetch(self::CACHE_KEY);
}
if ($data) {
$this->localCache = $data;
} else {
$this->loadMetadata();
}
}
}
/**
* @return array
*/
public function getAll()
{
$key = 'statistics';
if ($this->cache->contains($key)) {
return $this->cache->fetch($key);
}
$statistics = $this->articleRepository->findStatistics();
$mostPopularArticle = $this->articleRepository->findMostPopular();
if ($mostPopularArticle) {
$statistics['mostPopularArticleData'] = ['slug' => $mostPopularArticle->getSlug(), 'title' => $mostPopularArticle->getTitle(), 'viewsCount' => $mostPopularArticle->getViewsCount()];
}
$this->cache->save($key, $statistics, $this->cacheLifetime);
return $statistics;
}
/**
* Makes sure that tree data are loaded and cached
*/
protected function ensureTreeLoaded()
{
if ($this->tree === null) {
$treeData = null;
if ($this->cache) {
$treeData = $this->cache->fetch(self::CACHE_KEY);
}
if ($treeData) {
$this->tree = $treeData;
} else {
$this->loadTree();
}
}
}
/**
* @param \DateTime $date
* @param \Hyper\AdsBundle\Entity\Zone[] $zones
* @return array
*/
private function getNumberOfBannersOfAllZonesInGivenDay(\DateTime $date, $zones)
{
static $warmUpZones = array();
$formattedDate = $date->format(self::DATE_FORMAT);
$zonesNumberMap = array();
foreach ($zones as $zone) {
if (!isset($warmUpZones[$zone->getId()])) {
$this->warmUp($zone);
$warmUpZones[$zone->getId()] = true;
}
$cacheId = self::CACHE_PREFIX . $zone->getId() . '_' . $formattedDate;
$zonesNumberMap[$zone->getId() . '_' . $zone->getName()] = intval($this->cache->fetch($cacheId));
}
return $zonesNumberMap;
}
/**
* Return the user's environments.
*
* @param Project $project The project.
* @param bool $refresh Whether to refresh the list.
* @param bool $updateAliases Whether to update Drush aliases if the list changes.
*
* @return Environment[] The user's environments.
*/
public function getEnvironments(Project $project = null, $refresh = false, $updateAliases = true)
{
$project = $project ?: $this->getSelectedProject();
$projectId = $project->getProperty('id');
$cacheKey = 'environments:' . $projectId;
$cached = self::$cache->contains($cacheKey);
if ($refresh || !$cached) {
$environments = array();
$toCache = array();
foreach ($project->getEnvironments() as $environment) {
$environments[$environment['id']] = $environment;
$toCache[$environment['id']] = $environment->getData();
}
// Recreate the aliases if the list of environments has changed.
if ($updateAliases && (!$cached || array_diff_key($environments, self::$cache->fetch($cacheKey)))) {
$this->updateDrushAliases($project, $environments);
}
self::$cache->save($cacheKey, $toCache, $this->environmentsTtl);
} else {
$environments = array();
$connector = $this->getClient(false)->getConnector();
$endpoint = $project->hasLink('self') ? $project->getLink('self', true) : $project['endpoint'];
$client = $connector->getClient();
foreach ((array) self::$cache->fetch($cacheKey) as $id => $data) {
$environments[$id] = Environment::wrap($data, $endpoint, $client);
}
}
return $environments;
}
/**
* Add uri based on route.
*
* @param array $options
*/
protected function processRoute(array &$options = array())
{
if (!empty($options['route'])) {
$params = array();
if (isset($options['routeParameters'])) {
$params = $options['routeParameters'];
}
$cacheKey = null;
$hasInCache = false;
$uri = null;
if ($this->cache) {
$cacheKey = $this->getCacheKey('route_uri', $options['route'] . ($params ? serialize($params) : ''));
if ($this->cache->contains($cacheKey)) {
$uri = $this->cache->fetch($cacheKey);
$hasInCache = true;
}
}
if (!$hasInCache) {
$absolute = false;
if (isset($options['routeAbsolute'])) {
$absolute = $options['routeAbsolute'];
}
$uri = $this->router->generate($options['route'], $params, $absolute);
if ($this->cache) {
$this->cache->save($cacheKey, $uri);
}
}
$options['uri'] = $uri;
$options = array_merge_recursive(array('extras' => array('routes' => array($options['route']), 'routesParameters' => array($options['route'] => $params))), $options);
}
}
/**
* @param string $file
* @param \Doctrine\Common\Cache\CacheProvider $cache
* @throws \Heystack\Core\Exception\ConfigurationException
*/
public function __construct($file, CacheProvider $cache)
{
// if it isn't an absolute path (detected by the file not existing)
if (!file_exists($file)) {
$file = BASE_PATH . '/' . $file;
}
if (!file_exists($file)) {
throw new ConfigurationException(sprintf("Your file '%s' doesn't exist", $file));
}
// Use the contents as the key so invalidation happens on change
$key = md5(file_get_contents($file));
if (($config = $cache->fetch($key)) === false) {
$config = $this->parseFile($file);
$cache->save($key, $config);
}
if (!is_array($config)) {
throw new ConfigurationException(sprintf("Your config is empty for file '%s'", $file));
}
if (!array_key_exists('id', $config)) {
throw new ConfigurationException(sprintf("Identifier missing for file '%s'", $file));
}
if (!array_key_exists('flat', $config)) {
throw new ConfigurationException(sprintf("Flat config missing for file '%s'", $file));
}
$this->config = $config;
}
/**
* Wrapper function to run shell commands. Supports local and remote commands
* depending on the gitEnvironment details.
*
* @param string $command command to run
* @param bool $cacheCommand command to run
* @param bool $trim do not trim response. Maybe need for some command responses
*
* @return string Result of command
*
* @throws \RuntimeException
*/
public function runCommand($command, $cacheCommand = true, $trim = true)
{
$response = '';
if ($this->stopwatch) {
$this->stopwatch->start('git_request', 'version_control');
}
$fullCommand = sprintf('cd %s && %s', $this->gitPath, $command);
$cacheId = md5($this->gitEnvironment->getId() . $fullCommand);
if ($this->gitEnvironment->getSsh() === true) {
//Run remote command over ssh
if ($cacheCommand === true) {
$response = $this->cache->fetch($cacheId);
if ($response === false) {
$response = $this->runRemoteCommand($fullCommand);
$this->cache->save($cacheId, $response);
}
} else {
$response = $this->runRemoteCommand($fullCommand);
}
} else {
//Run local commands
$start = microtime(true);
$response = $this->runLocalCommand($command);
$this->logCommand($fullCommand, 'local', array(), $start);
}
return $trim === true ? trim($response) : $response;
}
