220 lines
6.9 KiB
Plaintext
220 lines
6.9 KiB
Plaintext
ChatGPT Antwort
|
||
##################################################################################################################
|
||
|
||
### **Breaking Down the WordPress Cron Job Script**
|
||
|
||
This PHP script is a **pseudo-cron daemon** for scheduling and executing WordPress tasks. Normally, WordPress cron jobs are triggered when someone visits the website. However, if a site does not get frequent visits, scheduled tasks might be delayed. This script ensures that WordPress cron jobs run as expected by allowing them to be triggered externally (e.g., via a server's actual cron job).
|
||
|
||
I will break the script into **logical sections**, explain each one, and then describe how they interact.
|
||
|
||
---
|
||
|
||
## **1. Setting Up the Environment**
|
||
|
||
### **Ignoring User Abort**
|
||
```php
|
||
ignore_user_abort( true );
|
||
```
|
||
This line ensures that the script continues to execute even if the user (or browser) disconnects before it completes. This is important for cron jobs that may take longer to execute.
|
||
|
||
### **Preventing Caching**
|
||
```php
|
||
if ( ! headers_sent() ) {
|
||
header( 'Expires: Wed, 11 Jan 1984 05:00:00 GMT' );
|
||
header( 'Cache-Control: no-cache, must-revalidate, max-age=0' );
|
||
}
|
||
```
|
||
These headers prevent browsers and proxy servers from caching the response. Since this is a background task, caching would be unnecessary and could cause unexpected behavior.
|
||
|
||
---
|
||
|
||
## **2. Attempting to Finish Request Early**
|
||
```php
|
||
if ( function_exists( 'fastcgi_finish_request' ) ) {
|
||
fastcgi_finish_request();
|
||
} elseif ( function_exists( 'litespeed_finish_request' ) ) {
|
||
litespeed_finish_request();
|
||
}
|
||
```
|
||
This part tells the web server that it can finish responding to the request while the script continues running in the background. This helps reduce the load time for any user that triggered the cron.
|
||
|
||
---
|
||
|
||
## **3. Checking If the Request Should Be Processed**
|
||
```php
|
||
if ( ! empty( $_POST ) || defined( 'DOING_AJAX' ) || defined( 'DOING_CRON' ) ) {
|
||
die();
|
||
}
|
||
```
|
||
- If the request is coming from an **AJAX request** or **another cron job is already running**, the script stops (`die();`).
|
||
- This prevents multiple cron jobs from running simultaneously and causing conflicts.
|
||
|
||
---
|
||
|
||
## **4. Defining Cron Execution Mode**
|
||
```php
|
||
define( 'DOING_CRON', true );
|
||
```
|
||
This constant tells WordPress that a cron job is currently running.
|
||
|
||
### **Loading WordPress Core**
|
||
```php
|
||
if ( ! defined( 'ABSPATH' ) ) {
|
||
require_once __DIR__ . '/wp-load.php';
|
||
}
|
||
```
|
||
This ensures that the script loads the WordPress environment, which is necessary for executing scheduled tasks.
|
||
|
||
### **Increasing PHP Memory for Cron Jobs**
|
||
```php
|
||
wp_raise_memory_limit( 'cron' );
|
||
```
|
||
- Increases the PHP memory limit so that large cron jobs don’t fail due to memory exhaustion.
|
||
|
||
---
|
||
|
||
## **5. Checking and Acquiring Cron Lock**
|
||
A "cron lock" ensures that only **one** cron process runs at a time. If multiple processes start, they could interfere with each other.
|
||
|
||
### **Fetching the Cron Lock**
|
||
```php
|
||
function _get_cron_lock() {
|
||
global $wpdb;
|
||
|
||
$value = 0;
|
||
if ( wp_using_ext_object_cache() ) {
|
||
$value = wp_cache_get( 'doing_cron', 'transient', true );
|
||
} else {
|
||
$row = $wpdb->get_row( $wpdb->prepare( "SELECT option_value FROM $wpdb->options WHERE option_name = %s LIMIT 1", '_transient_doing_cron' ) );
|
||
if ( is_object( $row ) ) {
|
||
$value = $row->option_value;
|
||
}
|
||
}
|
||
|
||
return $value;
|
||
}
|
||
```
|
||
- This function retrieves the current cron lock stored in the WordPress database.
|
||
- If caching is enabled, it tries to fetch the lock from the cache instead.
|
||
|
||
### **Checking if Cron Tasks Exist**
|
||
```php
|
||
$crons = wp_get_ready_cron_jobs();
|
||
if ( empty( $crons ) ) {
|
||
die();
|
||
}
|
||
```
|
||
- If no scheduled tasks are ready, the script stops.
|
||
|
||
### **Handling the Cron Lock**
|
||
```php
|
||
$gmt_time = microtime( true );
|
||
$doing_cron_transient = get_transient( 'doing_cron' );
|
||
|
||
if ( empty( $doing_wp_cron ) ) {
|
||
if ( empty( $_GET['doing_wp_cron'] ) ) {
|
||
if ( $doing_cron_transient && ( $doing_cron_transient + WP_CRON_LOCK_TIMEOUT > $gmt_time ) ) {
|
||
return;
|
||
}
|
||
$doing_wp_cron = sprintf( '%.22F', microtime( true ) );
|
||
set_transient( 'doing_cron', $doing_wp_cron );
|
||
} else {
|
||
$doing_wp_cron = $_GET['doing_wp_cron'];
|
||
}
|
||
}
|
||
```
|
||
- If another process is already running (`doing_cron` transient exists and is recent), the script stops.
|
||
- Otherwise, it sets a new lock using the current timestamp.
|
||
|
||
---
|
||
|
||
## **6. Executing the Cron Jobs**
|
||
```php
|
||
foreach ( $crons as $timestamp => $cronhooks ) {
|
||
if ( $timestamp > $gmt_time ) {
|
||
break;
|
||
}
|
||
|
||
foreach ( $cronhooks as $hook => $keys ) {
|
||
foreach ( $keys as $k => $v ) {
|
||
```
|
||
- This loops through all scheduled cron jobs and processes only those whose execution time has arrived.
|
||
|
||
### **Rescheduling Recurring Tasks**
|
||
```php
|
||
$schedule = $v['schedule'];
|
||
|
||
if ( $schedule ) {
|
||
$result = wp_reschedule_event( $timestamp, $schedule, $hook, $v['args'], true );
|
||
|
||
if ( is_wp_error( $result ) ) {
|
||
error_log( sprintf(
|
||
__( 'Cron reschedule event error for hook: %1$s, Error code: %2$s, Error message: %3$s, Data: %4$s' ),
|
||
$hook,
|
||
$result->get_error_code(),
|
||
$result->get_error_message(),
|
||
wp_json_encode( $v )
|
||
) );
|
||
do_action( 'cron_reschedule_event_error', $result, $hook, $v );
|
||
}
|
||
}
|
||
```
|
||
- If the cron job is a **recurring** event, it is rescheduled after execution.
|
||
|
||
### **Removing Completed Tasks**
|
||
```php
|
||
$result = wp_unschedule_event( $timestamp, $hook, $v['args'], true );
|
||
|
||
if ( is_wp_error( $result ) ) {
|
||
error_log( sprintf(
|
||
__( 'Cron unschedule event error for hook: %1$s, Error code: %2$s, Error message: %3$s, Data: %4$s' ),
|
||
$hook,
|
||
$result->get_error_code(),
|
||
$result->get_error_message(),
|
||
wp_json_encode( $v )
|
||
) );
|
||
do_action( 'cron_unschedule_event_error', $result, $hook, $v );
|
||
}
|
||
```
|
||
- After running, non-recurring cron jobs are removed from the schedule.
|
||
|
||
### **Executing the Cron Job**
|
||
```php
|
||
do_action_ref_array( $hook, $v['args'] );
|
||
```
|
||
- This runs the function associated with the scheduled hook.
|
||
|
||
### **Checking If Another Process Took Over**
|
||
```php
|
||
if ( _get_cron_lock() !== $doing_wp_cron ) {
|
||
return;
|
||
}
|
||
```
|
||
- If another cron process has taken over, the script stops.
|
||
|
||
---
|
||
|
||
## **7. Cleaning Up**
|
||
```php
|
||
if ( _get_cron_lock() === $doing_wp_cron ) {
|
||
delete_transient( 'doing_cron' );
|
||
}
|
||
die();
|
||
```
|
||
- If this process still holds the cron lock, it removes the lock to allow new cron jobs to run in the future.
|
||
- Finally, the script terminates.
|
||
|
||
---
|
||
|
||
## **How Everything Works Together**
|
||
1. The script sets up a background execution environment.
|
||
2. It checks whether another cron job is already running.
|
||
3. It fetches and locks the cron job list.
|
||
4. It loops through the scheduled cron jobs:
|
||
- If a job is due, it runs it.
|
||
- If it's a recurring job, it reschedules it.
|
||
- If it's a one-time job, it removes it.
|
||
5. It releases the cron lock when finished.
|
||
|
||
This ensures that WordPress cron jobs run efficiently without requiring visitor traffic.
|