Azioni e filtri – Personalizza WP STAGING

By , Founder · Updated

Gli sviluppatori possono personalizzare WP STAGING utilizzando le azioni e i filtri disponibili. Questo articolo documenta gli hook attuali e mostra esempi di utilizzo per personalizzare il processo di Backup, clonazione e push secondo le tue esigenze.

Per usare gli hook e i filtri, ti consigliamo di installare il nostro Plugin separato, chiamato  WP STAGING Hooks, oppure di usare gli hook e i filtri di questa pagina in un mu-plugin.
Altrimenti, non tutte le azioni potrebbero funzionare come previsto.

La maggior parte dei filtri di questa pagina richiede uno dei piani WP STAGING | PRO.

Plugin WP STAGING Hooks

Puoi scaricare il Plugin WP STAGING Hooks che contiene molti dei filtri menzionati in questo articolo, per un uso facile sul tuo sito.

Nota: non tutti i filtri menzionati in questo articolo sono inclusi nel repository GitHub.

Se c’è un filtro citato in questa pagina che non è disponibile nel Plugin WP STAGING Hooks, puoi copiare il codice specifico di questa pagina in un nuovo mu-plugin o in uno esistente come il mu-plugin di WP STAGING che trovi in wp-content/plugins/wp-staging-optimizer.php

Consulta questo articolo per “Imparare a creare un mu-plugin” sul tuo sito.

Copia il codice completo nell’intestazione del mu-plugin e adattalo alle tue esigenze. Se hai bisogno di aiuto, faccelo sapere.

Contents

Consentire un uso illimitato della memoria

WP STAGING limita il consumo massimo di memoria a 256M, che di solito è sufficiente per il suo processo di clonazione e Backup. Durante questo processo, tutti gli altri Plugin sono disattivati, ma ciò non influisce sulle altre pagine del sito.

Un limite di memoria di 256M è di solito sufficiente per eseguire WP STAGING con successo. Non consigliamo un WP_MEMORY_LIMIT o un limite massimo di memoria PHP superiore a 512M, poiché andare più in alto può indicare un problema con uno dei Plugin o con molti Plugin attivi. Non è consigliabile superare questi limiti perché il limite di memoria è collegato a ciascun processo PHP. Se viene impostato un consumo di memoria elevato per ogni richiesta WordPress, la memoria disponibile sulla macchina può riempirsi rapidamente, rendendo il sito non disponibile.

Tuttavia, nei casi in cui sia necessario superare il limite di 256M, è possibile disattivare il limite di memoria di WP STAGING. Ricorda che questo non è consigliato a meno che non ci sia una valida ragione e il server abbia memoria sufficiente disponibile.

Per disattivare il limite di memoria, usa il filtro fornito per consentire un consumo di memoria illimitato per WP STAGING. L’unico limite, in questo caso, è il limite massimo di memoria PHP.

PHP
add_filter('wpstg.resources.ignoreMemoryLimit', function() {
  return true;
});

Cambiare il logo WP STAGING nel form di login (versione Pro)

Puoi usare il codice qui sotto per cambiare il logo del modulo di login del sito di Staging:

PHP
add_filter('wpstg_login_form_logo', function(){
  return 'https://example.com/path/to/custom/image.png';
});

Aumentare il tempo di richiesta di WP STAGING e il tempo massimo di esecuzione di PHP

Di solito, il Backup e il ripristino di WP STAGING funzionano anche su Hosting modesti. Se hai un database o un sito enorme con milioni di righe, il limite di esecuzione PHP predefinito di 30 secondi potrebbe essere troppo basso. Per far funzionare la creazione/il ripristino del Backup, imposta il valore PHP  max_execution_time= 120 nel tuo php.ini.

Aumenta inoltre il valore apache Timeout 120 o imposta la direttiva Nginx fastcgi_read_timeout 120;

Dopo averlo fatto, aggiungi il filtro qui sotto in un mu-plugin come mu-plugin/wp-staging-optimizer.php.

PHP
​add_filter('wpstg.resources.executionTimeLimit', function(){
    return 100;
});

Assicurati che il valore di input sia inferiore al tempo massimo di esecuzione effettivamente consentito da PHP. Questo è necessario affinché il tempo di richiesta di WP STAGING non superi mai il tempo di esecuzione PHP.

Cambiare il titolo del sito di Staging

PHP
function wpstg_get_title(){
   return 'DEV';
}
add_filter('wpstg_staging_site_title', 'wpstg_get_title');

Cambiare il percorso della cartella cache

Per cambiare la cartella usata per memorizzare i file temporanei di Backup nella cartella PHP temp globale o in un’altra posizione, puoi usare il codice qui sotto:

PHP
​add_filter('wpstg.directory.cacheDirectory', function(){
        return trailingslashit(sys_get_temp_dir()) . 'wpstagingcache';​
​});

Escludere tabelle dall’operazione di Search & Replace

Usa questo se il processo di Search & Replace consuma molta della tua memoria disponibile e il processo di clonazione o push fallisce con un errore di memoria esaurita. Puoi anche usarlo per migliorare la velocità del processo di clonazione e push.

Escludi le tabelle che non hanno bisogno di alcuna sostituzione di link! Possono essere tabelle che contengono statistiche dei visitatori, indirizzi IP o simili. Dopo aver escluso queste tabelle, puoi aumentare il limite di Search & Replace del DB nelle impostazioni di WP STAGING a un valore più alto per ottenere prestazioni migliori.

