Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
0.00% covered (danger)
0.00%
0 / 110
0.00% covered (danger)
0.00%
0 / 4
CRAP
0.00% covered (danger)
0.00%
0 / 1
MigrateBlocks
0.00% covered (danger)
0.00%
0 / 107
0.00% covered (danger)
0.00%
0 / 4
552
0.00% covered (danger)
0.00%
0 / 1
 __construct
0.00% covered (danger)
0.00%
0 / 11
0.00% covered (danger)
0.00%
0 / 1
2
 getUpdateKey
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 doDBUpdates
0.00% covered (danger)
0.00%
0 / 16
0.00% covered (danger)
0.00%
0 / 1
30
 handleBatch
0.00% covered (danger)
0.00%
0 / 79
0.00% covered (danger)
0.00%
0 / 1
272
1<?php
2
3use Wikimedia\IPUtils;
4use Wikimedia\Rdbms\IMaintainableDatabase;
5
6require_once __DIR__ . "/Maintenance.php";
7
8/**
9 * Maintenance script that migrates rows from ipblocks to block and block_target.
10 * The data is normalized to match the new schema. Any corrupt data that is
11 * encountered may be skipped, but will be logged.
12 *
13 * The old ipblocks table is left touched.
14 *
15 * @ingroup Maintenance
16 * @since 1.42
17 */
18class MigrateBlocks extends LoggedUpdateMaintenance {
19    private IMaintainableDatabase $dbw;
20
21    public function __construct() {
22        parent::__construct();
23        $this->addDescription(
24            'Copy data from the ipblocks table into the new block and block_target tables'
25        );
26        $this->addOption(
27            'sleep',
28            'Sleep time (in seconds) between every batch. Default: 0',
29            false,
30            true
31        );
32        // Batch size is typically 1000, but we'll do 500 since there are 2 writes for each ipblock.
33        $this->setBatchSize( 500 );
34    }
35
36    protected function getUpdateKey() {
37        return __CLASS__;
38    }
39
40    protected function doDBUpdates() {
41        $this->dbw = $this->getDB( DB_PRIMARY );
42        if (
43            !$this->dbw->tableExists( 'block', __METHOD__ ) ||
44            !$this->dbw->tableExists( 'block_target', __METHOD__ )
45        ) {
46            $this->fatalError( "Run update.php to create the block and block_target tables." );
47        }
48        if ( !$this->dbw->tableExists( 'ipblocks', __METHOD__ ) ) {
49            $this->output( "No ipblocks table, skipping migration to block_target.\n" );
50            return true;
51        }
52
53        $this->output( "Populating the block and block_target tables\n" );
54        $migratedCount = 0;
55
56        $id = 0;
57        while ( $id !== null ) {
58            $this->output( "Migrating ipblocks with ID > $id...\n" );
59            [ $numBlocks, $id ] = $this->handleBatch( $id );
60            $migratedCount += $numBlocks;
61        }
62
63        $this->output( "Completed migration of $migratedCount ipblocks to block and block_target.\n" );
64
65        return true;
66    }
67
68    /**
69     * Handle up to $this->getBatchSize() pairs of INSERTs,
70     * one for block and one for block_target.
71     *
72     * @param int $lowId
73     * @return array [ number of blocks migrated, last ipb_id or null ]
74     */
75    private function handleBatch( int $lowId ): array {
76        $migratedCount = 0;
77        $res = $this->dbw->newSelectQueryBuilder()
78            ->select( '*' )
79            ->from( 'ipblocks' )
80            ->leftJoin( 'block', null, 'bl_id=ipb_id' )
81            ->where( [
82                $this->dbw->expr( 'ipb_id', '>', $lowId ),
83                'bl_id' => null
84            ] )
85            ->orderBy( 'ipb_id' )
86            ->limit( $this->getBatchSize() )
87            ->caller( __METHOD__ )
88            ->fetchResultSet();
89
90        if ( !$res->numRows() ) {
91            return [ $migratedCount, null ];
92        }
93
94        $highestId = $lowId;
95        foreach ( $res as $row ) {
96            $highestId = $row->ipb_id;
97            $isIP = IPUtils::isValid( $row->ipb_address );
98            $isRange = IPUtils::isValidRange( $row->ipb_address );
99            $isIPOrRange = $isIP || $isRange;
100            $ipHex = null;
101            if ( $isIP ) {
102                $ipHex = IPUtils::toHex( $row->ipb_address );
103            } elseif ( $isRange ) {
104                $ipHex = $row->ipb_range_start;
105            } elseif ( (int)$row->ipb_user === 0 ) {
106                // There was data corruption circa 2006 and 2011 where some accounts were
107                // blocked as if they were logged out users. Here we'll prune the erroneous
108                // data by simply not copying it to the new schema.
109                $this->output( "ipblock with ID $row->ipb_id: account block with ipb_user=0, skipping…\n" );
110                continue;
111            }
112
113            // Insert into block_target
114            $blockTarget = [
115                'bt_address'     => $isIPOrRange ? $row->ipb_address : null,
116                'bt_user'        => $isIPOrRange ? null : $row->ipb_user,
117                'bt_user_text'   => $isIPOrRange ? null : $row->ipb_address,
118                'bt_auto'        => $row->ipb_auto,
119                'bt_range_start' => $isRange ? $row->ipb_range_start : null,
120                'bt_range_end'   => $isRange ? $row->ipb_range_end : null,
121                'bt_ip_hex'      => $ipHex,
122                'bt_count'       => 1
123            ];
124            $this->dbw->newInsertQueryBuilder()
125                ->insertInto( 'block_target' )
126                ->row( $blockTarget )
127                ->caller( __METHOD__ )
128                ->execute();
129            $insertId = $this->dbw->insertId();
130            if ( !$insertId ) {
131                $this->fatalError(
132                    "ipblock with ID $row->ipb_id: Failed to create block_target. Insert ID is falsy!"
133                );
134            }
135
136            // Insert into block
137            $block = [
138                'bl_id'               => $row->ipb_id,
139                'bl_target'           => $insertId,
140                'bl_by_actor'         => $row->ipb_by_actor,
141                'bl_reason_id'        => $row->ipb_reason_id,
142                'bl_timestamp'        => $row->ipb_timestamp,
143                'bl_anon_only'        => $row->ipb_anon_only,
144                'bl_create_account'   => $row->ipb_create_account,
145                'bl_enable_autoblock' => $row->ipb_enable_autoblock,
146                'bl_expiry'           => $row->ipb_expiry,
147                'bl_deleted'          => $row->ipb_deleted,
148                'bl_block_email'      => $row->ipb_block_email,
149                'bl_allow_usertalk'   => $row->ipb_allow_usertalk,
150                // See T282890
151                'bl_parent_block_id'  => (int)$row->ipb_parent_block_id === 0 ? null : $row->ipb_parent_block_id,
152                'bl_sitewide'         => $row->ipb_sitewide,
153            ];
154            $this->dbw->newInsertQueryBuilder()
155                ->insertInto( 'block' )
156                ->ignore()
157                ->row( $block )
158                ->caller( __METHOD__ )
159                ->execute();
160            if ( $this->dbw->affectedRows() ) {
161                $migratedCount++;
162            }
163        }
164
165        $this->output( "Migrated $migratedCount blocks\n" );
166
167        // Sleep between batches for replication to catch up
168        $this->waitForReplication();
169        $sleep = (int)$this->getOption( 'sleep', 0 );
170        if ( $sleep > 0 ) {
171            sleep( $sleep );
172        }
173
174        return [ $migratedCount, $highestId ];
175    }
176}
177
178$maintClass = MigrateBlocks::class;
179require_once RUN_MAINTENANCE_IF_MAIN;