Método correcto de vaciar cachés y administrar el compilador

Me gustaría saber si hay algún procedimiento preferido para lo siguiente:

1. Vaciado del caché de Magento
2. Habilitar / deshabilitar el compilador de Magento

1. Lavado de la caché de Magento

Aquí hay algunas opciones, a saber:

• Verificación de las líneas de pedido y envío de actualizaciones desde el Actionscuadro desplegable
• Al hacer clic en el Flush Magento Cachebotón y
• Haciendo clic en el Flush Storage Cachebotón

¿Hay algún orden preferido para hacer esto? ¿Cuál es la diferencia entre el caché de Magento y el caché de almacenamiento?

2. Activación / desactivación del compilador de Magento

a) Habilitación del compilador

Cuando se trata de habilitar el compilador Magento, ¿debería uno tener todas las cachés de la tienda habilitadas? ¿O solo debe activar los cachés después de habilitar el compilador y ejecutar el proceso de compilación? Una vez que haya habilitado el compilador, ¿debería actualizar todas las cachés? Y si es así, ¿eso incluye Flushing the Magento cache & storage cache (como se mencionó anteriormente)

b) Deshabilitar el compilador

Cuando se trata de deshabilitar el compilador de Magento, ¿debe deshabilitar todas las cachés primero y luego volver a habilitarlas después de que se haya deshabilitado?

¿Hay alguna diferencia entre dejar los cachés y deshabilitar / habilitar el compilador? ¿Qué impacto en el rendimiento causa?

Cualquier aporte seria muy apreciado

Vaciar caché de Magento : esto borra el caché (var / caché) de cualquier elemento que Magento sepa que ha creado.

Flush Cache Storage : borra todo en var / cache, independientemente de cómo se crearon esos archivos.

Por lo tanto, si desea estar seguro está limpiando todo, puede elegir " Flush Cache Storage ", que esencialmente borrará var / cache.

Para el compilador, recomendaría vaciar el caché de Magento después de habilitar la compilación y ejecutar el proceso de compilación. Esto garantiza que la memoria caché se borre de los datos no compilados.

Al deshabilitar la compilación, primero la deshabilitaría, luego lave el caché de Magento. Esto nuevamente asegura que el caché esté libre de datos compilados.

A menos que esté probando muchas cosas, siempre recomendaría dejar las memorias caché. La compilación puede ser impredecible en términos de rendimiento. Lo he visto hacer las cosas más rápido, y muchas veces la compilación hace que las cosas sean más lentas y causa problemas con las extensiones de terceros. Recomiendo obtener una línea 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 verifique si hay una gran diferencia.

Probablemente sea mejor usar 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.

El 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 todo esto habilitado una vez que el sitio esté activo.

El caché también se puede borrar o enjuagar desde aquí. Al presionar el botón etiquetado “Flush Magento Cache”se eliminarán los archivos de caché que coincidan con un cierto conjunto de etiquetas predeterminadas incorporadas que utiliza Magento. Esta es la forma "más segura" de borrar el caché, ya que no borra absolutamente todo. Si está utilizando algún tipo de caché secundario, al hacer clic “Flush Cache Storage”se asegurará de haber limpiado 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 el caché es navegar a

websiteroot / var / cache

y eliminar manualmente todos los archivos. Lo mismo vale para

websiteroot / var / full_page__cache

si tiene habilitada la caché de página completa.

La memoria 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 almacena en caché cualquier 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 considera absolutamente necesario editar o eliminar cualquiera de estos bloques de la memoria caché, puede hacerlo creando un módulo dependiente del módulo PageCache y colocando cualquier modificación 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 memoria caché, este valor de ID en las etiquetas de marcador de posición se busca en la memoria caché, y si no existe, ese bloque se llama y se 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 reciba un mensaje del sistema que indica que ambos includes and includes/src/directorios deben poder escribirse. Cuando esto esté hecho, podemos presionar el botón 'Ejecutar proceso de compilación' y básicamente ya está listo, el núcleo de Magento está usando la compilación.