PHP
function wpstg_searchreplace_excl_tables($default){
    $tables = array('_posts', '_postmeta'); 
    return array_merge($default, $tables);
}
add_filter('wpstg_searchreplace_excl_tables','wpstg_searchreplace_excl_tables');

Search & Replace personalizzato per valori del database codificati

Usa questo filtro per eseguire operazioni di search and replace su dati codificati in base64 nel tuo database (spesso usati dai page builder o da impostazioni di Plugin complessi). Questo assicura che gli URL e altre stringhe siano aggiornati correttamente anche quando sono memorizzati in formato codificato durante il processo di clonazione, push o ripristino.

// Replace URLs inside base64-encoded database values during cloning/pushing/restore.
add_filter('wpstg.database.searchreplace.replace_extended_data', function ($data, $search, $replace) {
    $plain = base64_decode($data, true);
    if ($plain === false) {
        return $data;
    }

    $replaced = str_replace($search, $replace, $plain);
    if ($replaced === $plain) {
        return $data;
    }

    return base64_encode($replaced);
}, 10, 3);

Puoi usare questo filtro per sostituire ogni tipo di dato personalizzato nel database che non possa essere gestito automaticamente da WP STAGING.

Un altro esempio: alcuni Plugin salvano gli URL o altri valori dentro stringhe JSON codificate invece che in testo semplice. Un esempio comune è il JSON che contiene valori di proprietà codificati in base64.

In questi casi, il normale search/replace di WP STAGING non può rilevare l’URL originale, perché è nascosto dentro il valore codificato.

Per supportare questi casi, WP STAGING fornisce il filtro:

wpstg.database.searchreplace.replace_extended_data

Questo filtro permette agli sviluppatori di modificare il valore di una colonna del database dopo che il normale search/replace è già stato eseguito.

Può essere usato durante:

  • la clonazione
  • il push dello Staging alla produzione
  • il ripristino dei Backup

Quando dovrei usare questo filtro?

Usa questo filtro quando un Plugin o un Theme memorizza i dati in un formato come:

  • JSON con valori codificati in base64
  • strutture JSON annidate che contengono stringhe codificate
  • formati di dati personalizzati in cui gli URL non sono memorizzati come testo semplice

Senza questo filtro, gli URL all’interno di quei valori codificati resteranno invariati.

Parametri del filtro

Il filtro riceve tre parametri:

ParametroTipoDescrizione
$datastringIl valore della colonna del database dopo il normale search/replace
$searcharrayLe stringhe da cercare
$replacearrayLe stringhe di sostituzione

Idea di base

La tua callback può:

  1. ispezionare il valore del database
  2. rilevare se contiene dati codificati
  3. decodificare il valore
  4. eseguire str_replace() con gli array di search e replace
  5. ricodificare il valore
  6. restituire il risultato modificato

Se il valore non corrisponde al formato che ti aspetti, restituiscilo semplicemente invariato.

Esempio: search/replace dentro valori JSON codificati in base64

L’esempio di mu-plugin seguente mostra come sostituire URL dentro valori JSON le cui proprietà sono codificate in base64.

Crea questo file:

wp-content/mu-plugins/wpstg-base64-search-replace.php

Aggiungi questo codice:

<?php

/**
 * Decode base64-encoded values inside JSON database columns during
 * WP Staging search/replace so that URLs within them are replaced.
 */
add_filter('wpstg.database.searchreplace.replace_extended_data', function ($data, $search, $replace) {
    // Only process JSON-looking data
    if (empty($data) || ($data[0] !== '[' && $data[0] !== '{')) {
        return $data;
    }

    $decoded = json_decode($data, false);
    if (json_last_error() !== JSON_ERROR_NONE) {
        return $data;
    }

    $changed = false;

    // Recursively walk JSON to find base64-encoded string values at any depth
    $walk = function ($node) use (&$walk, &$changed, $search, $replace) {
        if (is_array($node)) {
            foreach ($node as $item) {
                $walk($item);
            }

            return;
        }

        if (!is_object($node)) {
            return;
        }

        foreach ($node as $key => $value) {
            if (is_array($value) || is_object($value)) {
                $walk($value);
                continue;
            }

            if (!is_string($value) || $value === '') {
                continue;
            }

            $plain = base64_decode($value, true);
            if ($plain === false) {
                continue;
            }

            $replaced = str_replace($search, $replace, $plain);
            if ($replaced !== $plain) {
                $node->$key = base64_encode($replaced);
                $changed = true;
            }
        }
    };

    $walk($decoded);

    return $changed ? wp_json_encode($decoded) : $data;
}, 10, 3);

Come funziona questo esempio

Questo esempio fa quanto segue:

  1. Controlla se il valore del database sembra essere JSON.
  2. Decodifica il JSON.
  3. Attraversa ricorsivamente tutti gli array e oggetti annidati.
  4. Tenta di decodificare in base64 ogni valore stringa.
  5. Esegue i valori di search/replace di WP STAGING sul contenuto decodificato.
  6. Se qualcosa è cambiato, codifica nuovamente il valore modificato in base64.
  7. Restituisce la stringa JSON aggiornata.

Dati di esempio

Immagina che un Plugin memorizzi questo nel database:

{
  "title": "Example",
  "url": "aHR0cHM6Ly9vbGQtc2l0ZS5jb20vcGFnZQ=="
}

Il valore url è codificato in base64. Decodificato, contiene:

https://old-site.com/page

Durante un clone, push o ripristino di WP STAGING, il normale search/replace non può vedere quell’URL direttamente perché è codificato.

Con il filtro qui sopra, WP STAGING:

  • decodifica il valore
  • sostituisce https://old-site.com con https://new-site.com
  • lo codifica nuovamente
  • salva il valore aggiornato di nuovo nel database

