Actions et filtres – Personnaliser WP Staging

By , Founder · Updated

Les développeurs peuvent personnaliser WP STAGING en utilisant ses actions et filtres disponibles. Cet article documente les hooks actuels et montre des exemples d’utilisation pour personnaliser le processus de Backup, de clonage et de push selon tes besoins.

Pour utiliser les hooks et filtres, nous recommandons d’installer notre Plugin séparé, nommé  WP STAGING Hooks, ou d’utiliser les hooks et filtres de cette page dans un mu-plugin.
Sinon, certaines actions pourraient ne pas fonctionner comme prévu.

La majorité des filtres de cette page nécessite l’un des abonnements WP Staging Pro.

Plugin WP Staging Hooks

Tu peux télécharger le Plugin WP STAGING Hooks qui contient beaucoup des filtres mentionnés dans cet article pour une utilisation facile sur ton site.

Remarque : tous les filtres mentionnés dans cet article ne sont pas inclus dans le dépôt github.

Si un filtre mentionné sur cette page n’est pas disponible dans le Plugin WP STAGING Hooks, tu peux copier le code spécifique de cette page vers un nouveau mu-plugin ou un existant comme le mu-plugin WP STAGING que tu peux trouver dans wp-content/plugins/wp-staging-optimizer.php

Consulte cet article pour « Apprendre à créer un mu-plugin » sur ton site.

Copie le code complet dans l’en-tête du mu-plugin et adapte-le à tes besoins. Si tu as besoin d’aide, dis-le nous.

Contents

Autoriser une utilisation mémoire illimitée

WP STAGING limite la consommation mémoire maximale à 256M, ce qui est généralement suffisant pour son processus de clonage et de Backup. Durant ce processus, tous les autres Plugins sont désactivés, mais cela n’affecte pas les autres pages du site.

Une limite mémoire de 256M est généralement suffisante pour faire fonctionner WP STAGING avec succès. Nous ne recommandons pas un WP_MEMORY_LIMIT ou une limite mémoire PHP max supérieure à 512M, car dépasser cette valeur peut indiquer un problème avec l’un des Plugins ou de nombreux Plugins actifs. Il n’est pas conseillé de dépasser ces limites car la limite mémoire est liée à chaque processus PHP. Si une consommation mémoire autorisée élevée est définie pour chaque requête WordPress, la mémoire disponible sur la machine peut rapidement être saturée, rendant le site indisponible.

Cependant, dans les cas où il est nécessaire de dépasser la limite de 256M, il est possible de désactiver la limite mémoire de WP STAGING. Remarque que cela n’est pas recommandé à moins d’avoir une raison valable de le faire et que le serveur dispose d’une mémoire suffisante.

Pour désactiver la limite mémoire, utilise le filtre fourni pour autoriser une consommation mémoire illimitée pour WP STAGING. La seule limite, dans ce cas, est la limite mémoire PHP max.

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

Modifier le logo WP Staging sur le formulaire de connexion (version Pro)

Tu peux utiliser le code ci-dessous pour modifier le logo du formulaire de connexion du site de staging :

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

Augmenter le temps de requête WP STAGING et le temps d’exécution maximum de PHP

En général, le Backup et la restauration WP STAGING fonctionnent même sur des hébergements mineurs. Si tu as une très grande base de données ou un site avec des millions de lignes, la limite de temps d’exécution PHP par défaut de 30 secondes peut être trop faible. Pour que la création/restauration du Backup fonctionne, définis la valeur PHP max_execution_time= 120 dans ton php.ini.

Augmente également la valeur Apache Timeout 120 ou définis la directive Nginx fastcgi_read_timeout 120;

Après cela, ajoute le filtre ci-dessous dans un mu-plugin comme mu-plugin/wp-staging-optimizer.php.

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

Assure-toi que la valeur d’entrée est inférieure au temps d’exécution maximum PHP autorisé. Cela est nécessaire pour que le temps de requête WP STAGING ne dépasse jamais le temps d’exécution PHP.

Modifier le titre du site de staging

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

