/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/tedivm/stash/src/Stash/Utilities.php
*
* @throws Exception\RuntimeException
* @throws Exception\InvalidArgumentException
*/
public static function checkFileSystemPermissions($path, int $permissions)
{
if (!isset($path)) {
throw new RuntimeException('Cache path was not set correctly.');
}
if (file_exists($path) && !is_dir($path)) {
throw new InvalidArgumentException('Cache path is not a directory.');
}
if (!is_dir($path) && !@mkdir($path, $permissions, true)) {
throw new InvalidArgumentException('Failed to create cache path.');
}
if (!is_writable($path)) {
throw new InvalidArgumentException('Cache path is not writable.');
}
}
/**
* Checks to see if a directory is empty.
*
* @param string $path
* @return bool
*/
public static function checkForEmptyDirectory($path)
{
$empty = true;
$dir = opendir($path);
while ($file = readdir($dir)) {
if ($file != '.' && $file != '..') {
$empty = false;
break;
}
}
closedir($dir);
Arguments
"Cache path is not writable."
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/tedivm/stash/src/Stash/Driver/FileSystem.php
$encoder = $options['encoder'];
if (is_object($encoder)) {
if (!($encoder instanceof EncoderInterface)) {
throw new RuntimeException('Encoder object must implement EncoderInterface');
}
$this->encoder = new $encoder;
} else {
$encoderInterface = 'Stash\Driver\FileSystem\EncoderInterface';
$encoderClass = 'Stash\Driver\FileSystem\\' . $encoder . 'Encoder';
if (class_exists($encoder) && in_array($encoderInterface, class_implements($encoder))) {
$this->encoder = new $encoder();
} elseif (class_exists($encoderClass) && in_array($encoderInterface, class_implements($encoderClass))) {
$this->encoder = new $encoderClass();
} else {
throw new RuntimeException('Invalid Encoder: ' . $encoder);
}
}
}
Utilities::checkFileSystemPermissions($this->cachePath, $this->dirPermissions);
}
/**
* Converts a key array into a key string.
*
* @param array $key
* @return string
*/
protected function makeKeyString($key)
{
$keyString = '';
foreach ($key as $group) {
$keyString .= $group . '/';
}
return $keyString;
}
/**
* This function retrieves the data from the file. If the file does not exist, or is currently being written to, it
Arguments
"/home/newbrokersallian/public_html/application/files/cache/expensive/"
493
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/tedivm/stash/src/Stash/Driver/AbstractDriver.php
* @package Stash
* @author Robert Hafner <[email protected]>
*/
abstract class AbstractDriver implements DriverInterface
{
/**
* Initializes the driver.
*
* @param array $options
* An additional array of options to pass through to setOptions().
*
* @throws RuntimeException
*/
public function __construct(array $options = array())
{
if (!static::isAvailable()) {
throw new RuntimeException(get_class($this) . ' is not available.');
}
$this->setOptions($options);
}
/**
* @return array
*/
public function getDefaultOptions()
{
return array();
}
/**
* {@inheritdoc}
*/
protected function setOptions(array $options = array())
{
// empty
}
/**
* {@inheritdoc}
Arguments
array:6 [
"path" => "/home/newbrokersallian/public_html/application/files/cache/expensive"
"dirPermissions" => 493
"filePermissions" => 420
"dirSplit" => 2
"memKeyLimit" => 20
"keyHashFunction" => "md5"
]
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Cache/Cache.php
/**
* Function used to build a driver from a driverConfig array.
*
* @param array $driverConfig The config item belonging to the driver
*
* @return null|\Stash\Interfaces\DriverInterface
*/
private function buildDriver(array $driverConfig)
{
$class = array_get($driverConfig, 'class', '');
if ($class && class_exists($class)) {
$implements = class_implements($class);
// Make sure that the provided class implements the DriverInterface
if (isset($implements['Stash\Interfaces\DriverInterface'])) {
/* @var \Stash\Interfaces\DriverInterface $tempDriver */
// Only add if the driver is available
if ($class::isAvailable()) {
$tempDriver = new $class(array_get($driverConfig, 'options', null));
return $tempDriver;
}
} else {
throw new \RuntimeException('Cache driver class must implement \Stash\Interfaces\DriverInterface.');
}
}
return null;
}
public function getPool()
{
return $this->pool;
}
/**
* Deletes an item from the cache.
*
* @param string $key Name of the cache item ID
Arguments
array:3 [
"path" => "/home/newbrokersallian/public_html/application/files/cache/expensive"
"dirPermissions" => 493
"filePermissions" => 420
]
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Cache/Cache.php
*
* @return \Stash\Interfaces\DriverInterface
*/
protected function loadConfig($level)
{
$app = Application::getFacadeApplication();
$drivers = [];
$driverConfigs = $app['config']->get("concrete.cache.levels.{$level}.drivers", []);
$preferredDriverName = $app['config']->get("concrete.cache.levels.{$level}.preferred_driver", null);
// Load the preferred driver(s) first
if (!empty($preferredDriverName)) {
if (is_array($preferredDriverName)) {
foreach ($preferredDriverName as $driverName) {
$preferredDriver = array_get($driverConfigs, $driverName, []);
$drivers[] = $this->buildDriver($preferredDriver);
}
} else {
$preferredDriver = array_get($driverConfigs, $preferredDriverName, []);
$drivers[] = $this->buildDriver($preferredDriver);
}
}
// If we dont have any perferred drivers or preferred drivers available
// Build Everything
if (empty($drivers)) {
foreach ($driverConfigs as $driverConfig) {
if (!$driverConfig) {
continue;
}
$drivers[] = $this->buildDriver($driverConfig);
}
}
// Remove any empty arrays for an accurate count
array_filter($drivers);
$count = count($drivers);
if ($count > 1) {
$driver = new Composite(['drivers' => $drivers]);
} elseif ($count === 1) {
Arguments
array:2 [
"class" => "Concrete\Core\Cache\Driver\FileSystemStashDriver"
"options" => array:3 [
"path" => "/home/newbrokersallian/public_html/application/files/cache/expensive"
"dirPermissions" => 493
"filePermissions" => 420
]
]
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Cache/Level/ExpensiveCache.php
<?php
namespace Concrete\Core\Cache\Level;
use Concrete\Core\Cache\Cache;
use Config;
use Stash\Driver\BlackHole;
use Stash\Pool;
/**
* Class ExpensiveCache
* This cache stores data that is expensive to build that will see a performance boost if stored on disk.
*
* \@package Concrete\Core\Cache\Level
*/
class ExpensiveCache extends Cache
{
protected function init()
{
if (Config::get('concrete.cache.enabled') == true) {
$driver = $this->loadConfig('expensive');
$this->pool = new Pool($driver);
} else {
$this->pool = new Pool(new BlackHole());
}
$this->enable();
}
}
Arguments
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Cache/Cache.php
* - ObjectCache
* - RequestCache
*
* Cache storage is performed using the Stash Library, see http://www.stashphp.com/
*
* This class imports the various caching settings from Config class, sets
* up the Stash pools and provides a basic caching API for all of Concrete5.
*/
abstract class Cache implements FlushableInterface
{
/** @var Pool */
public $pool = null;
/** @var bool */
protected $enabled = false;
/** @var \Stash\Interfaces\DriverInterface */
protected $driver = null;
public function __construct()
{
$this->init();
}
/**
* Initializes the cache by setting up the cache pool and enabling the cache.
*/
abstract protected function init();
/**
* Loads the composite driver from constants.
*
* @param $level
*
* @return \Stash\Interfaces\DriverInterface
*/
protected function loadConfig($level)
{
$app = Application::getFacadeApplication();
$drivers = [];
$driverConfigs = $app['config']->get("concrete.cache.levels.{$level}.drivers", []);
$preferredDriverName = $app['config']->get("concrete.cache.levels.{$level}.preferred_driver", null);
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/illuminate/container/Container.php
return new $concrete;
}
$dependencies = $constructor->getParameters();
// Once we have all the constructor's parameters we can create each of the
// dependency instances and then use the reflection instances to make a
// new instance of this class, injecting the created dependencies in.
try {
$instances = $this->resolveDependencies($dependencies);
} catch (BindingResolutionException $e) {
array_pop($this->buildStack);
throw $e;
}
array_pop($this->buildStack);
return $reflector->newInstanceArgs($instances);
}
/**
* Resolve all of the dependencies from the ReflectionParameters.
*
* @param \ReflectionParameter[] $dependencies
* @return array
*
* @throws \Illuminate\Contracts\Container\BindingResolutionException
*/
protected function resolveDependencies(array $dependencies)
{
$results = [];
foreach ($dependencies as $dependency) {
// If the dependency has an override for this particular build we will use
// that instead as the value. Otherwise, we will continue with this run
// of resolutions and let reflection attempt to determine the result.
if ($this->hasParameterOverride($dependency)) {
$results[] = $this->getParameterOverride($dependency);
Arguments
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Application/Application.php
$args = $this->isRunThroughCommandLineInterface() && isset($_SERVER['argv']) ? $_SERVER['argv'] : null;
$detector = new EnvironmentDetector();
return $this->environment = $detector->detect($environments, $args);
}
/**
* Instantiate a concrete instance of the given type.
*
* @param string $concrete
* @param array $parameters
*
* @throws \Illuminate\Contracts\Container\BindingResolutionException
*
* @return mixed
*/
public function build($concrete)
{
$object = parent::build($concrete);
if (is_object($object)) {
if ($object instanceof ApplicationAwareInterface) {
$object->setApplication($this);
}
if ($object instanceof LoggerAwareInterface) {
$logger = $this->make('log/factory')->createLogger($object->getLoggerChannel());
$object->setLogger($logger);
} elseif ($object instanceof PsrLoggerAwareInterface) {
$logger = $this->make('log/factory')->createLogger(Channels::CHANNEL_APPLICATION);
$object->setLogger($logger);
}
}
return $object;
}
/**
* @return RuntimeInterface
*/
Arguments
"Concrete\Core\Cache\Level\ExpensiveCache"
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/illuminate/container/Container.php
// If the abstract type was already resolved in this container we'll fire the
// rebound listener so that any objects which have already gotten resolved
// can have their copy of the object updated via the listener callbacks.
if ($this->resolved($abstract)) {
$this->rebound($abstract);
}
}
/**
* Get the Closure to be used when building a type.
*
* @param string $abstract
* @param string $concrete
* @return \Closure
*/
protected function getClosure($abstract, $concrete)
{
return function ($container, $parameters = []) use ($abstract, $concrete) {
if ($abstract == $concrete) {
return $container->build($concrete);
}
return $container->resolve(
$concrete, $parameters, $raiseEvents = false
);
};
}
/**
* Determine if the container has a method binding.
*
* @param string $method
* @return bool
*/
public function hasMethodBinding($method)
{
return isset($this->methodBindings[$method]);
}
/**
Arguments
"Concrete\Core\Cache\Level\ExpensiveCache"
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/illuminate/container/Container.php
{
return $concrete === $abstract || $concrete instanceof Closure;
}
/**
* Instantiate a concrete instance of the given type.
*
* @param \Closure|string $concrete
* @return mixed
*
* @throws \Illuminate\Contracts\Container\BindingResolutionException
* @throws \Illuminate\Contracts\Container\CircularDependencyException
*/
public function build($concrete)
{
// If the concrete type is actually a Closure, we will just execute it and
// hand back the results of the functions, which allows functions to be
// used as resolvers for more fine-tuned resolution of these objects.
if ($concrete instanceof Closure) {
return $concrete($this, $this->getLastParameterOverride());
}
try {
$reflector = new ReflectionClass($concrete);
} catch (ReflectionException $e) {
throw new BindingResolutionException("Target class [$concrete] does not exist.", 0, $e);
}
// If the type is not instantiable, the developer is attempting to resolve
// an abstract type such as an Interface or Abstract Class and there is
// no binding registered for the abstractions so we need to bail out.
if (! $reflector->isInstantiable()) {
return $this->notInstantiable($concrete);
}
$this->buildStack[] = $concrete;
$constructor = $reflector->getConstructor();
// If there are no constructors, that means there are no dependencies then
Arguments
Concrete\Core\Application\Application {#9}
[]
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Application/Application.php
$args = $this->isRunThroughCommandLineInterface() && isset($_SERVER['argv']) ? $_SERVER['argv'] : null;
$detector = new EnvironmentDetector();
return $this->environment = $detector->detect($environments, $args);
}
/**
* Instantiate a concrete instance of the given type.
*
* @param string $concrete
* @param array $parameters
*
* @throws \Illuminate\Contracts\Container\BindingResolutionException
*
* @return mixed
*/
public function build($concrete)
{
$object = parent::build($concrete);
if (is_object($object)) {
if ($object instanceof ApplicationAwareInterface) {
$object->setApplication($this);
}
if ($object instanceof LoggerAwareInterface) {
$logger = $this->make('log/factory')->createLogger($object->getLoggerChannel());
$object->setLogger($logger);
} elseif ($object instanceof PsrLoggerAwareInterface) {
$logger = $this->make('log/factory')->createLogger(Channels::CHANNEL_APPLICATION);
$object->setLogger($logger);
}
}
return $object;
}
/**
* @return RuntimeInterface
*/
Arguments
Closure($container, $parameters = []) {#167 …4}
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/illuminate/container/Container.php
$needsContextualBuild = ! empty($parameters) || ! is_null($concrete);
// If an instance of the type is currently being managed as a singleton we'll
// just return an existing instance instead of instantiating new instances
// so the developer can keep using the same objects instance every time.
if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
return $this->instances[$abstract];
}
$this->with[] = $parameters;
if (is_null($concrete)) {
$concrete = $this->getConcrete($abstract);
}
// We're ready to instantiate an instance of the concrete type registered for
// the binding. This will instantiate the types, as well as resolve any of
// its "nested" dependencies recursively until all have gotten resolved.
if ($this->isBuildable($concrete, $abstract)) {
$object = $this->build($concrete);
} else {
$object = $this->make($concrete);
}
// If we defined any extenders for this type, we'll need to spin through them
// and apply them to the object being built. This allows for the extension
// of services, such as changing configuration or decorating the object.
foreach ($this->getExtenders($abstract) as $extender) {
$object = $extender($object, $this);
}
// If the requested type is registered as a singleton we'll want to cache off
// the instances in "memory" so we can return it later without creating an
// entirely new instance of an object on each subsequent request for it.
if ($this->isShared($abstract) && ! $needsContextualBuild) {
$this->instances[$abstract] = $object;
}
if ($raiseEvents) {
$this->fireResolvingCallbacks($abstract, $object);
Arguments
Closure($container, $parameters = []) {#167 …4}
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/illuminate/container/Container.php
*
* @throws \Illuminate\Contracts\Container\BindingResolutionException
*/
public function makeWith($abstract, array $parameters = [])
{
return $this->make($abstract, $parameters);
}
/**
* Resolve the given type from the container.
*
* @param string|callable $abstract
* @param array $parameters
* @return mixed
*
* @throws \Illuminate\Contracts\Container\BindingResolutionException
*/
public function make($abstract, array $parameters = [])
{
return $this->resolve($abstract, $parameters);
}
/**
* {@inheritdoc}
*
* @return mixed
*/
public function get($id)
{
try {
return $this->resolve($id);
} catch (Exception $e) {
if ($this->has($id) || $e instanceof CircularDependencyException) {
throw $e;
}
throw new EntryNotFoundException($id, $e->getCode(), $e);
}
}
Arguments
"Concrete\Core\Cache\Level\ExpensiveCache"
[]
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Support/Facade/Facade.php
* Handle dynamic, static calls to the object.
*
* @param string $method
* @param array $args
*
* @return mixed
*/
public static function __callStatic($method, $args)
{
$instance = static::resolveFacadeInstance(static::getFacadeAccessor());
if (!method_exists($instance, $method) && !method_exists($instance, '__call')) {
throw new \Exception(t('Invalid Method on class %s: %s.', get_class($instance), $method));
}
switch (count($args)) {
case 0:
return $instance->$method();
case 1:
return $instance->$method($args[0]);
case 2:
return $instance->$method($args[0], $args[1]);
case 3:
return $instance->$method($args[0], $args[1], $args[2]);
case 4:
return $instance->$method($args[0], $args[1], $args[2], $args[3]);
default:
return call_user_func_array(array($instance, $method), $args);
}
}
}
Arguments
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Cache/Adapter/DoctrineCacheDriver.php
/**
* @var string Name of the cache being used
*/
private $cacheName;
/**
* @param string $cacheName Name of the cache being used. Defaults to cache.
*/
public function __construct($cacheName = 'cache')
{
$this->cacheName = $cacheName;
}
/**
* @return Cache
*/
private function getC5Cache()
{
if ($this->c5Cache === null) {
$this->c5Cache = Core::make($this->cacheName);
}
return $this->c5Cache;
}
/**
* {@inheritdoc}
*/
protected function doFetch($id)
{
if (!$this->getC5Cache()->isEnabled()) {
return false;
}
$item = $this->getC5Cache()->getItem('doctrine/' . $id);
return $item->isMiss() ? false : $item->get();
}
/**
* {@inheritdoc}
Arguments
"make"
array:1 [
0 => "cache/expensive"
]
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Cache/Adapter/DoctrineCacheDriver.php
}
/**
* @return Cache
*/
private function getC5Cache()
{
if ($this->c5Cache === null) {
$this->c5Cache = Core::make($this->cacheName);
}
return $this->c5Cache;
}
/**
* {@inheritdoc}
*/
protected function doFetch($id)
{
if (!$this->getC5Cache()->isEnabled()) {
return false;
}
$item = $this->getC5Cache()->getItem('doctrine/' . $id);
return $item->isMiss() ? false : $item->get();
}
/**
* {@inheritdoc}
*/
protected function doContains($id)
{
if (!$this->getC5Cache()->isEnabled()) {
return false;
}
return $this->getC5Cache()->exists('doctrine/' . $id);
}
/**
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/doctrine/cache/lib/Doctrine/Common/Cache/CacheProvider.php
/**
* Returns the namespace cache key.
*/
private function getNamespaceCacheKey(): string
{
return sprintf(self::DOCTRINE_NAMESPACE_CACHEKEY, $this->namespace);
}
/**
* Returns the namespace version.
*/
private function getNamespaceVersion(): int
{
if ($this->namespaceVersion !== null) {
return $this->namespaceVersion;
}
$namespaceCacheKey = $this->getNamespaceCacheKey();
$this->namespaceVersion = (int) $this->doFetch($namespaceCacheKey) ?: 1;
return $this->namespaceVersion;
}
/**
* Default implementation of doFetchMultiple. Each driver that supports multi-get should owerwrite it.
*
* @param string[] $keys Array of keys to retrieve from cache
*
* @return mixed[] Array of values retrieved for the given keys.
*/
protected function doFetchMultiple(array $keys)
{
$returnValues = [];
foreach ($keys as $key) {
$item = $this->doFetch($key);
if ($item === false && ! $this->doContains($key)) {
continue;
}
Arguments
"DoctrineNamespaceCacheKey[]"
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/doctrine/cache/lib/Doctrine/Common/Cache/CacheProvider.php
if ($this->doSave($namespaceCacheKey, $namespaceVersion)) {
$this->namespaceVersion = $namespaceVersion;
return true;
}
return false;
}
/**
* Prefixes the passed id with the configured namespace value.
*
* @param string $id The id to namespace.
*
* @return string The namespaced id.
*/
private function getNamespacedId(string $id): string
{
$namespaceVersion = $this->getNamespaceVersion();
return sprintf('%s[%s][%s]', $this->namespace, $id, $namespaceVersion);
}
/**
* Returns the namespace cache key.
*/
private function getNamespaceCacheKey(): string
{
return sprintf(self::DOCTRINE_NAMESPACE_CACHEKEY, $this->namespace);
}
/**
* Returns the namespace version.
*/
private function getNamespaceVersion(): int
{
if ($this->namespaceVersion !== null) {
return $this->namespaceVersion;
}
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/doctrine/cache/lib/Doctrine/Common/Cache/CacheProvider.php
$this->namespace = (string) $namespace;
$this->namespaceVersion = null;
}
/**
* Retrieves the namespace that prefixes all cache ids.
*
* @return string
*/
public function getNamespace()
{
return $this->namespace;
}
/**
* {@inheritdoc}
*/
public function fetch($id)
{
return $this->doFetch($this->getNamespacedId($id));
}
/**
* {@inheritdoc}
*/
public function fetchMultiple(array $keys)
{
if (empty($keys)) {
return [];
}
// note: the array_combine() is in place to keep an association between our $keys and the $namespacedKeys
$namespacedKeys = array_combine($keys, array_map([$this, 'getNamespacedId'], $keys));
$items = $this->doFetchMultiple($namespacedKeys);
$foundItems = [];
// no internal array function supports this sort of mapping: needs to be iterative
// this filters and combines keys in one pass
foreach ($namespacedKeys as $requestedKey => $namespacedKey) {
if (! isset($items[$namespacedKey]) && ! array_key_exists($namespacedKey, $items)) {
Arguments
"Concrete\Core\Entity\Package"
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/doctrine/annotations/lib/Doctrine/Common/Annotations/CachedReader.php
* Clears loaded annotations.
*
* @return void
*/
public function clearLoadedAnnotations()
{
$this->loadedAnnotations = [];
$this->loadedFilemtimes = [];
}
/**
* Fetches a value from the cache.
*
* @param string $cacheKey The cache key.
*
* @return mixed The cached value or false when the value is not in cache.
*/
private function fetchFromCache($cacheKey, ReflectionClass $class)
{
$data = $this->cache->fetch($cacheKey);
if ($data !== false) {
if (! $this->debug || $this->isCacheFresh($cacheKey, $class)) {
return $data;
}
}
return false;
}
/**
* Saves a value to the cache.
*
* @param string $cacheKey The cache key.
* @param mixed $value The value.
*
* @return void
*/
private function saveToCache($cacheKey, $value)
{
$this->cache->save($cacheKey, $value);
Arguments
"Concrete\Core\Entity\Package"
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/doctrine/annotations/lib/Doctrine/Common/Annotations/CachedReader.php
/** @param bool $debug */
public function __construct(Reader $reader, Cache $cache, $debug = false)
{
$this->delegate = $reader;
$this->cache = $cache;
$this->debug = (bool) $debug;
}
/**
* {@inheritDoc}
*/
public function getClassAnnotations(ReflectionClass $class)
{
$cacheKey = $class->getName();
if (isset($this->loadedAnnotations[$cacheKey])) {
return $this->loadedAnnotations[$cacheKey];
}
$annots = $this->fetchFromCache($cacheKey, $class);
if ($annots === false) {
$annots = $this->delegate->getClassAnnotations($class);
$this->saveToCache($cacheKey, $annots);
}
return $this->loadedAnnotations[$cacheKey] = $annots;
}
/**
* {@inheritDoc}
*/
public function getClassAnnotation(ReflectionClass $class, $annotationName)
{
foreach ($this->getClassAnnotations($class) as $annot) {
if ($annot instanceof $annotationName) {
return $annot;
}
}
return null;
Arguments
"Concrete\Core\Entity\Package"
ReflectionClass {#1295
+name: "Concrete\Core\Entity\Package"
implements: array:1 [
0 => "Concrete\Core\Package\LocalizablePackageInterface"
]
constants: []
properties: array:8 [
"pkgID" => ReflectionProperty {#1357
+name: "pkgID"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Id @ORM\Column(type="integer", options={"unsigned":true})\n
* @ORM\GeneratedValue(strategy="AUTO")\n
*/
"""
}
}
"pkgHandle" => ReflectionProperty {#1361
+name: "pkgHandle"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="string", unique=true)\n
*/
"""
}
}
"pkgVersion" => ReflectionProperty {#1363
+name: "pkgVersion"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="string")\n
*/
"""
}
}
"pkgIsInstalled" => ReflectionProperty {#1364
+name: "pkgIsInstalled"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="boolean")\n
*/
"""
}
}
"pkgAvailableVersion" => ReflectionProperty {#1360
+name: "pkgAvailableVersion"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="string", nullable=true)\n
*/
"""
}
}
"pkgDescription" => ReflectionProperty {#1362
+name: "pkgDescription"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="text")\n
*/
"""
}
}
"pkgDateInstalled" => ReflectionProperty {#1365
+name: "pkgDateInstalled"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="datetime")\n
*/
"""
}
}
"pkgName" => ReflectionProperty {#1366
+name: "pkgName"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="string", nullable=true)\n
*/
"""
}
}
]
methods: array:20 [
"getPackageHandle" => ReflectionMethod {#1367
+name: "getPackageHandle"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageHandle" => ReflectionMethod {#1368
+name: "setPackageHandle"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgHandle: ReflectionParameter {#1406
+name: "pkgHandle"
position: 0
}
}
modifiers: "public"
}
"getPackageID" => ReflectionMethod {#1369
+name: "getPackageID"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageID" => ReflectionMethod {#1370
+name: "setPackageID"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgID: ReflectionParameter {#1408
+name: "pkgID"
position: 0
}
}
modifiers: "public"
}
"isPackageInstalled" => ReflectionMethod {#1371
+name: "isPackageInstalled"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setIsPackageInstalled" => ReflectionMethod {#1372
+name: "setIsPackageInstalled"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgIsInstalled: ReflectionParameter {#1412
+name: "pkgIsInstalled"
position: 0
}
}
modifiers: "public"
}
"getPackageVersion" => ReflectionMethod {#1373
+name: "getPackageVersion"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageVersion" => ReflectionMethod {#1374
+name: "setPackageVersion"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgVersion: ReflectionParameter {#1416
+name: "pkgVersion"
position: 0
}
}
modifiers: "public"
}
"getPackageVersionUpdateAvailable" => ReflectionMethod {#1375
+name: "getPackageVersionUpdateAvailable"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageAvailableVersion" => ReflectionMethod {#1376
+name: "setPackageAvailableVersion"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgAvailableVersion: ReflectionParameter {#1420
+name: "pkgAvailableVersion"
position: 0
}
}
modifiers: "public"
}
"getPackageDescription" => ReflectionMethod {#1377
+name: "getPackageDescription"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageDescription" => ReflectionMethod {#1378
+name: "setPackageDescription"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgDescription: ReflectionParameter {#1424
+name: "pkgDescription"
position: 0
}
}
modifiers: "public"
}
"getPackageDateInstalled" => ReflectionMethod {#1379
+name: "getPackageDateInstalled"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageDateInstalled" => ReflectionMethod {#1380
+name: "setPackageDateInstalled"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgDateInstalled: ReflectionParameter {#1428
+name: "pkgDateInstalled"
position: 0
}
}
modifiers: "public"
}
"getPackageName" => ReflectionMethod {#1381
+name: "getPackageName"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageName" => ReflectionMethod {#1382
+name: "setPackageName"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgName: ReflectionParameter {#1432
+name: "pkgName"
position: 0
}
}
modifiers: "public"
}
"__construct" => ReflectionMethod {#1383
+name: "__construct"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"getController" => ReflectionMethod {#1384
+name: "getController"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"__call" => ReflectionMethod {#1385
+name: "__call"
+class: "Concrete\Core\Entity\Package"
parameters: {
$method: ReflectionParameter {#1437
+name: "method"
position: 0
}
$arguments: ReflectionParameter {#1438
+name: "arguments"
position: 1
}
}
modifiers: "public"
}
"getTranslationFile" => ReflectionMethod {#1386
+name: "getTranslationFile"
+class: "Concrete\Core\Entity\Package"
parameters: {
$locale: ReflectionParameter {#1441
+name: "locale"
position: 0
}
}
modifiers: "public"
}
]
}
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/AnnotationDriver.php
$this->addPaths((array) $paths);
}
/**
* {@inheritDoc}
*
* @psalm-param class-string<T> $className
* @psalm-param ClassMetadata<T> $metadata
*
* @template T of object
*/
public function loadMetadataForClass($className, PersistenceClassMetadata $metadata)
{
$class = $metadata->getReflectionClass()
// this happens when running annotation driver in combination with
// static reflection services. This is not the nicest fix
?? new ReflectionClass($metadata->name);
$classAnnotations = $this->reader->getClassAnnotations($class);
foreach ($classAnnotations as $key => $annot) {
if (! is_numeric($key)) {
continue;
}
$classAnnotations[get_class($annot)] = $annot;
}
// Evaluate Entity annotation
if (isset($classAnnotations[Mapping\Entity::class])) {
$entityAnnot = $classAnnotations[Mapping\Entity::class];
assert($entityAnnot instanceof Mapping\Entity);
if ($entityAnnot->repositoryClass !== null) {
$metadata->setCustomRepositoryClass($entityAnnot->repositoryClass);
}
if ($entityAnnot->readOnly) {
$metadata->markReadOnly();
}
} elseif (isset($classAnnotations[Mapping\MappedSuperclass::class])) {
Arguments
ReflectionClass {#1295
+name: "Concrete\Core\Entity\Package"
implements: array:1 [
0 => "Concrete\Core\Package\LocalizablePackageInterface"
]
constants: []
properties: array:8 [
"pkgID" => ReflectionProperty {#1450
+name: "pkgID"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Id @ORM\Column(type="integer", options={"unsigned":true})\n
* @ORM\GeneratedValue(strategy="AUTO")\n
*/
"""
}
}
"pkgHandle" => ReflectionProperty {#1451
+name: "pkgHandle"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="string", unique=true)\n
*/
"""
}
}
"pkgVersion" => ReflectionProperty {#1452
+name: "pkgVersion"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="string")\n
*/
"""
}
}
"pkgIsInstalled" => ReflectionProperty {#1454
+name: "pkgIsInstalled"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="boolean")\n
*/
"""
}
}
"pkgAvailableVersion" => ReflectionProperty {#1453
+name: "pkgAvailableVersion"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="string", nullable=true)\n
*/
"""
}
}
"pkgDescription" => ReflectionProperty {#1444
+name: "pkgDescription"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="text")\n
*/
"""
}
}
"pkgDateInstalled" => ReflectionProperty {#1442
+name: "pkgDateInstalled"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="datetime")\n
*/
"""
}
}
"pkgName" => ReflectionProperty {#1439
+name: "pkgName"
+class: "Concrete\Core\Entity\Package"
modifiers: "protected"
extra: {
docComment: """
/**\n
* @ORM\Column(type="string", nullable=true)\n
*/
"""
}
}
]
methods: array:20 [
"getPackageHandle" => ReflectionMethod {#1433
+name: "getPackageHandle"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageHandle" => ReflectionMethod {#1429
+name: "setPackageHandle"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgHandle: ReflectionParameter {#1398
+name: "pkgHandle"
position: 0
}
}
modifiers: "public"
}
"getPackageID" => ReflectionMethod {#1425
+name: "getPackageID"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageID" => ReflectionMethod {#1421
+name: "setPackageID"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgID: ReflectionParameter {#1388
+name: "pkgID"
position: 0
}
}
modifiers: "public"
}
"isPackageInstalled" => ReflectionMethod {#1417
+name: "isPackageInstalled"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setIsPackageInstalled" => ReflectionMethod {#1413
+name: "setIsPackageInstalled"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgIsInstalled: ReflectionParameter {#1355
+name: "pkgIsInstalled"
position: 0
}
}
modifiers: "public"
}
"getPackageVersion" => ReflectionMethod {#1409
+name: "getPackageVersion"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageVersion" => ReflectionMethod {#1405
+name: "setPackageVersion"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgVersion: ReflectionParameter {#1438
+name: "pkgVersion"
position: 0
}
}
modifiers: "public"
}
"getPackageVersionUpdateAvailable" => ReflectionMethod {#1401
+name: "getPackageVersionUpdateAvailable"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageAvailableVersion" => ReflectionMethod {#1399
+name: "setPackageAvailableVersion"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgAvailableVersion: ReflectionParameter {#1424
+name: "pkgAvailableVersion"
position: 0
}
}
modifiers: "public"
}
"getPackageDescription" => ReflectionMethod {#1397
+name: "getPackageDescription"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageDescription" => ReflectionMethod {#1395
+name: "setPackageDescription"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgDescription: ReflectionParameter {#1408
+name: "pkgDescription"
position: 0
}
}
modifiers: "public"
}
"getPackageDateInstalled" => ReflectionMethod {#1393
+name: "getPackageDateInstalled"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageDateInstalled" => ReflectionMethod {#1391
+name: "setPackageDateInstalled"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgDateInstalled: ReflectionParameter {#1384
+name: "pkgDateInstalled"
position: 0
}
}
modifiers: "public"
}
"getPackageName" => ReflectionMethod {#1389
+name: "getPackageName"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"setPackageName" => ReflectionMethod {#1390
+name: "setPackageName"
+class: "Concrete\Core\Entity\Package"
parameters: {
$pkgName: ReflectionParameter {#1380
+name: "pkgName"
position: 0
}
}
modifiers: "public"
}
"__construct" => ReflectionMethod {#1443
+name: "__construct"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"getController" => ReflectionMethod {#1440
+name: "getController"
+class: "Concrete\Core\Entity\Package"
modifiers: "public"
}
"__call" => ReflectionMethod {#1436
+name: "__call"
+class: "Concrete\Core\Entity\Package"
parameters: {
$method: ReflectionParameter {#1375
+name: "method"
position: 0
}
$arguments: ReflectionParameter {#1374
+name: "arguments"
position: 1
}
}
modifiers: "public"
}
"getTranslationFile" => ReflectionMethod {#1435
+name: "getTranslationFile"
+class: "Concrete\Core\Entity\Package"
parameters: {
$locale: ReflectionParameter {#1371
+name: "locale"
position: 0
}
}
modifiers: "public"
}
]
}
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/doctrine/persistence/src/Persistence/Mapping/Driver/MappingDriverChain.php
/**
* Gets the array of nested drivers.
*
* @return MappingDriver[] $drivers
*/
public function getDrivers()
{
return $this->drivers;
}
/**
* {@inheritDoc}
*/
public function loadMetadataForClass($className, ClassMetadata $metadata)
{
foreach ($this->drivers as $namespace => $driver) {
assert($driver instanceof MappingDriver);
if (strpos($className, $namespace) === 0) {
$driver->loadMetadataForClass($className, $metadata);
return;
}
}
if ($this->defaultDriver !== null) {
$this->defaultDriver->loadMetadataForClass($className, $metadata);
return;
}
throw MappingException::classNotFoundInNamespaces($className, array_keys($this->drivers));
}
/**
* {@inheritDoc}
*/
public function getAllClassNames()
{
$classNames = [];
Arguments
"Concrete\Core\Entity\Package"
Doctrine\ORM\Mapping\ClassMetadata {#1291}
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/ClassMetadataFactory.php
$class->setIdentifier($parent->identifier);
$class->setVersioned($parent->isVersioned);
$class->setVersionField($parent->versionField);
$class->setDiscriminatorMap($parent->discriminatorMap);
$class->addSubClasses($parent->subClasses);
$class->setLifecycleCallbacks($parent->lifecycleCallbacks);
$class->setChangeTrackingPolicy($parent->changeTrackingPolicy);
if (! empty($parent->customGeneratorDefinition)) {
$class->setCustomGeneratorDefinition($parent->customGeneratorDefinition);
}
if ($parent->isMappedSuperclass) {
$class->setCustomRepositoryClass($parent->customRepositoryClassName);
}
}
// Invoke driver
try {
$this->driver->loadMetadataForClass($class->getName(), $class);
} catch (ReflectionException $e) {
throw MappingException::reflectionFailure($class->getName(), $e);
}
// If this class has a parent the id generator strategy is inherited.
// However this is only true if the hierarchy of parents contains the root entity,
// if it consists of mapped superclasses these don't necessarily include the id field.
if ($parent && $rootEntityFound) {
$this->inheritIdGeneratorMapping($class, $parent);
} else {
$this->completeIdGeneratorMapping($class);
}
if (! $class->isMappedSuperclass) {
foreach ($class->embeddedClasses as $property => $embeddableClass) {
if (isset($embeddableClass['inherited'])) {
continue;
}
if (! (isset($embeddableClass['class']) && $embeddableClass['class'])) {
Arguments
"Concrete\Core\Entity\Package"
Doctrine\ORM\Mapping\ClassMetadata {#1291}
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/doctrine/persistence/src/Persistence/Mapping/AbstractClassMetadataFactory.php
// Move down the hierarchy of parent classes, starting from the topmost class
$parent = null;
$rootEntityFound = false;
$visited = [];
$reflService = $this->getReflectionService();
foreach ($parentClasses as $className) {
if (isset($this->loadedMetadata[$className])) {
$parent = $this->loadedMetadata[$className];
if ($this->isEntity($parent)) {
$rootEntityFound = true;
array_unshift($visited, $className);
}
continue;
}
$class = $this->newClassMetadataInstance($className);
$this->initializeReflection($class, $reflService);
$this->doLoadMetadata($class, $parent, $rootEntityFound, $visited);
$this->loadedMetadata[$className] = $class;
$parent = $class;
if ($this->isEntity($class)) {
$rootEntityFound = true;
array_unshift($visited, $className);
}
$this->wakeupReflection($class, $reflService);
$loaded[] = $className;
}
return $loaded;
}
/**
* Provides a fallback hook for loading metadata when loading failed due to reflection/mapping exceptions
Arguments
Doctrine\ORM\Mapping\ClassMetadata {#1291}
null
false
[]
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/doctrine/persistence/src/Persistence/Mapping/AbstractClassMetadataFactory.php
$realClassName = $this->getRealClass($className);
}
if (isset($this->loadedMetadata[$realClassName])) {
// We do not have the alias name in the map, include it
return $this->loadedMetadata[$className] = $this->loadedMetadata[$realClassName];
}
$loadingException = null;
try {
if ($this->cache) {
$cached = $this->cache->getItem($this->getCacheKey($realClassName))->get();
if ($cached instanceof ClassMetadata) {
/** @psalm-var CMTemplate $cached */
$this->loadedMetadata[$realClassName] = $cached;
$this->wakeupReflection($cached, $this->getReflectionService());
} else {
$loadedMetadata = $this->loadMetadata($realClassName);
$classNames = array_combine(
array_map([$this, 'getCacheKey'], $loadedMetadata),
$loadedMetadata
);
assert(is_array($classNames));
foreach ($this->cache->getItems(array_keys($classNames)) as $item) {
if (! isset($classNames[$item->getKey()])) {
continue;
}
$item->set($this->loadedMetadata[$classNames[$item->getKey()]]);
$this->cache->saveDeferred($item);
}
$this->cache->commit();
}
} else {
$this->loadMetadata($realClassName);
}
Arguments
"Concrete\Core\Entity\Package"
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/doctrine/orm/lib/Doctrine/ORM/EntityManager.php
$this->conn->rollBack();
}
/**
* Returns the ORM metadata descriptor for a class.
*
* The class name must be the fully-qualified class name without a leading backslash
* (as it is returned by get_class($obj)) or an aliased class name.
*
* Examples:
* MyProject\Domain\User
* sales:PriceRequest
*
* Internal note: Performance-sensitive method.
*
* {@inheritDoc}
*/
public function getClassMetadata($className)
{
return $this->metadataFactory->getMetadataFor($className);
}
/**
* {@inheritDoc}
*/
public function createQuery($dql = '')
{
$query = new Query($this);
if (! empty($dql)) {
$query->setDQL($dql);
}
return $query;
}
/**
* {@inheritDoc}
*/
public function createNamedQuery($name)
Arguments
"Concrete\Core\Entity\Package"
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/doctrine/orm/lib/Doctrine/ORM/Repository/DefaultRepositoryFactory.php
/**
* This factory is used to create default repository objects for entities at runtime.
*/
final class DefaultRepositoryFactory implements RepositoryFactory
{
/**
* The list of EntityRepository instances.
*
* @var ObjectRepository[]
* @psalm-var array<string, ObjectRepository>
*/
private $repositoryList = [];
/**
* {@inheritdoc}
*/
public function getRepository(EntityManagerInterface $entityManager, $entityName): ObjectRepository
{
$repositoryHash = $entityManager->getClassMetadata($entityName)->getName() . spl_object_id($entityManager);
if (isset($this->repositoryList[$repositoryHash])) {
return $this->repositoryList[$repositoryHash];
}
return $this->repositoryList[$repositoryHash] = $this->createRepository($entityManager, $entityName);
}
/**
* Create a new repository instance for an entity class.
*
* @param EntityManagerInterface $entityManager The EntityManager instance.
* @param string $entityName The name of the entity.
*/
private function createRepository(
EntityManagerInterface $entityManager,
string $entityName
): ObjectRepository {
$metadata = $entityManager->getClassMetadata($entityName);
$repositoryClassName = $metadata->customRepositoryClassName
Arguments
"\Concrete\Core\Entity\Package"
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/vendor/doctrine/orm/lib/Doctrine/ORM/EntityManager.php
public function getRepository($entityName)
{
if (strpos($entityName, ':') !== false) {
if (class_exists(PersistentObject::class)) {
Deprecation::trigger(
'doctrine/orm',
'https://github.com/doctrine/orm/issues/8818',
'Short namespace aliases such as "%s" are deprecated and will be removed in Doctrine ORM 3.0.',
$entityName
);
} else {
throw NotSupported::createForPersistence3(sprintf(
'Using short namespace alias "%s" when calling %s',
$entityName,
__METHOD__
));
}
}
$repository = $this->repositoryFactory->getRepository($this, $entityName);
if (! $repository instanceof EntityRepository) {
Deprecation::trigger(
'doctrine/orm',
'https://github.com/doctrine/orm/pull/9533',
'Not returning an instance of %s from %s::getRepository() is deprecated and will cause a TypeError on 3.0.',
EntityRepository::class,
get_debug_type($this->repositoryFactory)
);
}
return $repository;
}
/**
* Determines whether an entity instance is managed in this EntityManager.
*
* @param object $entity
*
* @return bool TRUE if this EntityManager currently manages the given entity, FALSE otherwise.
*/
Arguments
Doctrine\ORM\EntityManager {#524
-config: Doctrine\ORM\Configuration {#516}
-conn: Concrete\Core\Database\Connection\Connection {#128}
-metadataFactory: Doctrine\ORM\Mapping\ClassMetadataFactory {#541}
-unitOfWork: Doctrine\ORM\UnitOfWork {#535}
-eventManager: Doctrine\Common\EventManager {#126}
-proxyFactory: Doctrine\ORM\Proxy\ProxyFactory {#544}
-repositoryFactory: Doctrine\ORM\Repository\DefaultRepositoryFactory {#542}
-expressionBuilder: null
-closed: false
-filterCollection: null
-cache: null
}
"\Concrete\Core\Entity\Package"
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Package/PackageList.php
{
CacheLocal::delete('packageHandleList', false);
CacheLocal::delete('pkgList', 1);
CacheLocal::delete('pkgList', 0);
}
/**
* @deprecated
* @param int $pkgIsInstalled
* @return static
*/
public static function get($pkgIsInstalled = 1)
{
$pkgList = CacheLocal::getEntry('pkgList', $pkgIsInstalled);
if ($pkgList != false) {
return $pkgList;
}
$em = \Database::connection()->getEntityManager();
$r = $em->getRepository('\Concrete\Core\Entity\Package');
$packages = $r->findBy(array('pkgIsInstalled' => true), array('pkgID' => 'asc'));
$list = new static();
foreach($packages as $pkg) {
$list->add($pkg);
}
CacheLocal::set('pkgList', $pkgIsInstalled, $list);
return $list;
}
}
Arguments
"\Concrete\Core\Entity\Package"
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Application/Application.php
} else {
$installedVersion = $config->get('concrete.version_installed');
$coreVersion = $config->get('concrete.version');
if (version_compare($installedVersion, $coreVersion, '<')) {
$update = true;
}
}
if ($update) {
$this->make(MutexInterface::class)->execute(Update::MUTEX_KEY, function () {
Update::updateToCurrentVersion();
});
}
}
/**
* Register package autoloaders. Has to come BEFORE session calls.
*/
public function setupPackageAutoloaders()
{
$pla = \Concrete\Core\Package\PackageList::get();
$pl = $pla->getPackages();
$cl = ClassLoader::getInstance();
/** @var \Package[] $pl */
foreach ($pl as $p) {
\Config::package($p);
if ($p->isPackageInstalled()) {
$pkg = $this->make('Concrete\Core\Package\PackageService')->getClass($p->getPackageHandle());
if (is_object($pkg) && (!$pkg instanceof \Concrete\Core\Package\BrokenPackage)) {
$cl->registerPackage($pkg);
$this->packages[] = $pkg;
}
}
}
}
/**
* Run startup and localization events on any installed packages.
*/
public function setupPackages()
{
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Foundation/Runtime/Boot/DefaultBooter.php
/**
* @param \Concrete\Core\Application\Application $app
* @param \Concrete\Core\Http\Request $request
*
* @return null|Response
*/
private function checkCache(Application $app, Request $request)
{
$response = $app->checkPageCache($request);
if ($response) {
return $response;
}
}
/**
* @param \Concrete\Core\Application\Application $app
*/
private function initializePackages(Application $app)
{
$app->setupPackageAutoloaders();
}
}
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Foundation/Runtime/Boot/DefaultBooter.php
if ($response = $this->checkInstall($app, $request)) {
return $response;
}
if ($this->app->isInstalled()) {
/*
* ----------------------------------------------------------------------------
* Check the page cache in case we need to return a result early.
* ----------------------------------------------------------------------------
*/
if ($response = $this->checkCache($app, $request)) {
return $response;
}
/*
* ----------------------------------------------------------------------------
* Now we load all installed packages, and register their package autoloaders.
* ----------------------------------------------------------------------------
*/
$this->initializePackages($app);
}
}
/**
* Enable configuration.
*
* @param Application $app
*
* @return Repository
*/
private function initializeConfig(Application $app)
{
$config_provider = $app->make('Concrete\Core\Config\ConfigServiceProvider');
$config_provider->register();
/*
* @var \Concrete\Core\Config\Repository\Repository
*/
$config = $app->make('config');
Arguments
Concrete\Core\Application\Application {#9}
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Foundation/Runtime/Boot/DefaultBooter.php
/*
* ----------------------------------------------------------------------------
* Registries for theme paths, assets, routes and file types.
* ----------------------------------------------------------------------------
*/
$this->initializeAssets($config);
$this->initializeRoutes($config);
$this->initializeFileTypes($config);
/*
* ----------------------------------------------------------------------------
* Certain components subscribing to the actions of other components.
* ----------------------------------------------------------------------------
*/
$this->initializeEvents($app);
// If we're not in the CLI SAPI, lets do additional booting for HTTP
if (!$this->app->isRunThroughCommandLineInterface()) {
return $this->bootHttpSapi($config, $app);
}
}
/**
* @param $config
* @param $app
*
* @return null|Response
*/
private function bootHttpSapi($config, $app)
{
/*
* ----------------------------------------------------------------------------
* Initialize the request
* ----------------------------------------------------------------------------
*/
$request = $this->initializeRequest($config);
/*
* ----------------------------------------------------------------------------
Arguments
Concrete\Core\Config\Repository\Repository {#28}
Concrete\Core\Application\Application {#9}
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/src/Foundation/Runtime/DefaultRuntime.php
{
$this->run_class = $run_class;
}
/**
* @param string $boot_class
*/
public function setBootClass($boot_class)
{
$this->boot_class = $boot_class;
}
/**
* Initialize the environment and prepare for running.
*/
public function boot()
{
$booter = $this->getBooter();
if ($response = $booter->boot()) {
$this->sendResponse($response);
} else {
$this->status = self::STATUS_ACTIVE;
}
}
/**
* Begin the runtime.
*/
public function run()
{
switch ($this->status) {
case self::STATUS_ENDED:
// We've already ended, lets just return
return;
case self::STATUS_INACTIVE:
throw new \RuntimeException('Runtime has not yet booted.');
}
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/bootstrap/start.php
* Handle text encoding.
* ----------------------------------------------------------------------------
*/
\Patchwork\Utf8\Bootup::initAll();
/*
* ----------------------------------------------------------------------------
* Instantiate Concrete
* ----------------------------------------------------------------------------
*/
/** @var \Concrete\Core\Application\Application $app */
$app = require DIR_APPLICATION . '/bootstrap/start.php';
$app->instance('app', $app);
// Bind fully application qualified class names
$app->instance('Concrete\Core\Application\Application', $app);
$app->instance('Illuminate\Container\Container', $app);
// Boot the runtime
$app->getRuntime()->boot();
return $app;
/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/dispatcher.php
* Make sure you cannot call dispatcher.php directly.
* ----------------------------------------------------------------------------
*/
if (basename($_SERVER['PHP_SELF']) === DISPATCHER_FILENAME_CORE) {
die('Access Denied.');
}
/*
* ----------------------------------------------------------------------------
* Include all autoloaders.
* ----------------------------------------------------------------------------
*/
require __DIR__ . '/bootstrap/autoload.php';
/*
* ----------------------------------------------------------------------------
* Begin Concrete startup.
* ----------------------------------------------------------------------------
*/
$app = require __DIR__ . '/bootstrap/start.php';
/** @var \Concrete\Core\Application\Application $app */
/*
* ----------------------------------------------------------------------------
* Run the runtime.
* ----------------------------------------------------------------------------
*/
$runtime = $app->getRuntime();
if ($response = $runtime->run()) {
/*
* ------------------------------------------------------------------------
* Shut it down.
* ------------------------------------------------------------------------
*/
$app->shutdown();
} else {
return $app;
}
Arguments
"/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/bootstrap/start.php"
/home/newbrokersallian/public_html/concrete/bootstrap/configure.php
defined('DIR_CONFIG_SITE') or define('DIR_CONFIG_SITE', DIR_APPLICATION . '/config');
/*
* ----------------------------------------------------------------------------
* Now that we've had the opportunity to load our config file, we know if we
* have a DIRNAME_CORE_UPDATED constant, which lives in that file, and which
* points to another core. If we have this constant, we exit this file
* immeditely and proceed into the updated core.
* ----------------------------------------------------------------------------
*/
if (!defined('APP_UPDATED_PASSTHRU')) {
$update_file = DIR_CONFIG_SITE . '/update.php';
if (file_exists($update_file)) {
$updates = (array) include $update_file;
if (isset($updates['core'])) {
define('APP_UPDATED_PASSTHRU', true);
define('DIRNAME_APP_UPDATED', $updates['core']);
if (is_dir(DIR_BASE . '/' . DIRNAME_UPDATES . '/' . DIRNAME_APP_UPDATED)) {
require DIR_BASE . '/' . DIRNAME_UPDATES . '/' . DIRNAME_APP_UPDATED . '/' . DIRNAME_CORE . '/' . 'dispatcher.php';
} elseif (file_exists(DIRNAME_UPDATES . '/' . DIRNAME_APP_UPDATED . '/' . DIRNAME_CORE . '/' . 'dispatcher.php')) {
require DIRNAME_UPDATES . '/' . DIRNAME_APP_UPDATED . '/' . DIRNAME_CORE . '/' . 'dispatcher.php';
} else {
die(sprintf('Invalid "%s" defined. Please remove it from %s.', 'update.core', $update_file));
}
exit;
}
}
unset($update_file);
define('APP_UPDATED_PASSTHRU', false);
}
if (!defined('DIRNAME_APP_UPDATED') && isset($updates['core'])) {
define('DIRNAME_APP_UPDATED', $updates['core']);
}
/*
* ----------------------------------------------------------------------------
* ## If we're still here, we're proceeding through this concrete directory,
* and it's time to load the rest of our hard-coded configuration options –
Arguments
"/home/newbrokersallian/public_html/updates/concrete-cms-9.2.1_remote_updater/concrete/dispatcher.php"
/home/newbrokersallian/public_html/concrete/dispatcher.php
<?php
if (!defined('PHP_VERSION_ID') || PHP_VERSION_ID < 50509) {
die("concrete5 requires PHP 5.5.9+ to run.\nYou are running PHP " . PHP_VERSION . "\n");
}
/*
* ----------------------------------------------------------------------------
* Set required constants, including directory names, attempt to include site configuration file with database
* information, attempt to determine if we ought to skip to an updated core, etc...
* ----------------------------------------------------------------------------
*/
require __DIR__ . '/bootstrap/configure.php';
/*
* ----------------------------------------------------------------------------
* Make sure you cannot call dispatcher.php directly.
* ----------------------------------------------------------------------------
*/
if (basename($_SERVER['PHP_SELF']) === DISPATCHER_FILENAME_CORE) {
die('Access Denied.');
}
/*
* ----------------------------------------------------------------------------
* Include all autoloaders.
* ----------------------------------------------------------------------------
*/
require __DIR__ . '/bootstrap/autoload.php';
/*
* ----------------------------------------------------------------------------
* Begin concrete5 startup.
* ----------------------------------------------------------------------------
*/
$app = require __DIR__ . '/bootstrap/start.php';
/** @var \Concrete\Core\Application\Application $app */
/*
* ----------------------------------------------------------------------------
Arguments
"/home/newbrokersallian/public_html/concrete/bootstrap/configure.php"
/home/newbrokersallian/public_html/index.php
<?php
//$actual_link = (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? "https" : "http") . "://$_SERVER[HTTP_HOST] $_SERVER[REQUEST_URI]";
//if(strpos($actual_link, '%') !== false){
//echo "Word Found!";
// header("Location: https://".$_SERVER[HTTP_HOST]);
//}
require 'concrete/dispatcher.php';
Arguments
"/home/newbrokersallian/public_html/concrete/dispatcher.php"