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]; }); }