vendor/friendsofsymfony/elastica-bundle/src/Doctrine/Listener.php line 183

  1. <?php
  3. /*
  4. * This file is part of the FOSElasticaBundle package.
  5. *
  6. * (c) FriendsOfSymfony <https://friendsofsymfony.github.com/>
  7. *
  8. * For the full copyright and license information, please view the LICENSE
  9. * file that was distributed with this source code.
  10. */
  12. namespace FOS\ElasticaBundle\Doctrine;
  14. use Doctrine\Persistence\Event\LifecycleEventArgs;
  15. use FOS\ElasticaBundle\Persister\ObjectPersister;
  16. use FOS\ElasticaBundle\Persister\ObjectPersisterInterface;
  17. use FOS\ElasticaBundle\Provider\IndexableInterface;
  18. use Psr\Log\LoggerInterface;
  19. use Symfony\Component\PropertyAccess\PropertyAccess;
  20. use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
  22. /**
  23. * Automatically update ElasticSearch based on changes to the Doctrine source
  24. * data. One listener is generated for each Doctrine entity / ElasticSearch type.
  25. */
  26. class Listener
  27. {
  28. /**
  29. * Objects scheduled for insertion.
  30. */
  31. public array $scheduledForInsertion = [];
  33. /**
  34. * Objects scheduled to be updated or removed.
  35. */
  36. public array $scheduledForUpdate = [];
  38. /**
  39. * IDs of objects scheduled for removal.
  40. */
  41. public array $scheduledForDeletion = [];
  42. /**
  43. * Object persister.
  44. */
  45. protected ObjectPersisterInterface $objectPersister;
  47. /**
  48. * PropertyAccessor instance.
  49. */
  50. protected PropertyAccessorInterface $propertyAccessor;
  52. /**
  53. * Configuration for the listener.
  54. */
  55. private array $config;
  57. private IndexableInterface $indexable;
  59. public function __construct(
  60. ObjectPersisterInterface $objectPersister,
  61. IndexableInterface $indexable,
  62. array $config = [],
  63. ?LoggerInterface $logger = null
  64. ) {
  65. $this->config = \array_merge([
  66. 'identifier' => 'id',
  67. 'defer' => false,
  68. ], $config);
  69. $this->indexable = $indexable;
  70. $this->objectPersister = $objectPersister;
  71. $this->propertyAccessor = PropertyAccess::createPropertyAccessor();
  73. if ($logger && $this->objectPersister instanceof ObjectPersister) {
  74. $this->objectPersister->setLogger($logger);
  75. }
  76. }
  78. /**
  79. * Handler for the "kernel.terminate" and "console.terminate" Symfony events.
  80. * These event are subscribed to if the listener is configured to persist asynchronously.
  81. */
  82. public function onTerminate()
  83. {
  84. if ($this->config['defer']) {
  85. $this->config['defer'] = false;
  86. $this->persistScheduled();
  87. $this->config['defer'] = true;
  88. }
  89. }
  91. /**
  92. * Looks for new objects that should be indexed.
  93. */
  94. public function postPersist(LifecycleEventArgs $eventArgs)
  95. {
  96. $entity = $eventArgs->getObject();
  98. if ($this->objectPersister->handlesObject($entity) && $this->isObjectIndexable($entity)) {
  99. $this->scheduledForInsertion[] = $entity;
  100. }
  101. }
  103. /**
  104. * Looks for objects being updated that should be indexed or removed from the index.
  105. */
  106. public function postUpdate(LifecycleEventArgs $eventArgs)
  107. {
  108. $entity = $eventArgs->getObject();
  110. if ($this->objectPersister->handlesObject($entity)) {
  111. if ($this->isObjectIndexable($entity)) {
  112. $this->scheduledForUpdate[] = $entity;
  113. } else {
  114. // Delete if no longer indexable
  115. $this->scheduleForDeletion($entity);
  116. }
  117. }
  118. }
  120. /**
  121. * Delete objects preRemove instead of postRemove so that we have access to the id. Because this is called
  122. * preRemove, first check that the entity is managed by Doctrine.
  123. */
  124. public function preRemove(LifecycleEventArgs $eventArgs)
  125. {
  126. $entity = $eventArgs->getObject();
  128. if ($this->objectPersister->handlesObject($entity)) {
  129. $this->scheduleForDeletion($entity);
  130. }
  131. }
  133. /**
  134. * Iterate through scheduled actions before flushing to emulate 2.x behavior.
  135. * Note that the ElasticSearch index will fall out of sync with the source
  136. * data in the event of a crash during flush.
  137. *
  138. * This method is only called in legacy configurations of the listener.
  139. *
  140. * @deprecated This method should only be called in applications that depend
  141. * on the behaviour that entities are indexed regardless of if a
  142. * flush is successful
  143. */
  144. public function preFlush()
  145. {
  146. $this->persistScheduled();
  147. }
  149. /**
  150. * Iterating through scheduled actions *after* flushing ensures that the
  151. * ElasticSearch index will be affected only if the query is successful.
  152. */
  153. public function postFlush()
  154. {
  155. $this->persistScheduled();
  156. }
  158. /**
  159. * Determines whether or not it is okay to persist now.
  160. *
  161. * @return bool
  162. */
  163. private function shouldPersist()
  164. {
  165. return !$this->config['defer'];
  166. }
  168. /**
  169. * Persist scheduled objects to ElasticSearch
  170. * After persisting, clear the scheduled queue to prevent multiple data updates when using multiple flush calls.
  171. */
  172. private function persistScheduled()
  173. {
  174. if ($this->shouldPersist()) {
  175. if (\count($this->scheduledForInsertion)) {
  176. $this->objectPersister->insertMany($this->scheduledForInsertion);
  177. $this->scheduledForInsertion = [];
  178. }
  179. if (\count($this->scheduledForUpdate)) {
  180. $this->objectPersister->replaceMany($this->scheduledForUpdate);
  181. $this->scheduledForUpdate = [];
  182. }
  183. if (\count($this->scheduledForDeletion)) {
  184. $this->objectPersister->deleteManyByIdentifiers($this->scheduledForDeletion);
  185. $this->scheduledForDeletion = [];
  186. }
  187. }
  188. }
  190. /**
  191. * Record the specified identifier to delete. Do not need to entire object.
  192. *
  193. * @param object $object
  194. */
  195. private function scheduleForDeletion($object)
  196. {
  197. if ($identifierValue = $this->propertyAccessor->getValue($object, $this->config['identifier'])) {
  198. $this->scheduledForDeletion[] = !\is_scalar($identifierValue) ? (string) $identifierValue : $identifierValue;
  199. }
  200. }
  202. /**
  203. * Checks if the object is indexable or not.
  204. *
  205. * @param object $object
  206. *
  207. * @return bool
  208. */
  209. private function isObjectIndexable($object)
  210. {
  211. return $this->indexable->isObjectIndexable(
  212. $this->config['indexName'],
  213. $object
  214. );
  215. }
  216. }