Modifier le chemin vers le dossier de cache

Pour modifier le dossier utilisé pour stocker les fichiers de Backup temporaires vers le dossier temp PHP global ou vers un autre endroit, tu peux utiliser le code ci-dessous :

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

Exclure des tables de l’opération de recherche & remplacement

Utilise ceci si le processus de recherche & remplacement consomme beaucoup de ta mémoire disponible et que le processus de clonage ou de push échoue avec une erreur de mémoire épuisée. Tu peux également l’utiliser pour améliorer la vitesse du processus de clonage et de push.

Exclus les tables qui n’ont pas besoin de recherche & remplacement de liens ! Il peut s’agir de tables contenant des statistiques de visiteurs, des adresses IP ou quelque chose de similaire. Après avoir exclus ces tables, tu peux augmenter la limite de Recherche & Remplacement DB dans les réglages WP STAGING à une valeur plus élevée pour de meilleures performances.

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

Recherche & remplacement personnalisé pour les valeurs de base de données encodées

Utilise ce filtre pour effectuer des opérations de recherche et de remplacement sur des données encodées en base64 dans ta base de données (souvent utilisées par les constructeurs de pages ou les réglages de Plugins complexes). Cela garantit que les URLs et autres chaînes sont correctement mises à jour même lorsqu’elles sont stockées dans un format encodé lors du clonage, du push ou du processus de restauration.

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

Tu peux utiliser ce filtre pour remplacer toutes sortes de données personnalisées dans la base de données qui ne pourraient pas être gérées automatiquement par WP Staging.

Autre exemple : certains Plugins enregistrent des URLs ou d’autres valeurs dans des chaînes JSON encodées au lieu de texte brut. Un exemple courant est du JSON contenant des valeurs de propriétés encodées en base64.

Dans ces cas, la recherche/remplacement normale de WP Staging ne peut pas détecter l’URL d’origine car elle est cachée dans la valeur encodée.

Pour prendre en charge ces cas, WP Staging fournit le filtre :

wpstg.database.searchreplace.replace_extended_data

Ce filtre permet aux développeurs de modifier une valeur de colonne de base de données après que la recherche/remplacement normale a déjà été effectuée.

Il peut être utilisé lors :

  • du clonage
  • du push du staging vers la production
  • de la restauration de Backups

Quand utiliser ce filtre ?

Utilise ce filtre quand un Plugin ou un Theme stocke des données dans un format comme :

  • JSON avec des valeurs encodées en base64
  • structures JSON imbriquées contenant des chaînes encodées
  • formats de données personnalisés où les URLs ne sont pas stockées en texte brut

Sans ce filtre, les URLs à l’intérieur de ces valeurs encodées resteront inchangées.

Paramètres du filtre

Le filtre reçoit trois paramètres :

ParamètreTypeDescription
$datastringLa valeur de colonne de base de données après la recherche/remplacement normale
$searcharrayLes chaînes de recherche
$replacearrayLes chaînes de remplacement

Idée de base

Ton callback peut :

  1. inspecter la valeur de la base de données
  2. détecter si elle contient des données encodées
  3. décoder la valeur
  4. exécuter str_replace() avec les tableaux de recherche et de remplacement
  5. ré-encoder la valeur
  6. retourner le résultat modifié

Si la valeur ne correspond pas au format attendu, retourne-la simplement inchangée.

Exemple : recherche/remplacement dans des valeurs JSON encodées en base64

L’exemple de mu-plugin suivant montre comment remplacer des URLs dans des valeurs JSON dont les propriétés sont encodées en base64.

Crée ce fichier :

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

Ajoute ce code :

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

Comment fonctionne cet exemple

Cet exemple fait ce qui suit :

  1. Il vérifie si la valeur de la base de données ressemble à du JSON.
  2. Il décode le JSON.
  3. Il parcourt récursivement tous les tableaux et objets imbriqués.
  4. Il essaie de décoder en base64 chaque valeur de chaîne.
  5. Il exécute les valeurs de recherche/remplacement WP Staging sur le contenu décodé.
  6. Si quelque chose a changé, il ré-encode la valeur modifiée en base64.
  7. Il retourne la chaîne JSON mise à jour.