Risultato

Dopo l’esecuzione del filtro, il valore memorizzato diventa la versione codificata in base64 di:

https://new-site.com/page

Dove dovrei inserire questo codice?

L’opzione più sicura è inserirlo in un mu-plugin, così verrà caricato automaticamente a ogni richiesta.

Percorso consigliato:

wp-content/mu-plugins/wpstg-base64-search-replace.php

Se la directory mu-plugins non esiste ancora, creala manualmente.

Note importanti

  • Questo filtro è pensato per formati di database personalizzati che non sono gestiti dal search/replace predefinito.
  • La tua callback dovrebbe sempre restituire i $data originali invariati se non corrispondono al formato atteso.
  • Mantieni la logica il più specifica possibile per evitare di modificare dati non correlati.
  • Prima di usarlo sui dati di produzione, prova questo su un sito di Staging.

Usa wpstg.database.searchreplace.replace_extended_data quando gli URL o altri valori sono nascosti dentro contenuti del database codificati.

È particolarmente utile per i Plugin che memorizzano valori in:

  • JSON codificato in base64
  • oggetti JSON annidati
  • altri formati codificati personalizzati

Dà agli sviluppatori il pieno controllo su come quei valori vengono decodificati, sostituiti e salvati di nuovo.

Filtri di clonazione & Staging

Eseguire un’azione sul sito di Staging dopo la clonazione

L’esempio qui sotto eseguirà una query SQL la prima volta che il sito di Staging viene aperto:

PHP
add_action('wpstg.clone_first_run', 'wpstg_execute_after_cloning', 10);

function wpstg_execute_after_cloning() {
   
global $wpdb;

$sql = "DELETE * FROM wpstg0_tablename WHERE ....";

$wpdb->query($sql);
}

Questa query verrà eseguita solo quando si tratta di un sito di Staging e solo sul sito di Staging, ma per maggiore sicurezza ti consigliamo di codificare in modo fisso i nomi delle tabelle includendo il prefisso specifico di Staging come nell’esempio, in modo da garantire che questa query non possa mai danneggiare il sito live nel caso venisse eseguita lì per errore.

Puoi aggiungere ogni tipo di codice a questa azione e verrà eseguito una sola volta alla prima apertura del nuovo sito di Staging.

Attivare o disattivare Plugin specifici sul sito di Staging dopo la clonazione

Per attivare o disattivare alcuni Plugin sul sito di Staging dopo la clonazione, usa il filtro wpstg.cloning.update_active_plugins in questo modo:

PHP
php
function wpstg_cloning_update_active_plugins($currentActivePlugins) {
// snippet to deactivate
$pluginsToDeactivate = array('plugin1-basename', 'plugin2-basename');
foreach ($pluginsToDeactivate as $pluginToDeactivate) {
  $key = array_search($pluginToDeactivate, $currentActivePlugins, true);
  if (false !== $key) {
    unset($currentActivePlugins[$key]);
  }
}

// snippet to activate
$pluginsToEnable      = array('plugin3-basename');
$currentActivePlugins = array_merge($currentActivePlugins, $pluginsToEnable);

return $currentActivePlugins;

}
add_filter('wpstg.cloning.update_active_plugins','wpstg_cloning_update_active_plugins');

Escludere righe dal Search & Replace in wp_options

PHP
function wpstg_clone_searchreplace_excl_rows($default){
   $rows = array('siteurl', 'home'); 
    return array_merge($default, $rows);

add_filter('wpstg_clone_searchreplace_excl_rows','wpstg_clone_searchreplace_excl_rows');

Escludere righe dalla clonazione

Questo esempio escluderà righe dalla tabella wp_options in base al nome dell’opzione, o escluderà articoli dalla tabella wp_posts in base a post_title e post_status e ai loro metadati di articolo.

Sono disponibili questi operatori:

['=', '>', '>=', '<', '<=', '<>', '!=', 'LIKE', 'NOT LIKE']

PHP
function queryCloningRows($filters) {
	$filters = [
// Clone only options where option_name is not 'wpstg_is_staging_site'
		'wp_options' => [
			'option_name' => [
				'operator' => '<>',
				'value' => 'wpstg_is_staging_site'
			]
		],
// Clone only posts where post_title LIKE 'Hello%' AND post_status = 'publish'
		'wp_posts' => [
			'post_title' => [
				'operator' => 'LIKE',
				'value' => 'Hello%'
			],
			'post_status' => 'publish'
		],
// will filter postmeta depending upon filtered data in wp_posts, see above wp_posts filter
    'wp_postmeta' => [
			'join' => [
				'table' => 'wp_posts',
				'primaryKey' => 'ID',
				'foreignKey' => 'post_id',
			]
		]
	];
	
	return $filters;
}

add_filter('wpstg.cloning.database.queryRows', 'queryCloningRows');

Escludere un custom post type dalla clonazione

Questo esempio escluderà gli articoli del custom post type “coupon” insieme ai relativi dati di postmeta:

Sono disponibili questi operatori:

['=', '>', '>=', '<', '<=', '<>', '!=', 'LIKE', 'NOT LIKE']

PHP
function queryCloningRows($filters) {
	$myFilters = [
// Clone only posts which do not belong to post_type coupon
		'wp_posts' => [
			'post_type' => [
				'operator' => '<>',
				'value' => 'coupon'
			]
		],
// will filter postmeta depending upon filtered data in wp_posts, see above wp_posts filter
    'wp_postmeta' => [
			'join' => [
				'table' => 'wp_posts',
				'primaryKey' => 'ID',
				'foreignKey' => 'post_id',
			]
		]
	];
	
// will filter postmeta depending upon filtered data in wp_posts, see above wp_posts filter
    'wp_postmeta' => [
			'join' => [
				'table' => 'wp_posts',
				'primaryKey' => 'ID',
				'foreignKey' => 'post_id',
			]
		]
	];

	return array_merge($filters, $myFilters);
}

