Méthode correcte de vidage des caches et de gestion du compilateur

Je voudrais savoir s'il existe une procédure préférée pour les éléments suivants:

1. Vidange du cache Magento
2. Activation / désactivation du compilateur Magento

1. Rinçage du cache Magento

Il y a quelques options ici, à savoir:

• Vérification des éléments de campagne et envoi d'une actualisation dans la Actionsliste déroulante
• Cliquer sur le Flush Magento Cachebouton, et
• Cliquer sur le Flush Storage Cachebouton

Y a-t-il un ordre préféré dans lequel procéder? Quelle est la différence entre le cache Magento et le cache de stockage?

2. Activation / désactivation du compilateur Magento

a) Activation du compilateur

Quand il s'agit d'activer le compilateur Magento, doit-on activer tous les caches de magasin? Ou devez-vous activer les caches uniquement après avoir activé le compilateur et exécuté le processus de compilation? Une fois que vous avez activé le compilateur, devez-vous actualiser tous les caches? Et si oui, cela inclut-il le vidage du cache Magento et du cache de stockage (comme mentionné ci-dessus)

b) Désactiver le compilateur

Quand il s'agit de désactiver le compilateur Magento, devez-vous d'abord désactiver tous les caches, puis les réactiver une fois qu'il a été désactivé?

Y a-t-il une différence entre laisser les caches et désactiver / activer le compilateur? Quel impact sur les performances cela entraîne-t-il?

Toute entrée serait très apprécié

Vider le cache Magento - Cela efface le cache (var / cache) de tous les éléments que Magento sait qu'il a créés.

Flush Cache Storage - Efface tout dans var / cache, quelle que soit la façon dont ces fichiers ont été créés.

Donc, si vous voulez être sûr de tout effacer, vous pouvez choisir " Flush Cache Storage " qui effacera essentiellement var / cache.

Pour le compilateur, je recommanderais de vider le cache Magento après avoir activé la compilation et exécuté le processus de compilation. Cela garantit que le cache est effacé de toutes les données non compilées.

Lors de la désactivation de la compilation, je la désactiverais d'abord, puis viderais le cache Magento par la suite. Cela garantit à nouveau que le cache est vide de toutes les données compilées.

À moins que vous ne testiez beaucoup les choses, je recommanderais toujours de laisser les caches. La compilation peut être aléatoire en termes de performances. Je l'ai vu accélérer les choses et la compilation a souvent ralenti les choses et causé des problèmes avec les extensions tierces. Je recommanderais d'obtenir une référence pour le temps de chargement d'une page de catégorie (en utilisant les outils Firebug / développeur) avec la compilation désactivée, puis à nouveau avec la compilation activée, et voir s'il y a une grande différence.

Vous feriez probablement mieux d'utiliser des choses comme un cache d'opcode en PHP, une bonne mise en cache des requêtes MySQL, une combinaison de fichiers css / js, une compression gzip, une extension de cache de page complète et des paramètres appropriés pour la mise en cache des fichiers par le navigateur.

Le cache Magento n'est pas différent. En commençant par les bases, les options de cache peuvent être affichées en accédant à

Système-> Gestion du cache

dans le backend. Vous pouvez voir les différents domaines de mise en cache qui peuvent être activés / désactivés, tels que les configurations, les fichiers layout.xml, les blocs, la page entière et les fichiers api. De toute évidence, l'idéal est d'activer tous ces éléments une fois le site en ligne.

Le cache peut également être vidé ou vidé à partir d'ici. Appuyez sur le bouton étiqueté “Flush Magento Cache”pour vider tous les fichiers de cache qui correspondent à un certain ensemble de balises par défaut intégrées que Magento utilise. Il s'agit de la méthode «plus sûre» pour vider le cache, car elle n'efface pas absolument tout. Si vous utilisez un type de cache secondaire, cliquez sur “Flush Cache Storage”pour vous assurer que vous avez vidé votre cache, car il efface TOUT. Les deux autres boutons que vous voyez sur la page d'administration effaceront les images javascript et css et les images de catalogue.

Un moyen alternatif et légèrement moins sûr de vider le cache consiste à accéder à

websiteroot / var / cache

et supprimer manuellement tous les fichiers. De même pour

websiteroot / var / full_page__cache

