/** * 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(); }