21262059095

Committed 22 Jan 2026 07:29PM UTC coverage: 85.402% (-0.1%) from 85.526%

Build # 21262059095

Build Type

Pull #9889

github

Committed by

web-flow

Commit Message

Merge e55be0bba into c7e784fe4

Pull Request Pull Request #9889: feat: FrankenPHP Worker Mode

Run Details

154 of 238 new or added lines in 19 files covered. (64.71%)

1 existing line in 1 file now uncovered.

22119 of 25900 relevant lines covered (85.4%)

205.29 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.37

/system/Database/Config.php

<?php

declare(strict_types=1);

/**
 * This file is part of CodeIgniter 4 framework.
 *
 * (c) CodeIgniter Foundation <admin@codeigniter.com>
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

namespace CodeIgniter\Database;

use CodeIgniter\Config\BaseConfig;
use CodeIgniter\Exceptions\InvalidArgumentException;
use Config\Database as DbConfig;

/**
 * @see \CodeIgniter\Database\ConfigTest
 */
class Config extends BaseConfig
{
    /**
     * Cache for instance of any connections that
     * have been requested as a "shared" instance.
     *
     * @var array
     */
    protected static $instances = [];

    /**
     * The main instance used to manage all of
     * our open database connections.
     *
     * @var Database|null
     */
    protected static $factory;

    /**
     * Returns the database connection
     *
     * @param array|BaseConnection|non-empty-string|null $group     The name of the connection group to use,
     *                                                              or an array of configuration settings.
     * @param bool                                       $getShared Whether to return a shared instance of the connection.
     *
     * @return BaseConnection
     */
    public static function connect($group = null, bool $getShared = true)
    {
        // If a DB connection is passed in, just pass it back
        if ($group instanceof BaseConnection) {
            return $group;
        }

        if (is_array($group)) {
            $config = $group;
            $group  = 'custom-' . md5(json_encode($config));
        } else {
            $dbConfig = config(DbConfig::class);

            if ($group === null) {
                $group = (ENVIRONMENT === 'testing') ? 'tests' : $dbConfig->defaultGroup;
            }

            assert(is_string($group));

            if (! isset($dbConfig->{$group})) {
                throw new InvalidArgumentException('"' . $group . '" is not a valid database connection group.');
            }

            $config = $dbConfig->{$group};
        }

        if ($getShared && isset(static::$instances[$group])) {
            return static::$instances[$group];
        }

        static::ensureFactory();

        $connection = static::$factory->load($config, $group);

        if ($getShared) {
            static::$instances[$group] = $connection;
        }

        return $connection;
    }

    /**
     * Returns an array of all db connections currently made.
     */
    public static function getConnections(): array
    {
        return static::$instances;
    }

    /**
     * Loads and returns an instance of the Forge for the specified
     * database group, and loads the group if it hasn't been loaded yet.
     *
     * @param array|ConnectionInterface|string|null $group
     *
     * @return Forge
     */
    public static function forge($group = null)
    {
        $db = static::connect($group);

        return static::$factory->loadForge($db);
    }

    /**
     * Returns a new instance of the Database Utilities class.
     *
     * @param array|string|null $group
     *
     * @return BaseUtils
     */
    public static function utils($group = null)
    {
        $db = static::connect($group);

        return static::$factory->loadUtils($db);
    }

    /**
     * Returns a new instance of the Database Seeder.
     *
     * @param non-empty-string|null $group
     *
     * @return Seeder
     */
    public static function seeder(?string $group = null)
    {
        $config = config(DbConfig::class);

        return new Seeder($config, static::connect($group));
    }

    /**
     * Ensures the database Connection Manager/Factory is loaded and ready to use.
     *
     * @return void
     */
    protected static function ensureFactory()
    {
        if (static::$factory instanceof Database) {
            return;
        }

        static::$factory = new Database();
    }

    /**
     * Reconnect database connections for worker mode at the start of a request.
     *
     * This should be called at the beginning of each request in worker mode,
     * before the application runs.
     */
    public static function reconnectForWorkerMode(): void
    {
        if (static::$instances === []) {
            return;
        }

        foreach (static::$instances as $connection) {
            $connection->reconnect();
        }
    }