si le cache pleine page est activé.

Le cache pleine page, disponible sur l'édition Enterprise, accélère votre site de 10 fois, mais il est important d'en savoir un peu plus à ce sujet, au cas où vous remarqueriez un contenu dynamique mis en cache. Un fichier intéressant à regarder est

websiteroot / app / code / core / Enterprise / PageCache / etc / cache.xml

Ici, vous pouvez voir ce qui est mis en cache par FPC, le nom du bloc, le nom du conteneur et la durée de vie de la session. Si vous trouvez qu'il est absolument nécessaire de modifier ou de supprimer l'un de ces blocs du cache, vous pouvez le faire en créant un module dépendant du module PageCache et en y plaçant toutes les modifications.

La balise d'espace réservé indique au FPC que ce bloc est considéré comme dynamique. Lorsqu'une page est chargée, si le bloc n'est pas encore dans le cache, cette valeur d'ID dans les balises d'espace réservé est recherchée dans le cache, et si elle n'existe pas, ce bloc est appelé et généré, et l'ID est ajouté à le cache.

La fonction de compilation de Magento se trouve sous

Système> Outils> Compilation

Si vous exécutez une nouvelle installation, vous obtenez probablement un message système indiquant que les deux includes and includes/src/répertoires doivent être rendus accessibles en écriture. Lorsque cela est fait, nous pouvons appuyer sur le bouton `` Exécuter le processus de compilation '' et vous avez pratiquement terminé, le cœur de Magento utilise la compilation.

Lorsque Magento compile son code source, le framework fait quelques choses. Étant soit déclenchée par l'administrateur ou shell, see shell/compiler.php, toute la compilation se fait par une seule classe: Mage_Compiler_Model_Process. Dans cette classe, vous trouverez l'extrait suivant qui est en fait une vue à vol d'oiseau de l'ensemble du processus.

/**
     * Run compilation process
     *
     * @return Mage_Compiler_Model_Process
     */
    public function run()
    {
        $this->_collectFiles();
        $this->_compileFiles();
        $this->registerIncludePath();
        return $this;
    }

Lancé par l' $this->_collectFiles();appel, Magento copie tous les fichiers PHP des deux

app / code

et les répertoires lib au

/ inclut / src

annuaire. Comme vous pouvez le voir dans l'extrait ci-dessous: pendant ce processus, Magento parcourt récursivement tous les fichiers et répertoires. Ces chemins sont finalement utilisés comme nom de fichier. Lorsque le processus récursif frappe un fichier, il recherche une extension PHP et, lorsqu'il est trouvé, le fichier est copié dans le répertoire du compilateur. Les autres types de fichiers ne sont pas modifiés.

A titre d'exemple: le chemin de la classe Mage_Catalog_Model_Category était

app / code / core / Mage / Catalogue / Model / Category.php

mais, avec la compilation activée, est devenu

inclut / 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;
    }

Les contrôleurs reçoivent un autre traitement. Tous les répertoires du contrôleur sont copiés dans

comprend / src /

mais sont stockés dans un répertoire qui porte le nom de son espace de noms associé, pensez: Mage, Enterprise ou votre propre espace de noms donné.

Dans ces répertoires d'espace de noms, les contrôleurs sont stockés par module et la structure du répertoire des contrôleurs reste intacte. Il en va de même pour le nom de fichier, c'est juste une copie exacte. Toute cette logique se retrouve dans la méthode suivante$this->_copyControllers($path);

Ce deuxième niveau de compilation recueille toutes les étendues et leurs listes de classes respectives auprès de l'administrateur. Toutes ces étendues sont en cours de traitement en récupérant le contenu des fichiers de classe associés et en les écrivant dans un seul fichier nommé d'après l'étendue donnée.