add_filter('wpstg.cloning.database.queryRows', 'queryCloningRows');

Escludere stringhe dal Search & Replace

PHP
function wpstg_clone_searchreplace_excl(){
    return array('blog.localhost.com','blog1.localhost.com');
}
add_filter('wpstg_clone_searchreplace_excl','wpstg_clone_searchreplace_excl');

Cambiare i parametri di Search & Replace

PHP
function wpstg_cloning_custom_params($args){
      // Default values - Can be changed
      $args['search_for'] = array_merge(
         $args['search_for'],
         array('SEARCHSTRING', 'SEARCHSTRING')
         );
         
     $args['replace_with'] = array_merge(
         $args['replace_with'],
         array('REPLACESTRING','REPLACESTRING2')
       );
       
      $args['replace_guids'] = 'off'; 
      $args['dry_run'] = 'off'; 
      $args['case_insensitive'] = false;
      $args['replace_guids'] = 'off';
      $args['replace_mails'] = 'off';
      $args['skip_transients'] = 'on';
      
      return $args;
}
add_filter('wpstg_clone_searchreplace_params', 'wpstg_cloning_custom_params');

Escludere file

PHP
/**
* Cloning: Exclude files from cloning
* Example: You can use a wildcard pattern like *.log to exclude all log files
*/
function wpstg_clone_excluded_file_names($default)
{
    $files = array('custom-file', '*LOG-*', '*.logs');
    return array_merge($default, $files);
}
add_filter('wpstg_clone_excluded_files', 'wpstg_clone_excluded_file_names');

Escludere file dalla clonazione usando il percorso completo

Per impostazione predefinita, WP STAGING esclude questi file dalla copia ogni volta che crea un sito di Staging:

  • .htaccess
  • Absolute/path/to/WordPress/directory/wp-content/db.php
  • Absolute/path/to/WordPress/directory/wp-content/object-cache.php
  • Absolute/path/to/WordPress/directory/wp-content/advanced-cache.php

Puoi modificare questo comportamento e l’elenco dei file esclusi usando il filtro qui sotto:

PHP
/**
* Exclude files from cloning using full path 
*/
function wpstg_clone_excluded_files_full_path($default)
{
    $files = ['full/path/custom-file1', 'full/path/custom-file2']; 
    return array_merge($default, $files);
}
add_filter('wpstg.clone.excluded_files_full_path','wpstg_clone_excluded_files_full_path');

Escludere cartelle

PHP
/**
* Excluded folders relative to the wp-content folder 
*/
function wpstg_exclude_folders_custom($args){
     $folders = array('plugins/wordpress-seo', 'custom-folder');
     return array_merge($args, $folders);
}
add_filter('wpstg_clone_excl_folders', 'wpstg_exclude_folders_custom');

Multisite: escludere cartelle (Plugin) dalla clonazione in un multisite

Se usi una rete multisite, usa il filtro `wpstg_clone_mu_excl_folders` per escludere cartelle relative alla cartella wp-content. Questo è utile se vuoi escludere un Plugin.

PHP
**
* Excluded folders relative to the wp-content folder
*/
function wpstg_exclude_folders_custom($args){
   $folders = array('plugins/wordpress-seo', 'themes/custom-folder');
   return array_merge($args, $folders);
}
add_filter('wpstg_clone_mu_excl_folders', 'wpstg_exclude_folders_custom');

Impedire il Search & Replace del prefisso della tabella in un’opzione della tabella wp_options

Per impostazione predefinita, WP STAGING clona tutte le tabelle e sostituisce i valori che iniziano con il prefisso della tabella del nuovo database. Puoi escludere opzioni da questa operazione di sostituzione affinché non vengano modificate durante la clonazione:

PHP
function wpstg_excl_option_name_custom($args){
     $cols = array('wp_mail_smtp', 'wp_mail_smtp_version');
     return array_merge($args, $cols);
}
add_filter('wpstg_data_excl_rows', 'wpstg_excl_option_name_custom');

Clonare multisite di rete e cambiare il nome host di destinazione

WP STAGING ha il supporto per i multisite basati su domini personalizzati. I siti di rete verranno creati automaticamente nel sottodominio specificato del sito principale.

Esempio:

C’è un sito di rete con il sito principale example.com e un sottosito di rete example.org e un altro example.net:

Se cloni l’intera rete su staging.example.com i siti di rete verranno clonati in:

  • staging.example.org
  • staging.example.net

Puoi modificare ogni sito usando il filtro qui sotto. È un filtro generico che può essere usato per sottositi basati su sottodominio, sottocartella o anche dominio.

PHP
// Convert staging site with ID 2 to dev.example.com
add_filter('wpstg.cloning.multisite.subsite_info', function ($subsiteInfo, $blogId, $stagingSiteURL, $addWWWPrefix) {

if ($blogId === 2) {
    $subsiteInfo['domain'] = 'dev.example.com';
    $subsiteInfo['path']   = '/';
    $subsiteInfo['url']    = 'https://dev.example.com';
}

return $subsiteInfo;
}, 10, 4);

Preservare il valore “upload_path” nel database

