vendor/can/rest/src/Can/RestBundle/EventListener/VersionListener.php line 64

Open in your IDE?
  1. <?php
  3. namespace Can\RestBundle\EventListener;
  5. use Can\RestBundle\CanRestBundle;
  6. use Can\RestBundle\Http\Exception\UpgradeRequiredHttpException;
  7. use Can\RestBundle\Mapping\Metadata\VersionMetadata;
  8. use Can\RestBundle\Mapping\MetadataStore;
  9. use Can\RestBundle\URI\ServiceNode;
  10. use Can\RestBundle\URI\WellKnownURIs;
  12. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  13. use Symfony\Component\HttpKernel\Event\RequestEvent;
  14. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  16. use DateTime;
  17. use Exception;
  19. /**
  20.  * @group service
  21.  *
  22.  * @package can/rest-bundle
  23.  * @author lechecacharro <lechecacharro@gmail.com>
  24.  */
  25. class VersionListener
  26. {
  28.     /**
  29.      * @var bool
  30.      */
  31.     private $enabled;
  33.     /**
  34.      * @var EventDispatcherInterface
  35.      */
  36.     private $dispatcher;
  38.     /**
  39.      * @var MetadataStore
  40.      */
  41.     private $metadataStore;
  44.     /**
  45.      * VersionListener constructor.
  46.      *
  47.      * @param bool                     $enabled
  48.      * @param MetadataStore            $metadataStore
  49.      * @param EventDispatcherInterface $dispatcher
  50.      */
  51.     public function __construct(bool $enabled, EventDispatcherInterface $dispatcher, MetadataStore $metadataStore)
  52.     {
  53.         $this->enabled = $enabled;
  54.         $this->dispatcher = $dispatcher;
  55.         $this->metadataStore = $metadataStore;
  56.     }
  59.     /**
  60.      * @param RequestEvent $event
  61.      *
  62.      * @throws Exception
  63.      */
  64.     public function onRequest(RequestEvent $event): void
  65.     {
  66.         if (! $this->enabled) {
  67.             return;
  68.         }
  70.         if (! $event->isMasterRequest()) {
  71.             return;
  72.         }
  74.         $request = $event->getRequest();
  76.         if (! $serviceNode = $request->attributes->get(CanRestBundle::ATTR_SERVICE_NODE)) {
  77.             return;
  78.         }
  80.         if (! $metadata = $this->getVersionMetadata($serviceNode)) {
  81.             return;
  82.         }
  84.         // If the requested service version is no longer supported, and we can
  85.         // offer an alternative to the consumer (that is a version upgrade),
  86.         // then return a 426 (Upgrade Required) response
  87.         if ($metadata->isNotSupported()) {
  88.             if ($upgradeToVersion = $this->getUpgradeToVersion($metadata)) {
  89.                 throw new UpgradeRequiredHttpException($serviceNode->getVersionNumber(), $upgradeToVersion, $metadata->getSupportEndsAt());
  90.             }
  91.         }
  93.         // Else, if the requested service version is already deprecated, then
  94.         // add a response listener to generate the appropriate HTTP headers
  95.         // to keep the consumer informed
  96.         if ($metadata->isDeprecated()) {
  97.             $this->dispatcher->addListener('kernel.response', [static::class, 'onResponse'], -1);
  98.         }
  99.     }
  101.     /**
  102.      * @param ResponseEvent $event
  103.      */
  104.     public function onResponse(ResponseEvent $event): void
  105.     {
  106.         $serviceNode = $event->getRequest()->attributes->get(CanRestBundle::ATTR_SERVICE_NODE);
  107.         $metadata = $this->getVersionMetadata($serviceNode);
  109.         // Add a Sunset header
  110.         $event->getResponse()->headers->set('Sunset', $this->getSunset($metadata));
  111.     }
  114.     /**
  115.      * @param ServiceNode $serviceNode
  116.      *
  117.      * @return VersionMetadata | null
  118.      */
  119.     private function getVersionMetadata(ServiceNode $serviceNode): ?VersionMetadata
  120.     {
  121.         if (! $versionNumber = $serviceNode->getVersionNumber()) {
  122.             return null;
  123.         }
  125.         if (WellKnownURIs::WELL_KNOWN === $versionNumber) {
  126.             return null;
  127.         }
  129.         return $this->metadataStore->getVersionMetadata($versionNumber);
  130.     }
  132.     /**
  133.      * @param VersionMetadata $metadata
  134.      *
  135.      * @return string
  136.      */
  137.     private function getSunset(VersionMetadata $metadata): string
  138.     {
  139.         return $metadata->getDeprecatedSince()->format(DateTime::RFC1123);
  140.     }
  142.     /**
  143.      * @param VersionMetadata $metadata
  144.      *
  145.      * @return string | null
  146.      *
  147.      * @throws Exception
  148.      */
  149.     private function getUpgradeToVersion(VersionMetadata $metadata): ?string
  150.     {
  151.         $serviceMetadata = $this->metadataStore->getServiceMetadata();
  152.         $versionIterator = $serviceMetadata->getVersions()->getIterator();
  153.         $versionNumber = $metadata->getNumber();
  155.         // Recommend always the LTS version
  156.         foreach ($versionIterator as $version) {
  157.             if ($version->isLongTermSupport()) {
  158.                 return $version->getNumber();
  159.             }
  160.         }
  162.         // If no LTS version is declared, then choose the immediate version
  163.         // number which is not deprecated
  164.         foreach ($versionIterator as $version) {
  165.             if ($version->getNumber() > $versionNumber && ! $version->isDeprecated()) {
  166.                 return $version->getNumber();
  167.             }
  168.         }
  170.         // Return the default service version, if it's different from the
  171.         // deprecated version
  172.         if ($serviceMetadata->getDefaultVersionMetadata() > $versionNumber) {
  173.             return $serviceMetadata->getDefaultVersion();
  174.         }
  176.         // Cannot find a version to upgrade to
  177.         return null;
  178.     }
  180. }