/**
     * 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;
    }

Par défaut, Magento crée quatre fichiers de portée différents:

__default.php, __catalog.php, __checkout.php et __cms.php

Pendant le processus de construction de ces fichiers de portée, Magento analyse automatiquement toutes les extensions de classe et les interfaces qui sont utilisées par les classes fournies dans la liste de portée.

Avec tous les fichiers en place et compilés, Magento est prêt à activer la fonction de compilation pour une utilisation.

Enfin, la configuration liée à la compilation est ajustée. Ce fichier se trouve sur includes/config.phpet contient les deux constantes suivantes. Lors de l'activation de la compilation, la ligne concernant COMPILER_INCLUDE_PATH n'est pas commentée et est donc prête à l'action.

> #define('COMPILER_INCLUDE_PATH', dirname(__FILE__).DIRECTORY_SEPARATOR.'src');
> #define('COMPILER_COLLECT_PATH', dirname(__FILE__).DIRECTORY_SEPARATOR.'stat');

Le code responsable de l'ajustement du fichier de configuration se trouve dans la méthode registerIncludePath du Mage_Compiler_Model_Process class.

Pendant le bootstrap, le fichier de configuration de la compilation est inclus dans le index.php file (around line 44). Cela rend les constantes include_path disponibles dans tout le framework. Le collect_path est quelque chose que vous ne pouvez activer que manuellement pour obtenir plus d'informations statistiques sur l'utilisation de vos fichiers compilés. Cela ne devrait pas être activé en direct.

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

À partir de ce moment, Magento vérifiera si le mode de compilation est activé avec l'instruction suivante. En parcourant la base de code (en utilisant 'grep'), vous remarquerez que la majeure partie de cette logique se trouve dans le lib/Varien/Autoload.phpfichier.

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

L'autre endroit à rechercher est le Mage_Core_Controller_Varien_Action. Dans cette classe, vous trouverez la preDispatch()méthode, qui est déclenchée pour chaque méthode d'action de contrôleur avant que la méthode ne soit réellement envoyée. Dans cette partie de la classe du chargeur automatique de Magento source, Varien_Autoload est appelé pour charger un fichier d'étendue de compilation spécifique.

 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)
        );

Lors de l'exécution en mode de compilation, Magento n'a qu'un seul chemin d'inclusion, le includes/src/répertoire, donc chaque fichier est trouvé directement au premier essai. Avec la quantité considérable de fichiers de Magento, cela fait gagner un peu de temps. L'extrait en dessous est tiré de la

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";
}

Lorsque PHP inclut un fichier, le contenu est compilé en opcode. Il s'agit d'un processus qui doit être effectué chaque fois qu'un fichier est inclus. Pour améliorer encore les performances de votre boutique, vous pouvez installer APC sur votre serveur. APC met en cache les versions opcodées des fichiers, les rendant disponibles pour les requêtes suivantes. Donc, à la prochaine demande: le fichier sera lu à partir du cache APC, au lieu de devoir recommencer le même processus et de drainer vos performances.

COMPILATEUR

Tous les fichiers du compilateur se trouvent dans includes/Just Don't wipe .htaccessou config.php. Si vous affichez config.phpVous remarquerez que l'activation / la désactivation du compilateur supprime les commentaires #avant les deux define. Il est sûr de supposer qu'un simple à rm -Rf includes/src;rm -Rf includes/statpartir de la racine Magento effacera les données compilées.

Pensez également à utiliser AOE_ClassPathCache avec APC, car ce sera de loin suffisant pour supprimer le compilateur de l'équation.

Aussi pour plus de discussion sur le sujet:

• est-il sûr d'exécuter le compilateur magento?

CACHES

Ceci est purement défini sur les backends de cache que vous utilisez via votre local.xml. Si vous utilisez le gestionnaire de filescache par défaut , effacez var/cacheet si Enterprise var/full_page_cache. Si vous utilisez un magasin de données tel que Memcache, vous devrez le faire via Magento Flush Cache Storageou via un moyen que le magasin de données du cache doit effacer / effacer son cache.

Aussi plus de détails sur les magasins de données possibles, Magento utilise Zend_Cache pour ses mécanismes de mise en cache. Ce que vous remarquerez concerne les local.xmlXpath du cache.

REMARQUE

Si vous exécutez Enterprise, vous trouverez un deuxième fichier de configuration etc/enterprise.xmloù le magasin de données pour le FPC est défini.

Quelle est la différence entre Flush Cache et Flush Cache Storage:

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

Une note très importante sur le compilateur Magento. Vous devez désactiver des choses comme APC lors de la compilation car le compilateur ne peut pas compiler ce qui est dans APC et corrompra votre compilation. Pour moi, cela signifierait décharger APC sur le serveur, puis redémarrer Apache (httpd).