Azioni e filtri – Personalizza WP STAGING

By , Founder · Updated

Quando il comportamento predefinito di WP Staging non si adatta al tuo sito — escludere tabelle specifiche, disattivare Plugin sullo Staging, gestire valori del database codificati in base64 — i filtri e le azioni PHP ti permettono di regolare ogni passaggio da un mu-plugin senza modificare il Plugin stesso. Questa pagina è il riferimento completo agli hook di WP Staging, con un esempio pronto da copiare e incollare per ogni filtro disponibile.

Riferimento rapido: i 6 filtri più usati

Filtro / Azione Cosa fa Vai a
wpstg.resources.ignoreMemoryLimit Disattiva il limite di memoria di 256 MB Consentire un uso illimitato della memoria
wpstg.cloning.update_active_plugins Attiva o disattiva Plugin sullo Staging dopo la clonazione Attivare o disattivare Plugin dopo la clonazione
wpstg_clone_excl_folders Esclude directory dal processo di clonazione Escludere cartelle
wpstg.database.searchreplace.replace_extended_data Gestisce valori del database codificati in base64 o con codifica personalizzata Search & Replace personalizzato per valori codificati
wpstg.pushing.update_active_plugins Attiva o disattiva Plugin sulla produzione dopo il push Attivare o disattivare Plugin dopo il push
wpstg_preserved_options Impedisce la sovrascrittura di righe specifiche di wp_options durante il push Preservare dati in wp_options
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

Quick-start: i filtri più usati

Tutti i filtri vanno inseriti in un file mu-plugin in modo che vengano caricati automaticamente a ogni richiesta. WP Staging elabora i mu-plugin prima del proprio codice, quindi gli hook registrati lì si attivano al momento corretto durante il processo di clonazione, push o Backup.

I due filtri più immediati da copiare e incollare subito:

Disattivare il limite di memoria — WP Staging si limita a 256 MB per impostazione predefinita. Rimuovi quel limite:

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

Sovrascrivere il limite del tempo di esecuzione — aumenta il tempo massimo di esecuzione PHP che WP Staging richiede (valore in secondi; mantienilo al di sotto del max_execution_time effettivo del tuo server):

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

Per i restanti filtri comuni — attivazione dei Plugin, esclusioni di cartelle, search-replace di valori codificati, preservazione delle opzioni — consulta le rispettive sezioni dedicate qui sotto. Ogni sezione contiene il blocco di codice completo pronto all’uso.

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)

Per impostazione predefinita, il sito di Staging usa il logo di login standard di WordPress. Sostituirlo con un’immagine personalizzata o con il logo della tua azienda rende l’ambiente di Staging visivamente distinto dalla schermata di login di produzione, aiutando a evitare di lavorare per errore sul sito sbagliato.

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

Per impostazione predefinita, il sito di Staging condivide lo stesso titolo del tuo sito live. Impostare un nome distinto — ad esempio [STAGING] Il mio sito o DEV — rende l’ambiente evidente nella barra di amministrazione di WordPress e nella scheda del browser, riducendo il rischio di pubblicare o modificare contenuti sull’installazione sbagliata.

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

Cambiare il percorso della cartella cache

Per impostazione predefinita, WP Staging scrive i file temporanei di Backup all’interno della tua installazione di WordPress. Spostare la cartella cache — ad esempio in una directory temp di sistema fuori dalla webroot o in un percorso su storage più veloce — può migliorare le prestazioni del Backup su server con I/O lento sulla document root e soddisfa le policy di sicurezza che limitano la scrittura a directory specifiche.

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:

Parametro Tipo Descrizione
$data string Il valore della colonna del database dopo il normale search/replace
$search array Le stringhe da cercare
$replace array Le 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

Usa questa azione per eseguire un’operazione una tantum sul database di Staging la prima volta che il sito di Staging viene aperto — ad esempio, per eliminare dati di test dal sito live, svuotare una tabella di log o inserire righe di configurazione specifiche dello Staging. L’azione si attiva esattamente una volta al caricamento iniziale del sito di Staging.

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

Usa questo filtro quando righe di opzioni specifiche devono mantenere invariati i loro valori del sito di Staging durante la fase di search-and-replace della clonazione — ad esempio, chiavi di licenza, endpoint API o token di autenticazione che puntano a servizi diversi su Staging e produzione. Il filtro accetta un array di valori option_name da saltare.

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:

