/**
* {@inheritDoc}
*
* @return \Zend\ServiceManager\Proxy\LazyServiceFactory
*/
public function createService(ServiceLocatorInterface $serviceLocator)
{
$config = $serviceLocator->get('Config');
if (!isset($config['lazy_services'])) {
throw new Exception\InvalidArgumentException('Missing "lazy_services" config key');
}
$lazyServices = $config['lazy_services'];
if (!isset($lazyServices['class_map'])) {
throw new Exception\InvalidArgumentException('Missing "class_map" config key in "lazy_services"');
}
$factoryConfig = new Configuration();
if (isset($lazyServices['proxies_target_dir'])) {
$factoryConfig->setProxiesTargetDir($lazyServices['proxies_target_dir']);
}
if (!isset($lazyServices['write_proxy_files']) || !$lazyServices['write_proxy_files']) {
$factoryConfig->setGeneratorStrategy(new EvaluatingGeneratorStrategy());
}
if (isset($lazyServices['auto_generate_proxies'])) {
$factoryConfig->setAutoGenerateProxies($lazyServices['auto_generate_proxies']);
// register the proxy autoloader if the proxies already exist
if (!$lazyServices['auto_generate_proxies']) {
spl_autoload_register($factoryConfig->getProxyAutoloader());
$factoryConfig->setGeneratorStrategy(new EvaluatingGeneratorStrategy());
}
}
//if (!isset($lazyServicesConfig['runtime_evaluate_proxies']))
if (isset($lazyServices['proxies_namespace'])) {
$factoryConfig->setProxiesNamespace($lazyServices['proxies_namespace']);
}
return new LazyServiceFactory(new LazyLoadingValueHolderFactory($factoryConfig), $lazyServices['class_map']);
}
/**
* Create a new configuration
*
* @param array $config
* @param bool $devMode
*
* @return Configuration
*/
public static function create(array $config, $devMode = true)
{
$resolver = self::buildOptionsResolver();
$config = $resolver->resolve($config);
$conf = new self();
$map = new IdentityMap();
$metadataRegistry = self::buildMetadataregistry($config, $devMode);
foreach ($metadataRegistry->getMetadatas() as $meta) {
$map->addClass($meta->getClass());
if ($meta->hasAlias()) {
$map->addAlias($meta->getAlias(), $meta->getClass());
}
}
$proxyConfig = new ProxyConfig();
if ($devMode === true) {
$path = $config['cache'] . self::PROXIES_DIRECTORY;
$filesystem = new Filesystem();
if (!$filesystem->exists($path)) {
$filesystem->mkdir($path);
}
$proxyConfig->setProxiesTargetDir($path);
spl_autoload_register($proxyConfig->getProxyAutoloader());
}
$conf->setIdentityMap($map)->setMetadataRegistry($metadataRegistry)->setProxyFactory(new LazyLoadingGhostFactory($proxyConfig));
return $conf;
}
/**
* @return \OpenClassrooms\ServiceProxy\ServiceProxyBuilderInterface
*/
protected function getServiceProxyBuilder($cacheDir = null)
{
$serviceProxyBuilder = new ServiceProxyBuilder();
$configuration = new Configuration();
$configuration->setProxiesTargetDir($cacheDir);
$serviceProxyBuilder->setProxyFactory($this->buildProxyFactory($configuration));
return $serviceProxyBuilder;
}
/**
* @param string $proxyManagerCacheDir
*
* @return Configuration
*
* @throws \InvalidArgumentException When $proxyManagerCacheDir is not a dir
*/
protected function getProxyManagerConfiguration($proxyManagerCacheDir)
{
if (!is_dir($proxyManagerCacheDir)) {
throw new \InvalidArgumentException(sprintf('"%s" is not a dir', $proxyManagerCacheDir));
}
$proxyConfiguration = new Configuration();
$proxyConfiguration->setProxiesTargetDir($proxyManagerCacheDir);
return $proxyConfiguration;
}
private function cacheProxy()
{
$proxiesFolder = new Folder(sys_get_temp_dir() . DIRECTORY_SEPARATOR . SphringCacheEnum::CACHE_FOLDER . DIRECTORY_SEPARATOR . SphringCacheEnum::CACHE_FOLDER_PROXIES);
$proxiesFolder->create();
$proxyManagerConfiguration = new Configuration();
$proxyManagerConfiguration->setProxiesTargetDir($proxiesFolder->absolute());
$proxyFactory = new AccessInterceptorValueHolderFactory($proxyManagerConfiguration);
ProxyGenerator::getInstance()->setProxyFactory($proxyFactory);
spl_autoload_register($proxyManagerConfiguration->getProxyAutoloader());
}
/**
* @param mixed $cacheDir
*/
public function __construct($cacheDir = null)
{
// set a proxy cache for performance tuning
$config = new Configuration();
if (null !== $cacheDir) {
$config->setProxiesTargetDir($cacheDir);
}
// then register the autoloader
spl_autoload_register($config->getProxyAutoloader());
$this->factory = new LazyLoadingValueHolderFactory($config);
}
/**
* ProxyManagerFactory constructor.
*/
public function __construct($cacheDir = null)
{
$this->cache = array();
// set a proxy cache for performance tuning
$config = new Configuration();
if (!is_null($cacheDir)) {
$config->setProxiesTargetDir($cacheDir);
}
// then register the autoloader
spl_autoload_register($config->getProxyAutoloader());
$this->factory = new AccessInterceptorValueHolderFactory($config);
}
/**
* @param \GraphAware\Neo4j\OGM\Metadata\ClassMetadata $classMetadata
* @param \GraphAware\Neo4j\OGM\EntityManager $manager
* @param string $className
*/
public function __construct(NodeEntityMetadata $classMetadata, EntityManager $manager, $className)
{
$this->classMetadata = $classMetadata;
$this->entityManager = $manager;
$this->className = $className;
$config = new Configuration();
$dir = sys_get_temp_dir();
$config->setGeneratorStrategy(new FileWriterGeneratorStrategy(new FileLocator($dir)));
$config->setProxiesTargetDir($dir);
spl_autoload_register($config->getProxyAutoloader());
$this->lazyLoadingFactory = new LazyLoadingGhostFactory($config);
}
/**
* @param Container $container
*/
public static function create(Container $container)
{
$proxyTargetDir = $container->getParameter('phpro.annotated_cache.params.proxies_target_dir');
$proxyNamespace = $container->getParameter('phpro.annotated_cache.params.proxies_namespace');
$shouldAutoload = $container->getParameter('phpro.annotated_cache.params.proxies_register_autoloader');
// Make sure to touch the filesystem.
$container->get('filesystem')->mkdir($proxyTargetDir);
$configuration = new Configuration();
$configuration->setProxiesTargetDir($proxyTargetDir);
$configuration->setProxiesNamespace($proxyNamespace);
if ($shouldAutoload) {
spl_autoload_register($configuration->getProxyAutoloader());
}
}
/**
* @return Configuration
*/
public function create($cacheDir, $dumpAutoload = false)
{
if (!is_dir($cacheDir)) {
if (false === @mkdir($cacheDir, 0777, true)) {
throw new \RuntimeException(sprintf('Could not create cache directory "%s".', $cacheDir));
}
}
$configuration = new Configuration();
$configuration->setProxiesTargetDir($cacheDir);
if ($dumpAutoload) {
spl_autoload_register($configuration->getProxyAutoloader());
}
return $configuration;
}
/**
* proxy_instantiator constructor
* @param string $cache_dir Cache dir for fall back when using open_basedir
*/
public function __construct($cache_dir)
{
$config = new Configuration();
// Prevent trying to write to system temp dir in case of open_basedir
// restrictions being in effect
$ini_wrapper = new IniGetWrapper();
$filesystem = new filesystem();
$tmp_dir = function_exists('sys_get_temp_dir') ? sys_get_temp_dir() : '';
if (empty($tmp_dir) || $ini_wrapper->getString('open_basedir') && (!$filesystem->exists($tmp_dir) || !$filesystem->is_writable($tmp_dir))) {
$config->setProxiesTargetDir($cache_dir);
}
$config->setGeneratorStrategy(new EvaluatingGeneratorStrategy());
$this->factory = new LazyLoadingValueHolderFactory($config);
}
public function register(Slim $app)
{
$app->container->singleton('cache', function () {
return new FilesystemCache('tmp/cache/db');
});
$app->container->singleton('connection', function () {
$dbOptions = (require 'config/connection.config.php');
$config = new Configuration();
return DriverManager::getConnection($dbOptions, $config);
});
$app->container->singleton('log', function () {
$logger = new Logger('echale-gas');
$logger->pushHandler(new StreamHandler('tmp/logs/app.log', LogLevel::DEBUG));
return $logger;
});
$app->container->singleton('paginator', function () use($app) {
return new PagerfantaPaginator($app->config('defaultPageSize'));
});
$app->container->singleton('paginatorFactory', function () use($app) {
return new PaginatorFactory($app->paginator);
});
$app->container->singleton('proxiesConfiguration', function () use($app) {
$config = new ProxyConfiguration();
$config->setProxiesTargetDir('tmp/cache/proxies');
spl_autoload_register($config->getProxyAutoloader());
return $config;
});
$app->urlHelper = new TwigExtension();
$app->container->singleton('twig', function () use($app) {
$twig = new Twig();
$twig->parserOptions = ['charset' => 'utf-8', 'cache' => realpath('tmp/cache/twig'), 'auto_reload' => true, 'strict_variables' => false, 'autoescape' => true];
$twig->parserExtensions = [$app->urlHelper, new HalRendererExtension()];
return $twig;
});
$app->container->singleton('controllerEvents', function () use($app) {
$eventManager = new EventManager();
// Ensure rendering is performed at the end by assigning a very low priority
$eventManager->attach('postDispatch', new RenderResourceListener($app->twig), -100);
$eventManager->attach('renderErrors', new RenderErrorsListener($app->twig), -100);
return $eventManager;
});
$app->container->singleton('controller', function () use($app) {
$controller = new RestController($app->request(), $app->response());
$factory = new RestControllerProxyFactory($app->proxiesConfiguration, $app->controllerEvents);
$controller = $factory->createProxy($controller);
$factory->addEventManagement($controller);
return $controller;
});
$app->view($app->twig);
}
/**
* {@inheritDoc}
* @return ConfigurationOptions
*/
public function createService(ServiceLocatorInterface $serviceLocator)
{
/** @var \Detail\Core\ProxyManager\Options\ConfigurationOptions $options */
$options = $serviceLocator->get('Detail\\Core\\ProxyManager\\Options\\ConfigurationOptions');
$factoryConfig = new Configuration();
if ($options->getProxiesNamespace()) {
$factoryConfig->setProxiesNamespace($options->getProxiesNamespace());
}
if ($options->getProxiesTargetDir()) {
$factoryConfig->setProxiesTargetDir($options->getProxiesTargetDir());
}
if (!$options->getWriteProxyFiles()) {
$factoryConfig->setGeneratorStrategy(new EvaluatingGeneratorStrategy());
}
spl_autoload_register($factoryConfig->getProxyAutoloader());
return new LazyLoadingValueHolderFactory($factoryConfig);
}
private function createProxyManager()
{
if ($this->proxyManager !== null) {
return;
}
if (!class_exists('ProxyManager\\Configuration')) {
throw new \RuntimeException('The ocramius/proxy-manager library is not installed. Lazy injection requires that library to be installed with Composer in order to work. Run "composer require ocramius/proxy-manager:~0.3".');
}
$config = new Configuration();
if ($this->writeProxiesToFile) {
$config->setProxiesTargetDir($this->proxyDirectory);
spl_autoload_register($config->getProxyAutoloader());
} else {
$config->setGeneratorStrategy(new EvaluatingGeneratorStrategy());
}
$this->proxyManager = new LazyLoadingValueHolderFactory($config);
}
public function createService(ServiceLocatorInterface $serviceLocator)
{
$config = $serviceLocator->get('Config');
// Config must be available
if (!isset($config['proxyManager'])) {
throw new RuntimeException('Proxy Manager configuration must be defined. Did you copy the config file?');
}
$config = $config['proxyManager'];
$configuration = new Configuration();
// ProxiesTargetDir for caching, where set.
if (isset($config['proxiesTargetDir'])) {
// Directory cross-platform sensitivity
str_replace('\\', DIRECTORY_SEPARATOR, $config['proxiesTargetDir']);
$configuration->setProxiesTargetDir($config['proxiesTargetDir']);
spl_autoload_register($configuration->getProxyAutoloader());
}
return $configuration;
}
/**
* @param ServiceLocatorInterface $serviceLocator
* @return LazyLoadingValueHolderFactory
* @throws InvalidArgumentException
*/
public function getLazyFactory(ServiceLocatorInterface $serviceLocator)
{
$config = $serviceLocator->has('config') ? $serviceLocator->get('config') : [];
$config['lazy_services'] = ArrayUtils::merge(isset($config['lazy_services']) ? $config['lazy_services'] : [], $config['bsb_flysystem']['adapter_manager']['lazy_services']);
if (!isset($config['lazy_services'])) {
throw new \InvalidArgumentException('Missing "lazy_services" config key');
}
$lazyServices = $config['lazy_services'];
$factoryConfig = new Configuration();
if (isset($lazyServices['proxies_namespace'])) {
$factoryConfig->setProxiesNamespace($lazyServices['proxies_namespace']);
}
if (isset($lazyServices['proxies_target_dir'])) {
$factoryConfig->setProxiesTargetDir($lazyServices['proxies_target_dir']);
}
if (!isset($lazyServices['write_proxy_files']) || !$lazyServices['write_proxy_files']) {
$factoryConfig->setGeneratorStrategy(new EvaluatingGeneratorStrategy());
}
spl_autoload_register($factoryConfig->getProxyAutoloader());
return new LazyLoadingValueHolderFactory($factoryConfig);
}
private function createProxyManager()
{
if ($this->proxyManager !== null) {
return;
}
if (!class_exists('ProxyManager\\Configuration')) {
throw new \RuntimeException('The ocramius/proxy-manager library is not installed. Lazy injection requires that library to be installed with Composer in order to work. Run "composer require ocramius/proxy-manager:~0.3".');
}
$config = new Configuration();
/**
* @todo useless since ProxyManager 0.5, line kept for compatibility with 0.3 and 0.4 which are
* the only versions that work with PHP < 5.3.23
* Remove when support for PHP 5.3 is dropped
*/
$config->setAutoGenerateProxies(true);
if ($this->writeProxiesToFile) {
$config->setProxiesTargetDir($this->proxyDirectory);
spl_autoload_register($config->getProxyAutoloader());
} else {
$config->setGeneratorStrategy(new EvaluatingGeneratorStrategy());
}
$this->proxyManager = new LazyLoadingValueHolderFactory($config);
}
public function __construct(Entity $metadata, SerialisedData $data, EntityManager $entity_manager)
{
$this->metadata = $metadata;
$this->serialised_data = $data;
$this->entity_manager = $entity_manager;
$conf = new Configuration();
$conf->setProxiesTargetDir($entity_manager->getConfig()->getCacheDir());
$conf->setProxiesNamespace(self::PROXY_NAMESPACE);
$factory = new OrmProxyFactory($conf);
$writer = $this;
// Create the proxy with a Closure responsible for lazy-loading via this instance of the Writer
$this->proxy = $factory->createProxy($metadata->getClassName(), function (LazyLoadingInterface $proxy, $method, array $parameters, &$initializer) use($writer) {
// Hydrate the primitive data
if (!$writer->is_hydrated) {
$writer->hydrate();
}
// Hydrate foreign relatives on request
$this->examineMethodForHydration($method);
return true;
});
if (!$this->proxy) {
throw new \RuntimeException("Unable to create proxy object of entity");
}
}
/**
* @covers \ProxyManager\Configuration::getProxiesTargetDir
* @covers \ProxyManager\Configuration::setProxiesTargetDir
*/
public function testSetGetProxiesTargetDir()
{
$this->assertTrue(is_dir($this->configuration->getProxiesTargetDir()));
$this->configuration->setProxiesTargetDir(__DIR__);
$this->assertSame(__DIR__, $this->configuration->getProxiesTargetDir());
}
/**
* Creates a ProxyManager configuration instance
*
* @return Configuration
*/
private function getProxyFactoryConfiguration()
{
$configuration = new Configuration();
if ($this->proxyCacheDirectory) {
$this->ensureDirectoryExists($this->proxyCacheDirectory);
$configuration->setProxiesTargetDir($this->proxyCacheDirectory);
}
return $configuration;
}
/**
* @return LazyLoadingValueHolderFactory
*/
private function buildProxyFactory()
{
$config = new Configuration();
// TODO useless since ProxyManager 0.5, line kept for compatibility with previous versions
$config->setAutoGenerateProxies(true);
if ($this->writeProxiesToFile) {
$config->setProxiesTargetDir($this->proxyDirectory);
spl_autoload_register($config->getProxyAutoloader());
} else {
$config->setGeneratorStrategy(new EvaluatingGeneratorStrategy());
}
return new LazyLoadingValueHolderFactory($config);
}
/**
* Setter for fileCachePath
*
* @param string $fileCachePath
* @return SdkClient
*/
public function setFileCachePath($fileCachePath)
{
$this->proxyManagerConfig = new Configuration();
$this->proxyManagerConfig->setProxiesTargetDir($fileCachePath);
return $this;
}
/**
* Returns the ProxyManager configuration based on the current
* {@link \bitExpert\Disco\BeanFactoryConfiguration}.
*
* @return Configuration
*/
public function getProxyManagerConfiguration() : Configuration
{
$proxyManagerConfiguration = new Configuration();
$proxyManagerConfiguration->setProxiesTargetDir($this->proxyTargetDir);
if ($this->proxyWriterGenerator instanceof GeneratorStrategyInterface) {
$proxyManagerConfiguration->setGeneratorStrategy($this->proxyWriterGenerator);
}
if ($this->proxyAutoloader instanceof AutoloaderInterface) {
$proxyManagerConfiguration->setProxyAutoloader($this->proxyAutoloader);
}
return $proxyManagerConfiguration;
}
/**
* Create the lazy services delegator factory.
*
* Creates the lazy services delegator factory based on the lazy_services
* configuration present.
*
* @return Proxy\LazyServiceFactory
* @throws ServiceNotCreatedException when the lazy service class_map
* configuration is missing
*/
private function createLazyServiceDelegatorFactory()
{
if ($this->lazyServicesDelegator) {
return $this->lazyServicesDelegator;
}
if (!isset($this->lazyServices['class_map'])) {
throw new ServiceNotCreatedException('Missing "class_map" config key in "lazy_services"');
}
$factoryConfig = new ProxyConfiguration();
if (isset($this->lazyServices['proxies_namespace'])) {
$factoryConfig->setProxiesNamespace($this->lazyServices['proxies_namespace']);
}
if (isset($this->lazyServices['proxies_target_dir'])) {
$factoryConfig->setProxiesTargetDir($this->lazyServices['proxies_target_dir']);
}
if (!isset($this->lazyServices['write_proxy_files']) || !$this->lazyServices['write_proxy_files']) {
$factoryConfig->setGeneratorStrategy(new EvaluatingGeneratorStrategy());
}
spl_autoload_register($factoryConfig->getProxyAutoloader());
$this->lazyServicesDelegator = new Proxy\LazyServiceFactory(new LazyLoadingValueHolderFactory($factoryConfig), $this->lazyServices['class_map']);
return $this->lazyServicesDelegator;
}