    /**
     * Cleanup database connections for worker mode.
     *
     * Rolls back any uncommitted transactions and resets transaction status
     * to ensure a clean state for the next request.
     *
     * Uncommitted transactions at this point indicate a bug in the
     * application code (transactions should be completed before request ends).
     *
     * Called at the END of each request to clean up state.
     */
    public static function cleanupForWorkerMode(): void
    {
        foreach (static::$instances as $group => $connection) {
            if ($connection->transDepth > 0) {
                log_message('error', "Uncommitted transaction detected in database group '{$group}'. Transactions must be completed before request ends.");

                while ($connection->transDepth > 0) {
                    $connection->transRollback();
                }
            }

            $connection->resetTransStatus();
        }
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	/**
6	* This file is part of CodeIgniter 4 framework.
7	*
8	* (c) CodeIgniter Foundation <admin@codeigniter.com>
9	*
10	* For the full copyright and license information, please view
11	* the LICENSE file that was distributed with this source code.
12	*/
13
14	namespace CodeIgniter\Database;
15
16	use CodeIgniter\Config\BaseConfig;
17	use CodeIgniter\Exceptions\InvalidArgumentException;
18	use Config\Database as DbConfig;
19
20	/**
21	* @see \CodeIgniter\Database\ConfigTest
22	*/
23	class Config extends BaseConfig
24	{
25	/**
26	* Cache for instance of any connections that
27	* have been requested as a "shared" instance.
28	*
29	* @var array
30	*/
31	protected static $instances = [];
32
33	/**
34	* The main instance used to manage all of
35	* our open database connections.
36	*
37	* @var Database\|null
38	*/
39	protected static $factory;
40
41	/**
42	* Returns the database connection
43	*
44	* @param array\|BaseConnection\|non-empty-string\|null $group The name of the connection group to use,
45	* or an array of configuration settings.
46	* @param bool $getShared Whether to return a shared instance of the connection.
47	*
48	* @return BaseConnection
49	*/
50	public static function connect($group = null, bool $getShared = true)
51	{
52	// If a DB connection is passed in, just pass it back
53	if ($group instanceof BaseConnection) {	908✔
54	return $group;	814✔
55	}
56
57	if (is_array($group)) {	901✔
58	$config = $group;	40✔
59	$group = 'custom-' . md5(json_encode($config));	40✔
60	} else {
61	$dbConfig = config(DbConfig::class);	892✔
62
63	if ($group === null) {	892✔
64	$group = (ENVIRONMENT === 'testing') ? 'tests' : $dbConfig->defaultGroup;	169✔
65	}
66
67	assert(is_string($group));
68
69	if (! isset($dbConfig->{$group})) {	892✔
70	throw new InvalidArgumentException('"' . $group . '" is not a valid database connection group.');	3✔
71	}
72
73	$config = $dbConfig->{$group};	892✔
74	}
75
76	if ($getShared && isset(static::$instances[$group])) {	901✔
77	return static::$instances[$group];	884✔
78	}
79
80	static::ensureFactory();	61✔
81
82	$connection = static::$factory->load($config, $group);	61✔
83
84	if ($getShared) {	61✔
85	static::$instances[$group] = $connection;	27✔
86	}
87
88	return $connection;	61✔
89	}
90
91	/**
92	* Returns an array of all db connections currently made.
93	*/
94	public static function getConnections(): array
95	{
96	return static::$instances;	100✔
97	}
98
99	/**
100	* Loads and returns an instance of the Forge for the specified
101	* database group, and loads the group if it hasn't been loaded yet.
102	*
103	* @param array\|ConnectionInterface\|string\|null $group
104	*
105	* @return Forge
106	*/
107	public static function forge($group = null)
108	{
109	$db = static::connect($group);	821✔
110
111	return static::$factory->loadForge($db);	821✔
112	}
113
114	/**
115	* Returns a new instance of the Database Utilities class.
116	*
117	* @param array\|string\|null $group
118	*
119	* @return BaseUtils
120	*/
121	public static function utils($group = null)
122	{
123	$db = static::connect($group);	2✔
124
125	return static::$factory->loadUtils($db);	2✔
126	}
127
128	/**
129	* Returns a new instance of the Database Seeder.
130	*
131	* @param non-empty-string\|null $group
132	*
133	* @return Seeder
134	*/
135	public static function seeder(?string $group = null)
136	{
137	$config = config(DbConfig::class);	803✔
138
139	return new Seeder($config, static::connect($group));	803✔
140	}
141
142	/**
143	* Ensures the database Connection Manager/Factory is loaded and ready to use.
144	*
145	* @return void
146	*/
147	protected static function ensureFactory()
148	{
149	if (static::$factory instanceof Database) {	61✔
150	return;	52✔
151	}
152
153	static::$factory = new Database();	10✔
154	}
155
156	/**
157	* Reconnect database connections for worker mode at the start of a request.
158	*
159	* This should be called at the beginning of each request in worker mode,
160	* before the application runs.
161	*/
162	public static function reconnectForWorkerMode(): void
163	{
164	if (static::$instances === []) {	1✔
NEW 165	return;	×
166	}
167
168	foreach (static::$instances as $connection) {	1✔
169	$connection->reconnect();	1✔
170	}
171	}
172
173	/**
174	* Cleanup database connections for worker mode.
175	*
176	* Rolls back any uncommitted transactions and resets transaction status
177	* to ensure a clean state for the next request.
178	*
179	* Uncommitted transactions at this point indicate a bug in the
180	* application code (transactions should be completed before request ends).
181	*
182	* Called at the END of each request to clean up state.
183	*/
184	public static function cleanupForWorkerMode(): void
185	{
186	foreach (static::$instances as $group => $connection) {	1✔
187	if ($connection->transDepth > 0) {	1✔
188	log_message('error', "Uncommitted transaction detected in database group '{$group}'. Transactions must be completed before request ends.");	1✔
189
190	while ($connection->transDepth > 0) {	1✔
191	$connection->transRollback();	1✔
192	}
193	}
194
195	$connection->resetTransStatus();	1✔
196	}
197	}
198	}

codeigniter4 / CodeIgniter4 / 21262059095

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous