Actions y filters: personalizar WP Staging

Los desarrolladores pueden personalizar WP STAGING usando sus actions y filters disponibles. Este artículo documenta los hooks actuales y muestra ejemplos de uso para adaptar el proceso de Backup, clonado y publicación a tus necesidades.

Plugin WP Staging Hooks

Puedes descargar el Plugin WP STAGING hooks, que contiene muchos de los filters mencionados en este artículo para usarlos fácilmente en tu sitio.

Nota: no todos los filters mencionados en este artículo están incluidos en el repositorio de GitHub.

Si hay un filter mencionado en esta página que no está disponible en el Plugin WP STAGING hooks, puedes copiar el código concreto de esta página en un nuevo mu-plugin o en uno existente, como el mu-plugin de WP STAGING que encuentras en wp-content/plugins/wp-staging-optimizer.php

Consulta este artículo para «Aprende cómo crear un mu-plugin» en tu sitio.

Copia el código completo en la cabecera del mu-plugin y ajústalo a tus necesidades. Si necesitas ayuda con ello, avísanos.

Permitir uso ilimitado de memoria

WP STAGING limita el consumo máximo de memoria a 256M, que normalmente es suficiente para su proceso de clonado y Backup. Durante este proceso, todos los demás Plugins se desactivan, pero esto no afecta a las demás páginas del sitio web.

Un límite de memoria de 256M suele ser suficiente para ejecutar WP STAGING correctamente. No recomendamos un WP_MEMORY_LIMIT o un límite máximo de memoria de PHP superior a 512M, ya que ir más alto puede indicar un problema con uno de los Plugins o con muchos Plugins activos. No es aconsejable superar estos límites porque el límite de memoria está asociado a cada proceso de PHP. Si se permite un consumo de memoria muy alto para cada petición de WordPress, la memoria disponible en la máquina puede agotarse rápidamente y dejar el sitio web no disponible.

Sin embargo, en los casos en los que sea necesario superar el límite de 256M, es posible desactivar el límite de memoria de WP STAGING. Ten en cuenta que esto no se recomienda salvo que haya una razón válida para hacerlo y el servidor tenga suficiente memoria disponible.

Para desactivar el límite de memoria, usa el filter proporcionado para permitir un consumo ilimitado de memoria en WP STAGING. En este caso, el único límite es el límite máximo de memoria de PHP.

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

Cambiar el logo de WP Staging en el formulario de inicio de sesión (versión Pro)

Puedes usar el código de abajo para cambiar el logo del formulario de inicio de sesión del sitio de staging:

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

Aumentar el tiempo de petición de WP STAGING y el tiempo máximo de ejecución de PHP

Normalmente, el Backup y la restauración de WP STAGING funcionan incluso en proveedores de Hosting modestos. Si tienes una base de datos o un sitio web enorme con millones de filas, el límite por defecto de tiempo de ejecución de PHP de 30 segundos puede ser demasiado bajo. Para que la creación o restauración del Backup funcione, fija el valor de PHP  max_execution_time= 120 en tu php.ini.

También aumenta el valor de Apache Timeout 120 o fija la directiva de Nginx fastcgi_read_timeout 120;

Después de hacer eso, añade el filter de abajo en un mu-plugin como mu-plugin/wp-staging-optimizer.php.

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

Asegúrate de que el valor introducido sea inferior al tiempo máximo de ejecución permitido por PHP. Esto es necesario para que el tiempo de petición de WP STAGING nunca supere el tiempo de ejecución de PHP.

Cambiar el título del sitio de staging

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

Cambiar la ruta a la carpeta de caché

Para cambiar la carpeta que se usa para almacenar los archivos temporales del Backup a la carpeta temporal global de PHP o a otra ubicación, puedes usar el código de abajo:

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

Excluir tablas de la operación de búsqueda y reemplazo

Usa esto si el proceso de búsqueda y reemplazo consume mucha de tu memoria disponible y el proceso de clonado o publicación falla con un error de memoria agotada.  También puedes usarlo para mejorar la velocidad del clonado y de la publicación.

Excluye las tablas que no necesiten ninguna búsqueda ni reemplazo de enlaces. Pueden ser tablas con estadísticas de visitantes, direcciones IP o similares. Tras excluir esas tablas, puedes aumentar el límite de búsqueda y reemplazo en la base de datos en los ajustes de WP STAGING para obtener mejor rendimiento.

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

