Actions und Filter – WP Staging anpassen

Entwickler können WP STAGING mit den verfügbaren Actions und Filtern anpassen. Dieser Artikel dokumentiert die aktuellen Hooks und zeigt Beispielverwendungen, um den Backup-, Klon- und Push-Prozess nach deinen Bedürfnissen anzupassen.

WP Staging Hooks Plugin

Du kannst das WP STAGING Hooks Plugin herunterladen, das viele der in diesem Artikel erwähnten Filter für die einfache Nutzung auf deiner Website enthält.

Hinweis: Nicht alle in diesem Artikel erwähnten Filter sind im GitHub-Repository enthalten.

Wenn ein auf dieser Seite erwähnter Filter nicht im WP STAGING Hooks Plugin verfügbar ist, kannst du den jeweiligen Code auf dieser Seite in ein neues mu-plugin oder ein bestehendes kopieren, wie das WP STAGING mu-plugin, das du unter wp-content/plugins/wp-staging-optimizer.php findest.

Lies diesen Artikel, um zu erfahren, wie du ein „mu-plugin erstellen“ kannst.

Kopiere den vollständigen Code in den Kopf des mu-plugins und passe ihn nach deinen Bedürfnissen an. Wenn du Hilfe dabei benötigst, lass es uns einfach wissen.

Unbegrenzten Speicherverbrauch erlauben

WP STAGING begrenzt den maximalen Speicherverbrauch auf 256M, was normalerweise für den Klon- und Backup-Prozess ausreichend ist. Während dieses Prozesses werden alle anderen Plugins deaktiviert, dies hat jedoch keine Auswirkungen auf andere Seiten der Website.

Ein Speicherlimit von 256M ist normalerweise ausreichend, um WP STAGING erfolgreich auszuführen. Wir empfehlen kein höheres WP_MEMORY_LIMIT oder PHP-Max-Speicherlimit über 512M, da ein höherer Wert auf ein Problem mit einem der Plugins oder vielen aktiven Plugins hinweisen kann. Es ist nicht ratsam, diese Grenzen zu überschreiten, da das Speicherlimit mit jedem PHP-Prozess zusammenhängt. Wenn ein hoher erlaubter Speicherverbrauch für jede WordPress-Anfrage festgelegt wird, kann der verfügbare Speicher auf dem Server schnell aufgebraucht werden, wodurch die Website nicht mehr erreichbar ist.

In Fällen, in denen es jedoch notwendig ist, das 256M-Limit zu überschreiten, ist es möglich, das WP STAGING Speicherlimit zu deaktivieren. Bitte beachte, dass dies nur empfohlen wird, wenn ein triftiger Grund vorliegt und der Server über ausreichend Speicher verfügt.

Um das Speicherlimit zu deaktivieren, verwende den bereitgestellten Filter, um unbegrenzten Speicherverbrauch für WP STAGING zu erlauben. Das einzige Limit ist in diesem Fall das PHP-Max-Speicherlimit.

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

WP Staging Logo im Login-Formular ändern (Pro-Version)

Du kannst den folgenden Code verwenden, um das Logo im Login-Formular der Staging-Seite zu ändern:

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

WP STAGING Anfrage-Zeit und PHPs maximale Ausführungszeit erhöhen

Normalerweise funktioniert das WP STAGING Backup und Restore sogar bei kleineren Webhostern. Wenn du eine sehr große Datenbank oder Website mit Millionen von Zeilen hast, kann das PHP-Standard-Ausführungszeitlimit von 30 Sekunden zu niedrig sein. Um die Backup-Erstellung/Wiederherstellung zum Laufen zu bringen, setze den PHP-Wert  max_execution_time= 120 in deiner php.ini.

Erhöhe außerdem den Apache-Wert Timeout 120 oder setze die Nginx-Direktive fastcgi_read_timeout 120;

Füge danach den folgenden Filter in ein mu-plugin wie mu-plugin/wp-staging-optimizer.php ein.

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

Stelle sicher, dass der Eingabewert niedriger als die tatsächlich erlaubte maximale PHP-Ausführungszeit ist. Dies ist notwendig, damit die WP STAGING Anfrage-Zeit die PHP-Ausführungszeit niemals überschreitet.

Staging-Seite Titel ändern

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

Pfad zum Cache-Ordner ändern

Um den Ordner, der zum Speichern temporärer Backup-Dateien verwendet wird, auf den globalen PHP-Temp-Ordner oder einen anderen Ort zu ändern, kannst du den folgenden Code verwenden:

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