Données d’exemple

Imagine qu’un Plugin stocke ceci dans la base de données :

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

La valeur url est encodée en base64. Décodée, elle contient :

https://old-site.com/page

Lors d’un clone, push ou restauration WP Staging, la recherche/remplacement normale ne peut pas voir cette URL directement car elle est encodée.

Avec le filtre ci-dessus, WP Staging va :

  • décoder la valeur
  • remplacer https://old-site.com par https://new-site.com
  • l’encoder à nouveau
  • enregistrer la valeur mise à jour dans la base de données

Résultat

Après l’exécution du filtre, la valeur stockée devient la version encodée en base64 de :

https://new-site.com/page

Où placer ce code ?

L’option la plus sûre est de le placer dans un mu-plugin afin qu’il se charge automatiquement à chaque requête.

Chemin recommandé :

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

Si le répertoire mu-plugins n’existe pas encore, crée-le manuellement.

Remarques importantes

  • Ce filtre est destiné aux formats de base de données personnalisés qui ne sont pas gérés par la recherche/remplacement par défaut.
  • Ton callback doit toujours retourner le $data original inchangé s’il ne correspond pas au format attendu.
  • Garde la logique aussi spécifique que possible pour éviter de modifier des données sans rapport.
  • Teste cela sur un site de staging d’abord avant de l’utiliser sur des données de production.

Résumé

Utilise wpstg.database.searchreplace.replace_extended_data quand des URLs ou d’autres valeurs sont cachées dans du contenu de base de données encodé.

C’est particulièrement utile pour les Plugins qui stockent des valeurs dans :

  • du JSON encodé en base64
  • des objets JSON imbriqués
  • d’autres formats encodés personnalisés

Il donne aux développeurs un contrôle total sur la façon dont ces valeurs sont décodées, remplacées et enregistrées à nouveau.

Filtres de clonage & staging

Exécuter une action sur le site de staging après le clonage

L’exemple ci-dessous exécutera une requête SQL lors de la toute première ouverture du site de staging :

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

Cette requête ne sera exécutée que sur un site de staging et uniquement sur le site de staging, mais par mesure de sécurité supplémentaire, nous recommandons de coder en dur les noms de tables incluant leur préfixe de staging particulier comme dans l’exemple pour s’assurer que cette requête ne peut jamais nuire au site en production au cas où elle serait exécutée accidentellement.

Tu peux ajouter toutes sortes de code à cette action et il sera exécuté une fois lors de l’ouverture initiale du nouveau site de staging.

Activer ou désactiver des Plugins spécifiques sur le site de staging après le clonage

Pour activer ou désactiver certains Plugins sur le site de staging après le clonage, utilise le filtre wpstg.cloning.update_active_plugins comme ceci :

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

Exclure des lignes de la recherche & remplacement dans 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');

Exclure des lignes du clonage

Cet exemple exclura les lignes de la table wp_options en fonction du nom de l’option ou exclura les articles de la table wp_posts en fonction du post_title et du post_status et de leurs métadonnées d’article.

Ces opérateurs sont disponibles :

['=', '>', '>=', '<', '<=', '<>', '!=', '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');

Exclure un type de contenu personnalisé du clonage

Cet exemple exclura les articles sous le type de contenu personnalisé « coupon » ainsi que ses données postmeta :

Ces opérateurs sont disponibles :

['=', '>', '>=', '<', '<=', '<>', '!=', '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');

Exclure des chaînes de la recherche & remplacement

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

Modifier les paramètres de recherche & remplacement

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

Exclure des fichiers

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

Exclure des fichiers du clonage en utilisant le chemin complet

Par défaut, WP STAGING exclut ces fichiers de la copie lors de la création d’un site de staging :

  • .htaccess
  • Chemin/absolu/vers/répertoire/WordPress/wp-content/db.php
  • Chemin/absolu/vers/répertoire/WordPress/wp-content/object-cache.php
  • Chemin/absolu/vers/répertoire/WordPress/wp-content/advanced-cache.php