['=', '&gt;', '&gt;=', '&lt;', '&lt;=', '&lt;&gt;', '!=', '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

Usa questo filtro quando un custom post type sul tuo sito live non deve essere clonato sullo Staging — ad esempio, ordini dello shop, prenotazioni o articoli di abbonamento che ingombrerebbero il database di Staging con dati transazionali di produzione.

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

Sono disponibili questi operatori:

['=', '&gt;', '&gt;=', '&lt;', '&lt;=', '&lt;&gt;', '!=', '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

Usa questo filtro quando determinate stringhe nel tuo database devono restare identiche tra Staging e live — ad esempio, un hostname CDN o un URL di servizio di terze parti che non deve essere sostituito durante la sostituzione degli URL nella clonazione. Aggiungi ogni stringa all’array di esclusione per impedire che venga modificata.

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

Usa questo filtro quando i parametri predefiniti di search-and-replace degli URL non coprono tutte le stringhe che differiscono tra il tuo sito live e quello di Staging — ad esempio, quando devi sostituire un alias di dominio o scambiare valori aggiuntivi non rilevati automaticamente. Ti permette di specificare esattamente le stringhe di ricerca e sostituzione e di controllare i flag di sostituzione PHP.

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

Usa questo filtro per impedire che file specifici vengano copiati dal live allo Staging. Questo è utile per file di configurazione specifici dell’ambiente, file di log di grandi dimensioni o file di licenza che non dovrebbero esistere sul sito di Staging.

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

Usa questo filtro per escludere intere directory dal processo di clonazione. È comunemente usato per saltare directory di Plugin o Theme non necessarie sullo Staging, librerie multimediali di grandi dimensioni o cartelle di artefatti di build. I percorsi sono relativi alla directory wp-content.

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

Usa questo filtro quando il push richiede sostituzioni di URL aggiuntive oltre a quelle che WP Staging rileva automaticamente — ad esempio, un sottodominio CDN, un endpoint API o un dominio alias che differisce tra Staging e produzione.

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

Usa questo filtro per impedire che tabelle del database specifiche vengano trasferite con il push al sito di produzione — ad esempio, una tabella di log personalizzata, una tabella di analytics o qualsiasi tabella di Plugin che gestisce dati esclusivi della produzione indipendentemente dallo Staging.

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:

['=', '&gt;', '&gt;=', '&lt;', '&lt;=', '&lt;&gt;', '!=', '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

Usa questo quando determinati post type sullo Staging non devono mai sovrascrivere i loro equivalenti di produzione — ad esempio, ordini, abbonamenti o altri dati transazionali che sono gestiti in modo indipendente sul sito live.

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

Sono disponibili questi operatori:

['=', '&gt;', '&gt;=', '&lt;', '&lt;=', '&lt;&gt;', '!=', '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.

Questa azione si attiva sul sito di produzione subito dopo il completamento di un push dello Staging. Usala per svuotare le cache di produzione, notificare un servizio di monitoraggio esterno o eseguire migrazioni del database che dipendono dai contenuti appena trasferiti con il push.

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)

Questo filtro ti permette di escludere percorsi specifici della directory uploads dall’essere eliminati durante la fase di pulizia del ripristino quando migri un sottosito di rete su un’altra rete multisite.

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

Usa questo filtro per saltare dal Backup file di tipi specifici — ad esempio, asset compilati, archivi temporanei o file di log che occupano spazio ma non sono necessari per un ripristino.

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

Usa questo filtro per saltare dal Backup intere directory — ad esempio, cartelle contenenti file di log di grandi dimensioni, artefatti di build o dati in cache che non devono essere salvati e che gonfierebbero inutilmente la dimensione del file di 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

Questi filtri impediscono a WP Staging di sovrascrivere o eliminare tipi di file specifici durante il ripristino di un Backup — utile quando vuoi mantenere i tuoi file di Plugin o Theme attuali e ripristinare solo il database o contenuti specifici.

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

La modalità sicura usa un approccio I/O più lento ma più compatibile che funziona su hosting condiviso dove le scritture aggressive di file generano errori 503. Attivala solo se i Backup o i ripristini falliscono senza di essa, poiché riduce le prestazioni su server capaci.

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

I filtri Remote Sync permettono agli sviluppatori di regolare il modo in cui WP STAGING gestisce le richieste tra i siti di origine e di destinazione durante Remote Sync. Questi filtri sono utili per configurazioni con autenticazione a livello di server, regole del firewall, header personalizzati o restrizioni di hosting che possono impedire alla connessione di funzionare correttamente.

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 $allowedHost, $username e $password in base alle impostazioni del tuo server.

Updated on Giugno 3, 2026

Rene Hermenau

Autore: Rene Hermenau

Informazioni sull'autore: René Hermenau è il fondatore di WP STAGING. Si occupa di backup WordPress, staging, migrazioni, gestione dei database e flussi di deployment sicuri.