it-swarm.it

Ricostruisci imagecache

Ho un campo immagine per nodo che passa attraverso imagecache. Poiché imagecache viene memorizzato nella cache su richiesta, i file/le varianti della cache non vengono creati fino alla prima richiesta. Quindi, se aggiorno un mucchio di immagini, ri-distribuisco o soffio in altro modo l'intera cache, spetta al primo visitatore elaborare quel file.

Come posso risparmiare all'utente il tempo di caricamento e ricostruire manualmente l'intera cache?

L'ultima volta che è venuto fuori, ho caricato a livello di codice ogni collegamento nodo con jquery ...

Sembra un perfetto plugin Drush ... probabilmente dovrebbe cercare di scriverlo, ma sono curioso di sapere se qualcun altro ha una soluzione per questo.

5
ack

È possibile creare un modulo personalizzato e quindi utilizzare hook_cron () per ricostruire l'immagine.

Aggiornare

Ho appena trascorso l'ultima ora a cercare di capire come farlo sul lato server e penso di averlo risolto.

/**
 * Implements hook_cron().
 */
function rebuildimagecache_cron() {
    global $base_url;

    // get published nodes
    $result = db_query('SELECT nid FROM {node} WHERE status = 1');
    while ($nodes = db_fetch_array($result)) {
        $node = node_load($nodes['nid']);
        $node_type = $node->type;

        // get cck fields for the current nodes node_type
        $fields = content_fields(NULL, $node_type);
        foreach ($fields as $key => $value) {

            // only deal with file fields that use the image widegt tyoe
            if ($value['type'] == 'filefield' && $value['widget']['type'] == 'imagefield_widget') {
                $preset_tokens = explode('_', $value['display_settings']['full']['format']);
                $imagecache_preset = $preset_tokens[0];
                $field_name = $value['field_name'];

                // iterate over each field instance 
                foreach ($node->$field_name as $field_instance) {
                    $filepath = $field_instance['filepath'];
                    $cachedpath = imagecache_create_path($imagecache_preset, $filepath);
                    file_get_contents($base_url . base_path() . $cachedpath);
                }
            }
        }       
    }   
}

Come funziona:

  1. Ottieni tutti i nodi pubblicati
  2. Per ogni nodo ottiene il tipo di nodo
  3. Ottiene una matrice di campi per il nodo corrente che viene iterato
  4. Scorre tutti i campi e controlla se ci sono campi immagine
  5. Se viene trovato un campo immagine, associa il preset della cache immagine
  6. Scorrere le istanze del campo immagine del nodo
  7. Per ogni istanza del campo immagine ottenere percorso file immagine
  8. Converti il ​​percorso del file immagine nel percorso cache dell'immagine
  9. Leggere il percorso del file utilizzando file_get_contents () su HTTP per forzare la cache dell'immagine a generare l'immagine memorizzata nella cache.

L'ho provato e ha funzionato benissimo per me in Drupal 6. A Drupal 7 versione sarebbe leggermente più complicato a causa delle modifiche nel file sottostante API.

Dovrai creare un modulo personalizzato e incollare questa funzione. Assicurati di cambiare anche il nome hook da rebuildimagecache al nome del tuo modulo personalizzato.

Ho usato hook_cron() in modo che venga eseguito quando cron viene eseguito ma è possibile eseguirlo manualmente tramite un comando drush.

12
Camsoft

Approccio a bassa tecnologia ...

  1. Crea una nuova vista del nodo.
  2. Imposta un filtro per il tipo di contenuto che contiene i campi immagine.
  3. Aggiungi i tuoi campi immagine, usando qualunque preset ImageCache desideri pre-cache.
  4. Impostalo su non pagina, senza limite di conteggio nodi.
  5. Carica la vista.
  6. Guarda il tuo server schiacciare sotto il carico. In caso di timeout, ricaricare la vista.

Oh, e assicurati che solo gli amministratori dispongano delle autorizzazioni per quella vista.

5
rogerhoward

Un consiglio sulle prestazioni: non è necessario caricare l'intero contenuto dell'immagine per attivare imagecache, ma è anche possibile richiedere le intestazioni. Quindi questa linea:

file_get_contents($base_url . base_path() . $cachedpath);

diventa

get_headers($base_url . base_path() . $cachedpath);
4
Stan James

La mia soluzione:

function example_cron() {
    $result = db_query('SELECT fid, uri FROM {file_managed} WHERE filemime like :mime AND status = :status', array('mime' => 'image/%', 'status' => FILE_STATUS_PERMANENT));
    $queue = DrupalQueue::get('generate_image_styles');
    foreach ($result as $img_info) {
        foreach(image_styles() as $style) {
            $derivative_uri = image_style_path($style['name'], $img_info->uri);
            if (file_exists($derivative_uri)) continue; // skip existing files
            $data = (object) array(
                    'style' => $style,
                    'img_info' => $img_info,
                    'derivative_uri' => $derivative_uri
                     );
        $queue->createItem($data);
        }
    }
}


function example_cron_queue_info(){
    $queues['generate_image_styles'] = array(
        'worker callback' => '_example_generate_image_styles',
        'time' => 30
        );
return $queues;
}

function _example_generate_image_styles($data){
    if (!file_exists($data->derivative_uri)) {
        image_style_create_derivative($data->style, $data->img_info->uri, $data->derivative_uri);
    }
}
3
atavio

C'è stato un tentativo di far funzionare questo tipo di cose, vedi Imagecache Batch ma non sono sicuro di dove sia lo sviluppo di queste funzionalità. Non menzionate se avete a che fare con D6 o D7, ma vorrei esaminare le azioni e le regole in 6.x-2.x-dev e vedere dove si trova.

2
George

Questo è stato fatto e funziona bene, vedi qui https://drupal.org/node/587086

Prova la patch di file completa alla fine del thread. Assicurati di eseguirlo all'interno di /sites/all/modules/imagecache/imagecache.drush.inc e non alla radice, come standard.

0
Gabriel R.