Tu peux modifier ce comportement et cette liste de fichiers exclus en utilisant le filtre ci-dessous :

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

Exclure des dossiers

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 : exclure des dossiers (Plugins) du clonage dans un multisite

Si tu utilises un réseau multisite, utilise le filtre `wpstg_clone_mu_excl_folders` pour exclure des dossiers relatifs au dossier wp-content. C’est utile si tu veux exclure 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');

Empêcher la recherche & remplacement du préfixe de table dans une option de la table wp_options

Par défaut, WP STAGING clone toutes les tables et remplace les valeurs qui commencent par le préfixe de table de la nouvelle base de données. Tu peux exclure des options de cette opération de remplacement afin qu’elles ne soient pas modifiées lors du clonage :

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

Cloner des multisites réseau et modifier le nom d’hôte de destination

WP STAGING prend en charge les multisites basés sur un domaine personnalisé. Les sites réseau seront automatiquement créés dans le sous-domaine spécifié du site principal.

Exemple :

Il y a un site réseau avec le site principal example.com, un sous-site réseau example.org et un autre example.net :

Si tu clones l’ensemble du réseau vers staging.example.com, les sites réseau seront clonés vers :

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

Tu peux ajuster chaque site en utilisant le filtre ci-dessous. C’est un filtre générique qui peut être utilisé pour des sous-sites basés sur des sous-domaines, des sous-répertoires ou même des domaines.

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

Conserver la valeur « upload_path » dans la base de données

Dans les anciens sites WordPress Network, tu pourras avoir besoin de conserver l’upload_path pour qu’il ne soit pas modifié, utilise ce filtre pour y parvenir :

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

Filtres de push

Activer ou désactiver des Plugins spécifiques sur le site de production après le push d’un site de staging

Pour activer ou désactiver certains Plugins sur le site en production après le push d’un site de staging, utilise le filtre wpstg.pushing.update_active_plugins comme ceci :

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

Modifier les paramètres de recherche & remplacement

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

Exclure des tables du 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');

Remarque : les noms de tables dans le code doivent être sans préfixes de table !

Cet exemple exclut les tables wp_posts et wp_options d’être poussées vers le site en production.

Exclure des lignes du push. Copier uniquement des lignes spécifiques

Cet exemple exclura certaines lignes de la table wp_options en fonction du nom de l’option ou exclura les articles de la table wp_posts en fonction du post_title et du post_status ainsi que leurs données postmeta.

Ces opérateurs sont disponibles :

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

Attention : Le préfixe de table doit être wpstg0_, wpstg1_, wpstg3, etc. selon le préfixe de table réel du site de staging, donc tu dois remplacer wpstg[int]_ par le préfixe réel.

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

Remarque : exclure ces types de contenu signifie qu’ils ne seront plus disponibles ni inclus dans le site en production après la copie du site de staging vers la production.

Exclure un type de contenu spécifique du push

Cet exemple exclura les articles avec le type de contenu personnalisé « coupon » ainsi que ses données postmeta :

Ces opérateurs sont disponibles :

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

Attention : Le préfixe de table doit être wpstg0_, wpstg1_, wpstg3, etc. selon le préfixe de table réel du site de staging, donc tu dois remplacer wpstg0_ par le préfixe réel.

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

Exclure des dossiers du push

Par défaut, WP STAGING PRO n’itère pas ni ne pousse aucun de ces dossiers vers le site de production :

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

Tu peux ajouter des dossiers personnalisés à cette liste en utilisant le filtre ci-dessous :

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

Exclure des fichiers du push

Par défaut, WP STAGING PRO ne pousse aucun de ces fichiers vers le site de production :

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

Tu peux ajouter des fichiers personnalisés à cette liste en utilisant le filtre ci-dessous :

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

Conserver les données dans wp_options et les exclure du push

Conserver les données signifie que tu peux pousser le site de staging vers le site de production et exclure des données spécifiques d’être écrasées lors du processus de push.