Nei vecchi siti WordPress Network, potresti dover impedire la modifica di upload_path; usa questo filtro per ottenere ciò:

PHP
add_filter('wpstg.cloning.preserve_upload_path',  '__return_true');

Filtri di Push

Attivare o disattivare Plugin specifici sul sito di produzione dopo il push di un sito di Staging

Per attivare o disattivare alcuni Plugin sul sito live dopo il push di un sito di Staging, usa il filtro wpstg.pushing.update_active_plugins in questo modo:

PHP
function wpstg_pushing_update_active_plugins($currentActivePlugins)
{
    // snippet to deactivate
    $pluginsToDeactivate = array('plugin1-basename', 'plugin2-basename');
    foreach ($pluginsToDeactivate as $pluginToDeactivate) {
        $key = array_search($pluginToDeactivate, $currentActivePlugins, true);
        if (false !== $key) {
            unset($currentActivePlugins[$key]);
        }
    }

    // snippet to activate
    $pluginsToEnable      = array('plugin3-basename');
    $currentActivePlugins = array_merge($currentActivePlugins, $pluginsToEnable);

    return $currentActivePlugins;
}
add_filter('wpstg.pushing.update_active_plugins','wpstg_pushing_update_active_plugins');

Cambiare i parametri di Search & Replace

PHP
function wpstg_push_custom_params($args){
      // Default values - Can be changed
         $args['search_for'] = array_merge(
         $args['search_for'],
         array('SEARCHSTRING', 'SEARCHSTRING2')
         );
         $args['replace_with'] = array_merge(
         $args['replace_with'],
         array('REPLACESTRING','REPLACESTRING2')
       );
      $args['replace_guids'] = 'off'; 
      $args['dry_run'] = 'off'; 
      $args['case_insensitive'] = false;
      $args['replace_guids'] = 'off';
      $args['replace_mails'] = 'off';
      $args['skip_transients'] = 'on';
      return $args;
}
add_filter('wpstg_push_searchreplace_params', 'wpstg_push_custom_params');

Escludere tabelle dal push

PHP
function wpstg_push_excluded_tables($tables){
    $customTables = ['options', 'posts']; 
    return array_merge($tables, $customTables);
}
add_filter('wpstg_push_excluded_tables','wpstg_push_excluded_tables');

Nota: i nomi delle tabelle nel codice devono essere senza prefisso di tabella!

Questo esempio esclude le tabelle wp_posts e wp_options dal push al sito live.

Escludere righe dal push. Copiare solo righe specifiche

Questo esempio escluderà certe righe dalla tabella wp_options in base al nome dell’opzione, o escluderà articoli dalla tabella wp_posts in base a post_title e post_status insieme ai loro dati postmeta.

Sono disponibili questi operatori:

['=', '>', '>=', '<', '<=', '<>', '!=', 'LIKE', 'NOT LIKE']

Attenzione: il prefisso della tabella deve essere wpstg0_, wpstg1_, wpstg3, ecc. a seconda del prefisso effettivo delle tabelle del sito di Staging, quindi devi sostituire wpstg[int]_ con il prefisso effettivo.

PHP
function queryPushingRows($filters) {
	$filters = [
		// will only push options where option_name is not 'wpstg_is_staging_site'
		'wpstg0_options' => [
			'option_name' => [
				'operator' => '<>',
				'value' => 'wpstg_is_staging_site'
			]
		],
		// will only push posts where post_title LIKE 'Hello%' AND post_status = 'publish'
		'wpstg0_posts' => [
			'post_title' => [
				'operator' => 'LIKE',
				'value' => 'Hello%'
			],
			'post_status' => 'publish'
		],
    // will filter postmeta depending upon filtered data in wp_posts, see above wp_posts filter
    'wpstg0_postmeta' => [
			'join' => [
				'table' => 'wpstg0_posts',
				'primaryKey' => 'ID',
				'foreignKey' => 'post_id',
			]
		]
	];
	
	return $filters;
}

add_filter('wpstg.pushing.database.queryRows', 'queryPushingRows');

Nota: escludere questi post type significa che non saranno più disponibili e non saranno più inclusi nel sito live dopo aver copiato il sito di Staging al live.

Escludere un determinato post type dal push

Questo esempio escluderà gli articoli con il custom post type “coupon” insieme ai loro dati postmeta:

Sono disponibili questi operatori:

['=', '>', '>=', '<', '<=', '<>', '!=', 'LIKE', 'NOT LIKE']

Attenzione: il prefisso della tabella deve essere wpstg0_, wpstg1_, wpstg3, ecc. a seconda del prefisso effettivo delle tabelle del sito di Staging, quindi devi sostituire wpstg0_ con il prefisso effettivo.

PHP
function queryPushingRows($filters) {
	$myFilters = [
		// Push only posts where post_type is not 'coupon'
		'wpstg0_posts' => [
			'post_type' => [
				'operator' => '<>',
				'value' => 'coupon'
			]
		],
    // will push postmeta depending upon filtered data in wp_posts, see above wp_posts filter
    'wpstg0_postmeta' => [
			'join' => [
				'table' => 'wpstg0_posts',
				'primaryKey' => 'ID',
				'foreignKey' => 'post_id',
			]
		]
	];

	return array_merge($filters, $myFilters);
}

add_filter('wpstg.pushing.database.queryRows', 'queryPushingRows');

Escludere cartelle dal push

Per impostazione predefinita, WP STAGING | PRO non scorre né trasferisce nessuna di queste cartelle al sito di produzione:

  • cache
  • wps-hide-login
  • node_modules
  • nbproject
  • wp-staging