Tabellen von der Suchen & Ersetzen-Operation ausschließen

Verwende dies, wenn der Suchen & Ersetzen-Prozess viel deines verfügbaren Speichers verbraucht und der Klon- oder Push-Prozess mit einem Memory-Exhausted-Fehler fehlschlägt.  Du kannst dies auch verwenden, um die Geschwindigkeit des Klon- und Push-Prozesses zu verbessern.

Schließe Tabellen aus, die kein Suchen & Ersetzen von Links benötigen! Dies können Tabellen sein, die Besucherstatistiken, IP-Adressen oder Ähnliches enthalten. Nach dem Ausschließen dieser Tabellen kannst du das DB Suchen & Ersetzen-Limit in den WP STAGING Einstellungen auf einen höheren Wert setzen, um eine bessere Performance zu erzielen.

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

Klonen & Staging Filter

Eine Action auf der Staging-Seite nach dem Klonen ausführen

Das folgende Beispiel führt eine SQL-Abfrage aus, wenn die Staging-Seite zum allerersten Mal geöffnet wird:

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

Diese Abfrage wird nur ausgeführt, wenn es sich um eine Staging-Seite handelt und nur auf der Staging-Seite. Zur zusätzlichen Sicherheit empfehlen wir, die Tabellennamen einschließlich des jeweiligen Staging-Präfixes fest im Code zu verankern, wie im Beispiel gezeigt, um sicherzustellen, dass diese Abfrage niemals Schaden auf der Live-Seite anrichten kann, falls sie versehentlich dort ausgeführt wird.

Du kannst alle Arten von Code zu dieser Action hinzufügen und er wird einmalig beim erstmaligen Öffnen der neuen Staging-Seite ausgeführt.

Bestimmte Plugins auf der Staging-Seite nach dem Klonen aktivieren oder deaktivieren

Um einige Plugins auf der Staging-Seite nach dem Klonen zu aktivieren oder zu deaktivieren, verwende den Filter wpstg.cloning.update_active_plugins wie folgt:

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

Zeilen vom Suchen & Ersetzen in wp_options ausschließen

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

Zeilen vom Klonen ausschließen

Dieses Beispiel schließt Zeilen aus der wp_options-Tabelle basierend auf dem Optionsnamen aus oder schließt Beiträge aus der wp_posts-Tabelle basierend auf post_title und post_status sowie deren Beitrags-Metadaten aus.

Diese Operatoren sind verfügbar:

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

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

Benutzerdefinierten Beitragstyp vom Klonen ausschließen

Dieses Beispiel schließt Beiträge des benutzerdefinierten Beitragstyps „coupon“ zusammen mit den dazugehörigen Postmeta-Daten aus:

Diese Operatoren sind verfügbar:

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

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

Zeichenketten vom Suchen & Ersetzen ausschließen

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

Suchen & Ersetzen-Parameter ändern

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

Dateien ausschließen

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

Dateien vom Klonen mit vollständigem Pfad ausschließen

Standardmäßig schließt WP STAGING diese Dateien beim Kopieren aus, wenn eine Staging-Seite erstellt wird:

• .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

Du kannst dieses Verhalten ändern und die Liste der ausgeschlossenen Dateien mit dem folgenden Filter anpassen:

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

Ordner ausschließen