L’exemple ci-dessous conserve les valeurs des options WordPress ‘siteurl’ et ‘home’ dans la table wp_options du site en production.

N’importe quel nombre d’options supplémentaires peut être ajouté.

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

Exemple : comment conserver la clé de licence WPML après le push

Tu peux utiliser ce code comme fichier 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');

Exécuter une action après le push du site de production.

Tu peux utiliser ce hook pour appeler une méthode sur le site de production après le push d’un site de staging vers la production.

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

Filtres de Backup

Restaurer un multisite complet sur un autre multisite (migration)

Si tu as créé un Backup depuis un réseau multisite complet et que tu veux restaurer le Backup sur un autre multisite existant, par exemple pour copier le multisite vers un autre serveur, il y a quelques points à considérer selon le type de multisite que tu opères. Lis cet article qui explique en détail comment faire cela et comment utiliser un filtre spécifique pour cette opération.

Restaurer un site réseau multisite vers un autre réseau multisite (migration)

Prend un tableau de chemins (dans le répertoire uploads) (fichier ou dossier) à exclure lors du nettoyage pendant la restauration du Backup. Exemple d’utilisation :

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

Par défaut, WP Staging conserve le contenu original (dossier de langue, mu-plugins, Plugins, Themes et autres fichiers à côté des médias) lors de la restauration d’un Backup sur un sous-site réseau. Au lieu de conserver le contenu existant, nous pouvons les remplacer en utilisant ces filtres :

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

Étendre la recherche et le remplacement pour modifier les URLs de tous les sous-sites dans la base de données

Par défaut, pour accélérer le processus de restauration du Backup, seules les URLs appartenant au site actuel seront remplacées. S’il s’agit d’un multisite et qu’un site contient des URLs d’autres sites du réseau, tu peux utiliser un filtre pour remplacer ces URLs également. Note que plus tu as de sites, plus cela prendra du temps pour remplacer toutes les URLs des sites.

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

Exclure une extension de fichier du Backup

Permettre aux utilisateurs d’exclure des extensions de fichiers spécifiques de l’exportation du 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');

Exclure les fichiers plus grands qu’une taille spécifique du Backup

Par défaut, WP Staging ignore tous les fichiers de plus de 200 Mo lors de l’ajout à un Backup. Tu peux augmenter cette valeur en utilisant le filtre ci-dessous :

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

Exclure les fichiers avec des extensions particulières plus grands qu’une taille spécifique du Backup

Par défaut, WP Staging ignore les fichiers zip de plus de 50 Mo lors de l’ajout à un Backup. Tu peux modifier cela en utilisant le filtre ci-dessous pour chaque extension individuellement :

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

Exclure des répertoires d’être inclus dans 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');

Exclure des fichiers d’être restaurés

Ce filtre exclut des fichiers ou des dossiers complets de la restauration du Backup. Tu peux passer un tableau de chemins relatifs à la racine de l’installation WordPress et ces fichiers ou dossiers ne seront alors pas extraits du Backup lors du démarrage du processus de restauration.

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

Restaurer le Backup et conserver les fichiers médias, Plugins ou Themes existants

Tu peux utiliser les filtres ci-dessous pour conserver les fichiers existants :

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

Modifier le préfixe temporaire de table de base de données pour la restauration du Backup

Il est possible d’utiliser un préfixe de base de données temporaire personnalisé lors du processus de restauration du Backup.

Utilisation :

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

Cet exemple remplacera {WPSTG_TMP_PREFIX} par wpstgt_ au lieu d’utiliser le préfixe tmp par défaut wpstgtmp_. Cela réduira les risques d’erreurs de restauration si le nom de la table, incluant le préfixe temporaire, dépasse 64 caractères, car c’est la limite de caractères MySQL pour les identifiants dans la base de données.

D’après l’exemple ci-dessus, s’il existe déjà une table avec le préfixe wpstgt_ dans la table actuelle lors du processus de restauration, il reviendra à l’utilisation du préfixe tmp par défaut wpstgtmp_

Activer les Backups multipartites