Puoi aggiungere cartelle personalizzate a questo elenco usando il filtro qui sotto:

PHP
function wpstg_push_directories_excl($default){
    $dirs = array('custom-folder', 'custom-folder2'); 
    return array_merge($default, $dirs);
}
add_filter('wpstg.push_excluded_directories', 'wpstg_push_directories_excl');

Escludere file dal push

Per impostazione predefinita, WP STAGING | PRO non trasferisce nessuno di questi file al sito di produzione:

  • .htaccess
  • .DS_Store
  • .git
  • .svn
  • .tmp
  • desktop.ini
  • .gitignore
  • .log
  • wp-staging-optimizer.php

Puoi aggiungere file personalizzati a questo elenco usando il filtro qui sotto:

PHP
function wpstg_push_excluded_files($default){
    $files = array('custom-file', 'custom-file2'); 
    return array_merge($default, $files);
}
add_filter('wpstg_push_excluded_files','wpstg_push_excluded_files');

Preservare dati in wp_options ed escluderli dal push

Preservare i dati significa che puoi fare il push del sito di Staging al sito di produzione escludendo dati specifici dalla sovrascrittura durante il processo di push.

L’esempio qui sotto preserva i valori delle opzioni WordPress ‘siteurl’ e ‘home’ nella tabella wp_options del sito live.

Si possono aggiungere quante opzioni aggiuntive si desidera.

PHP
function wpstg_push_preserve_options($options){
       $preserveOptions = ['siteurl', 'home'];
       return array_merge($options, $preserveOptions );
}
add_filter('wpstg_preserved_options','wpstg_push_preserve_options');

Esempio: come preservare la chiave di licenza WPML dopo il push

Puoi usare questo codice come file mu-plugin:

PHP
<?php
/*
Plugin Name: mu-plugin to keep the WPML license of the live site
Description: After you push the staging site to the live site, the live site's WPML license won't change
Version: 1.0
Author: WPSTAGING
*/

function wpstg_push_preserve_options($options){
    $preserveOptions = ['wp_installer_settings'];
    return array_merge($options, $preserveOptions );
}
add_filter('wpstg_preserved_options','wpstg_push_preserve_options');

Eseguire un’azione dopo il push del sito di produzione.

Puoi usare questo hook per chiamare un metodo sul sito di produzione dopo il push di un sito di Staging al sito live.

PHP
function pushingComplete()
{
// do something
}
add_action( 'wpstg_pushing_complete', 'pushingComplete' );

Filtri di Backup

Ripristinare un multisite completo su un altro multisite (migrazione)

Se hai creato un Backup da una rete multisite completa e vuoi ripristinarlo su un altro multisite esistente, ad esempio per copiare il multisite su un altro server, ci sono alcune cose da considerare, in base al tipo di multisite che gestisci. Leggi questo articolo che spiega in dettaglio come farlo e come usare un filtro specifico per quell’operazione.

Ripristinare un sito di rete multisite su un’altra rete multisite (migrazione)

Prende un array di percorsi (nella directory uploads) (file o directory) da escludere durante il ripristino del Backup dalla pulizia. Esempio di utilizzo:

PHP
add_filter('wpstg.backup.restore.exclude_media_during_cleanup', function ($pathsToExclude) {
    $pathsToExclude[] = '/full/path/to/a/directory';
    $pathsToExclude[] = '/full/path/to/a/file';
    return $pathsToExclude;
});

Per impostazione predefinita, WP STAGING preserva il contenuto originale (cartella lingua, mu-plugins, Plugin, Theme e altri file oltre ai media) quando ripristina un Backup su un sottosito di rete. Invece di preservare i contenuti esistenti, possiamo sostituirli usando questi filtri:

PHP
add_filter('wpstg.backup.restore.replace_existing_languages', '__return_true');
add_filter('wpstg.backup.restore.replace_existing_mu_plugins', '__return_true');
add_filter('wpstg.backup.restore.replace_existing_other_files', '__return_true');
add_filter('wpstg.backup.restore.replace_existing_plugins', '__return_true');
add_filter('wpstg.backup.restore.replace_existing_themes', '__return_true');

Estendere il Search and Replace per cambiare gli URL di tutti i sottositi nel database

Per impostazione predefinita, per velocizzare il processo di ripristino del Backup, vengono sostituiti solo gli URL che appartengono al sito corrente. Se si tratta di un multisite e un sito contiene URL di altri siti della rete, puoi usare un filtro per sostituire anche questi URL. Nota: più siti hai, più tempo ci vorrà per sostituire tutti gli URL dei siti.

PHP
add_filter('wpstg.multisite.full_search_replace', '__return_true');

Escludere un’estensione di file dal Backup

Permetti agli utenti di escludere estensioni di file specifiche dall’essere esportate nel Backup.

PHP
function wpstg_backup_files_ignore_extensions($default_excluded){
    return array_merge($default_excluded, ['zip', 'gz']);
}
add_filter( 'wpstg.export.files.ignore.file_extension', 'wpstg_backup_files_ignore_extensions');

Escludere file più grandi di una dimensione specifica dal Backup

Per impostazione predefinita, WP STAGING salta tutti i file più grandi di 200MB dall’essere aggiunti a un Backup. Puoi aumentare quel valore usando il filtro qui sotto:

PHP
function wpstg_backup_files_ignore_files_bigger_than($default){
    return 200 * MB_IN_BYTES;
}

add_filter( 'wpstg.export.files.ignore.file_bigger_than', 'wpstg_backup_files_ignore_files_bigger_than');

Escludere file con determinate estensioni più grandi di una dimensione specifica dal Backup