/**
* 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: Ordner (Plugins) vom Klonen in einer Multisite ausschließen

Wenn du ein Multisite-Netzwerk verwendest, nutze den Filter `wpstg_clone_mu_excl_folders`, um Ordner relativ zum wp-content-Ordner auszuschließen. Dies ist hilfreich, wenn du ein Plugin ausschließen möchtest.

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

Suchen & Ersetzen des Tabellenpräfixes in einer Option der Tabelle wp_options verhindern

Standardmäßig klont WP STAGING alle Tabellen und ersetzt Werte, die mit dem Tabellenpräfix der neuen Datenbank beginnen. Du kannst Optionen von dieser Ersetzungsoperation ausschließen, sodass sie beim Klonen nicht geändert werden:

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

Netzwerk-Multisites klonen und den Ziel-Hostnamen ändern

WP STAGING unterstützt benutzerdefinierte domainbasierte Multisites. Netzwerkseiten werden automatisch in der angegebenen Subdomain der Hauptseite erstellt.

Beispiel:

Es gibt eine Netzwerkseite mit der Hauptseite example.com und einer Netzwerk-Unterseite example.org sowie einer weiteren example.net:

Wenn du das gesamte Netzwerk auf staging.example.com klonst, werden die Netzwerkseiten geklont zu:

• staging.example.org

• staging.example.net
  

Du kannst jede Seite mit dem folgenden Filter anpassen. Es ist ein generischer Filter, der für subdomain-basierte, unterverzeichnis-basierte oder sogar domain-basierte Unterseiten verwendet werden kann.

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

Den „upload_path“-Wert in der Datenbank beibehalten

Bei alten WordPress-Netzwerkseiten musst du möglicherweise den upload_path vor Änderungen schützen. Verwende diesen Filter, um das zu erreichen:

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

Push-Filter

Bestimmte Plugins auf der Live-Seite nach dem Pushen einer Staging-Seite aktivieren oder deaktivieren

Um einige Plugins auf der Live-Seite nach dem Pushen einer Staging-Seite zu aktivieren oder zu deaktivieren, verwende den Filter wpstg.pushing.update_active_plugins wie folgt:

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

Suchen & Ersetzen-Parameter ändern

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

Tabellen vom Pushen ausschließen

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

Hinweis: Die Tabellennamen im Code müssen ohne Tabellenpräfixe angegeben werden!

Dieses Beispiel schließt die Tabellen wp_posts und wp_options vom Pushen auf die Live-Seite aus.

Zeilen vom Pushen ausschließen. Nur bestimmte Zeilen kopieren

Dieses Beispiel schließt bestimmte Zeilen aus der wp_options-Tabelle basierend auf dem Optionsnamen aus oder schließt Beiträge aus der wp_posts-Tabelle basierend auf post_title und post_status zusammen mit den dazugehörigen Postmeta-Daten aus.

Diese Operatoren sind verfügbar:

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

Achtung: Das Tabellenpräfix muss wpstg0_, wpstg1_, wpstg3 usw. lauten, abhängig vom tatsächlichen Tabellenpräfix der Staging-Seite. Du musst wpstg[int]_ durch das tatsächliche Präfix ersetzen.

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

Hinweis: Das Ausschließen dieser Beitragstypen bedeutet, dass sie nicht mehr verfügbar sind und nach dem Kopieren der Staging-Seite auf die Live-Seite nicht mehr enthalten sind.

Bestimmten Beitragstyp vom Pushen ausschließen

Dieses Beispiel schließt Beiträge mit dem benutzerdefinierten Beitragstyp „coupon“ zusammen mit den dazugehörigen Postmeta-Daten aus:

Diese Operatoren sind verfügbar:

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

Achtung: Das Tabellenpräfix muss wpstg0_, wpstg1_, wpstg3 usw. lauten, abhängig vom tatsächlichen Tabellenpräfix der Staging-Seite. Du musst wpstg0_ durch das tatsächliche Präfix ersetzen.

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

Ordner vom Pushen ausschließen

Hinweis: Dieser Filter wird bald implementiert. Er funktioniert noch nicht!

Standardmäßig durchsucht WP STAGING PRO diese Ordner nicht und pusht sie auch nicht auf die Produktionswebsite:

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

Du kannst mit dem folgenden Filter benutzerdefinierte Ordner zu dieser Liste hinzufügen:

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

Dateien vom Pushen ausschließen

Standardmäßig pusht WP STAGING PRO keine dieser Dateien auf die Produktionswebsite:

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

Du kannst mit dem folgenden Filter benutzerdefinierte Dateien zu dieser Liste hinzufügen:

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

Daten in wp_options beibehalten und vom Pushen ausschließen

Daten beibehalten bedeutet, dass du die Staging-Seite auf die Produktionsseite pushen und bestimmte Daten vom Überschreiben während des Push-Prozesses ausschließen kannst.

Das folgende Beispiel behält die Werte für die WordPress-Optionen ’siteurl‘ und ‚home‘ in der wp_options-Tabelle der Live-Seite bei.

Es können beliebig viele zusätzliche Optionen hinzugefügt werden.

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

Beispiel: So behältst du den WPML-Lizenzschlüssel nach dem Pushen bei

Du kannst diesen Code als mu-plugin-Datei verwenden:

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

Eine Action nach dem Pushen der Produktionsseite ausführen.

Du kannst diesen Hook verwenden, um eine Methode auf der Produktionsseite aufzurufen, nachdem eine Staging-Seite live gepusht wurde.

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

Backup-Filter

Eine vollständige Multisite auf einer anderen Multisite wiederherstellen (Migration)

Wenn du ein Backup eines vollständigen Multisite-Netzwerks erstellt hast und das Backup auf einer anderen bestehenden Multisite wiederherstellen möchtest, zum Beispiel um die Multisite auf einen anderen Server zu kopieren, gibt es einige Dinge zu beachten, abhängig von der Art der Multisite, die du betreibst. Bitte lies diesen Artikel, der im Detail erklärt, wie das geht und wie du einen bestimmten Filter für diese Operation verwenden kannst.

Eine Multisite-Netzwerkseite auf einem anderen Multisite-Netzwerk wiederherstellen (Migration)

Nimm ein Array von Pfaden (im Uploads-Verzeichnis) (Datei oder Verzeichnis), die während der Backup-Wiederherstellung vom Bereinigen ausgeschlossen werden sollen. Beispielverwendung:

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

Standardmäßig behält WP Staging den Originalinhalt (Sprachordner, mu-plugins, Plugins, Themes und andere Dateien neben Medien) bei der Wiederherstellung eines Backups auf einer Netzwerk-Unterseite bei. Anstatt vorhandene Inhalte beizubehalten, können wir sie mit diesen Filtern ersetzen:

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

Suchen und Ersetzen erweitern, um URLs aller Unterseiten in der Datenbank zu ändern

Standardmäßig werden zur Beschleunigung des Backup-Wiederherstellungsprozesses nur URLs ersetzt, die zur aktuellen Seite gehören. Bei einer Multisite, die URLs anderer Seiten aus dem Netzwerk enthält, kannst du einen Filter verwenden, um auch diese URLs zu ersetzen. Hinweis: Je mehr Seiten du hast, desto länger dauert es, alle Seiten-URLs zu ersetzen.

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

Eine Dateierweiterung vom Backup ausschließen

Ermöglicht es, bestimmte Dateierweiterungen vom Backup-Export auszuschließen.

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

Dateien größer als eine bestimmte Dateigröße vom Backup ausschließen

Standardmäßig überspringt WP Staging alle Dateien größer als 200MB beim Hinzufügen zu einem Backup. Du kannst diesen Wert mit dem folgenden Filter erhöhen:

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

Dateien mit bestimmten Erweiterungen größer als eine bestimmte Dateigröße vom Backup ausschließen

Standardmäßig überspringt WP Staging ZIP-Dateien, die größer als 50MB sind, beim Hinzufügen zu einem Backup. Du kannst dies mit dem folgenden Filter für jede Erweiterung einzeln ändern:

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

Verzeichnisse vom Backup ausschließen

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

Dateien von der Wiederherstellung ausschließen

Dieser Filter schließt Dateien oder vollständige Ordner von der Backup-Wiederherstellung aus. Du kannst ein Array von Pfaden relativ zum Stammverzeichnis der WordPress-Installation übergeben, und diese Dateien oder Ordner werden dann nicht aus dem Backup extrahiert, wenn du den Backup-Wiederherstellungsprozess startest.

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

Backup wiederherstellen und vorhandene Mediendateien, Plugins oder Themes behalten

Du kannst die folgenden Filter verwenden, um vorhandene Dateien zu behalten:

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

Temporäres Datenbank-Tabellenpräfix bei der Backup-Wiederherstellung ändern

Die Verwendung eines benutzerdefinierten temporären Datenbankpräfixes während des Backup-Wiederherstellungsprozesses ist möglich.

Verwendung:

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

Dieses Beispiel ersetzt {WPSTG_TMP_PREFIX} durch wpstgt_ anstatt das Standard-tmp-Präfix wpstgtmp_ zu verwenden. Dies verringert die Wahrscheinlichkeit von Wiederherstellungsfehlern, wenn der Tabellenname einschließlich des temporären Präfixes 64 Zeichen überschreitet, da dies das MySQL-Zeichenlimit für Bezeichner in der Datenbank ist.

Im obigen Beispiel wird, wenn bereits eine Tabelle mit dem wpstgt_-Präfix in der aktuellen Tabelle während des Wiederherstellungsprozesses vorhanden ist, auf das Standard-tmp-Präfix wpstgtmp_ zurückgegriffen

Mehrteilige Backups aktivieren

WP Staging unterstützt die Erstellung mehrteiliger Backups, mit denen du die Größe jeder Backup-Datei begrenzen kannst. Diese Funktion kann mehrere Backup-Dateien für Plugins, Themes, Mediendateien und die Datenbank erstellen. Dies ist nützlich, wenn du eine sehr große Seite hast und es nicht möglich ist, Backup-Dateien mit mehreren Gigabyte an Daten zu erstellen.

Verwende den folgenden Filter, um diese Funktion zu aktivieren und die maximale Backup-Dateigröße festzulegen:

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

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

Teile während des Backup-Wiederherstellungsprozesses ausschließen

Manchmal möchtest du nicht das gesamte Backup wiederherstellen. Stattdessen kannst du diesen Filter verwenden, um nur bestimmte Teile wie Plugins, Themes oder die Datenbank wiederherzustellen und die vorhandenen Daten zu behalten.

Beispiel

Dieser Code stellt nur die mu-plugins wieder her und schließt alle anderen Teile aus:

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

Cloud-Anbieter Backup-Upload-Chunks erhöhen

Dies sollte helfen, die Anfragen an Google Drive (zum Beispiel) zu reduzieren, was hilfreich sein kann, falls die IP deines Servers von Google blockiert wurde. Warte 6 Stunden, bevor du den Backup-Upload zu Google erneut versuchst. Dies ist die Zeit, für die deine IP-Adresse von Google blockiert wird.

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

Verzögerung zwischen Anfragen an Cloud-Anbieter erhöhen

Verwende diesen Filter, um die Verzögerung zwischen Anfragen von deinem Server an Google Drive während des Backup-Prozesses zu erhöhen. Dies sollte helfen, falls deine IP von Google blockiert wurde. Warte 6 Stunden, bevor du den Backup-Upload zu Google erneut versuchst. Dies ist die Zeit, für die deine IP-Adresse von Google blockiert wird.

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

Upload auf FTP-Remote-Speicher über die FTP-Erweiterung erzwingen

Standardmäßig lädt WP STAGING Backup-Dateien über die curl-Erweiterung auf FTP hoch. Du kannst mit diesem Filter auf die FTP-Erweiterung wechseln:

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

Ein Backup von einer HTTP-Seite auf einer HTTPS-Seite wiederherstellen oder umgekehrt

Dieser Filter ist erforderlich, wenn du ein Backup von einer HTTP-Seite auf einer HTTPS-Seite wiederherstellen musst oder umgekehrt.

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

Dateien und Verzeichnisse vom Löschen während der Backup-Wiederherstellung ausschließen

Wenn du ein Backup wiederherstellst und bestimmte Dateien und Ordner vor dem Bereinigen und Löschen schützen möchtest, kannst du diesen Filter verwenden, um diese Dateien zu sperren:

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

Datenbank-Collation während der Backup-Wiederherstellung durch benutzerdefinierte Fallback-Collation ersetzen

Dieser Filter ermöglicht es dir, fehlende oder nicht unterstützte Datenbank-Collations während des Backup-Wiederherstellungsprozesses zu ersetzen. Wenn eine Collation auf dem Zielserver nicht verfügbar ist, versucht WP STAGING, sie durch eine allgemeine Variante zu ersetzen (z.B. utf8mb4_general_ci).

Mit diesem Filter kannst du deine eigenen bevorzugten Fallback-Collations definieren.

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

Parameter:

• $collationSearchReplace (Array): Ein assoziatives Array von zu ersetzenden Collations, wobei der Schlüssel die fehlende Collation und der Wert der Ersatz ist.

Beispiel:

Wenn dein Backup utf8mb4_uca1400_ai_ci enthält, der Ziel-MySQL-Server diese aber nicht unterstützt, kannst du sie durch utf8mb4_0900_ai_ci ersetzen, wie im obigen Beispiel.

Tabellen von der Backup-Wiederherstellung ausschließen

Du kannst bestimmte Datenbanktabellen mit dem folgenden Code-Snippet von der Wiederherstellung ausschließen:

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

Sicheren Performance-Modus während Backup/Restore aktivieren

Verwende den sicheren Modus, um 503-Fehler auf schwachen Servern zu verhindern. Beeinträchtigt die Backup-Performance. Verwende ihn nicht, wenn Backups korrekt erstellt werden.

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

Remote-Sync-Filter

Apache Basic Authentication umgehen

Wenn die Zielseite hinter einer serverseitigen „Apache Basic Authentication“ liegt, musst du diesen Filter verwenden, damit die Remote-Sync-Funktion ordnungsgemäß funktioniert. Dies umgeht den serverseitigen Passwortschutz:

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

Ändere die Werte für $host, $username und $password auf deine Servereinstellungen.