/**
* Loads the configuration and plugins in the right order
* @method configure
* @static
* @param boolean [$force_reload=false] If true, forces the reload of the cache.
* Otherwise it happens only if Q/configServer/interval seconds
* have passed since the last time.
* @throws {Q_Exception_MissingPlugin}
*/
static function configure($force_reload = false)
{
$app_tree = new Q_Tree();
// check if config need to be reloaded
if (Q_Cache::connected()) {
// we need to know reload interval
$app_tree->load('config/Q.json');
$app_tree->load('config/app.json');
$app_tree->load('local/app.json');
$config_files = $app_tree->get('Q', 'configFiles', array());
foreach ($config_files as $cf) {
$app_tree->merge(Q_Config::getFromServer($cf));
}
// second round to catch configFiles inside configFiles
$config_files = $app_tree->get('Q', 'configFiles', array());
foreach ($config_files as $cf) {
$app_tree->merge(Q_Config::getFromServer($cf));
}
$interval = $app_tree->get('Q', 'configServer', 'interval', 60);
// reload each minute by default
$app_tree->clear(null);
$timestamp = Q_Cache::get("Q_Config\tupdate_time");
if (!isset($timestamp) || time() - $timestamp > $interval) {
$force_reload = true;
}
}
if ($force_reload) {
$old_setting = Q_Cache::ignore(true);
}
Q_Config::clear(null);
// clear the config
Q_Config::load('config/Q.json');
// Get the app config, but don't load it yet
$app_tree->load('config/app.json');
$app_tree->load('local/app.json');
// Load all the plugin config files first
$paths = explode(PS, get_include_path());
$plugins = $app_tree->get('Q', 'plugins', array());
if (!in_array('Q', $plugins)) {
array_unshift($plugins, 'Q');
}
global $Q_Bootstrap_config_plugin_limit;
$i = 0;
foreach ($plugins as $k => $v) {
++$i;
if (isset($Q_Bootstrap_config_plugin_limit) and $i > $Q_Bootstrap_config_plugin_limit) {
continue;
}
$plugin = is_numeric($k) ? $v : $k;
$plugin_path = Q::realPath('plugins' . DS . $v);
if (!$plugin_path) {
throw new Q_Exception_MissingPlugin(compact('plugin'));
}
Q_Config::load($plugin_path . DS . 'config' . DS . 'plugin.json');
array_splice($paths, 1, 0, array($plugin_path));
$PLUGIN = strtoupper($plugin);
if (!defined($PLUGIN . '_PLUGIN_DIR')) {
define($PLUGIN . '_PLUGIN_DIR', $plugin_path);
}
if (!defined($PLUGIN . '_PLUGIN_CONFIG_DIR')) {
define($PLUGIN . '_PLUGIN_CONFIG_DIR', $plugin_path . DS . 'config');
}
if (!defined($PLUGIN . '_PLUGIN_CLASSES_DIR')) {
define($PLUGIN . '_PLUGIN_CLASSES_DIR', $plugin_path . DS . 'classes');
}
if (!defined($PLUGIN . '_PLUGIN_FILES_DIR')) {
define($PLUGIN . '_PLUGIN_FILES_DIR', $plugin_path . DS . 'files');
}
if (!defined($PLUGIN . '_PLUGIN_HANDLERS_DIR')) {
define($PLUGIN . '_PLUGIN_HANDLERS_DIR', $plugin_path . DS . 'handlers');
}
if (!defined($PLUGIN . '_PLUGIN_PLUGINS_DIR')) {
define($PLUGIN . '_PLUGIN_PLUGINS_DIR', $plugin_path . DS . 'plugins');
}
if (!defined($PLUGIN . '_PLUGIN_SCRIPTS_DIR')) {
define($PLUGIN . '_PLUGIN_SCRIPTS_DIR', $plugin_path . DS . 'scripts');
}
if (!defined($PLUGIN . '_PLUGIN_VIEWS_DIR')) {
define($PLUGIN . '_PLUGIN_VIEWS_DIR', $plugin_path . DS . 'views');
}
if (!defined($PLUGIN . '_PLUGIN_TESTS_DIR')) {
define($PLUGIN . '_PLUGIN_TESTS_DIR', $plugin_path . DS . 'tests');
}
if (!defined($PLUGIN . '_PLUGIN_WEB_DIR')) {
define($PLUGIN . '_PLUGIN_WEB_DIR', $plugin_path . DS . 'web');
}
self::$plugins[$plugin] = $plugin_path;
}
$paths = array_unique($paths);
set_include_path(implode(PS, $paths));
// Now, we can merge in our app's config
Q_Config::merge($app_tree);
// Now, load any other files we were supposed to load
$config_files = Q_Config::get('Q', 'configFiles', array());
foreach ($config_files as $cf) {
Q_Config::merge(Q_Config::getFromServer($cf));
}
// second round to catch configFiles inside configFiles
$config_files = Q_Config::get('Q', 'configFiles', array());
foreach ($config_files as $cf) {
Q_Config::merge(Q_Config::getFromServer($cf));
}
$script_files = Q_Config::get('Q', 'scriptFiles', array());
foreach ($script_files as $cf) {
Q::includeFile($cf);
}
error_reporting(Q_Config::get('Q', 'errorReporting', E_ALL));
if (isset($old_setting)) {
Q_Cache::ignore($old_setting);
}
set_time_limit(Q_Config::get('Q', 'internal', 'phpTimeout', 30));
self::setDefaultTimezone();
}
/**
* Split shard partitin to new shards. It takes the full table or single partition
* and split it to multiple partitions according to the number of provided 'parts'.
* When doing initioa split 'shard' may be ommited however 'fields' shall be provided
* @method split
* @static
* @param {Q_Tree} $config Contains all necessary information for split procedure in the following format:
* @example
* {
* "plugin": "PLUGINNAME", // the name of plugin - shall be used by app
* "connection": "CONNECTIONNAME", // connection - shall be registered with plugin
* "table": "TABLENAME", // the table to shard
* "class": "CLASSNAME", // the class which is stored in the table
* "fields": {"FIELDNAME": "HASH", "FIELDNAME": "HASH", ...}, // Optional. Used only when starting sharding
* "shard": "SHARDNAME" // Optionsl. The shard to split. If no shards defined or SHARDNAME does not exist the script will fail
* // "parts" can be either array of connections or object {"SHARDNAME": connection, ...}
* "parts": {
* "SHARDNAME": {
* "prefix": "PREFIX",
* "dsn": "DSN",
* ...
* },
* "SHARDNAME": {
* "prefix": "PREFIX",
* "dsn": "DSN",
* "username": "******",
* "password": "******",
* "driver_options": {
* "3": 2
* }
* },
* ...
* }
* }
*
* @return {boolean} Weather php part of the process completed successfuly
*/
static function split($config)
{
// all input data shall be provided
// for future extension plugin/connection/table/class are considered unrelated
if (!($plugin = $config->get('plugin', false))) {
echo "Plugin name is not defined\n";
return false;
}
// plugin shall be registered!
if (!Q_Config::get('Q', 'pluginInfo', $plugin, false)) {
echo "Plugin '{$plugin}' is not registered in the platform\n";
return false;
}
if (!($connection = $config->get('connection', false))) {
echo "Connection '{$connection}' is not defined\n";
return false;
}
// connection shall exist and be registered with plugin!
if (!Q_Config::get('Db', 'connections', $connection, false)) {
echo "Connection '{$connection}' does not exist\n";
return false;
}
if (!in_array($connection, Q_Config::get('Q', 'pluginInfo', $plugin, 'connections', array()))) {
echo "Connection '{$connection}' is not registered for plugin '{$plugin}'\n";
return false;
}
if (!($class = $config->get('class', false))) {
echo "Class name is not defined\n";
return false;
}
if (!($table = $config->get('table', false))) {
echo "Table name is not defined\n";
return false;
}
if (!($shard = $config->get('shard', false)) && Q_Config::get('Db', 'connections', $connection, 'shards', false)) {
echo "Shard to partition is not defined\n";
return false;
}
if (!($parts = $config->get('parts', false))) {
echo "New parts are not defined\n";
return false;
}
if ($node = $config->get('node', null)) {
$nodeInternal = Q_Config::expect('Q', 'nodeInternal');
$node = array("http://{$nodeInternal['host']}:{$nodeInternal['port']}/Q_Utils/query", $node);
}
// now we shall distinguish if table is already sharded or not
if ($shard === false) {
if (!($fields = $config->get('fields', false))) {
echo "To start sharding you shall define 'fields' parameter\n";
return false;
}
}
// weather provided split config is mapped or not
$split_mapped = array_keys($parts) !== range(0, count($parts) - 1);
// set up config for shards if it does not exist yet
if ($shard === false) {
$partition = array();
foreach ($fields as $name => $hash) {
if (empty($hash)) {
$hash = 'md5';
}
$part = explode('%', $hash);
$hash = $part[0];
$len = isset($part[1]) ? $part[1] : Db_Query::HASH_LEN;
// "0" has the lowest ascii code for both md5 and normalize
// $partition[] = $hash === 'md5' ? str_pad('', $len, "0", STR_PAD_LEFT) : str_pad('', $len, " ", STR_PAD_LEFT);
$partition[] = str_pad('', $len, "0", STR_PAD_LEFT);
}
$shard = join('.', $partition);
if (Q_Config::get('Db', 'connections', $connection, 'indexes', $table, false)) {
echo "Shards are not defined but indexes for table '{$table}' are defined in local config\n";
return false;
}
// Let's merge in dummy shards section - shard with name '' is handled as single table
Q_Config::merge(array('Db' => array('connections' => array($connection => array("shards" => array(), "indexes" => array($table => array("fields" => $fields, "partition" => $split_mapped ? array($shard => '') : array($shard))))))));
$shard_name = '';
}
// get partition information
if (!($partition = Q_Config::get('Db', 'connections', $connection, 'indexes', $table, 'partition', false))) {
echo "Upps, cannot get shards partitioning\n";
return false;
}
// weather main config is mapped or not
// also $points contains the partitioning array without mapping
$points = ($mapped = array_keys($partition) !== range(0, count($partition) - 1)) ? array_keys($partition) : $partition;
$i = array_search($shard, $points);
$next = isset($points[++$i]) ? $points[$i] : null;
$fields = Q_Config::expect('Db', 'connections', $connection, 'indexes', $table, 'fields');
// now $shard and $next contain boundaries for data to split
// $points contain partitioning array without mapping - array
// $parts contains split parts (shards) definition - array or object ($split_mapped)
// $partition contains current partitioning - array or object ($mapped)
// $fields contains field names and hashes
// time to calculate new split point(s)
if (!isset($shard_name)) {
$shard_name = $mapped ? $partition[$shard] : $shard;
}
$shard_db = $class::db();
$pdo = $shard_db->reallyConnect($shard_name);
$shard_table = $class::table();
$shard_table = str_replace('{$dbname}', $shard_db->dbname, $shard_table);
$shard_table = str_replace('{$prefix}', $shard_db->prefix, $shard_table);
// verify if current shard is updated to latest version
$current_version = $shard_db->select('version', "{$shard_db->prefix}Q_plugin")->where(array("plugin" => $plugin))->fetchAll(PDO::FETCH_ASSOC);
if (!empty($current_version)) {
$current_version = $current_version[0]['version'];
$version = Q_Config::get('Q', "pluginInfo", $plugin, 'version', null);
if (Q::compareVersion($current_version, $version) < 0) {
echo "Please, update plugin '{$plugin}' to version '{$version}' (currently {$current_version})\n";
return false;
}
} else {
echo "Cannot get installed version of plugin '{$plugin}'\n";
return false;
}
// We'll limit search with shard boundaries using latin1 string comparison
$lower = join(explode('.', $shard));
$upper = isset($next) ? join(explode('.', $next)) : null;
$normalize = false;
$where = $group = $order = array();
foreach (array_keys($fields) as $i => $field) {
$hash = !empty($fields[$field]) ? $fields[$field] : 'md5';
$part = explode('%', $hash);
$normalize = $normalize || ($hash = strtoupper($part[0])) === 'NORMALIZE';
$len = isset($part[1]) ? $part[1] : Db_Query::HASH_LEN;
$group[] = $field;
$order[] = "CAST({$hash}({$field}) AS CHAR({$len}))";
}
// if any field uses 'normalize' hash
// the original shard shall have MySQL NORMALIZE() function defined
// MySQL version of NORMALIZE handles only 255 chars and does not add md5 hash
// (see Db_Utils::normalize)
if ($normalize) {
try {
$pdo->exec("DROP FUNCTION IF EXISTS NORMALIZE;");
$pdo->exec("CREATE FUNCTION NORMALIZE(s CHAR(255))\n\t\t\t\t\t\tRETURNS CHAR(255) DETERMINISTIC\n\t\t\t\t\t\tBEGIN\n\t\t\t\t\t \tDECLARE res CHAR(255) DEFAULT '';\n\t\t\t\t\t \t\tDECLARE t CHAR(1);\n\t\t\t\t\t \tWHILE LENGTH(s) > 0 DO\n\t\t\t\t\t \tSET t = LOWER(LEFT(s, 1));\n\t\t\t\t\t \t SET s = SUBSTRING(s FROM 2);\n\t\t\t\t\t \tIF t REGEXP '[^A-Za-z0-9]' THEN\n\t\t\t\t\t \tSET t = '_';\n\t\t\t\t\t \tEND IF;\n\t\t\t\t\t \tSET res = CONCAT(res, t);\n\t\t\t\t\t \tEND WHILE;\n\t\t\t\t\t \tRETURN res;\n\t\t\t\t\t\tEND");
} catch (Exception $e) {
//echo "ERROR: {$e->getMessage()}\n";
echo "Please, make sure that db user for shard '{$shard_name}' has 'CREATE ROUTINE' permission\n";
return false;
}
}
$order = join(', ', $order);
$group = join(', ', $group);
$where = "(STRCMP(CONCAT({$order}), '{$lower}') >= 0)" . (isset($upper) ? " AND (STRCMP(CONCAT({$order}), '{$upper}') < 0)" : "");
$count = reset($pdo->query("SELECT COUNT(*) FROM {$shard_table} WHERE {$where}")->fetchAll(PDO::FETCH_NUM));
if (empty($count)) {
echo "Failed to connect to shard '{$shard_name}'\n";
return false;
}
$count = reset($count);
if ($count == 0) {
echo "Cannot split empty shard!\n";
return false;
}
// if only one new shard provided script will copy data and cnange config
if (($num_shards = count($parts)) < 1) {
echo "Please, provide at least one new shard";
return false;
}
$break = round($count / $num_shards);
// if split config is not mapped and current config is mapped we shall convert split
// config to mapped
$new_partition = $mapped || $split_mapped ? array($shard => $split_mapped ? reset(array_keys($parts)) : $shard) : array($shard);
$new_shards = array($split_mapped ? reset(array_keys($parts)) : $shard => reset($parts));
$i = 0;
foreach (array_slice($parts, 1) as $name => $dsn) {
$offset = $break * ++$i;
$split = reset($pdo->query("SELECT {$group} FROM {$shard_table} WHERE {$where} ORDER BY {$order} LIMIT {$offset}, 1")->fetchAll(PDO::FETCH_ASSOC));
foreach ($fields as $field => $hash) {
$split[$field] = Db_Query::hashed($split[$field], $hash);
}
$split = join('.', $split);
if ($mapped || $split_mapped) {
$new_partition[$split] = $split_mapped ? $name : $split;
} else {
$new_partition[] = $split;
}
$new_shards[$new_name = $split_mapped ? $name : $split] = $dsn;
if (Q_Config::get('Db', 'connections', $connection, 'shards', $new_name, false)) {
echo "WARNING!!! Shard already exists: '{$new_name}'\n";
}
}
Q_Config::merge(array('Db' => array('connections' => array($connection => array("shards" => $new_shards)))));
// if split config is mapped and current config is not we shall convert app config to mapped
if ($split_mapped && !$mapped) {
$partition = array();
foreach ($points as $point) {
$partition[$point] = $point;
}
Q_Config::set('Db', 'connections', $connection, 'indexes', $table, 'partition', $partition);
$mapped = true;
}
// TODO: verify if new shards sizes are approx. equal
// Verify versions of existing shards and
// Install pligin schema to new shards
Q_Plugin::installSchema(Q_PLUGINS_DIR . DS . $plugin, $plugin, 'plugin', $connection, array('sql' => array($connection => array('enabled' => true))));
// make sure 'upcoming' config is loaded
$configFiles = Q_Config::get('Q', 'configFiles', array());
// 'local/Q/bootstrap.json' should be loaded already but we'll better check
if (!in_array('Q/config/bootstrap.json', $configFiles)) {
echo "Config file 'Q/config/bootstrap.json' shall be loaded via 'Q/configFiles key'\non every Q server - check 'platform/config/Q.json'\n";
return false;
}
$upcoming_file = Q_Config::get('Q', 'internal', 'sharding', 'upcoming', 'Db/config/upcoming.json');
//if (!unlink ($upcoming_file)) {
// echo "Please, manually remove file '$upcoming_file' and start this script again.\n";
// return false;
//}
if (!in_array($upcoming_file, $configFiles)) {
// add upcoming.json to config
if (!Q_Config::setOnServer('Q/config/bootstrap.json', array('Q' => array('configFiles' => array($upcoming_file))))) {
echo "Failed to update 'local/Q/bootstrap.json'\n";
return false;
}
}
// Now after some short time all workers (php and node) will be ready for splitting
// We'll let node server to wait necessary amount of time.
$res = Q_Utils::queryInternal('Db/Shards', array('Q/method' => 'split', 'shard' => $shard_name, 'shards' => Q::json_encode($new_shards), 'part' => $shard, 'table' => $table, 'dbTable' => $shard_table, 'class' => $class, 'plugin' => $plugin, 'connection' => $connection, 'where' => $where, 'parts' => Q::json_encode(array('partition' => $new_partition, 'fields' => $fields))), $node);
if ($res) {
echo "Split process for shard '{$shard_name}' ({$shard}) has started\nPlease, monitor node.js console for important messages and process status\n";
return true;
}
echo "Failed to start split process at node server\n";
return false;
}