Búsqueda y reemplazo personalizado para valores de base de datos codificados

Usa este filter para realizar operaciones de búsqueda y reemplazo en datos que están codificados en base64 en tu base de datos (a menudo usados por constructores de páginas o configuraciones complejas de Plugin). Esto garantiza que las URLs y otras cadenas se actualicen correctamente incluso cuando se almacenan en formato codificado durante el proceso de clonado, publicación o restauración.

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

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

Puedes usar este filter para reemplazar todo tipo de datos personalizados en la base de datos que WP Staging no puede gestionar automáticamente.

Otro ejemplo: algunos Plugins guardan URLs u otros valores dentro de cadenas JSON codificadas en lugar de texto plano. A common example es JSON que contiene valores de propiedades codificados en base64.

In these cases, WP Staging’s normal search/replace cannot detect the original URL, because it is hidden inside the encoded value.

Para admitir estos casos, WP Staging proporciona el filter:

wpstg.database.searchreplace.replace_extended_data

Este filter permite a los desarrolladores modificar el valor de una columna de base de datos después de que ya se haya ejecutado la búsqueda/reemplazo normal.

Se puede usar durante:

• clonado
• publicación del staging a producción
• restauración de Backups

¿Cuándo debo usar este filter?

Usa este filter cuando un Plugin o Theme almacene datos en un formato como:

• JSON con valores codificados en base64
• estructuras JSON anidadas que contienen cadenas codificadas
• formatos de datos personalizados donde las URLs no se almacenan como texto plano

Sin este filter, las URLs dentro de esos valores codificados permanecerán sin cambios.

Parámetros del filter

El filter recibe tres parámetros:

Idea básica

Tu callback puede:

1. inspeccionar el valor de la base de datos
2. detectar si contiene datos codificados
3. decodificar el valor
4. run str_replace() with the search and replace arrays
5. volver a codificar el valor
6. devolver el resultado modificado

Si el valor no coincide con el formato esperado, simplemente devuélvelo sin cambios.

Ejemplo: búsqueda/reemplazo dentro de valores JSON codificados en base64

El siguiente ejemplo de mu-plugin muestra cómo reemplazar URLs dentro de valores JSON cuyas propiedades están codificadas en base64.

Crea este archivo:

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

Añade este código:

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

Cómo funciona este ejemplo

Este ejemplo hace lo siguiente:

1. Comprueba si el valor de la base de datos tiene apariencia de JSON.
2. Decodifica el JSON.
3. Recorre de forma recursiva todos los arrays y objetos anidados.
4. Intenta decodificar en base64 cada valor de cadena.
5. Ejecuta los valores de búsqueda/reemplazo de WP Staging sobre el contenido decodificado.
6. Si algo ha cambiado, vuelve a codificar en base64 el valor modificado.
7. Devuelve la cadena JSON actualizada.

Datos de ejemplo

Imagina que un Plugin almacena esto en la base de datos:

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

El valor url está codificado en base64. Decodificado, contiene:

https://old-site.com/page

Durante un clonado, publicación o restauración de WP Staging, la búsqueda/reemplazo normal no puede ver esa URL directamente porque está codificada.

Con el filter anterior, WP Staging:

• decodificar el valor
• replace https://old-site.com with https://new-site.com
• volver a codificarlo
• guardar el valor actualizado de nuevo en la base de datos

Resultado

Tras ejecutarse el filter, el valor almacenado pasa a ser la versión codificada en base64 de:

https://new-site.com/page

¿Dónde debo colocar este código?

La opción más segura es colocarlo en un mu-plugin para que se cargue automáticamente en cada solicitud.

Ruta recomendada:

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

Si el directorio mu-plugins aún no existe, créalo manualmente.

Notas importantes

• This filter is meant for custom database formats that are not handled by the default search/replace.
• Your callback should always return the original $data unchanged if it does not match the expected format.
• Mantén la lógica lo más específica posible para evitar cambiar datos no relacionados.
• Prueba esto primero en un sitio de Staging antes de usarlo con datos de producción.

Resumen

Usa wpstg.database.searchreplace.replace_extended_data cuando las URLs u otros valores estén ocultos dentro del contenido de la base de datos codificado.

Esto es especialmente útil para Plugins que almacenan valores en:

• JSON codificado en base64
• objetos JSON anidados
• otros formatos personalizados codificados

Ofrece a los desarrolladores control total sobre cómo se decodifican, reemplazan y guardan esos valores.

Filters de clonado y staging

Ejecutar una action en el sitio de staging después del clonado

El ejemplo de abajo ejecuta una consulta SQL la primera vez que se abre el sitio de staging:

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

Esta consulta solo se ejecutará cuando sea un sitio de staging y solo en el sitio de staging, pero por seguridad extra recomendamos codificar fijo los nombres de las tablas incluido su prefijo de staging concreto como en el ejemplo, para asegurar que esta consulta nunca pueda causar daño en el sitio en vivo si se ejecutara allí por accidente.

Puedes añadir todo tipo de código a esa action y se ejecutará una sola vez al abrir por primera vez el nuevo sitio de staging.

Activar o desactivar Plugins concretos en el sitio de staging después del clonado

Para activar o desactivar algunos Plugins en el sitio de staging tras el clonado, usa el filter wpstg.cloning.update_active_plugins así:

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

Excluir filas de la búsqueda y reemplazo en wp_options

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

Excluir filas del clonado

Este ejemplo excluirá filas de la tabla wp_options según el nombre de la opción o excluirá entradas de la tabla wp_posts según el post_title y el post_status y sus postmeta.

Estos operadores están disponibles:

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

Excluir un custom post type del clonado

Este ejemplo excluirá las entradas del custom post type «coupon» junto con sus datos de postmeta:

Estos operadores están disponibles:

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

Excluir cadenas de la búsqueda y reemplazo

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

Cambiar los parámetros de búsqueda y reemplazo

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

Excluir archivos

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

Excluir archivos del clonado usando la ruta completa

Por defecto, WP STAGING excluye estos archivos al copiar cuando crea un sitio de 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

Puedes cambiar este comportamiento y modificar esta lista de archivos excluidos usando el filter de abajo:

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

Excluir carpetas

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

Multisitio: excluir carpetas (Plugins) del clonado en un multisitio

Si usas una red multisitio, utiliza el filter `wpstg_clone_mu_excl_folders` para excluir carpetas relativas a la carpeta wp-content. Esto es útil si quieres excluir un Plugin.

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

Evitar la búsqueda y reemplazo del prefijo de tabla en una opción de la tabla wp_options

Por defecto, WP STAGING clona todas las tablas y reemplaza los valores que comienzan con el prefijo de tabla de la nueva base de datos. Puedes excluir opciones de esta operación de reemplazo para que no se modifiquen durante el clonado:

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

Clonar multisitios en red y cambiar el hostname de destino

WP STAGING admite multisitios basados en dominio personalizado. Los sitios de la red se crearán automáticamente en el subdominio indicado del sitio principal.

Ejemplo:

Hay una red con sitio principal example.com y un subsitio example.org y otro example.net:

Si clonas toda la red a staging.example.com, los sitios de la red se clonarán a:

• staging.example.org

• staging.example.net
  

Puedes ajustar cada sitio usando el filter de abajo. Es un filter genérico que se puede usar para subsitios basados en subdominio, subdirectorio o incluso en dominio.

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

Preservar el valor «upload_path» en la base de datos

En sitios antiguos de WordPress Network, puede que necesites evitar que se modifique upload_path; usa este filter para conseguirlo:

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

Filters de publicación (push)

Activar o desactivar Plugins concretos en el sitio de producción después de publicar un sitio de staging

Para activar o desactivar algunos Plugins en el sitio en vivo tras publicar un sitio de staging, usa el filter wpstg.pushing.update_active_plugins así:

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

Cambiar los parámetros de búsqueda y reemplazo

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

Excluir tablas de la publicación

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: ¡los nombres de las tablas en el código deben ir sin prefijo!

Este ejemplo excluye las tablas wp_posts y wp_options de ser publicadas al sitio en vivo.

Excluir filas de la publicación. Copiar solo filas concretas

Este ejemplo excluye determinadas filas de la tabla wp_options según el nombre de la opción o excluye entradas de la tabla wp_posts según el post_title y el post_status, junto con sus datos de postmeta.

Estos operadores están disponibles:

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

