PHP EntityManager::isOpen方法代碼示例

 /**
  * Get EntityManager
  *
  * @return Doctrine\ORM\EntityManager
  */
 public function getEntityManager()
 {
     if ($this->em !== null && $this->em->isOpen()) {
         return $this->em;
     }
     return $this->_configureEntityManager();
 }

 /**
  * Flush on kernel terminate.
  */
 public function onKernelTerminate()
 {
     if ($this->em->isOpen()) {
         $this->em->flush();
         // That was not so hard... And you need a bundle to do that! Poor guy...
     }
 }

 /**
  * Because the EntityManager gets closed when there's an error, it needs to
  * be created again
  *
  * @return EntityManager
  * @throws ORMException
  */
 protected function getEntityManager()
 {
     if (!$this->em) {
         $this->em = $this->getContainer()->get('doctrine.orm.entity_manager');
     }
     if (!$this->em->isOpen()) {
         $this->em = $this->em->create($this->em->getConnection(), $this->em->getConfiguration());
     }
     return $this->em;
 }

 /**
  * Getter for entityManager
  *
  * @return EntityManager
  */
 public static function getEntityManager()
 {
     #if(null === self::$_entityManager) {
     #  self::$_entityManager = \Zend_Controller_Front::getInstance()->getParam('bootstrap')->getResource('entityManager');
     #}
     // Check if entitymanager has been closed (most likely due to a previously thrown PDOException)
     if (!self::$_entityManager->isOpen()) {
         // Entitymanger has closed, create a new one
         $connection = self::$_entityManager->getConnection();
         $config = self::$_entityManager->getConfiguration();
         self::$_entityManager = EntityManager::create($connection, $config);
     }
     return self::$_entityManager;
 }

 /**
  * Prepares EntityManager, reset it if closed with error
  */
 protected function ensureEntityManagerReady()
 {
     $this->em = $this->registry->getManager();
     if (!$this->em->isOpen()) {
         $this->registry->resetManager();
         $this->ensureEntityManagerReady();
     }
 }

 /**
  * @param string $jobType
  * @param string $jobName
  * @param array $configuration
  * @return JobResult
  */
 public function executeJob($jobType, $jobName, array $configuration = array())
 {
     // create and persist job instance and job execution
     $jobInstance = new JobInstance(self::CONNECTOR_NAME, $jobType, $jobName);
     $jobInstance->setCode($this->generateJobCode($jobName));
     $jobInstance->setLabel(sprintf('%s.%s', $jobType, $jobName));
     $jobInstance->setRawConfiguration($configuration);
     $jobExecution = new JobExecution();
     $jobExecution->setJobInstance($jobInstance);
     // persist batch entities
     $this->batchJobManager->persist($jobInstance);
     $this->batchJobManager->persist($jobExecution);
     // do job
     $jobResult = $this->doJob($jobInstance, $jobExecution);
     // EntityManager can be closed when there was an exception in flush method called inside some jobs execution
     // Can't be implemented right now due to OroEntityManager external dependencies
     // on ExtendManager and FilterCollection
     if (!$this->entityManager->isOpen()) {
         $this->managerRegistry->resetManager();
         $this->entityManager = $this->managerRegistry->getManager();
     }
     // flush batch entities
     $this->batchJobManager->flush($jobInstance);
     $this->batchJobManager->flush($jobExecution);
     // set data to JobResult
     $jobResult->setJobId($jobInstance->getId());
     $jobResult->setJobCode($jobInstance->getCode());
     // TODO: Find a way to work with multiple amount of job and step executions
     // TODO: https://magecore.atlassian.net/browse/BAP-2600
     /** @var JobExecution $jobExecution */
     $jobExecution = $jobInstance->getJobExecutions()->first();
     if ($jobExecution) {
         $stepExecution = $jobExecution->getStepExecutions()->first();
         if ($stepExecution) {
             $context = $this->contextRegistry->getByStepExecution($stepExecution);
             $jobResult->setContext($context);
         }
     }
     return $jobResult;
 }

 /**
  * Writes the record down to the log of the implementing handler
  *
  * @param  array $record
  *
  * @return void
  */
 protected function write(array $record)
 {
     $this->record = $record;
     $error = new Error();
     $error->setMessage($this->getFromRecord('message'));
     $error->setFile($this->getFile());
     $error->setLine($this->getLine());
     $error->setTrace($this->getTrace());
     $error->setType($this->getType());
     $error->setCode($this->getCode());
     $error->setUri($this->getFromRecordExtra('uri'));
     $error->setRoute($this->getFromRecordExtra('route'));
     $error->setController($this->getFromRecordExtra('controller'));
     $error->setUserAgent($this->getFromRecordExtra('userAgent'));
     $error->setUserContext($this->getFromRecordExtra('userContext'));
     $error->setUser($this->getFromRecordExtra('user'));
     if (!$this->entityManager->isOpen()) {
         $this->entityManager = $this->entityManager->create($this->entityManager->getConnection(), $this->entityManager->getConfiguration());
     }
     $this->entityManager->persist($error);
     $this->entityManager->flush($error);
     $this->lastError->setId($error->getId());
 }

 /** CREATE LOGS **/
 public function setLogTalk($ação, $erro)
 {
     if (!$this->entityManager->isOpen()) {
         $this->entityManager = $this->entityManager->create($this->entityManager->getConnection(), $this->entityManager->getConfiguration());
     }
     $log = new Logs();
     $log->setDataLogs(new \DateTime('now'));
     $log->setDescricaoLogs($erro);
     $log->setDescricaoAcaoLogs($ação);
     try {
         $this->entityManager->persist($log);
         $this->entityManager->flush();
     } catch (\Exception $e) {
         throw new \Exception("Não foi possível guardar as mensagens recebidas:" . $e->getMessage());
     }
 }

 /**
  * @param ScheduledCommand $scheduledCommand
  * @param OutputInterface $output
  * @param InputInterface $input
  */
 private function executeCommand(ScheduledCommand $scheduledCommand, OutputInterface $output, InputInterface $input)
 {
     $scheduledCommand = $this->em->merge($scheduledCommand);
     $scheduledCommand->setLastExecution(new \DateTime());
     $scheduledCommand->setLocked(true);
     $this->em->flush();
     try {
         $command = $this->getApplication()->find($scheduledCommand->getCommand());
     } catch (\InvalidArgumentException $e) {
         $scheduledCommand->setLastReturnCode(-1);
         $output->writeln('<error>Cannot find ' . $scheduledCommand->getCommand() . '</error>');
         return;
     }
     $input = new ArrayInput(array_merge(array('command' => $scheduledCommand->getCommand(), '--env' => $input->getOption('env')), $scheduledCommand->getArguments(true)));
     // Use a StreamOutput or NullOutput to redirect write() and writeln() in a log file
     if (false === $this->logPath && "" != $scheduledCommand->getLogFile()) {
         $logOutput = new NullOutput();
     } else {
         $logOutput = new StreamOutput(fopen($this->logPath . $scheduledCommand->getLogFile(), 'a', false), $this->commandsVerbosity);
     }
     // Execute command and get return code
     try {
         $output->writeln('<info>Execute</info> : <comment>' . $scheduledCommand->getCommand() . ' ' . $scheduledCommand->getArguments() . '</comment>');
         $result = $command->run($input, $logOutput);
     } catch (\Exception $e) {
         $logOutput->writeln($e->getMessage());
         $logOutput->writeln($e->getTraceAsString());
         $result = -1;
     }
     if (false === $this->em->isOpen()) {
         $output->writeln('<comment>Entity manager closed by the last command.</comment>');
         $this->em = $this->em->create($this->em->getConnection(), $this->em->getConfiguration());
     }
     $scheduledCommand = $this->em->merge($scheduledCommand);
     $scheduledCommand->setLastReturnCode($result);
     $scheduledCommand->setLocked(false);
     $scheduledCommand->setExecuteImmediately(false);
     $this->em->flush();
     /*
      * This clear() is necessary to avoid conflict between commands and to be sure that none entity are managed
      * before entering in a new command
      */
     $this->em->clear();
     unset($command);
     gc_collect_cycles();
 }

 /**
  * @author Krzysztof Bednarczyk
  * @param Language $language
  * @param string $token
  * @param string $domain
  * @return bool
  */
 public function createTranslation(Language $language, $token, $domain)
 {
     try {
         if (!$this->em->isOpen()) {
             $this->em = $this->em->create($this->em->getConnection(), $this->em->getConfiguration());
         }
         $language = $this->em->getRepository("BordeuxLanguageBundle:Language")->find($language->getId());
         $translation = new LanguageTranslation();
         $translation->setLanguage($language->getAlias() ?: $language);
         $translation->setTranslation($token);
         $translation->setLanguageToken($this->getToken($token));
         $translation->setDomain($domain);
         $this->em->persist($translation);
         $this->em->flush([$translation]);
     } catch (\Exception $e) {
         return false;
     }
     return true;
 }

 protected function resetEntityManager()
 {
     if (!$this->entityManager->isOpen()) {
         $this->entityManager = $this->entityManager->create($this->entityManager->getConnection(), $this->entityManager->getConfiguration());
     }
 }

 /**
  * @param EntityManager $em
  * @return EntityManager
  * @throws \Doctrine\ORM\ORMException
  */
 public static function getEntityManager(EntityManager $em)
 {
     if (!$em->isOpen()) {
         $em = $em->create($em->getConnection(), $em->getConfiguration());
     }
     return $em;
 }

 /**
  * {@inheritDoc}
  *
  * @static 
  */
 public static function isOpen()
 {
     return \Doctrine\ORM\EntityManager::isOpen();
 }

 /**
  * {@inheritdoc}
  */
 public function isOpen()
 {
     return $this->wrapped->isOpen();
 }