unit_config_reader.php
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Wed, Feb 26, 1:36 PM

unit_config_reader.php
View Options

	<?php

	class kUnitConfigReader extends kBase {

	/**
	* Configs readed
	*
	* @var Array
	* @access private
	*/
	var $configData = Array();
	var $configFiles = Array();

	var $CacheExpired = false;

	var $prefixFiles = array();

	var $ProcessAllConfigs = false;
	var $FinalStage = false;
	var $StoreCache = false;
	var $AfterConfigProcessed = array();

	/**
	* Scan kernel and user classes
	* for available configs
	*
	* @access protected
	*/
	function Init($prefix,$special)
	{
	parent::Init($prefix,$special);
	}

	function CacheParsedData()
	{
	$event_manager =& $this->Application->recallObject('EventManager');
	$aggregator =& $this->Application->recallObject('TagsAggregator', 'kArray');

	$config_vars = Array (
	'SessionTimeout',
	'SessionCookieName',
	'SessionReferrerCheck',
	'CookieSessions',
	'UseCronForRegularEvent',
	'User_GuestGroup',
	'User_LoggedInGroup',
	'SessionTimeout',
	'UseModRewrite',
	'UseOutputCompression',
	'OutputCompressionLevel',
	'KeepSessionOnBrowserClose',
	'Config_Server_Time',
	'Config_Site_Time',
	'UseChangeLog',
	);

	foreach ($config_vars as $var) {
	$this->Application->ConfigValue($var);
	}

	$cache = Array(
	'Factory.Files' => $this->Application->Factory->Files,
	'Factory.realClasses' => $this->Application->Factory->realClasses,
	'Factory.Dependencies' => $this->Application->Factory->Dependencies,
	'ConfigReader.prefixFiles' => $this->prefixFiles,
	'EventManager.buildEvents' => $event_manager->buildEvents,
	'EventManager.beforeRegularEvents' => $event_manager->beforeRegularEvents,
	'EventManager.afterRegularEvents' => $event_manager->afterRegularEvents,
	'EventManager.beforeHooks' => $event_manager->beforeHooks,
	'EventManager.afterHooks' => $event_manager->afterHooks,
	'TagsAggregator.data' => $aggregator->_Array,

	// the following caches should be reset based on admin interaction (adjusting config, enabling modules etc)
	'Application.Caches.ConfigVariables' => $this->Application->Caches['ConfigVariables'],
	'Application.ConfigCacheIds' => $this->Application->ConfigCacheIds,
	'Application.ConfigHash' => $this->Application->ConfigHash,
	'Application.ReplacementTemplates' => $this->Application->ReplacementTemplates,
	'Application.ModuleInfo' => $this->Application->ModuleInfo,
	);

	$conn =& $this->Application->GetADODBConnection();
	if (isset($this->Application->Memcached)) {
	$this->Application->Memcached->set('master:configs_parsed', serialize($cache));
	$this->Application->Memcached->set('master:config_files', serialize($this->configFiles));
	}
	else {
	$conn->Query('REPLACE '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ("configs_parsed", '.$conn->qstr(serialize($cache)).', '.adodb_mktime().')');
	$conn->Query('REPLACE '.TABLE_PREFIX.'Cache (VarName, Data, Cached) VALUES ("config_files", '.$conn->qstr(serialize($this->configFiles)).', '.adodb_mktime().')');
	}

	$cache_rebuild_by = SERVER_NAME . ' (' . getenv('REMOTE_ADDR') . ') - ' . adodb_date('d/m/Y H:i:s');
	$conn->Query('REPLACE ' . TABLE_PREFIX . 'Cache (VarName, Data, Cached) VALUES ("last_cache_rebuild", ' . $conn->qstr($cache_rebuild_by) . ', ' . adodb_mktime() . ')');

	unset($this->configFiles);
	}

	function RestoreParsedData()
	{
	$conn =& $this->Application->GetADODBConnection();
	if (!isset($this->Application->Memcached) \|\| !($data = $this->Application->Memcached->get('master:configs_parsed'))) {
	$data = $conn->GetOne('SELECT Data FROM '.TABLE_PREFIX.'Cache WHERE VarName = "configs_parsed"');
	}
	if ($data) {
	$cache = unserialize($data);
	$this->Application->Factory->Files = $cache['Factory.Files'];
	$this->Application->Factory->realClasses = $cache['Factory.realClasses'];
	$this->Application->Factory->Dependencies = $cache['Factory.Dependencies'];
	$this->prefixFiles = $cache['ConfigReader.prefixFiles'];

	$event_manager =& $this->Application->recallObject('EventManager');
	$event_manager->buildEvents = $cache['EventManager.buildEvents'];
	$event_manager->beforeRegularEvents = $cache['EventManager.beforeRegularEvents'];
	$event_manager->afterRegularEvents = $cache['EventManager.afterRegularEvents'];
	$event_manager->beforeHooks = $cache['EventManager.beforeHooks'];
	$event_manager->afterHooks = $cache['EventManager.afterHooks'];

	$aggregator =& $this->Application->recallObject('TagsAggregator', 'kArray');
	$aggregator->_Array = $cache['TagsAggregator.data'];

	$this->Application->ConfigHash = $cache['Application.ConfigHash'];

	$this->Application->Caches['ConfigVariables'] = $cache['Application.ConfigCacheIds'];
	$this->Application->ConfigCacheIds = $cache['Application.ConfigCacheIds'];

	$this->Application->ReplacementTemplates = $cache['Application.ReplacementTemplates'];

	$this->Application->ModuleInfo = $cache['Application.ModuleInfo'];

	return true;

	}
	else return false;
	}

	function ResetParsedData($include_sections = false)
	{
	$conn =& $this->Application->GetADODBConnection();
	$conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "configs_parsed"');
	if (isset($this->Application->Memcached)) {
	$this->Application->Memcached->delete('master:configs_parsed');
	}

	if ($include_sections) {
	$conn->Query('DELETE FROM '.TABLE_PREFIX.'Cache WHERE VarName = "sections_parsed"');
	if (isset($this->Application->Memcached)) {
	$this->Application->Memcached->delete('master:sections_parsed');
	}
	}
	}

	function scanModules($folderPath, $cache = true)
	{
	if (defined('IS_INSTALL') && IS_INSTALL && !defined('FORCE_CONFIG_CACHE')) {
	// disable config caching during installation
	$cache = false;
	}

	if ($cache) {
	$restored = $this->RestoreParsedData();
	if ($restored) return;
	}

	$this->ProcessAllConfigs = true;

	$this->includeConfigFiles($folderPath, $cache);
	$this->ParseConfigs();

	// tell AfterConfigRead to store cache if neede
	// can't store it here beacuse AfterConfigRead needs ability to change config data
	$this->StoreCache = $cache;
	}

	function findConfigFiles($folderPath)
	{
	// if FULL_PATH = "/" ensure, that all "/" in $folderPath are not deleted
	$reg_exp = '/^'.preg_quote(FULL_PATH, '/').'/';
	$folderPath = preg_replace($reg_exp, '', $folderPath, 1); // this make sense, since $folderPath may NOT contain FULL_PATH

	$fh = opendir(FULL_PATH.$folderPath);
	while (($sub_folder = readdir($fh))) {
	$full_path = FULL_PATH.$folderPath.'/'.$sub_folder;
	if ($this->isDir($full_path)) {
	if (preg_match('/^\./', $sub_folder)) continue; // don't scan .folders
	//the following is to exclude OLD, not removed files when upgrading to 'core'
	if (preg_match('/^\/kernel\/kernel4\//', $folderPath) \|\| ($folderPath == '/kernel/units' && file_exists(FULL_PATH.$this->getConfigName('/core/units/'.$sub_folder)))) {
	continue;
	}
	if (file_exists(FULL_PATH.$this->getConfigName($folderPath.'/'.$sub_folder))) {
	$this->configFiles[] = $this->getConfigName($folderPath.'/'.$sub_folder);
	}
	$this->findConfigFiles($full_path);

	// if (filemtime($full_path) > $cached) { }

	}
	}
	}

	function includeConfigFiles($folderPath, $cache = true)
	{
	$this->Application->refreshModuleInfo();

	$conn =& $this->Application->GetADODBConnection();
	if (!isset($this->Application->Memcached) \|\| !($data = $this->Application->Memcached->get('master:config_files'))) {
	$data = $conn->GetOne('SELECT Data FROM '.TABLE_PREFIX.'Cache WHERE VarName = "config_files"');
	}
	if ($cache && $data) {
	$this->configFiles = unserialize($data);
	shuffle($this->configFiles);
	}
	else {
	$this->findConfigFiles($folderPath); // search from base directory
	}

	foreach ($this->configFiles as $filename)
	{
	$prefix = $this->PreloadConfigFile($filename);
	if (!$prefix) {
	trigger_error('Prefix not defined in config file '.$filename, E_USER_ERROR);
	}
	}
	}

	/**
	* Process all read config files - called ONLY when there is no cache!
	*
	*/
	function ParseConfigs()
	{
	// 1. process normal configs and their dependencies
	$prioritized_configs = array();
	foreach ($this->configData as $prefix => $config) {
	if (isset($config['ConfigPriority'])) {
	$prioritized_configs[$prefix] = $config['ConfigPriority'];
	continue;
	}
	$this->parseConfig($prefix);
	}

	foreach ($this->configData as $prefix => $config) {
	$this->ProcessDependencies($prefix);
	$this->postProcessConfig($prefix, 'AggregateConfigs', 'sub_prefix');
	$clones = $this->postProcessConfig($prefix, 'Clones', 'prefix');
	}

	// 2. process prioritized configs and their dependencies
	asort($prioritized_configs);
	foreach ($prioritized_configs as $prefix => $priority) {
	$this->parseConfig($prefix);
	}

	foreach ($prioritized_configs as $prefix => $priority) {
	$this->ProcessDependencies($prefix);
	}
	}

	function AfterConfigRead($store_cache = null)
	{
	// if (!$this->ProcessAllConfigs) return ;
	$this->FinalStage = true;
	foreach ($this->configData as $prefix => $config) {
	if (in_array($prefix, $this->AfterConfigProcessed)) {
	continue;
	}

	$this->Application->HandleEvent( new kEvent($prefix.':OnAfterConfigRead') );
	$this->AfterConfigProcessed[] = $prefix;
	}

	if (!isset($store_cache)) {
	// store cache not overrided -> use global setting
	$store_cache = $this->StoreCache;
	}

	if ($store_cache \|\| (defined('IS_INSTALL') && IS_INSTALL)) {
	// cache is not stored during install, but dynamic clones should be processed in any case
	$this->processDynamicClones();
	}

	if ($store_cache) {
	$this->CacheParsedData();

	if ($this->Application->isDebugMode(false) && constOn('DBG_VALIDATE_CONFIGS')) {
	// validate configs here to have changes from OnAfterConfigRead hooks to prefixes
	foreach ($this->configData as $prefix => $config) {
	if (!isset($config['TableName'])) continue;
	$this->ValidateConfig($prefix);
	}
	}

	$after_event = new kEvent('adm:OnAfterCacheRebuild');
	$this->Application->HandleEvent($after_event);
	}
	}

	/**
	* Re-reads all configs
	*
	*/
	function ReReadConfigs()
	{
	// clear restored cache (not in db)
	$this->Application->Factory->Files = Array ();
	$this->Application->Factory->realClasses = Array ();
	$this->Application->Factory->Dependencies = Array ();

	$this->Application->EventManager->beforeRegularEvents = Array ();
	$this->Application->EventManager->afterRegularEvents = Array ();
	$this->Application->EventManager->beforeHooks = Array ();
	$this->Application->EventManager->afterHooks = Array ();

	// otherwise ModulesHelper indirectly used from includeConfigFiles won't work
	$this->Application->RegisterDefaultClasses();

	// parse all configs
	$this->ProcessAllConfigs = true;
	$this->includeConfigFiles(MODULES_PATH, false);
	$this->ParseConfigs();
	$this->AfterConfigRead(false);
	$this->processDynamicClones();
	}

	/**
	* Process clones, that were defined via OnAfterConfigRead event
	*
	*/
	function processDynamicClones()
	{
	$new_clones = Array();
	foreach ($this->configData as $prefix => $config) {
	$clones = $this->postProcessConfig($prefix, 'Clones', 'prefix');
	if ($clones) {
	$new_clones = array_merge($new_clones, $clones);
	}
	}

	// call OnAfterConfigRead for cloned configs
	$new_clones = array_unique($new_clones);
	foreach ($new_clones as $prefix) {
	if (in_array($prefix, $this->AfterConfigProcessed)) {
	continue;
	}

	$this->Application->HandleEvent( new kEvent($prefix.':OnAfterConfigRead') );
	$this->AfterConfigProcessed[] = $prefix;
	}
	}

	/**
	* Register nessasary classes
	* This method should only process the data which is cached!
	*
	* @param string $prefix
	* @access private
	*/
	function parseConfig($prefix)
	{
	$config =& $this->configData[$prefix];
	$event_manager =& $this->Application->recallObject('EventManager');

	$register_classes = getArrayValue($config,'RegisterClasses');
	if (!$register_classes) $register_classes = Array();
	$class_params=Array('ItemClass','ListClass','EventHandlerClass','TagProcessorClass');
	foreach($class_params as $param_name)
	{
	if ( !(isset($config[$param_name]) ) ) continue;
	$config[$param_name]['pseudo'] = $this->getPrefixByParamName($param_name,$prefix);
	$register_classes[] = $config[$param_name];
	}

	foreach($register_classes as $class_info)
	{
	$require_classes = getArrayValue($class_info, 'require_classes');
	if ($require_classes) {
	if (!is_array($require_classes)) {
	$require_classes = array($require_classes);
	}
	if (!isset($config['_Dependencies'][$class_info['class']])) {
	$config['_Dependencies'][$class_info['class']] = array();
	}
	$config['_Dependencies'][$class_info['class']] = array_merge($config['_Dependencies'][$class_info['class']], $require_classes);
	}
	$this->Application->registerClass(
	$class_info['class'],
	$config['BasePath'].'/'.$class_info['file'],
	$class_info['pseudo']/*,
	getArrayValue($class_info, 'require_classes')*/
	);
	if (getArrayValue($class_info, 'build_event')) {
	$event_manager->registerBuildEvent($class_info['pseudo'],$class_info['build_event']);
	}
	}

	$regular_events = getArrayValue($config, 'RegularEvents');
	if($regular_events)
	{
	foreach($regular_events as $short_name => $regular_event_info)
	{
	$event_manager->registerRegularEvent( $short_name, $config['Prefix'].':'.$regular_event_info['EventName'], $regular_event_info['RunInterval'], $regular_event_info['Type'] );
	}
	}

	$hooks = getArrayValue($config, 'Hooks');
	if (is_array($hooks) && count($hooks) > 0) {
	foreach ($hooks as $hook) {
	if (isset($config['ParentPrefix']) && $hook['HookToPrefix'] == $config['ParentPrefix']) {
	trigger_error('Depricated Hook Usage [prefix: <b>'.$config['Prefix'].'</b>; do_prefix: <b>'.$hook['DoPrefix'].'</b>] use <b>#PARENT#</b> as <b>HookToPrefix</b> value, where HookToPrefix is same as ParentPrefix', E_USER_NOTICE);
	}

	if ($hook['HookToPrefix'] == '') {
	$hook['HookToPrefix'] = $config['Prefix']; // new: set hooktoprefix to current prefix if not set
	}

	if (isset($config['ParentPrefix'])) {
	// new: allow to set hook to parent prefix what ever it is
	if ($hook['HookToPrefix'] == '#PARENT#') {
	$hook['HookToPrefix'] = $config['ParentPrefix'];
	}

	if ($hook['DoPrefix'] == '#PARENT#') {
	$hook['DoPrefix'] = $config['ParentPrefix'];
	}
	}
	elseif ($hook['HookToPrefix'] == '#PARENT#' \|\| $hook['DoPrefix'] == '#PARENT#') {
	continue; // we need parent prefix but it's not set !
	}

	$do_prefix = $hook['DoPrefix'] == '' ? $config['Prefix'] : $hook['DoPrefix'];

	if ( !is_array($hook['HookToEvent']) ) {
	$hook_events = Array( $hook['HookToEvent'] );
	}
	else {
	$hook_events = $hook['HookToEvent'];
	}
	foreach ($hook_events as $hook_event) {
	$this->Application->registerHook($hook['HookToPrefix'], $hook['HookToSpecial'], $hook_event, $hook['Mode'], $do_prefix, $hook['DoSpecial'], $hook['DoEvent'], $hook['Conditional']);
	}
	}
	}

	if ( is_array(getArrayValue($config, 'AggregateTags')) ) {
	foreach ($config['AggregateTags'] as $aggregate_tag) {
	if (isset($config['ParentPrefix'])) {
	if ($aggregate_tag['AggregateTo'] == $config['ParentPrefix']) {
	trigger_error('Depricated Aggregate Tag Usage [prefix: <b>'.$config['Prefix'].'</b>; AggregateTo: <b>'.$aggregate_tag['AggregateTo'].'</b>] use <b>#PARENT#</b> as <b>AggregateTo</b> value, where AggregateTo is same as ParentPrefix', E_USER_NOTICE);
	}

	if ($aggregate_tag['AggregateTo'] == '#PARENT#') {
	$aggregate_tag['AggregateTo'] = $config['ParentPrefix'];
	}
	}
	$aggregate_tag['LocalPrefix'] = $config['Prefix'];
	$this->Application->registerAggregateTag($aggregate_tag);
	}
	}

	if (isset($config['ReplacementTemplates']) && $config['ReplacementTemplates']) {
	// replacement templates defined in this config
	$this->Application->ReplacementTemplates = array_merge_recursive2($this->Application->ReplacementTemplates, $config['ReplacementTemplates']);
	}
	}

	function ValidateConfig($prefix)
	{
	global $debugger;

	$config =& $this->configData[$prefix];

	$tablename = $config['TableName'];
	$float_types = Array ('float', 'double', 'numeric');
	$conn =& $this->Application->GetADODBConnection();

	$table_found = $conn->Query('SHOW TABLES LIKE "'.$tablename.'"');
	if (!$table_found) {
	// config present, but table missing, strange
	$debugger->appendHTML("<b class='debug_error'>Config Warning: </b>Table <strong>$tablename</strong> missing, but prefix <b>".$config['Prefix']."</b> requires it!");
	safeDefine('DBG_RAISE_ON_WARNINGS', 1);
	return ;
	}

	$res = $conn->Query('DESCRIBE '.$tablename);
	$config_link = $debugger->getFileLink(FULL_PATH.$this->prefixFiles[$config['Prefix']], 1, $config['Prefix']);

	$error_messages = Array (
	'field_not_found' => 'Field <strong>%s</strong> exists in the database, but <strong>is not defined</strong> in config',
	'default_missing' => 'Default value for field <strong>%s</strong> not set in config',
	'not_null_error1' => 'Field <strong>%s</strong> is NOT NULL in the database, but is not configured as not_null', // or required',
	'not_null_error2' => 'Field <strong>%s</strong> is described as NOT NULL in config, but <strong>does not have DEFAULT value</strong>',
	'not_null_error3' => 'Field <strong>%s</strong> is described as <strong>NOT NULL in config</strong>, but is <strong>NULL in db</strong>',
	'invalid_default' => '<strong>Default value</strong> for field %s<strong>%s</strong> not sync. to db (in config = %s, in db = %s)',
	'type_missing' => '<strong>Type definition</strong> for field <strong>%s</strong> missing in config',
	);

	$config_errors = Array ();
	$tablename = preg_replace('/^'.preg_quote(TABLE_PREFIX, '/').'(.*)/', '\\1', $tablename); // remove table prefix

	foreach ($res as $field) {
	$f_name = $field['Field'];

	if (getArrayValue($config, 'Fields')) {
	if (preg_match('/l[\d]+_[\w]/', $f_name)) {
	// skip multilingual fields
	continue;
	}

	if (!array_key_exists ($f_name, $config['Fields'])) {
	$config_errors[] = sprintf($error_messages['field_not_found'], $f_name);
	}
	else {
	if (is_numeric($field['Default'])) {
	$field['Default'] = preg_match('/[\.,]/', $field['Default']) ? (float)$field['Default'] : (int)$field['Default'];
	}

	$options = $config['Fields'][$f_name];
	$default_missing = false;
	if (!array_key_exists('default', $options)) {
	$config_errors[] = sprintf($error_messages['default_missing'], $f_name);
	$default_missing = true;
	}

	if ($field['Null'] != 'YES') {
	// field is NOT NULL in database (MySQL5 for null returns "NO", but MySQL4 returns "")
	if ( $f_name != $config['IDField'] && !isset($options['not_null']) /&& !isset($options['required'])/ ) {
	$config_errors[] = sprintf($error_messages['not_null_error1'], $f_name);
	}
	if (isset($options['not_null']) && $options['not_null'] && !isset($options['default']) ) {
	$config_errors[] = sprintf($error_messages['not_null_error2'], $f_name);
	}
	}
	else {
	if (isset($options['not_null']) && $options['not_null']) {
	$config_errors[] = sprintf($error_messages['not_null_error3'], $f_name);
	}
	}

	if (!array_key_exists('type', $options)) {
	$config_errors[] = sprintf($error_messages['type_missing'], $f_name);
	}

	if (!$default_missing) {
	if ($f_name == $config['IDField'] && $options['type'] != 'string' && $options['default'] !== 0) {
	$config_errors[] = sprintf($error_messages['invalid_default'], '<span class="debug_error">IDField</span> ', $f_name, $this->varDump($options['default']), $this->varDump($field['Default']));
	}
	else if ($options['default'] != '#NOW#' && $field['Default'] !== $options['default'] && !in_array($options['type'], $float_types)) {
	$config_errors[] = sprintf($error_messages['invalid_default'], '', $f_name, $this->varDump($options['default']), $this->varDump($field['Default']));
	}
	}
	}
	}
	}

	if ($config_errors) {
	$error_prefix = '<strong class="debug_error">Config Error'.(count($config_errors) > 1 ? 's' : '').': </strong> for prefix <strong>'.$config_link.'</strong> ('.$tablename.') in unit config:<br />';
	$config_errors = $error_prefix.'   '.implode('<br />   ', $config_errors);

	$debugger->appendHTML($config_errors);
	safeDefine('DBG_RAISE_ON_WARNINGS', 1);
	}
	}

	function varDump($value)
	{
	return '<strong>'.var_export($value, true).'</strong> of '.gettype($value);
	}

	function ProcessDependencies($prefix)
	{
	$config =& $this->configData[$prefix];
	$deps = getArrayValue($config, '_Dependencies');
	if (!$deps) return ;

	foreach ($deps as $real_class => $requires) {
	foreach ($requires as $class) {
	$this->Application->registerDependency($real_class, $class);
	}
	}
	unset($config['_Dependencies']);
	}

	function postProcessConfig($prefix, $config_key, $dst_prefix_var)
	{
	$main_config =& $this->configData[$prefix];
	$sub_configs = isset($main_config[$config_key]) && $main_config[$config_key] ? $main_config[$config_key] : false; // getArrayValue($main_config, $config_key);
	if (!$sub_configs) {
	return array();
	}
	unset($main_config[$config_key]);

	$processed = array();
	foreach ($sub_configs as $sub_prefix => $sub_config) {
	if ($config_key == 'AggregateConfigs' && !isset($this->configData[$sub_prefix])) {
	$this->loadConfig($sub_prefix);
	}
	$sub_config['Prefix'] = $sub_prefix;
	$this->configData[$sub_prefix] = array_merge_recursive2($this->configData[$$dst_prefix_var], $sub_config);

	// when merging empty array to non-empty results non-empty array, but empty is required
	foreach ($sub_config as $sub_key => $sub_value) {
	if (!$sub_value) {
	unset($this->configData[$sub_prefix][$sub_key]);
	}
	}
	if ($config_key == 'Clones') {
	$this->prefixFiles[$sub_prefix] = $this->prefixFiles[$prefix];
	}

	$this->postProcessConfig($sub_prefix, $config_key, $dst_prefix_var);
	if ($config_key == 'AggregateConfigs') {
	$processed = array_merge($this->postProcessConfig($sub_prefix, 'Clones', 'prefix'), $processed);
	}
	elseif ($this->ProcessAllConfigs) {
	$this->parseConfig($sub_prefix);
	}
	array_push($processed, $sub_prefix);
	}

	if (!$prefix) {
	// configs, that used only for cloning & not used ifself
	unset($this->configData[$prefix]);
	}
	return array_unique($processed);
	}

	function PreloadConfigFile($filename)
	{
	$config_found = file_exists(FULL_PATH.$filename) && $this->configAllowed($filename);

	if( defined('DEBUG_MODE') && DEBUG_MODE && constOn('DBG_PROFILE_INCLUDES') )
	{
	if ( in_array($filename, get_required_files()) ) return;
	global $debugger;
	if($config_found) {
	$file = FULL_PATH.$filename;
	$debugger->ProfileStart('inc_'.crc32($file), $file);
	include_once($file);
	$debugger->ProfileFinish('inc_'.crc32($file));
	$debugger->profilerAddTotal('includes', 'inc_'.crc32($file));
	}
	}
	else
	{
	if ($config_found) include_once(FULL_PATH.$filename);
	}

	if ($config_found) {
	if (isset($config) && $config) {
	// config file is included for 1st time -> save it's content for future processing
	$prefix = isset($config['Prefix']) ? $config['Prefix'] : '';

	preg_match('/\/(.*)\//U', $filename, $rets);
	$config['ModuleFolder'] = $rets[1];
	$config['BasePath'] = dirname(FULL_PATH.$filename);
	if (isset($config['AdminTemplatePath'])) {
	// append template base folder for admin templates path of this prefix
	$module_templates = $rets[1] == 'core' ? '' : $rets[1].'/';
	$config['AdminTemplatePath'] = $module_templates.$config['AdminTemplatePath'];
	}
	$this->configData[$prefix] = $config;
	$this->prefixFiles[$prefix] = $filename;
	return $prefix;
	}
	elseif ($prefix = array_search($filename, $this->prefixFiles)) {
	// attempt is made to include config file twice or more, but include_once prevents that,
	// but file exists on hdd, then it is already saved to all required arrays, just return it's prefix
	return $prefix;
	}
	}
	return 'dummy';
	}

	function loadConfig($prefix)
	{
	if (!isset($this->prefixFiles[$prefix])) {
	if ($this->Application->isDebugMode()) $this->Application->Debugger->appendTrace();
	trigger_error('Configuration file for prefix <b>'.$prefix.'</b> is unknown', E_USER_ERROR);
	return ;
	}
	$file = $this->prefixFiles[$prefix];
	$prefix = $this->PreloadConfigFile($file);

	$clones = $this->postProcessConfig($prefix, 'AggregateConfigs', 'sub_prefix');
	$clones = array_merge($this->postProcessConfig($prefix, 'Clones', 'prefix'), $clones);

	if ($this->FinalStage) {
	array_unshift($clones, $prefix);
	$clones = array_unique($clones);
	foreach ($clones as $a_prefix) {
	$this->Application->HandleEvent( new kEvent($a_prefix.':OnAfterConfigRead') );
	}
	}
	}

	/**
	* Reads unit (specified by $prefix)
	* option specified by $option
	*
	* @param string $prefix
	* @param string $name
	* @param mixed $default
	* @return string
	* @access public
	*/
	function getUnitOption($prefix, $name, $default = false)
	{
	if (preg_match('/(.)\.(.)/', $prefix, $rets)) {
	if (!isset($this->configData[$rets[1]])) {
	$this->loadConfig($rets[1]);
	}
	$ret = isset($this->configData[$rets[1]][$name][$rets[2]]) ? $this->configData[$rets[1]][$name][$rets[2]] : false;
	// $ret = getArrayValue($this->configData, $rets[1], $name, $rets[2]);
	}
	else {
	if (!isset($this->configData[$prefix])) {
	$this->loadConfig($prefix);
	}
	$ret = isset($this->configData[$prefix][$name]) ? $this->configData[$prefix][$name] : false;
	// $ret = getArrayValue($this->configData, $prefix, $name);
	}
	return $ret === false ? $default : $ret;
	}

	/**
	* Read all unit with $prefix options
	*
	* @param string $prefix
	* @return Array
	* @access public
	*/
	function getUnitOptions($prefix)
	{
	if (!isset($this->configData[$prefix])) {
	$this->loadConfig($prefix);
	}

	return $this->configData[$prefix];
	}

	/**
	* Set's new unit option value
	*
	* @param string $prefix
	* @param string $name
	* @param string $value
	* @access public
	*/
	function setUnitOption($prefix, $name, $value)
	{
	if (preg_match('/(.)\.(.)/', $prefix, $rets)) {
	if (!isset($this->configData[$rets[1]])) {
	$this->loadConfig($rets[1]);
	}
	$this->configData[$rets[1]][$name][$rets[2]] = $value;
	}
	else {
	if (!isset($this->configData[$prefix])) {
	$this->loadConfig($prefix);
	}
	$this->configData[$prefix][$name] = $value;
	}

	}

	function getPrefixByParamName($paramName,$prefix)
	{
	$pseudo_class_map=Array(
	'ItemClass'=>'%s',
	'ListClass'=>'%s_List',
	'EventHandlerClass'=>'%s_EventHandler',
	'TagProcessorClass'=>'%s_TagProcessor'
	);
	return sprintf($pseudo_class_map[$paramName],$prefix);
	}

	/**
	* Get's config file name based
	* on folder name supplied
	*
	* @param string $folderPath
	* @return string
	* @access private
	*/
	function getConfigName($folderPath)
	{
	return $folderPath.'/'.basename($folderPath).'_config.php';
	}

	/**
	* is_dir ajustment to work with
	* directory listings too
	*
	* @param string $folderPath
	* @return bool
	* @access private
	*/
	function isDir($folderPath)
	{
	$base_name = basename($folderPath);
	$ret = !( $base_name == '.' \|\| $base_name == '..' );
	return $ret && is_dir($folderPath);
	}

	/**
	* Checks if config file is allowed for includion (if module of config is installed)
	*
	* @param string $config_path relative path from in-portal directory
	*/
	function configAllowed($config_path)
	{
	if (defined('IS_INSTALL') && IS_INSTALL) {
	// at installation start no modules in db and kernel configs could not be read
	return true;
	}

	if (preg_match('#/plugins/\|/core#', $config_path)) {
	return true;
	}

	$module_found = false;
	if (!$this->Application->ModuleInfo) return false;

	foreach($this->Application->ModuleInfo as $module_name => $module_info)
	{
	$module_path = '/'.$module_info['Path'];
	if (preg_match('/^'.preg_quote($module_path, '/').'/', $config_path)) {
	// if (mb_substr($config_path, 0, mb_strlen($module_path)) == $module_path) {
	// config file path starts with module folder path
	$module_found = true;
	break;
	}
	}
	return $module_found;
	}

	/**
	* Returns true if config exists and is allowed for reading
	*
	* @param string $prefix
	* @return bool
	*/
	function prefixRegistred($prefix)
	{
	return isset($this->prefixFiles[$prefix]) ? true : false;
	}

	/**
	* Returns config file for given prefix
	*
	* @param string $prefix
	* @return string
	*/
	function getPrefixFile($prefix)
	{
	return array_key_exists($prefix, $this->prefixFiles) ? $this->prefixFiles[$prefix] : false;
	}

	function iterateConfigs($callback_function, $params)
	{
	$this->includeConfigFiles(MODULES_PATH); //make sure to re-read all configs
	$this->AfterConfigRead();

	foreach ($this->configData as $prefix => $config_data) {
	$callback_function[0]->$callback_function[1]($prefix, $config_data, $params);
	}
	}

	}


	?>

unit_config_reader.phpNo OneTemporaryActions

File Metadata

unit_config_reader.phpView Options

Event Timeline

unit_config_reader.php
No OneTemporary
Actions

unit_config_reader.php
View Options