Atención: el prefijo de tabla debe ser wpstg0_, wpstg1_, wpstg3, etc. según el prefijo real de tablas del sitio de staging, así que debes reemplazar wpstg[int]_ por el prefijo real.

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: excluir estos post types significa que ya no estarán disponibles ni se incluirán en el sitio en vivo tras copiar el sitio de staging al sitio en vivo.

Excluir cierto post type de la publicación

Este ejemplo excluirá las entradas con el custom post type «coupon» junto con sus datos de postmeta:

Estos operadores están disponibles:

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

Atención: el prefijo de tabla debe ser wpstg0_, wpstg1_, wpstg3, etc. según el prefijo real de tablas del sitio de staging, así que debes reemplazar wpstg0_ por el prefijo real.

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

Excluir carpetas de la publicación

Por defecto, WP STAGING PRO no recorre ni publica ninguna de estas carpetas en el sitio de producción:

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

Puedes añadir carpetas personalizadas a esta lista usando el filter de abajo:

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

Excluir archivos de la publicación

Por defecto, WP STAGING PRO no publica ninguno de estos archivos en el sitio de producción:

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

Puedes añadir archivos personalizados a esta lista usando el filter de abajo:

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

Preservar datos en wp_options y excluirlos de la publicación

Preservar datos significa que puedes publicar el sitio de staging al sitio de producción y excluir datos concretos para que no se sobrescriban durante el proceso de publicación.

El ejemplo de abajo preserva los valores de las opciones ‘siteurl’ y ‘home’ de WordPress en la tabla wp_options del sitio en vivo.

Se pueden añadir cualquier número de opciones adicionales.

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

Ejemplo: cómo preservar la clave de licencia de WPML tras la publicación

Puedes usar este código como un archivo mu-plugin:

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

Ejecutar una action después de publicar al sitio de producción.

Puedes usar este hook para llamar a un método en el sitio de producción tras publicar un sitio de staging al sitio en vivo.

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

Filters de Backup

Restaurar un multisitio completo en otro multisitio (migración)

Si creaste un Backup de una red multisitio completa y quieres restaurarlo en otro multisitio existente, por ejemplo, para copiar el multisitio a otro servidor, hay algunas cosas que tener en cuenta, según el tipo de multisitio que uses. Lee este artículo que explica cómo hacerlo en detalle y cómo usar un filter concreto para esa operación.

Restaurar un sitio de una red multisitio a otra red multisitio (migración)

Toma un array de rutas (en el directorio uploads) (archivo o directorio) para excluirlas durante la restauración del Backup en la limpieza. Ejemplo de uso:

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

Por defecto, WP Staging preserva el contenido original (carpeta de idioma, mu-plugins, Plugins, Themes y otros archivos además de los medios) al restaurar un Backup en un subsitio de la red. En lugar de preservar el contenido existente, podemos reemplazarlo usando estos filters:

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

Ampliar la búsqueda y reemplazo para cambiar las URL de todos los subsitios en la base de datos

Por defecto, para acelerar el proceso de restauración del Backup, solo se reemplazan las URL que pertenecen al sitio actual. Si es un multisitio y un sitio contiene URL de otros sitios de la red, puedes usar un filter para reemplazar también esas URL. Ten en cuenta que cuantos más sitios tengas, más tiempo se tarda en reemplazar todas las URL.

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

Excluir una extensión de archivo del Backup

Permite a los usuarios excluir extensiones de archivo concretas para que no se incluyan en el Backup exportado.

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

Excluir del Backup archivos mayores que un tamaño concreto

Por defecto, WP Staging omite del Backup todos los archivos de más de 200MB. Puedes aumentar ese valor usando el filter de abajo:

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

Excluir del Backup archivos con extensiones concretas mayores que un tamaño determinado

Por defecto, WP Staging omite del Backup los archivos zip de más de 50MB. Puedes cambiar esto usando el filter de abajo para cada extensión por separado:

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

Excluir directorios para que no se incluyan en un Backup

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

Excluir archivos de la restauración

Este filter excluye archivos o carpetas completas de la restauración del Backup. Puedes pasar un array de rutas relativas a la raíz de la instalación de WordPress y esos archivos o carpetas no se extraerán del Backup cuando inicies el proceso de restauración.

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

Restaurar Backup y conservar archivos multimedia, Plugins o Themes existentes

Puedes usar los filters de abajo para conservar los archivos existentes:

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

Cambiar el prefijo temporal de tabla de base de datos en la restauración del Backup