Cuando Magento compila su código fuente, el marco hace algunas cosas. Al estar ya sea provocada a través de la administración o shell, see shell/compiler.php, toda la compilación se realiza por 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 la $this->_collectFiles();llamada, Magento copia todos los archivos PHP de ambos

aplicación / código

y directorios de lib a la

/ incluye / src

directorio. Como puede ver en el fragmento a continuación: durante este proceso, Magento itera recursivamente a través de todos los archivos y directorios. Estas rutas se utilizan finalmente como el nombre del archivo. Cuando el proceso recursivo llega a un archivo, buscará una extensión PHP y, cuando se encuentre, el archivo se copia 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 a

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 están procesando recuperando el contenido de los archivos de clase relacionados y escribiéndolos en un solo archivo con el nombre del alcance 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;
    }

Por defecto, Magento crea cuatro archivos de alcance diferentes:

__default.php, __catalog.php, __checkout.php y __cms.php

Durante el proceso de creación de estos archivos de alcance, Magento analiza automáticamente todas las extensiones de clase e interfaces que están utilizando 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.phpy contiene las siguientes dos constantes. Al habilitar la compilación, la línea relativa a COMPILER_INCLUDE_PATH no está comentada 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 responsable de ajustar el archivo de configuración se puede encontrar en el método registerIncludePath de Mage_Compiler_Model_Process class.

Durante el arranque, el archivo de configuración de compilación se incluye dentro de 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 debe habilitarse en vivo.

/**
 * Compilation includes configuration file
 */
$compilerConfig = 'includes/config.php';
if (file_exists($compilerConfig)) {
    include $compilerConfig;
}

A partir de este momento, Magento verificará 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.phparchivo.

if (defined('COMPILER_COLLECT_PATH')) {
            // do stuff
        }

El otro lugar para buscar es el Mage_Core_Controller_Varien_Action. En esta clase, encontrará 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 fuente, se llama a la clase de autocargador Miennto 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, el 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 debajo se toma del

app / 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 opcode. Este es un proceso que debe hacerse 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, haciéndolos disponibles para solicitudes posteriores. Entonces, en la próxima solicitud: el archivo se leerá de la memoria 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 .htaccesso config.php. Si ve config.php, notará que todo lo que el compilador habilita / deshabilita es eliminar los comentarios #antes de los dos define. Es seguro asumir que un simple rm -Rf includes/src;rm -Rf includes/statdesde la raíz de Magento borrará los datos compilados.

También considere usar AOE_ClassPathCache junto con APC, ya que esto será lo suficientemente lejos como 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 los backends de almacenamiento en caché que está utilizando a través de su local.xml. Si está utilizando el filescontrolador de caché predeterminado , limpie var/cachey si es Enterprise var/full_page_cache. Si está utilizando un almacén de datos como Memcache, deberá hacerlo a través de Magento Flush Cache Storageo de un medio que el almacén de datos de la memoria caché tenga que borrar / borrar.

También más detalles sobre los posibles almacenes de datos, Magento utiliza Zend_Cache para sus mecanismos de almacenamiento en caché. Lo que notarás se relaciona con los local.xmlXpaths de caché.

NOTA

Si está ejecutando Enterprise, encontrará un segundo archivo de configuración etc/enterprise.xmldonde se define el almacén de datos para el FPC.

¿Cuál es la diferencia entre Flush Cache y Flush Cache Storage?

• /programming/5955365/what-is-the-difference-between-flush-magento-cache-and-flush-cache-storage-i

Una nota muy importante sobre el compilador de Magento. Debe desactivar cosas como APC al realizar la compilación ya que el compilador no puede compilar lo que está en APC y dañará su compilación. Para mí eso significaría descargar APC en el servidor y luego reiniciar Apache (httpd).