Per impostazione predefinita, WP STAGING salta i file zip più grandi di 50MB dall’essere aggiunti a un Backup. Puoi modificarlo usando il filtro qui sotto per ogni estensione individualmente:

PHP
function wpstg_backup_files_ignore_files_w_extension_bigger_than($default){
$ignoreFiles = [
    'gz' => 100 * MB_IN_BYTES, 
    'tar' => 200 * MB_IN_BYTES,
    'zip' => 200 * MB_IN_BYTES
];
return array_merge($default, $ignoreFiles);
}

add_filter( 'wpstg.export.files.ignore.file_extension_bigger_than', 'wpstg_backup_files_ignore_files_w_extension_bigger_than');

Escludere directory dall’essere incluse in un Backup

PHP
function wpstg_backup_exclude_directories($excludedDirectories){
        $customExcludedDirectories = [
            'var/www/example.com/htdocs/wp-content/cache'
        ];
        return array_merge($excludedDirectories, $customExcludedDirectories);
    }

add_filter( 'wpstg.backup.exclude.directories', 'wpstg_backup_exclude_directories');

Escludere file dall’essere ripristinati

Questo filtro esclude file o cartelle intere dal ripristino del Backup. Puoi passare un array di percorsi relativi alla radice dell’installazione WordPress; quei file o cartelle non verranno estratti dal Backup quando avvii il processo di ripristino.

PHP
/**
 * Backup: Exclude files or folders from being restored.
 * If path is a folder, the entire folder including all contained files and subfolders will be excluded from backup restoration.
 */
function wpstg_backup_restore_exclude_paths($excludedFiles)
{
    $customExcludedFiles = [
        ABSPATH . 'documents', // a path
        ABSPATH . 'wp-content/share', // a path inside parent folder
        ABSPATH . 'wp-content/plugins/wp-crontrol', // a plugin 
        ABSPATH . 'wp-content/plugins/foo.php', // a file inside plugins folder
        ABSPATH . 'wp-content/themes/twentytwentyfour' // a complete theme
    ];

    return array_merge($excludedFiles, $customExcludedFiles);
}
add_filter('wpstg.backup.restore.exclude_paths', 'wpstg_backup_restore_exclude_paths');

Ripristinare il Backup e mantenere i file media, i Plugin o i Theme esistenti

Puoi usare i filtri qui sotto per mantenere i file esistenti:

PHP
// Keep all plugins
add_filter('wpstg.backup.restore.keepExistingPlugins', function(){return true;});

// Keep all mu-plugins
add_filter('wpstg.backup.restore.keepExistingMuPlugins', function(){return true;});

// Keep all themes
add_filter('wpstg.backup.restore.keepExistingThemes', function(){return true;});

// Keep all media files in wp-content/uploads folder.
add_filter('wpstg.backup.restore.keepExistingMedia', function(){return true;});

// Keep all other files in wp-content folder.
add_filter('wpstg.backup.restore.keepExistingOtherFiles', function(){return true;});

Cambiare il prefisso temporaneo della tabella del database durante il ripristino del Backup

È possibile usare un prefisso temporaneo personalizzato per il database durante il processo di ripristino del Backup.

Utilizzo:

PHP
add_filter('wpstg.restore.tmp_database_prefix', function ($defaultTmpPrefix) {
	return 'wpstgt_';
});

Questo esempio sostituirà {WPSTG_TMP_PREFIX} con wpstgt_ invece di usare il prefisso tmp predefinito wpstgtmp_. Questo ridurrà le possibilità di errori di ripristino se il nome della tabella, incluso il prefisso temporaneo, supera i 64 caratteri, poiché questo è il limite di caratteri MySQL per gli identificatori nel database.

Nell’esempio precedente, se esiste già una tabella con il prefisso wpstgt_ nella tabella corrente durante il processo di ripristino, tornerà a usare il prefisso tmp predefinito wpstgtmp_

Attivare i Backup multipart

WP STAGING supporta la creazione di Backup multipart che puoi usare per limitare la dimensione di ciascun file di Backup. Questa funzione può creare più file di Backup per Plugin, Theme, file media e database. È utile se hai un sito molto grande e se non è possibile creare file di Backup con più gigabyte di dati.

Usa il filtro qui sotto per attivare questa funzione e per specificare la dimensione massima del file di Backup:

PHP
add_filter('wpstg.backup.isMultipartBackup', function() {
    return true;
});

// 256 MB 
add_filter('wpstg.backup.maxMultipartBackupSize', function() {
    return 256 * 1024 * 1024;
});

Escludere parti durante il processo di ripristino del Backup

A volte non vuoi ripristinare l’intero Backup; al suo posto, puoi usare questo filtro per ripristinare solo alcune parti come Plugin, Theme, database e mantenere i dati esistenti.

Esempio

Questo codice ripristinerà solo i mu-plugins ed escluderà tutte le altre parti:

PHP
//Will only restore mu-plugins
add_filter('wpstg.backup.restore.exclude_backup_parts', function ($partsToSkip)
{
    return [
        //'muplugins',
        'plugins',
        'uploads',
        'themes',
	      'lang',
        'wpcontent', // Doesn't include core wp directories inside wp-content (mu-plugins, plugins, themes, uploads, languages)
        'wproot', // Doesn't include core wp directories (wp-admin, wp-content, wp-includes)
        'wpstgdb' // database
    ];
});

Aumentare i chunk di upload del Backup verso i provider cloud

