Versión del contenido estático en Magento 2
La versión de los ficheros estáticos se encuentra en un fichero llamado deployed_version.txt y está en la ruta pub/static.
En modo developer, se crea una nueva versión cuando no se encuentra el fichero. Por eso cuando ejecutamos el comando setup:static-content:deploy,
la versión se renueva, porque este comando incluye la acción de eliminar el fichero.
Cuando se renueva, obligamos a los navegadores refrescar el caché del navegador.
También funciona para los servicios de CDN tales como FASTLY, AKAMAI, O CLOUDFLARE. En modo producción, si no se encuentra el fichero, Magento lanzará
un mensaje de error, si la regeneración de la versión no es a la demanda.
La versión es el resultado devuelto por la función time(). Este valor es la fecha Unix actual.
Podemos convertir esta fecha de forma más legible con Javascript.
# Generamos el tiempo Unix en la línea de comandos: php -a
echo time(); //1666645617
# Cogemos el resultado y lo convertimos con Javascript en una fecha y hora más legible para humanos
const fecha_y_hora = new Date(1666645617 * 1000).toLocaleString('es-ES')
console.log(fecha_y_hora) // '24/10/2022, 23:06:57'
# También podemos convertirlo en una fecha más legible con php
echo date('Y-m-d H:m:s', 1666645617)
A partir de la información de la versión podemos saber cuándo fue la fecha y hora del último despliegue. ¡Ojo! Siempre que la generación de los ficheros estáticos NO sea a la demanda. En producción, normalmente esta opción está desactivada.
Los comandos que hacen cambiar la firma de la versión de Magento son los siguientes:
- magento setup:upgrade
- magento setup:static-content:deploy
Análisis del código
En php, una clase se crea así:
# Para más info: https://www.php.net/manual/es/language.oop5.basic.php
# Creamos clase. Generalizamos, por ejemplo, Persona. Una persona tiene piernas y puede correr.
class ClaseSencilla
{
// Declaración de una constante
const constante = 'un valor predeterminado';
// Declaración de una propiedad
public $variable = 'un valor predeterminado';
// Declaración de un método
public function mostrarVariable() {
echo $this->variable;
}
}
# Creamos una instancia de la clase. Concretamos valores, por ejemplo, David, María etc.
# David es hombre y María es mujer. Los dos son personas.
$instancia = new ClaseSencilla();
Vamos a ver cómo se crea objeto de una clase en Magento.
# Interface StorageInterface: lib/internal/Magento/Framework/App/View/Deployment/Version/StorageInterface.php
# Clase File: lib/internal/Magento/Framework/App/View/Deployment/Version/Storage/File.php
...
public function __construct(
\Magento\Framework\Filesystem $filesystem,
$directoryCode,
$fileName
) {
$this->directory = $filesystem->getDirectoryWrite($directoryCode);
$this->fileName = $fileName;
}
...
# File implementa la interface StorageInterface
# La clase File tiene un constructor al que le pasamos 2 parámetros: $directoryCode y $fileName
# Los argumentos del constructor se definen en los ficheros xml.
// Ruta: app/etc/di.xml
<type name="Magento\Framework\App\View\Deployment\Version\Storage\File">
<arguments>
<argument name="directoryCode" xsi:type="const">Magento\Framework\App\Filesystem\DirectoryList::STATIC_VIEW</argument>
<argument name="fileName" xsi:type="string">deployed_version.txt</argument>
</arguments>
</type>
# Hasta aquí, hemos visto la clase File y hemos visto también que los parámetros se han definido en el fichero app/etc/di.xml.
# Vamos a ver cómo se crea el objeto File
// Mapeo de la interface StorageInterface a la clase File
<preference for="Magento\Framework\App\View\Deployment\Version\StorageInterface" type="Magento\Framework\App\View\Deployment\Version\Storage\File"/>
// Así podemos inyectar la StorageInterface en la clase Version. Automáticamente se hará instancia de la clase File
// Ruta: lib/internal/Magento/Framework/App/View/Deployment/Version.php
/**
* Deployment version of static files
*/
class Version
{
...
/**
* @var \Magento\Framework\App\View\Deployment\Version\StorageInterface
*/
private $versionStorage;
/**
* @param Version\StorageInterface $versionStorage
*/
public function __construct(
\Magento\Framework\App\View\Deployment\Version\StorageInterface $versionStorage,
) {
$this->versionStorage = $versionStorage; // asignar el objeto creado a la propiedad versionStorage
}
...
// Se han usado métodos del objeto versionStorage en este método
/**
* Load or generate deployment version of static files depending on the application mode
*
* @param string $appMode
* @return string
*/
protected function readValue($appMode)
{
$result = $this->versionStorage->load();
if (!$result) {
if ($appMode == \Magento\Framework\App\State::MODE_PRODUCTION
&& !$this->deploymentConfig->getConfigData(
ConfigOptionsListConstants::CONFIG_PATH_SCD_ON_DEMAND_IN_PRODUCTION
)
) {
$this->getLogger()->critical('Can not load static content version.');
throw new \UnexpectedValueException(
"Unable to retrieve deployment version of static files from the file system."
);
}
$result = $this->generateVersion();
$this->versionStorage->save($result);
}
return $result;
}
..
Si traducimos lo anterior a la sintaxis de php normal sería como lo siguiente:
$filesystem = new Filesystem(...);
$directoryCode = '';
$fileName = '';
$versionStorage = new File($filesystem, $directoryCode, $fileName);
$versionStorage->load();
$versionStorage->save($result);
¿Interesante no? Magento tiene muchos ejemplos como este. Ya iremos viendo más en otros artículos.