Changeset 3770239

Timestamp:

10/28/2026 08:48:12 AM (66 minutes ago)

Author:

andrewjbaker

Message:

Update trunk and assets to v3.2.860

Location:

cloudscale-backup-restore/trunk

Files:

• CHANGELOG.md (modified) (1 diff)
• cloudscale-backup.php (modified) (4 diffs)
• includes/class-cloudscale-licence.php (modified) (2 diffs)
• includes/class-cloudscale-telegram.php (modified) (4 diffs)
• includes/class-csbr-aws.php (modified) (2 diffs)
• includes/class-csbr-cli.php (modified) (1 diff)
• readme.txt (modified) (5 diffs)

cloudscale-backup-restore/trunk/CHANGELOG.md

@@ -1 +1 @@
 # Changelog
+
+## [3.2.860] - 2026-10-28
+
+### Changed
+- **Cloud copies download in parallel when that is faster.** A copy from S3 or CloudScale Managed (restore,
+  standby refresh, `wp csbr cloud-pull`) fetched one 128 MB range at a time, so a distant
+  region was limited by the round trip, not the link, the same reason uploads went
+  parallel in 3.2.834. After the first range, which says how big the backup is, each
+  pass fetches up to four ranges at once with `Requests::request_multiple()`, streamed to
+  disk. A pass never covers more than one old range, so it fits the same timeout and hop
+  budget on a slow link. Each range must answer 206 with a Content-Range at the offset
+  asked for and the exact size on disk; anything else is fetched again through the
+  one-at-a-time path, and ranges are appended strictly in order, so an interrupted copy
+  resumes as before. Behind a WP_Http proxy it stays one at a time.
+  The first wave is timed against the first sequential range and the rest of the hop
+  keeps whichever was faster: on 2026-10-28 a 3.55 GB Managed copy from Cape Town to the
+  QA Pi on Wi-Fi took 524 s one range at a time and 695 s four at a time, byte-identical
+  (`tools/benchmark-cloud-pull.sh`). Parallel pays where the round trip limits each
+  connection, a distant region; where the link is full it only adds contention.
+  `tests/s3-download-wave-test.php` (24 checks, wired into the build).
+- **`wp csbr cloud-pull` resumes.** It used `s3_get()`, one streamed request that
+  truncated on retry; it now uses the same resumable copy, keeping a shorter local file
+  and discarding one that cannot be a prefix of the backup.
 
 ## [3.2.858] - 2026-10-19

cloudscale-backup-restore/trunk/cloudscale-backup.php

@@ -4 +4 @@
  * Plugin URI:        https://cloudscale.consulting
  * Description:       No-nonsense WordPress backup and restore. Backs up database, media, plugins and themes into a single zip. Scheduled or manual, with safe restore and maintenance mode.
- * Version:     3.2.858
+ * Version:     3.2.860
  * Author:            CloudScale
  * Author URI:        https://cloudscale.consulting
@@ -121 +121 @@
 // wporg-risk-accepted-begin: PLUGINCHECK_SNIFF_47, WordPress.WP.I18n.TextDomainMismatch -- this plugin's WordPress.org slug is cloudscale-backup-restore and its Text Domain header says the same; existing installs keep the older folder name cloudscale-backup, which is what a folder-based check compares against
 
-define('CSBR_VERSION',    '3.2.858');
+define('CSBR_VERSION',    '3.2.860');
 define('CSBR_AMI_POLL_MAX_AGE', 5 * 600);              // Stop polling after 5 attempts (50 minutes)
 define('CSBR_AMI_POLL_INTERVAL', 600);                 // Re-poll every 10 minutes