Questo dovrebbe aiutare a ridurre le richieste a Google Drive (ad esempio), il che può essere utile se l’IP del tuo server è stato bloccato da Google. Aspetta 6 ore prima di riprovare a caricare il Backup su Google. Questo è il tempo per il quale il tuo indirizzo IP sarà bloccato da Google.

PHP
add_filter('wpstg.remoteStorages.chunkSize', function () {
    return 10 * 1024 * 1024; // 10 MB chunk size, try increasing the chunk size in multiple of 5 MB if this still fails.
});

Aumentare il ritardo tra le richieste ai provider cloud

Usa questo filtro per aumentare il ritardo tra le richieste fatte dal tuo server a Google Drive durante il processo di Backup. Questo dovrebbe aiutare nel caso in cui il tuo IP sia stato bloccato da Google. Aspetta 6 ore prima di riprovare a caricare il Backup su Google. Questo è il tempo per il quale il tuo indirizzo IP sarà bloccato da Google.

PHP
add_filter('wpstg.remoteStorages.delayBetweenRequests', function() {
    return 500; // 500ms, if this still fails, try increasing delay by multiple of 250ms.
});

Forzare l’upload allo storage remoto FTP tramite l’estensione FTP

Per impostazione predefinita, WP STAGING carica i file di Backup via l’estensione curl su FTP, ma puoi passare a curl usando questo filtro:

PHP
add_filter('wpstg.ftpclient.forceUseFtpExtension', '__return_true');

Ripristinare un Backup creato su un sito HTTP su un sito HTTPS o viceversa

Questo filtro è necessario quando devi ripristinare un Backup da un sito HTTP a un sito HTTPS, o viceversa.

PHP
add_filter('wpstg.backup.restore.use_current_scheme_on_same_site', '__return_true');

Escludere file e directory dall’eliminazione durante il ripristino del Backup

Se ripristini un Backup e vuoi evitare che file e cartelle specifici vengano puliti ed eliminati, puoi usare questo filtro per bloccarli:

PHP
add_filter( 'wpstg.backup.restore.exclude_enqueue_delete',
	function($excludedFiles) {
		return array_merge(
			$excludedFiles,
			[
				ABSPATH . 'wp-content/db.php',
				ABSPATH . 'wp-content/database',
				ABSPATH . 'wp-content/wp-staging',
				ABSPATH . 'wp-content/plugins/wp-staging',
				ABSPATH . 'wp-content/plugins/wp-staging-pro',
				ABSPATH . 'wp-content/plugins/wpstg-sqlite-integration',
				ABSPATH . 'wp-content/mu-plugins/0-staging-url.php',
				ABSPATH . 'wp-content/mu-plugins/0-allow-wp-org.php',
				ABSPATH . 'wp-content/mu-plugins/1-pretty-permalinks.php',
				ABSPATH . 'wp-content/mu-plugins/2-deactivate-sqlite-plugin.php',
				ABSPATH . 'wp-content/mu-plugins/sqlite-database-integration-main',
			]
		);
	}
);

Sostituire la collation del database durante il ripristino del Backup con una collation di fallback personalizzata

Questo filtro ti permette di sostituire collation del database mancanti o non supportate durante il processo di ripristino del Backup. Se una collation non è disponibile sul server di destinazione, WP STAGING tenterà di sostituirla con una variante generale (ad es. utf8mb4_general_ci).

Usando questo filtro, puoi definire le tue collation di fallback preferite.

PHP
add_filter('wpstg.database.importer.replace_collation', function ($collationSearchReplace) {
    $collationSearchReplace['utf8mb4_uca1400_ai_ci'] = 'utf8mb4_0900_ai_ci';
    return $collationSearchReplace;
});

Parametri:

  • $collationSearchReplace (array): un array associativo di collation da sostituire dove la chiave è la collation mancante e il valore è la sostituzione.

Esempio:

Se il tuo Backup contiene utf8mb4_uca1400_ai_ci ma il server MySQL di destinazione non lo supporta, puoi sostituirlo con utf8mb4_0900_ai_ci usando l’esempio sopra.

Escludere tabelle dal ripristino del Backup

Puoi escludere tabelle specifiche del database dall’essere ripristinate usando lo snippet di codice qui sotto:

PHP
add_filter('wpstg.backup.restore.exclude.tables', function ($excluded_tables) {
    $excluded_tables[] = 'users';
    $excluded_tables[] = 'usermeta';
    return $excluded_tables;
});


Attivare la modalità prestazioni sicure durante Backup/ripristino

Usa la modalità sicura per evitare errori 503 su server deboli. Influisce sulle prestazioni del Backup. Non usarla se i Backup vengono creati correttamente.

PHP
add_filter('wpstg.job.performance_mode', function ($mode) {
    return 'safe';
});

Filtri Remote Sync

Bypassare l’Apache Basic Authentication

Se il sito di destinazione è dietro a un'”Apache Basic Authentication” lato server, devi usare questo filtro per far funzionare correttamente la funzione Remote Sync. Questo bypasserà la protezione con password lato server:

add_filter('http_request_args', function ($parsed_args, $url) {

    $host = 'https://example.com/';
    $username = 'admin';
    $password = 'password';

    if (strpos($url, $expectedUrl) !== false) {
        $parsed_args['headers']['Authorization'] = 'Basic ' . base64_encode($username . ':' . $password);
    }

    return $parsed_args;
}, 10, 2);

Cambia i valori di $host, $username e $password in base alle impostazioni del tuo server.

Updated on Maggio 23, 2026

Rene Hermenau

Autore: Rene Hermenau

About the author: René Hermenau is the founder of WP STAGING. He works on WordPress backups, staging, migrations, database handling, and safe deployment workflows.