Método correto de liberar caches e gerenciar o compilador

Gostaria de saber se existe algum procedimento preferido para o seguinte:

1. Liberação do cache Magento
2. Ativando / desativando o compilador Magento

1. Liberação do cache Magento

Existem algumas opções aqui, a saber:

• Verificando os itens de linha e enviando atualização na Actionscaixa suspensa
• Clicando no Flush Magento Cachebotão e
• Clicando no Flush Storage Cachebotão

Existe alguma ordem preferida para fazer isso? Qual é a diferença entre o cache do Magento e o cache de armazenamento?

2. Ativando / Desativando o Magento Compiler

a) Habilitando o compilador

Quando se trata de ativar o compilador Magento, deve-se ter todos os caches de armazenamento ativados? Ou você só deve ativar os caches depois de ativar o compilador e executar o processo de compilação? Depois de ativar o compilador, você deve atualizar todos os caches? E, nesse caso, isso inclui a descarga do cache do Magento e do cache de armazenamento (como mencionado acima)

b) Desativando o compilador

Quando se trata de desabilitar o compilador Magento, você deve desabilitar todos os caches primeiro e depois reativá-los depois de desabilitados?

Existe alguma diferença entre deixar os caches ativados e desativar / ativar o compilador? Que impacto no desempenho isso causa?

Qualquer entrada seria muito apreciada

Liberar cache do Magento - Limpa o cache (var / cache) de todos os itens que o Magento sabe que ele criou.

Liberar armazenamento em cache - Limpa tudo em var / cache, independentemente de como esses arquivos foram criados.

Portanto, se você quer estar seguro, está limpando tudo, pode escolher " Flush Cache Storage ", que basicamente limpará var / cache.

Para o compilador, eu recomendaria liberar o cache do Magento após ativar a compilação e executar o processo de compilação. Isso garante que o cache seja limpo de quaisquer dados não compilados.

Ao desativar a compilação, eu a desabilitaria primeiro e depois liberaria o cache do Magento. Isso novamente garante que o cache esteja livre de quaisquer dados compilados.

A menos que você esteja testando muito as coisas, eu sempre recomendo deixar os caches ativados. A compilação pode ser um sucesso ou um fracasso em termos de desempenho. Eu já vi isso tornar as coisas mais rápidas e, muitas vezes, a compilação torna as coisas mais lentas e causa problemas com extensões de terceiros. Eu recomendo obter uma linha de base para o tempo de carregamento da página de categoria (usando as ferramentas Firebug / desenvolvedor) com a compilação desativada e, novamente, com a compilação ativada, e ver se há uma grande diferença.

Você provavelmente seria melhor usar coisas como um cache de código de operação em PHP, cache de consultas MySQL adequado, combinando arquivos css / js, usando compressão gzip, usando uma extensão de cache de página completa e configurações adequadas para o cache de arquivos no navegador.

O cache do Magento não é diferente. Começando com o básico, as opções de cache podem ser visualizadas navegando para

Sistema-> Gerenciamento de Cache

no back-end. Você pode ver as diferentes áreas do cache que podem ser ativadas / desativadas, como configurações, layout.xml, blocos, página inteira e arquivos API. Obviamente, o ideal é ter tudo isso ativado quando o site estiver ativo.

O cache também pode ser limpo ou liberado a partir daqui. Pressionar o botão rotulado “Flush Magento Cache”liberará todos os arquivos de cache que correspondem a um determinado conjunto de tags padrão incorporadas que o Magento usa. Essa é a maneira "mais segura" de limpar o cache, pois não limpa absolutamente tudo. Se você estiver usando algum tipo de cache secundário, clique em “Flush Cache Storage”para garantir que você limpou o cache, pois ele limpa TUDO. Os outros dois botões que você vê na página de administrador limparão as imagens javascript, css e catálogo.

Uma maneira alternativa e um pouco menos segura de limpar o cache é navegar para

