Sets the cache driver implementation that is used for metadata caching.
| public setMetadataCacheImpl ( Doctrine\Common\Cache\Cache $cacheImpl ) | ||
| $cacheImpl | Doctrine\Common\Cache\Cache | |
/**
*
* @param \Zend\ServiceManager\ServiceLocatorInterface $serviceLocator
* @return object
*/
public function createService(ServiceLocatorInterface $serviceLocator)
{
$manifest = $serviceLocator->get('manifest');
$extension = $serviceLocator->get('extension.odmcore');
$config = new Configuration();
$config->setProxyDir($extension->getProxyDir());
$config->setProxyNamespace('Proxies');
$config->setHydratorDir($extension->getHydratorDir());
$config->setHydratorNamespace('Hydrators');
$config->setDefaultDB($extension->getDefaultDb());
$config->setClassMetadataFactoryName($extension->getClassMetadataFactory());
$config->setMetadataCacheImpl(new ArrayCache());
//create driver chain
$chain = new MappingDriverChain();
foreach ($manifest->getModels() as $namespace => $path) {
$driver = new AnnotationDriver(new AnnotationReader(), $path);
$chain->addDriver($driver, $namespace);
}
$config->setMetadataDriverImpl($chain);
//register filters
foreach ($extension->getFilters() as $name => $class) {
$config->addFilter($name, $class);
}
//create event manager
$eventManager = new EventManager();
foreach ($manifest->getSubscribers() as $subscriber) {
$eventManager->addEventSubscriber($serviceLocator->get($subscriber));
}
//register annotations
AnnotationRegistry::registerLoader(function ($className) {
return class_exists($className);
});
$conn = new Connection(null, array(), $config);
return ModelManager::create($conn, $config, $eventManager);
}
/**
* Datasource constructor, creates the Configuration, Connection and DocumentManager objects
*
* ### You can pass the following configuration options
*
* - server: name of the server that will be used to connect to Mongo (default: `localhost`)
* - database: name of the database to use when connecting to Mongo (default: `cake`)
* - documentPaths: array containing a list of full path names where Document classes can be located (default: `App::path('Model')`)
* - proxyDir: full path to the directory that will contain the generated proxy classes for each document (default: `TMP . 'cache'`)
* - proxyNamespace: string representing the namespace the proxy classes will reside in (default: `Proxies`)
* - hydratorDir: directory well the hydrator classes will be generated in (default: `TMP . 'cache'`)
* - hydratorNamespace: string representing the namespace the hydrator classes will reside in (default: `Hydrators`)
*
* @param arary $config
* @param boolean $autoConnect whether this object should attempt connection on creation
* @throws MissingConnectionException if it was not possible to connect to MongoDB
*/
public function __construct($config = array(), $autoConnect = true)
{
$modelPaths = $this->_cleanupPaths(App::path('Model'));
$this->_baseConfig = array('proxyDir' => TMP . 'cache', 'proxyNamespace' => 'Proxies', 'hydratorDir' => TMP . 'cache', 'hydratorNamespace' => 'Hydrators', 'server' => 'localhost', 'database' => 'cake', 'documentPaths' => $modelPaths, 'prefix' => null);
foreach (CakePlugin::loaded() as $plugin) {
$this->_baseConfig['documentPaths'] = array_merge($this->_baseConfig['documentPaths'], $this->_cleanupPaths(App::path('Model', $plugin)));
}
parent::__construct($config);
extract($this->config, EXTR_OVERWRITE);
$configuration = new Configuration();
$configuration->setProxyDir($proxyDir);
$configuration->setProxyNamespace($proxyNamespace);
$configuration->setHydratorDir($hydratorDir);
$configuration->setHydratorNamespace($hydratorNamespace);
$configuration->setDefaultDB($database);
$configuration->setMetadataDriverImpl($this->_getMetadataReader($documentPaths));
if (Configure::read('debug') === 0) {
$configuration->setAutoGenerateHydratorClasses(false);
$configuration->setAutoGenerateProxyClasses(false);
$configuration->setMetadataCacheImpl(new ApcCache());
}
$this->configuration = $configuration;
$this->connection = new Connection($server, array(), $configuration);
$this->documentManager = DocumentManager::create($this->connection, $configuration);
$this->documentManager->getEventManager()->addEventListener(array(Events::prePersist, Events::preUpdate, Events::preRemove, Events::postPersist, Events::postUpdate, Events::postRemove), $this);
try {
if ($autoConnect) {
$this->connect();
}
} catch (Exception $e) {
throw new MissingConnectionException(array('class' => get_class($this)));
}
$this->setupLogger();
}
/**
*
* @param \Zend\ServiceManager\ServiceLocatorInterface $serviceLocator
* @return object
*/
public function createService(ServiceLocatorInterface $serviceLocator)
{
$manifest = $serviceLocator->get('manifest');
$config = new Configuration();
$config->setProxyDir(__DIR__ . '/../../../../Proxies');
$config->setProxyNamespace('Proxies');
$config->setHydratorDir(__DIR__ . '/../../../../Hydrators');
$config->setHydratorNamespace('Hydrators');
$config->setDefaultDB(self::DEFAULT_DB);
$config->setMetadataCacheImpl(new ArrayCache());
//create driver chain
$chain = new MappingDriverChain();
foreach ($manifest['documents'] as $namespace => $path) {
$driver = new AnnotationDriver(new AnnotationReader(), $path);
$chain->addDriver($driver, $namespace);
}
$config->setMetadataDriverImpl($chain);
//register filters
foreach ($manifest['filters'] as $name => $class) {
$config->addFilter($name, $class);
}
//create event manager
$eventManager = new EventManager();
foreach ($manifest['subscribers'] as $subscriber) {
$eventManager->addEventSubscriber($serviceLocator->get($subscriber));
}
//register annotations
AnnotationRegistry::registerLoader(function ($className) {
return class_exists($className);
});
$conn = new Connection(null, array(), $config);
return DocumentManager::create($conn, $config, $eventManager);
}
/**
*
* @param array $config
* @return DocumentManager
*/
public static function createDocumentManager($config, Container $container)
{
$configuration = new Configuration();
if (is_null($config['eventManager'])) {
$evm = new EventManager();
} else {
$evm = $config['eventManager'];
}
$configuration->setProxyDir($config['proxyDir']);
$configuration->setProxyNamespace($config['proxyNamespace']);
$configuration->setHydratorDir($config['hydratorDir']);
$configuration->setHydratorNamespace($config['hydratorNamespace']);
$configuration->setAutoGenerateHydratorClasses($config['autoGenerateHydratorClasses']);
$configuration->setAutoGenerateProxyClasses($config['autoGenerateProxyClasses']);
if (isset($config['metaDataCache'])) {
$metadataCache = $config['metaDataCache'];
} else {
$metadataCache = new $config['metaDataCacheClass']();
$metadataCache->setNamespace($config['cachePrefix']);
}
$configuration->setMetadataCacheImpl($metadataCache);
AnnotationDriver::registerAnnotationClasses();
$reader = new AnnotationReader();
if ($config['cacheAnnotations'] == TRUE) {
$reader = new CachedReader($reader, $metadataCache, $config['debug']);
}
if ($config['indexAnnotations'] == TRUE) {
$reader = new IndexedReader($reader);
}
if (class_exists(\Gedmo\DoctrineExtensions::class)) {
\Gedmo\DoctrineExtensions::registerAnnotations();
$configuration->addFilter('soft-deleteable', \Gedmo\SoftDeleteable\Filter\ODM\SoftDeleteableFilter::class);
foreach ($config['listeners'] as $listenerName => $enabled) {
if ($enabled) {
$listener = self::configureListener($listenerName, $reader);
$evm->addEventSubscriber($listener);
}
}
}
$driverImpl = new AnnotationDriver($reader, $config['documentsDir']);
$configuration->setMetadataDriverImpl($driverImpl);
$configuration->setDefaultDB($config['dbname']);
$logger = new Logger($config['logger'], $config['loggerPrefix']);
$configuration->setLoggerCallable([$logger, 'logQuery']);
$mongo = new MongoClient($config['uri'], $config['mongoOptions']);
$connection = new Connection($mongo);
$dm = DocumentManager::create($connection, $configuration, $evm);
foreach ($config['filters'] as $filter => $enabled) {
if ($enabled) {
$dm->getFilterCollection()->enable($filter);
}
}
return $dm;
}
/**
* @return EntityManager
*/
public static function createTestDocumentManager($paths = array())
{
$config = new Configuration();
$config->setAutoGenerateProxyClasses(true);
$config->setProxyDir(\sys_get_temp_dir());
$config->setHydratorDir(\sys_get_temp_dir());
$config->setProxyNamespace('GenemuFormBundleTests\\Doctrine');
$config->setHydratorNamespace('GenemuFormBundleTests\\Doctrine');
$config->setMetadataDriverImpl(new AnnotationDriver(new AnnotationReader(), $paths));
$config->setMetadataCacheImpl(new ArrayCache());
return DocumentManager::create(new Connection(), $config);
}
/**
* @return EntityManager
*/
public static function createTestDocumentManager($paths = array())
{
if (!class_exists('PDO') || !in_array('pgsql', \PDO::getAvailableDrivers())) {
self::markTestSkipped('This test requires PgSQL support in your environment');
}
$config = new Configuration();
$config->setAutoGenerateProxyClasses(true);
$config->setProxyDir(\sys_get_temp_dir());
$config->setHydratorDir(\sys_get_temp_dir());
$config->setProxyNamespace('GenemuFormBundleTests\\Doctrine');
$config->setHydratorNamespace('GenemuFormBundleTests\\Doctrine');
$config->setMetadataDriverImpl(new AnnotationDriver(new AnnotationReader(), $paths));
$config->setMetadataCacheImpl(new ArrayCache());
return DocumentManager::create(new Connection(), $config);
}
private function loadDoctrineMongoDBConfiguration(Application $app)
{
$app['doctrine.odm.mongodb.configuration'] = $app->share(function () use($app) {
$config = new Configuration();
$config->setMetadataCacheImpl($app['doctrine.odm.mongodb.metadata_cache']);
if (isset($app['doctrine.odm.mongodb.connection_options']['database'])) {
$config->setDefaultDB($app['doctrine.odm.mongodb.connection_options']['database']);
}
$chain = new MappingDriverChain();
$usingAnnotations = false;
foreach ((array) $app['doctrine.odm.mongodb.documents'] as $document) {
switch ($document['type']) {
case 'annotation':
$driver = AnnotationDriver::create((array) $document['path']);
$chain->addDriver($driver, $document['namespace']);
$usingAnnotations = true;
break;
case 'yml':
$driver = new YamlDriver((array) $document['path'], '.yml');
$chain->addDriver($driver, $document['namespace']);
break;
case 'xml':
$driver = new XmlDriver((array) $document['path'], '.xml');
$chain->addDriver($driver, $document['namespace']);
break;
default:
throw new \InvalidArgumentException(sprintf('"%s" is not a recognized driver', $document['type']));
break;
}
// add namespace alias
if (isset($document['alias'])) {
$config->addDocumentNamespace($document['alias'], $document['namespace']);
}
}
if ($usingAnnotations) {
AnnotationDriver::registerAnnotationClasses();
}
$config->setMetadataDriverImpl($chain);
$config->setProxyDir($app['doctrine.odm.mongodb.proxies_dir']);
$config->setProxyNamespace($app['doctrine.odm.mongodb.proxies_namespace']);
$config->setAutoGenerateProxyClasses($app['doctrine.odm.mongodb.auto_generate_proxies']);
$config->setHydratorDir($app['doctrine.odm.mongodb.hydrators_dir']);
$config->setHydratorNamespace($app['doctrine.odm.mongodb.hydrators_namespace']);
$config->setAutoGenerateHydratorClasses($app['doctrine.odm.mongodb.auto_generate_hydrators']);
$config->setLoggerCallable($app['doctrine.odm.mongodb.logger_callable']);
return $config;
});
}
public function setUp()
{
$config = new Configuration();
$config->setHydratorDir(sys_get_temp_dir());
$config->setHydratorNamespace('Hydrators');
$config->setProxyDir(sys_get_temp_dir());
$config->setProxyNamespace('Proxies');
$locatorXml = new SymfonyFileLocator(array(__DIR__ . '/../../../../../lib/Vespolina/Sync/Mapping' => 'Vespolina\\Sync\\Entity'), '.mongodb.xml');
$xmlDriver = new XmlDriver($locatorXml);
$config->setMetadataDriverImpl($xmlDriver);
$config->setMetadataCacheImpl(new ArrayCache());
$config->setAutoGenerateProxyClasses(true);
$doctrineODM = DocumentManager::create(null, $config);
$this->gateway = new SyncDoctrineMongoDBGateway($doctrineODM, 'Vespolina\\Entity\\Action\\Action');
parent::setUp();
}
protected function setUp()
{
$config = new Configuration();
$config->setHydratorDir(sys_get_temp_dir());
$config->setHydratorNamespace('Hydrators');
$config->setProxyDir(sys_get_temp_dir());
$config->setProxyNamespace('Proxies');
$locatorXml = new SymfonyFileLocator(array(__DIR__ . '/../../../../../lib/Vespolina/Brand/Mapping' => 'Vespolina\\Entity\\Brand'), '.mongodb.xml');
$xmlDriver = new XmlDriver($locatorXml);
$config->setMetadataDriverImpl($xmlDriver);
$config->setMetadataCacheImpl(new ArrayCache());
$config->setAutoGenerateProxyClasses(true);
$doctrineODM = DocumentManager::create(null, $config);
$doctrineODM->getEventManager()->addEventSubscriber(new TreeListener());
$this->brandGateway = new BrandDoctrineMongoDBGateway($doctrineODM, 'Vespolina\\Entity\\Brand\\Brand');
parent::setUp();
}
public function setUp()
{
Type::hasType('object') ? Type::overrideType('object', 'Payum\\Bridge\\Doctrine\\Types\\ObjectType') : Type::addType('object', 'Payum\\Bridge\\Doctrine\\Types\\ObjectType');
$conf = new Configuration();
$conf->setProxyDir(\sys_get_temp_dir());
$conf->setProxyNamespace('PayumTestsProxies');
$conf->setHydratorDir(\sys_get_temp_dir());
$conf->setHydratorNamespace('PayumTestsHydrators');
$conf->setMetadataDriverImpl($this->getMetadataDriverImpl());
$conf->setMetadataCacheImpl(new ArrayCache());
$conf->setDefaultDB('payum_tests');
$conn = new Connection(null, array(), $conf);
$this->dm = DocumentManager::create($conn, $conf);
foreach ($this->dm->getConnection()->selectDatabase('payum_tests')->listCollections() as $collection) {
$collection->drop();
}
}
public function loadDoctrineMongoDBConfiguration(Application $app)
{
$app['doctrine.odm.mongodb.configuration'] = $app->share(function () use($app) {
$config = new Configuration();
if ($app['doctrine.odm.mongodb.metadata_cache'] == 'apc') {
$cache = new ApcCache();
} else {
$cache = new ArrayCache();
}
$config->setMetadataCacheImpl($cache);
if (isset($app['doctrine.odm.mongodb.connection_options']['database'])) {
$config->setDefaultDB($app['doctrine.odm.mongodb.connection_options']['database']);
}
$chain = new DriverChain();
foreach ((array) $app['doctrine.odm.mongodb.documents'] as $document) {
switch ($document['type']) {
case 'annotation':
$reader = new AnnotationReader();
$driver = new AnnotationDriver($reader, (array) $document['path']);
$chain->addDriver($driver, $document['namespace']);
break;
case 'yml':
$driver = new YamlDriver((array) $document['path']);
$driver->setFileExtension('.yml');
$chain->addDriver($driver, $document['namespace']);
break;
case 'xml':
$driver = new XmlDriver((array) $document['path'], $document['namespace']);
$driver->setFileExtension('.xml');
$chain->addDriver($driver, $document['namespace']);
break;
default:
throw new \InvalidArgumentException(sprintf('"%s" is not a recognized driver', $document['type']));
break;
}
}
$config->setMetadataDriverImpl($chain);
$config->setProxyDir($app['doctrine.odm.mongodb.proxies_dir']);
$config->setProxyNamespace($app['doctrine.odm.mongodb.proxies_namespace']);
$config->setAutoGenerateProxyClasses($app['doctrine.odm.mongodb.auto_generate_proxies']);
$config->setHydratorDir($app['doctrine.odm.mongodb.hydrators_dir']);
$config->setHydratorNamespace($app['doctrine.odm.mongodb.hydrators_namespace']);
return $config;
});
}
/**
* @param \Zend\ServiceManager\ServiceLocatorInterface $serviceLocator
* @return \Doctrine\ODM\MongoDB\Configuration
* @throws \Exception
*/
public function createService(ServiceLocatorInterface $serviceLocator)
{
/** @var $options \DoctrineMongoODMModule\Options\Configuration */
$options = $this->getOptions($serviceLocator, 'configuration');
$config = new Configuration();
// logger
if ($options->getLogger()) {
$logger = $serviceLocator->get($options->getLogger());
$config->setLoggerCallable(array($logger, 'log'));
}
// proxies
$config->setAutoGenerateProxyClasses($options->getGenerateProxies());
$config->setProxyDir($options->getProxyDir());
$config->setProxyNamespace($options->getProxyNamespace());
// hydrators
$config->setAutoGenerateHydratorClasses($options->getGenerateHydrators());
$config->setHydratorDir($options->getHydratorDir());
$config->setHydratorNamespace($options->getHydratorNamespace());
// default db
$config->setDefaultDB($options->getDefaultDb());
// caching
$config->setMetadataCacheImpl($serviceLocator->get($options->getMetadataCache()));
// retries
$config->setRetryConnect($options->getRetryConnect());
$config->setRetryQuery($options->getRetryQuery());
// Register filters
foreach ($options->getFilters() as $alias => $class) {
$config->addFilter($alias, $class);
}
// the driver
$config->setMetadataDriverImpl($serviceLocator->get($options->getDriver()));
// metadataFactory, if set
if ($factoryName = $options->getClassMetadataFactoryName()) {
$config->setClassMetadataFactoryName($factoryName);
}
// custom types
foreach ($options->getTypes() as $name => $class) {
if (Type::hasType($name)) {
Type::overrideType($name, $class);
} else {
Type::addType($name, $class);
}
}
return $config;
}
public static function createDocumentManager(\Nette\DI\Container $container, $config)
{
$params = $container->parameters;
$configuration = new Configuration();
$configuration->setProxyDir($config['proxyDir']);
$configuration->setProxyNamespace('Proxies');
$configuration->setHydratorDir($config['hydratorDir']);
$configuration->setHydratorNamespace('Hydrators');
$isProductionMode = $params['productionMode'];
$configuration->setAutoGenerateHydratorClasses(!$isProductionMode);
$configuration->setAutoGenerateProxyClasses(!$isProductionMode);
$metadataCache = new $config['metaDataCacheClass']();
$metadataCache->setNamespace($config['cachePrefix']);
$configuration->setMetadataCacheImpl($metadataCache);
\Doctrine\Common\Annotations\AnnotationRegistry::registerFile(VENDORS_DIR . '/doctrine/mongodb-odm/lib/Doctrine/ODM/MongoDB/Mapping/Annotations/DoctrineAnnotations.php');
$reader = new AnnotationReader();
$driverImpl = new AnnotationDriver($reader, $config['documentsDir']);
$configuration->setMetadataDriverImpl($driverImpl);
$configuration->setDefaultDB($config['dbname']);
$mongo = new \Mongo($config['uri'], array('connect' => true));
$connection = new Connection($mongo);
$dm = \Doctrine\ODM\MongoDB\DocumentManager::create($connection, $configuration);
return $dm;
}
private function initDm()
{
$config = new Configuration();
$conn = new Connection($this->_config->getConfigData('mongo_server'));
if (true === $this->_config->getConfigData('development_environment')) {
$cache = new ArrayCache();
$config->setAutoGenerateHydratorClasses(true);
$config->setAutoGenerateProxyClasses(true);
} else {
$cache = new ApcCache(array('prefix' => $this->_app->getConfig()->getConfigData('app_name')));
$config->setAutoGenerateHydratorClasses(false);
$config->setAutoGenerateProxyClasses(false);
}
$config->setMetadataCacheImpl($cache);
$config->setProxyDir(ROOT . DS . 'app' . DS . 'proxies');
$config->setProxyNamespace('Proxies');
$config->setHydratorDir(ROOT . DS . 'app' . DS . 'hydrators');
$config->setHydratorNamespace('Hydrators');
$config->setDefaultDB($this->_config->getConfigData('mongo_dbName'));
$config->setMetadataDriverImpl(AnnotationDriver::create(ROOT . DS . 'app' . DS . 'models'));
AnnotationDriver::registerAnnotationClasses();
$this->_dm = DocumentManager::create($conn, $config);
ServiceContainer::set()['dm'] = $this->_dm;
}
/**
* {@inheritDoc}
*/
public function createStorage($modelClass, $idProperty, array $options)
{
if (false == Type::hasType('object')) {
Type::addType('object', 'Payum\\Core\\Bridge\\Doctrine\\Types\\ObjectType');
}
$driver = new MappingDriverChain();
// payum's basic models
$coreRootDir = dirname((new \ReflectionClass(GatewayInterface::class))->getFileName());
$driver->addDriver(new XmlDriver(new SymfonyFileLocator(array($coreRootDir . '/Bridge/Doctrine/Resources/mapping' => 'Payum\\Core\\Model'), '.mongodb.xml'), '.mongodb.xml'), 'Payum\\Core\\Model');
// your models
$sererRootDir = dirname((new \ReflectionClass(Application::class))->getFileName());
AnnotationDriver::registerAnnotationClasses();
$driver->addDriver(new AnnotationDriver(new AnnotationReader(), array($sererRootDir . '/Model')), 'Payum\\Server\\Model');
$config = new Configuration();
$config->setProxyDir(\sys_get_temp_dir() . '/PayumServer');
$config->setProxyNamespace('Proxies');
$config->setHydratorDir(\sys_get_temp_dir() . '/PayumServer');
$config->setHydratorNamespace('Hydrators');
$config->setMetadataDriverImpl($driver);
$config->setMetadataCacheImpl(new ArrayCache());
$config->setDefaultDB($options['databaseName']);
$connection = new Connection($options['host'], array(), $config);
return new DoctrineStorage(DocumentManager::create($connection, $config), $modelClass);
}
<?php
require '/Users/jwage/Sites/doctrine2git/lib/Doctrine/Common/ClassLoader.php';
use Doctrine\Common\ClassLoader, Doctrine\Common\Annotations\AnnotationReader, Doctrine\Common\Cache\ApcCache, Doctrine\ODM\MongoDB\DocumentManager, Doctrine\ODM\MongoDB\Mongo, Doctrine\ODM\MongoDB\Configuration, Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver;
$classLoader = new ClassLoader('Doctrine\\ODM', __DIR__ . '/../lib');
$classLoader->register();
$classLoader = new ClassLoader('Doctrine', '/Users/jwage/Sites/doctrine2git/lib');
$classLoader->register();
$config = new Configuration();
$config->setMetadataCacheImpl(new ApcCache());
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Proxies');
$reader = new AnnotationReader();
$reader->setDefaultAnnotationNamespace('Doctrine\\ODM\\MongoDB\\Mapping\\');
$config->setMetadataDriverImpl(new AnnotationDriver($reader, __DIR__ . '/Documents'));
$mongo = new Mongo();
$dm = DocumentManager::create($mongo, $config);
/** @Document(db="performance", collection="users") */
class User
{
/** @Id */
public $id;
/** @String */
public $username;
/** @String */
public $password;
}
$start = microtime(true);
/*
$user = new User();
$user->username = '******';
/**
* Create Doctrine ODM bare configuration.
*
* @param array $options
*
* @return \Doctrine\ODM\MongoDB\Configuration
*/
protected static function createBareConfiguration(array $options)
{
$proxyDir = $options['proxy_path'] ?: sys_get_temp_dir();
$cache = static::getCacheDriver($options);
if ($cache instanceof CacheProvider) {
$cache->setNamespace('odm_dc2_' . md5($proxyDir) . '_');
}
$config = new Configuration();
$config->setMetadataCacheImpl($cache);
$config->setProxyDir($proxyDir);
$config->setProxyNamespace('DoctrineODMProxy');
$config->setHydratorDir($options['hydrator_path'] ?: sys_get_temp_dir());
$config->setHydratorNamespace('DoctrineODMHydrator');
return $config;
}
/**
* @return \Doctrine\ODM\MongoDB\Configuration
*/
protected function getConfiguration()
{
$config = new Configuration();
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Proxies');
$config->setHydratorDir(__DIR__ . '/Hydrators');
$config->setHydratorNamespace('Hydrators');
$config->setDefaultDB(DOCTRINE_MONGODB_DATABASE);
$config->setClassMetadataFactoryName(ClassMetadataFactory::class);
$config->setMetadataDriverImpl($this->createMetadataDriverImpl());
$config->setMetadataCacheImpl(new FilesystemCache(__DIR__ . '/Cache'));
return $config;
}
/**
* Creates a configuration without a metadata driver.
*
* @param bool $isDevMode
* @param string $proxyDir
* @param Cache $cache
*
* @return Configuration
*/
public static function createConfiguration($isDevMode = false, $proxyDir = null, Cache $cache = null)
{
$proxyDir = $proxyDir ?: sys_get_temp_dir();
if ($isDevMode === false && $cache === null) {
if (extension_loaded('apc')) {
$cache = new \Doctrine\Common\Cache\ApcCache();
} elseif (extension_loaded('xcache')) {
$cache = new \Doctrine\Common\Cache\XcacheCache();
} elseif (extension_loaded('memcache')) {
$memcache = new \Memcache();
$memcache->connect('127.0.0.1');
$cache = new \Doctrine\Common\Cache\MemcacheCache();
$cache->setMemcache($memcache);
} elseif (extension_loaded('redis')) {
$redis = new \Redis();
$redis->connect('127.0.0.1');
$cache = new \Doctrine\Common\Cache\RedisCache();
$cache->setRedis($redis);
} else {
$cache = new ArrayCache();
}
} elseif ($cache === null) {
$cache = new ArrayCache();
}
if ($cache instanceof CacheProvider) {
$cache->setNamespace("dc2_" . md5($proxyDir) . "_");
// to avoid collisions
}
$config = new Configuration();
$config->setMetadataCacheImpl($cache);
// $config->setQueryCacheImpl($cache);
// $config->setResultCacheImpl($cache);
$config->setProxyDir($proxyDir);
$config->setProxyNamespace('DoctrineProxies');
$config->setAutoGenerateProxyClasses($isDevMode);
return $config;
}
/**
* Inits MongoDB ODM
*
* @return EntityManager|null
* @throws InvalidArgumentException
*/
private function initODMMongoDB()
{
$options = $this->getOptions();
if (isset($options['odm']['mongoDb'])) {
$odmOptions = $options['odm']['mongoDb'];
$this->assertProxyConfiguration($odmOptions);
$this->assertHydratorConfiguration($odmOptions);
$config = new MongoDBConfiguration();
$config->setMetadataCacheImpl($this->getCache($odmOptions, 'metadataCache'));
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver($this->getAnnotationDirectories($odmOptions)));
$config->setProxyDir(realpath($odmOptions['proxyDir']));
$config->setProxyNamespace($odmOptions['proxyNamespace']);
$config->setAutoGenerateProxyClasses((bool) isset($odmOptions['autoGenerateProxyClasses']) ? $odmOptions['autoGenerateProxyClasses'] : true);
$config->setHydratorDir(realpath($odmOptions['hydratorDir']));
$config->setHydratorNamespace($odmOptions['hydratorNamespace']);
$config->setAutoGenerateHydratorClasses((bool) isset($odmOptions['autoGenerateHydratorClasses']) ? $odmOptions['autoGenerateHydratorClasses'] : true);
if (isset($odmOptions['defaultDb'])) {
$config->setDefaultDB($odmOptions['defaultDb']);
}
return MongoDBDocumentManager::create(null, $config);
}
}
/**
* (register hook)
*
* @param \Silex\Application $application
*/
public function register(Application $application)
{
/*
* MongoDB Connection Manager Closure.
*
* @param string $connectionKey
*
* @return \Doctrine\MongoDB\Connection
*/
$application['doctrine_mongodb.connection'] = $application->protect(function ($connectionKey = 'default') use($application) {
if (isset($application['doctrine_mongodb']['connections'][$connectionKey])) {
$connectionOptions = $application['doctrine_mongodb']['connections'][$connectionKey];
if (isset($connectionOptions['server'])) {
$server = $connectionOptions['server'];
} else {
$defaults = array('host', 'database', 'port');
$missing = array_diff_key(array_flip($defaults), $connectionOptions);
if (!empty($missing)) {
throw new \RuntimeException(sprintf('The MongoDB connection options "%s" is missing', join(', ', $missing)));
}
$server = sprintf('mongodb://%s:%s/%s', $connectionOptions['host'], $connectionOptions['port'], $connectionOptions['database']);
}
$options = isset($connectionOptions['options']) ? $connectionOptions['options'] : array();
return new Connection($server, $options, $application['doctrine_mongodb.configuration']($connectionKey));
}
throw new \InvalidArgumentException(sprintf('Unable to find the MongoDB "%s" connection options', $connectionKey));
});
/*
* MongoDB Configuration Manager Closure.
*
* @param string $configurationKey The configuration key
*
* @return Configuration
*/
$application['doctrine_mongodb.configuration'] = $application->protect(function ($configurationKey = 'default') use($application) {
$configuration = new Configuration();
$options = array('db_name' => 'default', 'proxies_dir' => sys_get_temp_dir(), 'proxies_namespace' => 'DoctrineMongoDBProxy', 'auto_generate_proxies' => true, 'hydrators_dir' => sys_get_temp_dir(), 'hydrators_namespace' => 'DoctrineMongoDBHydrator', 'metadata_cache' => '\\Doctrine\\Common\\Cache\\ArrayCache', 'auto_generate_hydrators' => true, 'logger_callable' => null);
$doctrineMongoDB = $application['doctrine_mongodb'];
foreach ($options as $key => $value) {
if (isset($doctrineMongoDB[$key])) {
$options[$key] = $doctrineMongoDB[$key];
}
}
if (isset($doctrineMongoDB['document_managers'][$configurationKey]['mapping'])) {
$mappingChain = $doctrineMongoDB['document_managers'][$configurationKey]['mapping'];
$driverChain = new MappingDriverChain();
foreach ($mappingChain as $name => $mapping) {
$namespace = isset($mapping['alias']) ? $mapping['alias'] : $name;
$configuration->addDocumentNamespace($namespace, $mapping['namespace']);
$mappingPath = (array) $mapping['path'];
$mappingNamespace = $mapping['namespace'];
$isAnnotation = false;
switch (strtolower($mapping['type'])) {
case 'annotation':
$driver = $configuration->newDefaultAnnotationDriver($mappingPath);
$isAnnotation = true;
break;
case 'xml':
$driver = new XmlDriver($mappingPath);
break;
case 'yml':
$driver = new YamlDriver($mappingPath);
break;
default:
throw new \RuntimeException(sprintf('MongoDB Mapping Type "%s" is not supported or unknown', $mapping['type']));
}
$driverChain->addDriver($driver, $mappingNamespace);
if (true === $isAnnotation) {
AnnotationDriver::registerAnnotationClasses();
}
$configuration->setMetadataDriverImpl($driverChain);
}
}
$configuration->setProxyDir($options['proxies_dir']);
$configuration->setProxyNamespace($options['proxies_namespace']);
$configuration->setAutoGenerateProxyClasses($options['auto_generate_proxies']);
$configuration->setHydratorDir($options['hydrators_dir']);
$configuration->setHydratorNamespace($options['hydrators_namespace']);
$configuration->setAutoGenerateHydratorClasses($options['auto_generate_hydrators']);
$metaDataCacheClass = $options['metadata_cache'];
if (!class_exists($metaDataCacheClass, true)) {
throw new \RuntimeException(sprintf('Unable to find the Doctrine Metadata Cache "%s"', $metaDataCacheClass));
}
$configuration->setMetadataCacheImpl(new $metaDataCacheClass());
$configuration->setDefaultDB($options['db_name']);
return $configuration;
});
/*
* The MongoDB Document Manager Closure.
*
* @param string $managerKey
*
* @return \Doctrine\Common\Persistence\ObjectManager
*/
$application['doctrine_mongodb.document_manager'] = $application->protect(function ($managerKey) use($application) {
$key = strtolower($managerKey);
$serviceKey = sprintf('doctrine_mongodb.%s_document_manager', $key);
if (!$application->offsetExists($serviceKey)) {
$application[$serviceKey] = DocumentManager::create($application['doctrine_mongodb.connection']($key), $application['doctrine_mongodb.configuration']($key));
}
return $application[$serviceKey];
});
}