WP Staging prend en charge la création de Backups multipartites que tu peux utiliser pour limiter la taille de chaque fichier de Backup. Cette fonctionnalité peut créer plusieurs fichiers de Backup pour les Plugins, Themes, fichiers médias et la base de données. C’est utile si tu as un très grand site et s’il n’est pas possible de créer des fichiers de Backup de plusieurs gigaoctets de données.

Utilise le filtre ci-dessous pour activer cette fonctionnalité et spécifier la taille maximale du fichier de Backup :

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

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

Exclure des parties lors du processus de restauration du Backup

Parfois tu ne veux pas restaurer l’intégralité du Backup, tu peux utiliser ce filtre pour ne restaurer que certaines parties comme les Plugins, Themes, base de données et conserver les données existantes.

Exemple

Ce code restaurera uniquement les mu-plugins et exclura toutes les autres parties :

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

Augmenter les chunks d’upload de Backup des fournisseurs cloud

Cela devrait aider à réduire les requêtes vers Google Drive (par exemple) ce qui pourrait aider si l’IP de ton serveur a été bloquée par Google. Attends 6 heures avant de réessayer d’uploader le Backup vers Google. C’est le temps pendant lequel ton adresse IP sera bloquée par 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.
});

Augmenter le délai entre les requêtes des fournisseurs cloud

Utilise ce filtre pour augmenter le délai entre les requêtes faites depuis ton serveur vers Google Drive lors du processus de Backup. Cela devrait aider si ton IP a été bloquée par Google. Attends 6 heures avant de réessayer d’uploader le Backup vers Google. C’est le temps pendant lequel ton adresse IP sera bloquée par Google.

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

Forcer l’upload vers le stockage FTP distant via l’extension FTP

Par défaut, WP STAGING uploade les fichiers de Backup via l’extension curl vers FTP, mais tu peux passer à curl en utilisant ce filtre :

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

Restaurer un Backup créé sur un site HTTP vers un site HTTPS ou vice versa

Ce filtre est requis quand tu dois restaurer un Backup d’un site HTTP vers un site HTTPS, ou inversement.

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

Exclure des fichiers et répertoires de la suppression lors de la restauration du Backup

Si tu restaures un Backup et que tu veux conserver des fichiers et dossiers spécifiques d’être nettoyés et supprimés, tu peux utiliser ce filtre pour verrouiller ces fichiers :

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',
			]
		);
	}
);

Remplacer la collation de base de données lors de la restauration du Backup avec une collation de secours personnalisée

Ce filtre te permet de remplacer les collations de base de données manquantes ou non prises en charge lors du processus de restauration du Backup. Si une collation n’est pas disponible sur le serveur cible, WP STAGING tentera de la substituer par une variante générale (ex. utf8mb4_general_ci).

En utilisant ce filtre, tu peux définir tes propres collations de secours préférées.

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

Paramètres :

  • $collationSearchReplace (array) : un tableau associatif de collations à remplacer où la clé est la collation manquante et la valeur est le remplacement.

Exemple :

Si ton Backup contient utf8mb4_uca1400_ai_ci mais que le serveur MySQL cible ne le prend pas en charge, tu peux le remplacer par utf8mb4_0900_ai_ci en utilisant l’exemple ci-dessus.

Exclure des tables de la restauration du Backup

Tu peux exclure des tables de base de données spécifiques d’être restaurées en utilisant le code ci-dessous :

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


Activer le mode de performance sécurisé lors du Backup/Restauration

Utilise le mode sécurisé pour éviter les erreurs 503 sur les serveurs faibles. Affecte les performances du Backup. Ne l’utilise pas si les Backups sont créés correctement.

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

Filtres de synchronisation distante

Contourner l’authentification de base Apache

Si le site de destination est protégé par une « Authentification de base Apache » côté serveur, tu dois utiliser ce filtre pour que la fonctionnalité de synchronisation distante fonctionne correctement. Cela contournera la protection par mot de passe côté serveur :

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

Modifie les valeurs pour $host, $username et $password selon les réglages de ton serveur.

Updated on mai 23, 2026

Rene Hermenau

Auteur : 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.