Hola, tenemos la solución a tu interrogante, continúa leyendo y la hallarás más abajo.
Solución:
Vaciar caché de Magento – Esto borra la caché (var / cache) de cualquier elemento que Magento sepa que ha creado.
Vaciar almacenamiento de caché – Borra todo en var / cache, independientemente de cómo se crearon esos archivos.
Entonces, si quieres estar seguro, estás borrando todo, puedes elegir “Vaciar almacenamiento de caché“que esencialmente borrará var / cache.
Para el compilador, recomendaría vaciar la caché de Magento después de habilitar la compilación y ejecutar el proceso de compilación. Esto asegura que la caché se borre de cualquier dato no compilado.
Al deshabilitar la compilación, la deshabilitaría primero y luego limpiaría la caché de Magento. Esto nuevamente asegura que la caché esté libre de cualquier dato compilado.
A menos que esté probando muchas cosas, siempre recomendaría dejar los cachés activados. La compilación puede ser impredecible en términos de rendimiento. Lo he visto hacer las cosas más rápido, y muchas veces he visto que la compilación hace las cosas más lentas y causa problemas con extensiones de terceros. Recomendaría obtener una línea de base para el tiempo de carga de una página de categoría (usando Firebug / herramientas de desarrollador) con la compilación desactivada, luego nuevamente con la compilación activada, y ver si hay una gran diferencia.
Es probable que sea mejor que use cosas como un caché de código de operación en PHP, el almacenamiento en caché de consultas MySQL adecuado, la combinación de archivos css / js, el uso de compresión gzip, el uso de una extensión de caché de página completa y la configuración adecuada para el almacenamiento en caché de archivos del navegador.
La caché de Magento no es diferente. Comenzando con lo básico, las opciones de caché se pueden ver navegando a
Sistema-> Gestión de caché
en el backend. Puede ver las diferentes áreas de almacenamiento en caché que se pueden habilitar / deshabilitar, como cualquier configuración, layout.xml, bloques, página completa y archivos api. Obviamente, lo ideal es tener todos estos habilitados una vez que el sitio esté activo.
La caché también se puede borrar o vaciar desde aquí. Pulsando el botón etiquetado “Flush Magento Cache” Vaciará cualquier archivo de caché que coincida con un determinado conjunto de etiquetas predeterminadas integradas que utiliza Magento. Esta es la forma “más segura” de borrar la caché, ya que no borra absolutamente todo. Si está utilizando algún tipo de caché secundario, haga clic en “Flush Cache Storage” se asegurará de haber borrado su caché, ya que borra TODO. Los otros dos botones que ve en la página de administración borrarán las imágenes de JavaScript y CSS y del catálogo.
Una forma alternativa y un poco menos segura de borrar la caché es navegando a
websiteroot / var / cache
y eliminar manualmente todos los archivos. Lo mismo vale para
websiteroot / var / full_page__cache
si tiene la caché de página completa habilitada.
La caché de página completa, disponible en Enterprise Edition, acelera su sitio 10 veces, pero es importante saber un poco al respecto, en caso de que observe que se está almacenando en caché algún contenido dinámico. Un archivo interesante para mirar es
websiteroot / app / code / core / Enterprise / PageCache / etc / cache.xml
Aquí puede ver lo que FPC almacena en caché, el nombre del bloque, el nombre del contenedor y la duración de la sesión. Si encuentra que es absolutamente necesario editar o eliminar cualquiera de estos bloques de la caché, puede hacerlo creando un módulo dependiente del módulo PageCache y colocando las modificaciones allí.
La etiqueta de marcador de posición le dice al FPC que ese bloque se considera dinámico. Cuando se carga una página, si el bloque aún no está en la caché, este valor de ID en las etiquetas de marcador de posición se busca en la caché, y si no existe, ese bloque se llama y genera, y la ID se agrega a el caché.
La función de compilación de Magento se puede encontrar en
Sistema> Herramientas> Compilación
Si está ejecutando una instalación nueva, probablemente obtenga un mensaje del sistema que indica que tanto el includes and includes/src/ los directorios deben tener permisos de escritura. Una vez hecho esto, podemos presionar el botón ‘Ejecutar proceso de compilación’ y básicamente ya está, el núcleo de Magento está usando la compilación.
Cuando Magento compila su código fuente, el marco hace algunas cosas. Se activa a través del administrador o shell, see shell/compiler.php, toda la compilación la realiza una sola clase: Mage_Compiler_Model_Process. Dentro de esta clase, encontrará el siguiente fragmento que en realidad es una vista panorámica de todo el proceso.
/**
* Run compilation process
*
* @return Mage_Compiler_Model_Process
*/
public function run()
$this->_collectFiles();
$this->_compileFiles();
$this->registerIncludePath();
return $this;
Iniciado por el $this->_collectFiles(); llamar, Magento copia todos los archivos PHP tanto de la
aplicación / código
y directorios lib al
/ incluye / src
directorio. Como puede ver en el fragmento a continuación: durante este proceso, Magento itera de forma recursiva a través de todos los archivos y directorios. Estas rutas se utilizan eventualmente como nombre de archivo. Cuando el proceso recursivo llega a un archivo, buscará una extensión PHP y, cuando la encuentre, el archivo se copiará en el directorio del compilador. Otros tipos de archivos se mantienen intactos.
Como ejemplo: la ruta para la clase Mage_Catalog_Model_Category fue
app / code / core / Mage / Catalog / Model / Category.php
pero, con la compilación habilitada, ahora se ha convertido
incluye / src / Mage_Catalog_Model_Category.php
/**
* Copy files from all include directories to one.
* Lib files and controllers files will be copied as is
*
* @return Mage_Compiler_Model_Process
*/
protected function _collectFiles()
$paths = $this->_getIncludePaths();
$paths = array_reverse($paths);
$destDir= $this->_includeDir;
$libDir = Mage::getBaseDir('lib');
$this->_mkdir($destDir);
foreach ($paths as $path)
$this->_controllerFolders = array();
$this->_copy($path, $destDir); // this one will run recursively through all directories
$this->_copyControllers($path);
if ($path == $libDir)
$this->_copyAll($libDir, $destDir);
$destDir.= DS.'Data';
$this->_mkdir($destDir);
$this->_copyZendLocaleData($destDir);
return $this;
Los controladores están recibiendo otro tratamiento. Todos los directorios del controlador se copian en
incluye / src /
pero se almacenan dentro de un directorio que tiene el nombre de su espacio de nombres relacionado, piense: Mage, Enterprise o su propio espacio de nombres.
Dentro de estos directorios de espacio de nombres, los controladores se almacenan por módulo y la estructura del directorio del controlador se mantiene intacta. Lo mismo ocurre con el nombre del archivo, es solo una copia exacta. Toda esta lógica se puede encontrar en el siguiente método $this->_copyControllers($path);
Este segundo nivel de compilación recopila todos los ámbitos y sus respectivas listas de clases del administrador. Todos estos ámbitos se procesan obteniendo el contenido de los archivos de clase relacionados y escribiéndolos en un solo archivo con el nombre del ámbito dado.
/**
* Compile classes code to files
*
* @return Mage_Compiler_Model_Process
*/
protected function _compileFiles()
$classesInfo = $this->getCompileClassList();
foreach ($classesInfo as $code => $classes)
$classesSorce = $this->_getClassesSourceCode($classes, $code);
file_put_contents($this->_includeDir.DS.Varien_Autoload::SCOPE_FILE_PREFIX.$code.'.php', $classesSorce);
return $this;
De forma predeterminada, Magento crea cuatro archivos de alcance diferentes:
__default.php, __catalog.php, __checkout.php y __cms.php
Durante el proceso de construcción de estos archivos de alcance, Magento analiza automáticamente todas las extensiones de clase e interfaces que están siendo utilizadas por las clases proporcionadas en la lista de alcance.
Con todos los archivos en su lugar y compilados, Magento está listo para habilitar la función de compilación para su uso.
Por último, pero no menos importante, se ajusta la configuración relacionada con la compilación. Este archivo se puede encontrar en includes/config.php y contiene las siguientes dos constantes. Al habilitar la compilación, la línea relativa a COMPILER_INCLUDE_PATH no se comenta y, por lo tanto, está lista para la acción.
> #define('COMPILER_INCLUDE_PATH', dirname(__FILE__).DIRECTORY_SEPARATOR.'src');
> #define('COMPILER_COLLECT_PATH', dirname(__FILE__).DIRECTORY_SEPARATOR.'stat');
El código que se encarga de ajustar el archivo de configuración se puede encontrar en el método registerIncludePath del Mage_Compiler_Model_Process class.
Durante el bootstrap, el archivo de configuración de compilación se incluye en el index.php file (around line 44). Esto hace que las constantes include_path estén disponibles en todo el marco. Collect_path es algo que solo puede habilitar manualmente para obtener más información estadística sobre el uso de sus archivos compilados. Esto no debería estar habilitado en vivo.
/**
* Compilation includes configuration file
*/
$compilerConfig = 'includes/config.php';
if (file_exists($compilerConfig))
include $compilerConfig;
A partir de este punto, Magento comprobará si el modo de compilación está habilitado con la siguiente declaración. Al revisar la base de código (usando ‘grep’), notará que la mayor parte de esta lógica se puede encontrar en el lib/Varien/Autoload.php expediente.
if (defined('COMPILER_COLLECT_PATH'))
// do stuff
El otro lugar para buscar es el Mage_Core_Controller_Varien_Action. En esta clase encontrarás el preDispatch() método, que se activa para cada método de acción del controlador antes de que el método se envíe realmente. En esta parte de la clase de autocargador de Magento de origen, se llama a Varien_Autoload para cargar un archivo de alcance de compilación específico.
Mage::dispatchEvent('controller_action_predispatch', array('controller_action'=>$this));
Mage::dispatchEvent(
'controller_action_predispatch_'.$this->getRequest()->getRouteName(),
array('controller_action'=>$this)
);
Varien_Autoload::registerScope($this->getRequest()->getRouteName()); // right here
Mage::dispatchEvent(
'controller_action_predispatch_'.$this->getFullActionName(),
array('controller_action'=>$this)
);
Cuando se ejecuta en modo de compilación, Magento solo tiene una única ruta de inclusión, la includes/src/ directorio, por lo que cada archivo se encuentra directamente en el primer intento. Con la considerable cantidad de archivos que tiene Magento, esto ahorra bastante tiempo. El fragmento de abajo se toma del
aplicación / Mage.php
if (defined('COMPILER_INCLUDE_PATH'))
$appPath = COMPILER_INCLUDE_PATH;
set_include_path($appPath . PS . Mage::registry('original_include_path'));
include_once "Mage_Core_functions.php";
include_once "Varien_Autoload.php";
else
/**
* Set include path
*/
$paths[] = BP . DS . 'app' . DS . 'code' . DS . 'local';
$paths[] = BP . DS . 'app' . DS . 'code' . DS . 'community';
$paths[] = BP . DS . 'app' . DS . 'code' . DS . 'core';
$paths[] = BP . DS . 'lib';
$appPath = implode(PS, $paths);
set_include_path($appPath . PS . Mage::registry('original_include_path'));
include_once "Mage/Core/functions.php";
include_once "Varien/Autoload.php";
Cuando PHP incluye un archivo, el contenido se compila en código de operación. Este es un proceso que debe realizarse cada vez que se incluye un archivo. Para mejorar aún más el rendimiento de su tienda, puede instalar APC en su servidor. APC almacena en caché las versiones codificadas de los archivos, dejándolas disponibles para solicitudes posteriores. Entonces, en la próxima solicitud: el archivo se leerá de la caché de APC, en lugar de tener que pasar por el mismo proceso nuevamente y agotar su rendimiento.
COMPILADOR
Todos los archivos del compilador se pueden encontrar en includes/ Simplemente no limpie .htaccess o config.php. Si ves config.php Notará que todo lo que habilita / deshabilita el compilador es eliminar los comentarios # antes de los dos define. Es seguro asumir un simple rm -Rf includes/src;rm -Rf includes/stat de la raíz de Magento borrará los datos compilados.
También considere usar AOE_ClassPathCache junto con APC, ya que esto será suficiente para eliminar el compilador de la ecuación.
También para más discusión sobre el tema:
- ¿Es seguro ejecutar el compilador magento?
CACHES
Esto se define puramente en qué backends de almacenamiento en caché está utilizando a través de su local.xml. Si está utilizando el predeterminado files manejador de caché, luego borrando var/cache y si Enterprise var/full_page_cache. Si está utilizando un almacén de datos como Memcache, deberá hacerlo a través de Magento Flush Cache Storage o por algún medio, el almacén de datos de la caché tiene que borrar / borrar su caché.
También más detalles sobre los posibles almacenes de datos, Magento usa Zend_Cache para sus mecanismos de almacenamiento en caché. Lo que notará se relaciona con el local.xml caché XPaths.
NOTA
Si está ejecutando Enterprise, encontrará un segundo archivo de configuración etc/enterprise.xml es donde se define el almacén de datos para el FPC.
¿Cuál es la diferencia entre Flush Cache y Flush Cache Storage?
- https://stackoverflow.com/questions/5955365/what-is-the-difference-between-flush-magento-cache-and-flush-cache-storage-i
Reseñas y valoraciones
Si para ti ha sido útil este post, sería de mucha ayuda si lo compartes con el resto desarrolladores así nos ayudas a dar difusión a nuestro contenido.