websiteroot / var / cache

e excluindo manualmente todos os arquivos. O mesmo vale para

websiteroot / var / full_page__cache

se você tiver o cache de página completo ativado.

O cache de página inteira, disponível na Enterprise Edition, acelera o site em 10 vezes, mas é importante saber um pouco sobre ele, caso você note algum conteúdo dinâmico sendo armazenado em cache. Um arquivo interessante para se olhar é

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

Aqui você pode ver o que está sendo armazenado em cache pelo FPC, o nome do bloco, o nome do contêiner e a duração da sessão. Se você achar absolutamente necessário editar ou remover qualquer um desses blocos do cache, poderá fazê-lo criando um módulo dependente do módulo PageCache e colocando quaisquer modificações nele.

A tag do espaço reservado informa ao FPC que esse bloco é considerado dinâmico. Quando uma página é carregada, se o bloco ainda não estiver no cache, esse valor de ID nas tags de espaço reservado é pesquisado no cache e, se não existir, esse bloco será chamado e gerado, e o ID será adicionado a o cache.

O recurso de compilação do Magento pode ser encontrado em

Sistema> Ferramentas> Compilação

Se você estiver executando uma nova instalação, provavelmente receberá uma mensagem do sistema informando que ambos os includes and includes/src/diretórios devem ser gravados. Quando isso é feito, podemos clicar no botão 'Executar processo de compilação' e você está basicamente pronto, o núcleo do Magento está usando a compilação.

Quando o Magento compila seu código fonte, o framework faz algumas coisas. Sendo tanto acionado via de administração ou shell, see shell/compiler.php, toda a compilação é feita por uma única classe: Mage_Compiler_Model_Process. Nesta classe, você encontrará o seguinte trecho, que é na verdade uma visão panorâmica de todo o processo.

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

Iniciado pela $this->_collectFiles();chamada, o Magento copia todos os arquivos PHP dos dois

aplicativo / código

e diretórios lib para o

/ includes / src

diretório. Como você pode ver no trecho abaixo: durante esse processo, o Magento repete recursivamente todos os arquivos e diretórios. Esses caminhos são eventualmente usados ​​como o nome do arquivo. Quando o processo recursivo atinge um arquivo, ele verifica a extensão do PHP e, quando encontrado, o arquivo é copiado para o diretório do compilador. Outros tipos de arquivos são mantidos intocados.

Como exemplo: o caminho para a classe Mage_Catalog_Model_Category foi

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

mas, com a compilação ativada, tornou-se agora

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

Os controladores estão recebendo outro tratamento. Todos os diretórios do controlador são copiados para

inclui / src /

mas são armazenados em um diretório que tem o nome de seu espaço para nome relacionado, pense: Mage, Enterprise ou seu próprio espaço para nome.

Dentro desses diretórios de namespace, os controladores são armazenados por módulo e a estrutura de diretórios do controlador é mantida intocada. O mesmo vale para o nome do arquivo, é apenas uma cópia exata. Toda essa lógica pode ser encontrada no seguinte método$this->_copyControllers($path);

Este segundo nível de compilação coleta todos os escopos e suas respectivas listas de classes do administrador. Todos esses escopos estão sendo processados ​​buscando o conteúdo dos arquivos de classe relacionados e os gravando em um único arquivo nomeado após o escopo especificado.