Es posible usar un prefijo temporal personalizado para la base de datos durante el proceso de restauración del Backup.

Uso:

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

Este ejemplo reemplazará {WPSTG_TMP_PREFIX} por wpstgt_ en lugar de usar el prefijo temporal por defecto wpstgtmp_. Esto reducirá las probabilidades de errores en la restauración si el nombre de la tabla, incluido el prefijo temporal, supera los 64 caracteres, ya que es el límite de caracteres de MySQL para identificadores en la base de datos.

Si en el ejemplo de arriba ya existe una tabla con el prefijo wpstgt_ durante el proceso de restauración, volverá a usar el prefijo temporal por defecto wpstgtmp_

Activar Backups multipart

WP Staging admite la creación de Backups multipart que puedes usar para limitar el tamaño de cada archivo de Backup. Esta función puede crear varios archivos de Backup para Plugins, Themes, archivos multimedia y la base de datos. Es útil si tienes un sitio muy grande y no es posible crear archivos de Backup de varios gigabytes.

Usa el filter de abajo para activar esta función y especificar el tamaño máximo del archivo de Backup:

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

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

Excluir partes durante el proceso de restauración del Backup

A veces no quieres restaurar todo el Backup; en su lugar, puedes usar este filter para restaurar solo ciertas partes, como Plugins, Themes o la base de datos, y conservar los datos existentes.

Ejemplo

Este código restaurará solo los mu-plugins y excluirá todas las demás partes:

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

Aumentar los chunks de subida de Backup a proveedores en la nube

Esto debería ayudar a reducir las peticiones a Google Drive (por ejemplo), lo que puede servir si la IP de tu servidor ha sido bloqueada por Google. Espera 6 horas antes de reintentar la subida del Backup a Google. Es el tiempo que Google bloquea tu dirección IP.

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

Aumentar el retardo entre peticiones a proveedores en la nube

Usa este filter para aumentar el retardo entre las peticiones que tu servidor hace a Google Drive durante el proceso de Backup. Esto puede ayudar si Google ha bloqueado tu IP. Espera 6 horas antes de reintentar la subida del Backup a Google. Es el tiempo que Google bloquea tu dirección IP.

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

Forzar la subida al almacenamiento remoto FTP mediante la extensión FTP

Por defecto, WP STAGING sube los archivos de Backup vía la extensión curl a FTP, pero puedes cambiar a curl usando este filter:

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

Restaurar un Backup creado en un sitio HTTP a un sitio HTTPS o viceversa

Este filter es necesario cuando necesitas restaurar un Backup de un sitio HTTP en un sitio HTTPS, o al revés.

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

Excluir archivos y directorios del borrado durante la restauración del Backup

Si restauras un Backup y quieres evitar que se borren archivos y carpetas concretas durante la limpieza, puedes usar este filter para bloquear esos archivos:

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

Reemplazar la collation de la base de datos durante la restauración del Backup con una collation alternativa personalizada

Este filter te permite reemplazar collations de base de datos faltantes o no soportadas durante el proceso de restauración del Backup. Si una collation no está disponible en el servidor de destino, WP STAGING intentará sustituirla por una variante general (p. ej., utf8mb4_general_ci).

Usando este filter, puedes definir tus propias collations alternativas preferidas.

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

Parámetros:

• $collationSearchReplace (array): un array asociativo de collations a reemplazar, donde la clave es la collation que falta y el valor es el reemplazo.

Ejemplo:

Si tu Backup contiene utf8mb4_uca1400_ai_ci pero el servidor MySQL de destino no lo admite, puedes reemplazarla por utf8mb4_0900_ai_ci usando el ejemplo de arriba.

Excluir tablas de la restauración del Backup

Puedes excluir tablas concretas de la base de datos para que no se restauren usando el fragmento de código de abajo:

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

Activar el modo seguro de rendimiento durante el Backup/Restauración

Usa el modo seguro para evitar errores 503 en servidores poco potentes. Afecta al rendimiento del Backup. No lo uses si los Backups se crean correctamente.

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

Filters de Remote Sync

Saltarse la autenticación básica de Apache

Si el sitio de destino está detrás de la «Apache Basic Authentication» del servidor, debes usar este filter para que la función Remote Sync funcione correctamente. Esto saltará la protección por contraseña del servidor:

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 los valores de $host, $username y $password por los ajustes de tu servidor.