@@ -10331 +10331 @@
 function csbr_s3_fetch_resumable( CSBR_AWS $client, string $bucket, string $key, string $dest, int $deadline = 0 ): array {
     $chunk = defined( 'CSBR_PULL_CHUNK_BYTES' ) ? (int) CSBR_PULL_CHUNK_BYTES : ( 128 * 1024 * 1024 );
+    $lanes = defined( 'CSBR_PULL_LANES' ) ? max( 1, (int) CSBR_PULL_LANES ) : 4;
     $have  = file_exists( $dest ) ? (int) filesize( $dest ) : 0;
     $start = $have;
     $total = 0;
     $guard = 0;
+
+    // Bytes per second of the last full sequential range, and whether the first wave
+    // has been timed against it yet. See "KEEP WHICHEVER IS FASTER" below.
+    $seq_rate    = 0.0;
+    $wave_judged = false;
+
+    // Moves one finished range file onto the end of $dest and deletes it.
+    $append = static function ( string $part ) use ( $dest ): bool {
+        // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen -- appending the plugin's own partial download; WP_Filesystem has no append mode
+        $out = fopen( $dest, 'ab' );
+        // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen -- reading back the range just written
+        $in  = fopen( $part, 'rb' );
+        if ( false === $out || false === $in ) {
+            if ( is_resource( $out ) ) { fclose( $out ); } // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- paired with the fopen above
+            if ( is_resource( $in ) ) { fclose( $in ); } // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- paired with the fopen above
+            wp_delete_file( $part );
+            return false;
+        }
+        stream_copy_to_stream( $in, $out );
+        fclose( $in );  // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- paired with the fopen above
+        fclose( $out ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- paired with the fopen above
+        wp_delete_file( $part );
+        return true;
+    };
 
     while ( true ) {
@@ -10344 +10369 @@
         }
 
-        $part = $dest . '.range';
-        $r    = $client->s3_get_range( $bucket, $key, $part, $have, $chunk );
-        if ( empty( $r['ok'] ) ) {
-            if ( file_exists( $part ) ) {
+        /*
+         * PARALLEL ONCE THE SIZE IS KNOWN.
+         *
+         * The first range is fetched alone, because its Content-Range is what says
+         * how big the object is. After that each pass fetches up to $lanes ranges at
+         * once, covering no more than one $chunk between them, so a pass is never
+         * longer than a sequential range was and the time budget below still holds.
+         * Ranges are appended strictly in order, so $dest only ever holds a correct
+         * prefix of the object and an interrupted copy resumes exactly as before.
+         */
+        $wave = ( $total > 0 && $lanes > 1 ) ? CSBR_AWS::download_wave( $have, $total, $chunk, $lanes ) : array();
+        if ( count( $wave ) > 1 ) {
+            $jobs = array();
+            foreach ( $wave as $i => $range ) {
+                $jobs[ $i ] = array( $range[0], $range[1], $dest . '.range' . $i );
+            }
+            $wave_from = $have;
+            $wave_t0   = microtime( true );
+            $landed    = $client->s3_get_ranges( $bucket, $key, $jobs );
+
+            foreach ( $jobs as $i => $job ) {
+                list( $offset, $length, $part ) = $job;
+                if ( empty( $landed[ $i ] ) ) {
+                    // A range the wave missed goes through the one-at-a-time path.
+                    $r = $client->s3_get_range( $bucket, $key, $part, $offset, $length );
+                    if ( empty( $r['ok'] ) || (int) ( $r['written'] ?? 0 ) !== $length ) {
+                        foreach ( $jobs as $left ) {
+                            if ( file_exists( $left[2] ) ) {
+                                wp_delete_file( $left[2] );
+                            }
+                        }
+                        $error = empty( $r['ok'] ) ? (string) ( $r['error'] ?? 'Ranged download failed.' ) : sprintf( 'S3 sent %d bytes for a %d-byte range.', (int) ( $r['written'] ?? 0 ), $length );
+                        return array( 'ok' => false, 'error' => $error, 'resumed_from' => $start );
+                    }
+                }
+                if ( ! $append( $part ) ) {
+                    foreach ( $jobs as $left ) {
+                        if ( file_exists( $left[2] ) ) {
+                            wp_delete_file( $left[2] );
+                        }
+                    }
+                    return array( 'ok' => false, 'error' => 'Could not append the downloaded range to ' . basename( $dest ) . '.' );
+                }
+                $have += $length;
+            }
+
+            if ( $have >= $total ) {
+                break;
+            }
+
+            /*
+             * KEEP WHICHEVER IS FASTER.
+             *
+             * Parallel ranges win when each connection is held back by the round
+             * trip, a distant region. When the link itself is the limit they only
+             * compete for it: measured on 2026-10-28, a 3.55 GB copy from Cape Town
+             * to a Pi on Wi-Fi took 524 s one range at a time and 695 s four at a
+             * time, the same bytes both ways. So the first wave is timed against the first range, and
+             * unless it is clearly faster the rest of this hop goes one at a time.
+             * One wave is the most this can cost; the next hop measures again.
+             */
+            if ( ! $wave_judged && $seq_rate > 0 ) {
+                $wave_judged = true;
+                $wave_rate   = ( $have - $wave_from ) / max( 0.001, microtime( true ) - $wave_t0 );
+                if ( $wave_rate < $seq_rate * 1.15 ) {
+                    $lanes = 1;
+                }
+                csbr_log( sprintf(
+                    '[CloudScale Backup & Restore] Cloud copy: %.1f MB/s one range at a time, %.1f MB/s in parallel, continuing %s.',
+                    $seq_rate / 1048576,
+                    $wave_rate / 1048576,
+                    1 === $lanes ? 'one range at a time' : 'in parallel'
+                ) );
+            }
+        } else {
+            $part   = $dest . '.range';
+            $seq_t0 = microtime( true );
+            $r      = $client->s3_get_range( $bucket, $key, $part, $have, $chunk );
+            if ( empty( $r['ok'] ) ) {
+                if ( file_exists( $part ) ) {
+                    wp_delete_file( $part );
+                }
+                // $dest is deliberately LEFT in place. It holds real bytes, and deleting
+                // them is what made every retry start from zero.
+                return array( 'ok' => false, 'error' => (string) ( $r['error'] ?? 'Ranged download failed.' ), 'resumed_from' => $start );
+            }
+
+            if ( 0 === $total && ! empty( $r['total'] ) ) {
+                $total = (int) $r['total'];
+            }
+
+            $written = (int) ( $r['written'] ?? 0 );
+            if ( $written > 0 ) {
+                if ( ! $append( $part ) ) {
+                    return array( 'ok' => false, 'error' => 'Could not append the downloaded range to ' . basename( $dest ) . '.' );
+                }
+                $have += $written;
+                // Timed to the same point as a wave, append included.
+                if ( $written === $chunk ) {
+                    $seq_rate = $chunk / max( 0.001, microtime( true ) - $seq_t0 );
+                }
+            } else {
                 wp_delete_file( $part );
             }
-            // $dest is deliberately LEFT in place. It holds real bytes, and deleting
-            // them is what made every retry start from zero.
-            return array( 'ok' => false, 'error' => (string) ( $r['error'] ?? 'Ranged download failed.' ), 'resumed_from' => $start );
-        }
-
-        if ( 0 === $total && ! empty( $r['total'] ) ) {
-            $total = (int) $r['total'];
-        }
-
-        $written = (int) ( $r['written'] ?? 0 );
-        if ( $written > 0 ) {
-            // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen -- appending the plugin's own partial download; WP_Filesystem has no append mode
-            $out = fopen( $dest, 'ab' );
-            // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fopen -- reading back the range just written
-            $in  = fopen( $part, 'rb' );
-            if ( false === $out || false === $in ) {
-                if ( is_resource( $out ) ) { fclose( $out ); } // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- paired with the fopen above
-                if ( is_resource( $in ) ) { fclose( $in ); } // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- paired with the fopen above
-                wp_delete_file( $part );
-                return array( 'ok' => false, 'error' => 'Could not append the downloaded range to ' . basename( $dest ) . '.' );
+
+            if ( $written < $chunk ) {
+                // Short range means the end of the object.
+                break;
             }
-            stream_copy_to_stream( $in, $out );
-            fclose( $in );  // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- paired with the fopen above
-            fclose( $out ); // phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_fclose -- paired with the fopen above
-            $have += $written;
-        }
-        wp_delete_file( $part );
-
-        if ( $written < $chunk ) {
-            // Short range means the end of the object.
-            break;
-        }
-        if ( $total > 0 && $have >= $total ) {
-            break;
+            if ( $total > 0 && $have >= $total ) {
+                break;
+            }
         }
 

cloudscale-backup-restore/trunk/includes/class-cloudscale-licence.php

@@ -2006 +2006 @@
                         <div style="margin-bottom:8px;font-size:0.75rem;color:#6b7280;">
                                 <?php echo esc_html( ( $sub_provider ? $sub_provider . ' subscription:' : 'Subscription:' ) ); ?>
-                                <code style="font-size:0.75rem;background:#f3f4f6;padding:2px 6px;border-radius:4px;"><?php echo esc_html( $sub_code ); ?></code>
+                                <code style="font-size:0.75rem;background:#f3f4f6;color:#1f2937;padding:2px 6px;border-radius:4px;"><?php echo esc_html( $sub_code ); ?></code>
                         </div>
                         <?php endif; ?>
@@ -2067 +2067 @@
 
                         <a href="#" id="<?php echo esc_attr( $card_id ); ?>-disconnect"
-                           style="display:block;text-align:center;font-size:0.75rem;color:#999;margin-top:4px;">
+                           style="display:block;text-align:center;font-size:0.75rem;color:#4b5563;margin-top:4px;">
                                 <?php echo esc_html( 'Disconnect plugin only' ); ?>
                         </a>

cloudscale-backup-restore/trunk/includes/class-cloudscale-telegram.php

@@ -911 +911 @@
         }
 
-        private static function alert_origin(): string {
+        /**
+         * The origin block printed under every alert.
+         *
+         * @param bool $request_is_subject Whether the HTTP request executing this code is the alert's
+         *        subject. True for almost every alert (a login, a firewall block: the request is the
+         *        event). False when the current request only CARRIES the alert, which it never caused,
+         *        for example the Edge Gateway POSTing a batch of events it detected elsewhere: there the
+         *        courier is a trusted local request to our own events route, and 'From'/'Request' would
+         *        name that courier as though it were the attacker. The real actor is then in the body,
+         *        so only the host is printed and the request lines are left off.
+         * @return string
+         */
+        private static function alert_origin( bool $request_is_subject = true ): string {
                 $host = self::host_label();
 
@@ -932 +944 @@
                 $lines   = array();
                 $lines[] = 'Host: ' . $host . ( '' !== $server_ip ? ' (container ' . $server_ip . ')' : '' );
+
+                // The request lines describe the request in flight. When that request is only the courier
+                // of an event detected elsewhere, they name the courier, not the attacker, so they are
+                // omitted and the body's own 'from X' stands as the source.
+                if ( ! $request_is_subject ) {
+                        return "\n" . implode( "\n", $lines );
+                }
+
                 $lines[] = 'From: ' . self::trigger_source();
 
@@ -1159 +1179 @@
          * @param string $source  Plugin/feature name shown in the header (e.g. "Backup and Restore").
          * @param string $level   Alert level: info, warning, error, critical.
-         */
-        public static function send( string $text, string $source = '', string $level = 'info' ): bool {
+         * @param bool   $request_is_subject Whether the HTTP request in flight is this alert's subject.
+         *        Defaults true. Pass false for an alert the current request merely carries (an Edge
+         *        Gateway event batch), so the origin block does not name the courier as the actor.
+         */
+        public static function send( string $text, string $source = '', string $level = 'info', bool $request_is_subject = true ): bool {
                 // Before anything else, and before any call site's own toggle: a muted install
                 // sends nothing at all. See OPTION_MUTED for why this belongs here and not at
@@ -1202 +1225 @@
                 $full = self::alert_prefix( $source, $level )
                         . self::localise_utc_stamps( $text )
-                        . "\n" . self::alert_origin()
+                        . "\n" . self::alert_origin( $request_is_subject )
                         . "\n\n" . self::local_time();
 

cloudscale-backup-restore/trunk/includes/class-csbr-aws.php

@@ -155 +155 @@
      */
     private const MULTIPART_LANES = 4;
+
+    /**
+     * Smallest range a download wave splits a stretch into, see download_wave().
+     *
+     * @since 3.2.860
+     */
+    private const DOWNLOAD_MIN_RANGE = 8 * 1024 * 1024;
 
     /**
@@ -1211 +1218 @@
     }
 
+    /**
+     * Split the next stretch of a download into ranges to fetch at once.
+     *
+     * The stretch is never more than $chunk, the size one sequential range already
+     * was, so a wave moves no more bytes than a single range did and fits inside the
+     * same timeout and hop budget even when the link is slow. It only ever gets there
+     * sooner: a distant region limits each connection by its round trip, not by the
+     * link, which is what made uploads four times slower than they needed to be
+     * before 3.2.834.
+     *
+     * A stretch too small to split usefully stays one range, so a nearly finished
+     * download does not open four connections for a few megabytes.
+     *
+     * Pure, so tests/s3-download-wave-test.php can drive it.
+     *
+     * @since 3.2.860
+     * @param int $have  Bytes already on disk, the offset of the first range.
+     * @param int $total Size of the whole object.
+     * @param int $chunk Most bytes one wave may cover.
+     * @param int $lanes Most ranges in one wave.
+     * @return array<int, array{0:int,1:int}> Offset and length of each range, in order.
+     */
+    public static function download_wave( int $have, int $total, int $chunk, int $lanes = self::MULTIPART_LANES ): array {
+        if ( $have < 0 || $total <= $have || $chunk <= 0 ) {
+            return array();
+        }
+        $span  = min( $chunk, $total - $have );
+        $count = max( 1, min( $lanes, intdiv( $span, self::DOWNLOAD_MIN_RANGE ) ) );
+        $size  = (int) ceil( $span / $count );
+
+        $wave   = array();
+        $offset = $have;
+        $end    = $have + $span;
+        while ( $offset < $end ) {
+            $length  = min( $size, $end - $offset );
+            $wave[]  = array( $offset, $length );
+            $offset += $length;
+        }
+        return $wave;
+    }
+
+    /**
+     * Fetch several byte ranges of an object at once, each into its own file.
+     *
+     * Returns only the ranges S3 answered in full: 206, a Content-Range starting at
+     * the offset asked for, and exactly the bytes asked for on disk. Anything else is
+     * deleted and left out, and the caller fetches that range again through
+     * s3_get_range(), the one-at-a-time path. So, like s3_multipart_upload_wave(), a
+     * wave can only make a download faster: at worst it returns nothing.
+     *
+     * Same transport as the upload wave, for the same reason: WordPress has no
+     * parallel wrapper and direct cURL is not allowed on WordPress.org. A site behind
+     * a proxy that WP_Http would have applied gets the one-at-a-time path. Each body
+     * streams to disk through 'filename', so a wave holds no range in memory.
+     *
+     * @since 3.2.860
+     * @param string                                  $bucket  Bucket name.
+     * @param string                                  $key     Object key.
+     * @param array<int, array{0:int,1:int,2:string}> $ranges  Id => offset, length, destination file.
+     * @param int                                     $timeout Seconds for each request.
+     * @return array<int, true> Ids of the ranges that landed whole.
+     */
+    public function s3_get_ranges( string $bucket, string $key, array $ranges, int $timeout = 600 ): array {
+        if ( ! $ranges || ! class_exists( '\WpOrg\Requests\Requests' ) ) {
+            return array();
+        }
+        if ( class_exists( 'WP_HTTP_Proxy' ) && ( new WP_HTTP_Proxy() )->is_enabled() ) {
+            return array();
+        }
+
+        $encoded_key = implode( '/', array_map( 'rawurlencode', explode( '/', $key ) ) );
+        // wporg-risk-accepted: CS_REJECT_19 -- the AWS S3 and EC2 API endpoint the administrator's own bucket or instance lives on, documented under External services; nothing is offloaded, this is the storage the user chose
+        // phpcs:ignore PluginCheck.CodeAnalysis.Offloading.OffloadedContent -- S3 REST endpoint for the user's OWN bucket, to retrieve their own backups. Nothing is served to a browser.
+        $url = 'https://' . $bucket . '.s3.' . $this->region . '.amazonaws.com/' . ltrim( $encoded_key, '/' );
+
+        $requests = array();
+        foreach ( $ranges as $id => $range ) {
+            list( $offset, $length, $dest ) = $range;
+            // The Range header stays unsigned, as in s3_get_range().
+            $headers          = $this->sign( 'GET', $url, array(), '', 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855' );
+            $headers['Range'] = 'bytes=' . $offset . '-' . ( $offset + $length - 1 );
+
+            $requests[ $id ] = array(
+                'url'     => $url,
+                'type'    => 'GET',
+                'headers' => $headers,
+                'data'    => array(),
+                'options' => array(
+                    'timeout'         => $timeout,
+                    'connect_timeout' => self::CONNECT_TIMEOUT,
+                    'verify'          => CSBR_Paths::root_file( WPINC . '/certificates/ca-bundle.crt' ),
+                    'filename'        => $dest,
+                ),
+            );
+        }
+
+        try {
+            $responses = \WpOrg\Requests\Requests::request_multiple( $requests );
+        } catch ( \Throwable $e ) {
+            if ( function_exists( 'csbr_log' ) ) {
+                csbr_log( '[CloudScale Backup & Restore] Parallel S3 ranges failed to start, continuing one range at a time: ' . $e->getMessage() );
+            }
+            $responses = array();
+        }
+
+        $landed = array();
+        foreach ( $ranges as $id => $range ) {
+            list( $offset, $length, $dest ) = $range;
+            $response = $responses[ $id ] ?? null;
+
+            $ok = $response instanceof \WpOrg\Requests\Response && 206 === (int) $response->status_code;
+            if ( $ok ) {
+                $cr = (string) ( $response->headers['content-range'] ?? '' );
+                $ok = 1 === preg_match( '#^bytes (\d+)-#', $cr, $m ) && (int) $m[1] === $offset;
+            }
+            if ( $ok ) {
+                clearstatcache( true, $dest );
+                $ok = file_exists( $dest ) && (int) filesize( $dest ) === $length;
+            }
+
+            if ( $ok ) {
+                $landed[ $id ] = true;
+            } elseif ( file_exists( $dest ) ) {
+                wp_delete_file( $dest );
+            }
+        }
+
+        $missed = count( $ranges ) - count( $landed );
+        if ( $missed > 0 && function_exists( 'csbr_log' ) ) {
+            csbr_log( sprintf(
+                '[CloudScale Backup & Restore] %d of %d parallel S3 ranges did not land, fetching them again one at a time.',
+                $missed,
+                count( $ranges )
+            ) );
+        }
+
+        unset( $responses, $requests );
+        gc_collect_cycles();
+
+        return $landed;
+    }
+
     public function s3_get( string $bucket, string $key, string $dest_path ): array {
         $encoded_key    = implode( '/', array_map( 'rawurlencode', explode( '/', $key ) ) );

cloudscale-backup-restore/trunk/includes/class-csbr-cli.php

@@ -580 +580 @@
                 $key = rtrim( $this->prefix(), '/' ) . '/' . $filename;
                 WP_CLI::log( 'Downloading s3://' . $this->bucket() . '/' . $key . ' (' . CSBR_Backup_Utils::format_size( $expected ) . ')...' );
-                $result = $s3->s3_get( $this->bucket(), $key, $local );
+
+                // The same ranged, parallel and resumable copy the admin screen and the
+                // automatic restore use. It appends to what is on disk, so a shorter local
+                // file is resumed, and one that cannot be a prefix of this backup goes first.
+                if ( file_exists( $local ) && ( $force || (int) filesize( $local ) > $expected ) ) {
+                        wp_delete_file( $local );
+                }
+                $result = csbr_s3_fetch_resumable( $s3, $this->bucket(), $key, $local );
                 if ( empty( $result['ok'] ) || ! file_exists( $local ) ) {
                         WP_CLI::error( 'Download failed: ' . ( $result['error'] ?? 'file missing after download' ) );

cloudscale-backup-restore/trunk/readme.txt

@@ -5 +5 @@
 Tested up to: 7.1
 Requires PHP: 8.1
-Stable tag: 3.2.858
+Stable tag: 3.2.860
 License: GPL-2.0-or-later
 License URI: https://www.gnu.org/licenses/gpl-2.0.html
@@ -20 +20 @@
 * **Built for large sites.** The database is streamed in 500-row pages, never loaded into memory. Uploads go in chunks: S3 multipart over 100 MB, and OneDrive, Dropbox and Google Drive chunks are retried up to 5 times on a dropped connection, throttle or server error, resuming where the provider says it stopped.
 * **Five destinations at once.** Amazon S3, Google Drive, Dropbox and Microsoft OneDrive on your own accounts, plus CloudScale Managed Cloud. Every destination you enable gets every backup.
-* **Regional affinity.** Managed Cloud stores backups in one of ten regions: US East, US West, South America, Ireland, Frankfurt, Cape Town, Mumbai, Singapore, Tokyo or Sydney. Automatic mode measures which is nearest your site; or pick one for data residency.
-* **Automated recovery to a new site.** A standby server restores itself from the newest cloud backup on a schedule, refuses a stale one, and reports recovery time and a file-by-file reconciliation.
+* **Ten storage regions on six continents.** Managed Cloud keeps backups on Amazon S3 in US East, US West, São Paulo, Ireland, Frankfurt, Cape Town, Mumbai, Singapore, Tokyo and Sydney. Automatic mode times each region from your server and keeps your backups in the nearest one, so copies and restores take the shortest, lowest-latency path. Large backups upload up to four parts at a time, downloads go parallel whenever that is faster, and a restore starts at once, with no archive thaw. Or pick a region for data residency.
+* **Automated disaster recovery.** A standby server restores itself from the newest cloud backup on a schedule, refuses a stale one, and reports recovery time and a file-by-file reconciliation.
 * **Self-healing backups.** A backup killed mid-run (deploy, PHP restart, out of memory) is detected through a file lock and finished or restarted, and you are told. Every archive can be integrity-checked before it is uploaded or older backups are deleted.
 * **Rollback for bad plugin updates.** Automatic Crash Recovery copies a plugin before WordPress updates it and can roll it back if the site starts failing.
@@ -41 +41 @@
 * **Full restore** puts back the backup's files, then its database. It runs on the server, so you can close the page
 * **Specific tables only** or a **single post or page** with its metadata, no maintenance mode needed
-* Restore from this server, from an uploaded `.zip` or `.sql`, or pull straight from S3, Google Drive, Dropbox, OneDrive or Managed Cloud to the server. S3 and Managed Cloud downloads resume where they stopped
+* Restore from this server, from an uploaded `.zip` or `.sql`, or pull straight from S3, Google Drive, Dropbox, OneDrive or Managed Cloud to the server. S3 and Managed Cloud downloads go four ranges at a time when that is faster, and resume where they stopped
 * Encrypted backups are checked against your password before anything is touched
 * Visitors see a maintenance page; it is removed whether the restore succeeds or fails
@@ -71 +71 @@
 = Managed Cloud =
 
-Don't have a cloud account? CloudScale Managed Cloud is $5/month for 750 GB on Amazon S3 Glacier Instant Retrieval, in the region you choose or the nearest one. Your own S3, Google Drive, Dropbox and OneDrive destinations are always free.
+Don't have a cloud account? CloudScale Managed Cloud is $5/month for 750 GB on Amazon S3 Glacier Instant Retrieval, in ten regions worldwide: the one nearest your site by default, or the one you choose. Instant Retrieval means a restore downloads straight away, with no archive thaw. Your own S3, Google Drive, Dropbox and OneDrive destinations are always free.
 
 **Automatic backups are off by default.** Run your first backup by hand to confirm your server, then switch on a schedule. Full documentation: [help.cloudscale.consulting](https://help.cloudscale.consulting/plugin-help/backup-restore/).
@@ -216 +216 @@
 == Changelog ==
 
+= 3.2.860 =
+* IMPROVED: Copies from Amazon S3 and CloudScale Managed (restores, standby refreshes, `wp csbr cloud-pull`) download four ranges at a time when that is faster. Each copy times both ways and keeps the faster, since on a link that is already full four connections are slower. Each range is checked before it is added, and an interrupted copy still resumes where it stopped.
+* IMPROVED: `wp csbr cloud-pull` resumes a partial download instead of starting again.
+
 = 3.2.858 =
 * FIX: Uninstall now removes the plugin's state files in wp-content. Backup archives, the token naming their folder, and the site-role and alert-label markers shared with other CloudScale plugins are kept on purpose.