/**
     * 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 padrão, o Magento cria quatro arquivos de escopo diferentes:

__default.php, __catalog.php, __checkout.php e __cms.php

Durante o processo de construção desses arquivos de escopo, o Magento analisa automaticamente todas as extensões e interfaces de classes que estão sendo usadas pelas classes fornecidas na lista de escopos.

Com todos os arquivos no lugar e compilados, o Magento está pronto para ativar o recurso de compilação para uso.

Por último, mas não menos importante, a configuração relacionada à compilação é ajustada. Este arquivo pode ser encontrado em includes/config.phpe contém as duas constantes a seguir. Ao ativar a compilação, a linha referente a COMPILER_INCLUDE_PATH é descomentada e, portanto, pronta para a ação.

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

O código responsável pelo ajuste do arquivo de configuração pode ser encontrado no método registerIncludePath do Mage_Compiler_Model_Process class.

Durante a inicialização, o arquivo de configuração da compilação é incluído no index.php file (around line 44). Isso disponibiliza as constantes include_path em toda a estrutura. O caminho_de_coleta é algo que você só pode ativar manualmente para obter mais informações estatísticas sobre o uso de seus arquivos compilados. Isso não deve ser ativado ao vivo.

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

A partir deste ponto, o Magento verificará se o modo de compilação está ativado com a seguinte instrução. Ao percorrer a base de código (usando 'grep'), você notará que grande parte dessa lógica pode ser encontrada no lib/Varien/Autoload.phparquivo.

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

O outro lugar para procurar é o Mage_Core_Controller_Varien_Action. Nesta classe, você encontrará o preDispatch()método, que é acionado para cada método de ação do controlador antes que o método seja realmente despachado. Nesta parte da classe de carregador automático Magento de origem, Varien_Autoload está sendo chamado para carregar um arquivo de escopo de compilação 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)
        );

Ao executar no modo de compilação, o Magento possui apenas um único caminho de inclusão, o includes/src/diretório, para que cada arquivo seja encontrado diretamente na primeira tentativa. Com a quantidade considerável de arquivos que o Magento possui, isso economiza bastante tempo. O trecho abaixo é retirado do

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

Quando o PHP inclui um arquivo, o conteúdo é compilado no código de operação. Esse é um processo que precisa ser realizado toda vez que um arquivo é incluído. Para melhorar ainda mais o desempenho da sua loja, você pode instalar a APC no seu servidor. A APC armazena em cache as versões codificadas dos arquivos, disponibilizando-as para solicitações subsequentes. Assim, na próxima solicitação: o arquivo será lido no cache da APC, em vez de ter que passar pelo mesmo processo novamente e esgotar seu desempenho.

COMPILADOR

Todos os arquivos do compilador podem ser encontrados em includes/Apenas não limpe .htaccessou config.php. Se você visualizar, config.phpvocê perceberá que tudo o que o compilador ativador / desativador faz é remover os comentários #antes dos dois define. É seguro supor que um simples rm -Rf includes/src;rm -Rf includes/statda raiz do Magento limpe os dados compilados.

Considere também usar AOE_ClassPathCache junto com a APC, pois isso será de longe o suficiente para remover o compilador da equação.

Também para mais discussões sobre o tema:

• é seguro rodar o compilador magento?

CACHES

Isso é puramente definido em quais back-ends de cache você está usando através do seu local.xml. Se você estiver usando o filesmanipulador de cache padrão , limpevar/cache e se Enterprise var/full_page_cache. Se você estiver usando um armazenamento de dados como o Memcache, precisará fazer isso através do Magento Flush Cache Storageou através de um meio que o armazenamento de dados em cache precise limpar / limpar seu cache.

Além disso, mais detalhes sobre os possíveis armazenamentos de dados, o Magento usa o Zend_Cache para seus mecanismos de Cache. Você notará que está relacionado aos local.xmlXpaths de cache.

NOTA

Se você estiver executando o Enterprise, encontrará um segundo arquivo de configuração etc/enterprise.xml onde é definido o armazenamento de dados para o FPC.

Qual é a diferença entre Flush Cache e Flush Cache Storage:

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

Uma observação muito importante sobre o Magento Compiler. Você precisa desativar coisas como a APC ao fazer a compilação, pois o compilador não pode compilar o que está na APC e corromperá sua compilação. Para mim, isso significaria descarregar a APC no servidor e reiniciar o Apache (httpd).