/** @return ADORecordSet */ private static function executeQuery($query, $params = false, &$queryFinal = null, array &$paramsFinal = null) { $queryFinal = $query instanceof Query ? $query->build($params) : $query; $queryFinal = normalize_string($queryFinal); $paramsFinal = to_array($params); $LOGGER = PsLogger::inst(__CLASS__); $PROFILER = PsProfiler::inst(__CLASS__); $PROFILER->start(strtolower($queryFinal)); try { if ($LOGGER->isEnabled()) { $LOGGER->info("[{$queryFinal}]" . ($paramsFinal ? ', PARAMS: ' . array_to_string($paramsFinal) : '')); } $rs = PsConnectionPool::conn()->execute($queryFinal, $paramsFinal); if (is_object($rs)) { $PROFILER->stop(); return $rs; } $error = PsConnectionPool::conn()->ErrorMsg(); $LOGGER->info('ERROR: {}', $error); throw new DBException($error, DBException::ERROR_NOT_CLASSIFIED, $queryFinal, $paramsFinal); } catch (Exception $ex) { $PROFILER->stop(false); if ($ex instanceof DBException) { ExceptionHandler::dumpError($ex); } throw $ex; } }
/** * Очищает все кеши */ public static function clearAll() { PsLogger::inst(__CLASS__)->info('! Clear all db caches'); foreach (self::$CACHES as $class => $cache) { self::clear($class); } }
private function __construct(array $params) { PsLibs::inst()->SpriteGenerator(); $this->CssSpriteGen = new CssSpriteGen($params); $this->LOGGER = PsLogger::inst(__CLASS__); $this->PROFILER = PsProfiler::inst(__CLASS__); }
private function __construct(array $params) { ExternalPluginsManager::SpriteGenerator(); $this->CssSpriteGen = new CssSpriteGen($params); $this->LOGGER = PsLogger::inst(__CLASS__); $this->PROFILER = PsProfiler::inst(__CLASS__); }
/** * Метод убеждается в том, что провайдер безопасности установлен. * Наша задача - установить провайдер один раз и проверить, чтобы он больше не менялся. */ public static function init() { self::$inited = check_condition(!self::$inited, 'Cannot initialize ' . __CLASS__ . ' twice'); if (self::$provider instanceof PsSecurityProvider) { //Провайдер безопастности был уже установлен } else { check_condition(is_null(self::$provider), __CLASS__ . ' is not correctly initialized'); if (PsContext::isCmd()) { //Если работаем под процессом - установим специальный провайдер безопастности self::$provider = new PsSecurityProviderCmd(); } else { //Устанавливаем базовый провайдер безопасности на основе сессии self::$provider = new PsSecurityProviderSdk(); } } check_condition(!PsContext::isCmd() || self::$provider instanceof PsSecurityProviderCmd, 'Invalid security provider for cmd process'); $LOGGER = PsLogger::inst(__CLASS__); if ($LOGGER->isEnabled()) { $LOGGER->info('Context: {}', PsContext::describe()); $LOGGER->info('Provider: {}', get_class(self::$provider)); $LOGGER->info('Is authorized: {}', var_export(self::$provider->isAuthorized(), true)); $LOGGER->info('Is admin: {}', var_export(self::$provider->isAuthorizedAsAdmin(), true)); $LOGGER->info('User ID: {}', self::$provider->getUserId()); } }
/** * Основной метод получения экземпляра. * * @param type $silentOnDoubleTry - признак, стоит ли нам ругаться, если мы * обнаруживаем зацикливание при попытке получения экземпляра класса. * * Это нужно для классов, которые выполняют сложную логику в конструкторе, которая * может привести к повторному вызову ::inst() внутри этого конструктора. * * Классы, которые используют эту возможность: * @link DbChangeListener - менеджер прослушивания изменений в БД */ protected static function inst($silentOnDoubleTry = false) { $class = get_called_class(); if (array_key_exists($class, self::$_insts_)) { return self::$_insts_[$class]; } if (array_key_exists($class, self::$_instsrq_)) { if ($silentOnDoubleTry) { return null; } raise_error("Double try to get singleton of [{$class}]"); } self::$_instsrq_[$class] = true; //Создаём экземпляр $sec = Secundomer::startedInst("Creating singleton of {$class}"); self::$_insts_[$class] = new $class(); $sec->stop(); //Экземпляр успешно создан unset(self::$_instsrq_[$class]); //Теперь добавим в профайлер. Всё это нужно для защиты от зацикливания. PsProfiler::inst(__CLASS__)->add($class, $sec); //Добавим к глобальному секундомеру - текущий $SECUNDOMER = self::$_secundomer_ ? self::$_secundomer_ : (self::$_secundomer_ = Secundomer::inst()); $SECUNDOMER->addSecundomer($sec); //Отлогируем PsLogger::inst(__CLASS__)->info("+ {$class} ({$sec->getAverage()} / {$SECUNDOMER->getTotalTimeRounded()})"); return self::$_insts_[$class]; }
/** * Метод вызывается для инициализации окружения: * 1. Директория ресурсов окружения будет подключена в Autoload * 2. Файл, включающий окружение, будет выполнен */ public static function init() { if (self::$inited) { return; //--- } self::$inited = true; //--- /* * Проверим, нужно ли подключать окружение */ if (self::isSkipInclude()) { return; //--- } $env = self::env(); if (!$env) { return; //--- } $envDir = array_get_value($env, ConfigIni::environments()); if (!$envDir) { return PsUtil::raise('Environment [{}] not found', $env); } if (!is_dir($envDir)) { return PsUtil::raise('Environment dir for [{}] not found', $env); } $envSrcDir = next_level_dir($envDir, DirManager::DIR_SRC); $envIncFile = file_path($envDir, $env, PsConst::EXT_PHP); if (!is_file($envIncFile)) { return PsUtil::raise('Environment include file for [{}] not found', $env); } $LOGGER = PsLogger::inst(__CLASS__); if ($LOGGER->isEnabled()) { $LOGGER->info('Including \'{}\' environment for context \'{}\'', $env, PsContext::describe()); $LOGGER->info('Env dir: {}', $envDir); $LOGGER->info('Src dir: {}', $envSrcDir); $LOGGER->info('Inc file: {}', $envIncFile); } //Проинициализировано окружение self::$included = true; //Регистрируем директорию с классами, специфичными только для данного окружения Autoload::inst()->registerBaseDir($envSrcDir, false); //Выполним необходимое действие $PROFILER = PsProfiler::inst(__CLASS__); try { $LOGGER->info('{'); $PROFILER->start($env); self::initImpl($LOGGER, $envIncFile); $secundomer = $PROFILER->stop(); $LOGGER->info('}'); $LOGGER->info('Inc file included for {} sec', $secundomer->getTime()); } catch (Exception $ex) { $PROFILER->stop(false); $LOGGER->info('Inc file execution error: [{}]', $ex->getMessage()); throw $ex; //--- } }
protected static final function isInclude($key) { if (array_key_exists($key, self::$included)) { return false; } self::$included[$key] = true; PsLogger::inst(__CLASS__)->info('+ {}', $key); return true; }
/** * Конструктор */ protected final function __construct() { $this->LOGGER = PsLogger::inst(__CLASS__); /* * Подключаться к БД будем в MainImport, чтобы не подключиться заранее */ //Поумолчанию коннектимся на продуктив //$this->CONNECTION_PARAMS = PsConnectionParams::get(PsConnectionParams::CONN_PRODUCTION); }
private function __construct(array $cells, $w, $h, $checkUser) { $this->LOGGER = PsLogger::inst(__CLASS__); $this->w = $w; $this->h = $h; $this->checkUser = !!$checkUser; $this->result = array(); $this->doProcess($cells); }
private function __construct($name, Spritable $spritable) { $this->LOGGER = PsLogger::inst(__CLASS__); $this->spritable = $spritable; $this->name = $name; $this->cssDi = self::autogenWs($name)->getDirItem(null, $name, 'css'); $this->imgDi = self::autogenWs($name)->getDirItem(null, $name, PsImg::getExt(SYSTEM_IMG_TYPE)); $this->LOGGER->info("INSTANCE CREATED FOR [{$name}]"); $this->rebuild(false); }
/** * Вызов выполнения метода. Используется из ajax. */ public static function execute($method, array $params) { check_condition(array_key_exists($method, self::getMethodsList()), "Method TestManager::{$method} cannot be called"); PsUtil::startUnlimitedMode(); PsLogger::inst('TestManager')->info("Method TestManager::{$method} called with params: " . array_to_string($params)); $s = Secundomer::startedInst(); call_user_func_array(array(TestManager::inst(), $method), $params); $s->stop(); PsLogger::inst('TestManager')->info("Call done in {$s->getTotalTime()} seconds"); }
protected final function __construct() { $this->CLASS = get_called_class(); PsUtil::assertClassHasDifferentConstValues($this->CLASS, 'CODE_'); PsUtil::assertClassHasDifferentConstValues($this->CLASS, 'ACTION_'); $this->ACTIONS = PsUtil::getClassConsts($this->CLASS, 'ACTION_'); $this->LOGGER = PsLogger::inst($this->CLASS); $this->PROCESS_CODE = $this->getProcessCode(); check_condition(in_array($this->PROCESS_CODE, PsUtil::getClassConsts(__CLASS__, 'CODE_')), "Класс [{$this->CLASS}] использует незарегистрированный код аудита [{$this->PROCESS_CODE}]."); $this->SESSION = SESSION_AUDIT_ACTION . '-' . $this->CLASS . '-' . $this->PROCESS_CODE; }
/** * Метод добавляет шорткоды * TODO - вынести на конфиги */ public static function addShortcodes() { $wpShortcodes = new PsWpShortCodes(); $methods = PsUtil::getClassMethods($wpShortcodes, true, false, true, false); $LOGGER = PsLogger::inst(__CLASS__); $LOGGER->info(); $LOGGER->info(__METHOD__); foreach ($methods as $action) { $LOGGER->info(' + {}', $action); add_shortcode($action, array($wpShortcodes, $action)); } }
/** * Функция, выполняющая закрытие классов. * Должна быть именно public, иначе не будет вызвана! */ static final function _doShotdown() { PsCheck::arr(self::$DESTRUCTS); ksort(self::$DESTRUCTS); /* @var $inst Destructable */ foreach (self::$DESTRUCTS as $ord => $inst) { //Пишем в логгер до закрытия класса, так как логгер закрывается последним PsLogger::inst(__CLASS__)->info($ord . '. ' . get_class($inst) . ' - desctucted'); $inst->onDestruct(); } self::$DESTRUCTS = null; }
/** * Конструктор у класса-источника может быть только один */ private final function __construct($class, array $params, $mident, $hash) { $this->CLASS = $class; $this->LOGGER = PsLogger::inst($class); $this->HASH = $hash; $this->MIDENT = $mident; $this->PARAMS = $params; check_condition($this->HASH, 'Уникальный код источника не может быть пустым'); check_condition($this->MIDENT, 'Идентификатор маппинга не может быть пустым'); check_condition(is_array($this->PARAMS), 'Параметры построения источника должны быть массивом'); $this->init($mident, $params); }
public function __construct() { /** * Подключаем cache lite */ PsLibs::inst()->CacheLite(); /* * Конфигурируем */ $liteOptions = array('readControl' => true, 'writeControl' => true, 'readControlType' => 'md5', 'automaticSerialization' => true, 'cacheDir' => DirManager::autogen('cache-lite')->absDirPath(), 'lifeTime' => ConfigIni::cacheFileLifetime() * 60, 'caching' => true); if (PsLogger::isEnabled()) { PsLogger::inst(__CLASS__)->info('Lite options: {}', print_r($liteOptions, true)); } $this->IMPL = new Cache_Lite($liteOptions); }
private function __construct($id) { $this->id = 1 * $id; $this->BEAN = MosaicImgBean::inst(); $params = ArrayAdapter::inst($this->BEAN->getImgInfo($this->id)); $this->width = $params->int('w'); $this->height = $params->int('h'); $this->cellsXcnt = $params->int('cx'); $this->cellsYcnt = $params->int('cy'); $this->cellWidth = $params->int('cw'); $this->cellHeight = $params->int('ch'); $this->cellsTotal = $this->cellsXcnt * $this->cellsYcnt; $this->LOGGER = PsLogger::inst(__CLASS__); $this->PROFILER = PsProfiler::inst(__CLASS__); $this->tryResyncImg(); }
public function __call($method, $arguments) { $method = first_char_remove($method); $source = $arguments[0]; /* @var $template Smarty_Internal_Template */ $template = $arguments[1]; $tplPath = $template->template_resource; //PsProfiler::inst(__CLASS__)->start($method); $result = $this->{$method}($source); //PsProfiler::inst(__CLASS__)->stop(); $call = ++$this->CALLS[$method]; $callttl = ++$this->CALLTTL; $callInfo = pad_right("[{$callttl}-{$call}].", 10, ' '); PsLogger::inst(__CLASS__)->info("{} {} filter called for template {}.", $callInfo, ucfirst($method), $tplPath); return $result; }
protected function __construct() { //Извлекаем все изменённые сущности БД $CHANGED = DbBean::inst()->getChangedEntitys(); if (empty($CHANGED)) { return; //--- } $LOGGER = PsLogger::inst(__CLASS__); $LOGGER->info('Изменённые сущности БД: ' . print_r($CHANGED, true)); foreach ($CHANGED as $chEntity) { $type = $chEntity['v_type']; $entity = $chEntity['v_entity']; $TypeEntity = "{$type} {$entity}"; switch ($type) { /* * 1. Проверим изменённые сущности фолдинга */ case DbBean::CHANGE_FOLD_ENT: $fentity = Handlers::getInstance()->getFoldedEntityByUnique($entity, false); if ($fentity) { $LOGGER->info('[{}] -> Сущность фолдинга [{}]', $TypeEntity, $fentity->getUnique()); FoldedResourcesManager::onEntityAction(FoldedResourcesManager::ACTION_ENTITY_CHANGED_DB, $fentity->getFolding(), $fentity->getIdent()); $fentity->onEntityChanged(); } break; /* * 2. Проверим изменённые таблицы/представления */ /* * 2. Проверим изменённые таблицы/представления */ case DbBean::CHANGE_TABLE: case DbBean::CHANGE_VIEW: /* @var $folding FoldedResources */ foreach (FoldedResourcesManager::inst()->getTableOrViewFoldings($entity) as $folding) { $LOGGER->info('[{}] -> Фолдинг [{}]', $TypeEntity, $folding->getUnique()); $folding->onFoldingChanged(); } foreach (PSCache::inst()->onDbEntityChanged($entity) as $cacheGr) { $LOGGER->info('[{}] -> Группа кеширования [{}]', $TypeEntity, $cacheGr); } break; } } }
protected final function __construct() { $this->LOGGER = PsLogger::inst(__CLASS__); $class = 'Memcache'; if (!class_exists($class)) { $this->LOGGER->info($class . ' class is not exists!'); return; //--- } $this->MEMCACHE = new $class(); if (!@$this->MEMCACHE->connect('127.0.0.1', 11211)) { $this->LOGGER->info('Could not connect to localhost!'); $this->MEMCACHE = null; return; //--- } $this->LOGGER->info($class . ' is enabled.'); }
private function executeImpl($lifeTimeOnCall, $__FUNCTION__) { if ($this->called) { return $this->executed; //--- } $this->called = true; $LOGGER = PsLogger::inst(__CLASS__); $LOGGER->info("Function [{$__FUNCTION__}] called."); $needProcess = false; $LOCKFILE = DirManager::autogen('service')->getDirItem(null, __CLASS__, 'lock'); if ($LOCKFILE->isFile()) { $lifeTime = $LOCKFILE->getFileLifetime(); $needProcess = !$lifeTime || !$lifeTimeOnCall || $lifeTime >= $lifeTimeOnCall; $LOGGER->info('{} process. Lock file modified {} seconds ago. Process delay: {} seconds.', $needProcess ? 'Need' : 'Not need', $lifeTime, $lifeTimeOnCall); } else { $needProcess = true; $LOGGER->info('Need process. Lock file is not exists.'); } if (!$needProcess) { return $this->executed; //--- } $locked = PsLock::lock(__CLASS__, false); $LOGGER->info('External process lock {} execution.', $locked ? 'acquired, start' : 'not acquired, skip'); if ($locked) { $LOCKFILE->touch(); PsUtil::startUnlimitedMode(); //Отпустим лок, так как внутри он может потребоваться для выполнения других действий, например для перестройки спрайтов PsLock::unlock(); //Начинаем выполнение $this->executed = true; $job = new ExternalProcessJob(); PsProfiler::inst(__CLASS__)->start(__FUNCTION__); $job->execute(); $secundomer = PsProfiler::inst(__CLASS__)->stop(); if ($secundomer) { $LOGGER->info("{$secundomer}"); } } return $this->executed; }
/** * Конструктор. В нём мы составим полный список директорий, в которых потом будет производиться поиск * * @param type $absDirPath * @param array $excluded * @param array $included */ private function __construct($absDirPath, array $excluded, array $included) { $this->LOGGER = PsLogger::inst(__CLASS__); $this->PROFILER = PsProfiler::inst(__CLASS__); $this->PATH = ensure_dir_endswith_dir_separator($absDirPath); $this->LOGGER->info("Dir: [{$this->PATH}]"); foreach ($excluded as $dir) { $path = ensure_dir_endswith_dir_separator(array($absDirPath, $dir)); $this->EXCLUDED[] = $path; $this->LOGGER->info("ExcludeDir: [{$path}]"); } foreach ($included as $dir) { $path = ensure_dir_endswith_dir_separator(array($absDirPath, $dir)); $this->INCLUDED[] = $path; $this->LOGGER->info("IncludeDir: [{$path}]"); } $this->LOGGER->info('Filling dirs for search'); $this->PROFILER->start('Fill search dirs'); $this->fillWithDirs($this->PATH); $this->LOGGER->info('Total dirs for search count: {}, excluded dirs: {}. Taken time: {}sec.', count($this->DIRS), count($this->DIRSEXCLUDED), $this->PROFILER->stop()->getTime()); foreach ($this->DIRSEXCLUDED as $path) { $this->LOGGER->info("- {$path}"); } }
/** @return PsLoggerInterface - логгер для данного класса сущности фолдинга */ protected final function LOGGER() { return PsLogger::inst(get_called_class()); }
/** * Метод возвращает логгер для того, чтобы в него могли писать другие подсистемы, * занимающиеся поиском классов. * * @return PsLoggerInterface */ public static function getLogger() { return PsLogger::inst(__CLASS__); }
/** * Основной метод, выполняющий подключение всех классов из kitcore. * Нужно постараться сделать так, чтобы он отрабатывал максимально быстро, * так как мы используем его вместо принудительного подключения всех классов * через require_once. * Возможно для ускорения работы однажды мы так и сделаем. */ public function includeCore() { if ($this->CALLED) { die(__CLASS__ . ' cannot be called twice.'); } $this->CALLED = true; /* * Засекаем время подключения */ $time = microtime(true); /* * Сразу подключаем настройки и утилитные функции */ include_once 'Globals.php'; include_once 'Defines.php'; /* * Инициализируем глобальные коллекции, так как доступ к ним будет * осуществляться из всех методов данного класса. */ $this->PATHES = array(); $this->INCLUDED = array(); /* * Собираем классы из kitcore, которые нужно подключить. * Пути к php-классам будут собраны в переменную класса, чтобы к ним был * доступ и из функции autoload. */ self::loadClassPath(__DIR__, $this->PATHES, true); /* * Подключим слушатель ошибки загрузки файлов, так как классы могут быть * загружены не в правильном порядке. */ spl_autoload_register(array($this, '_autoload')); /* * Начинаем подключение */ foreach ($this->PATHES as $name => $path) { if (!array_key_exists($name, $this->INCLUDED)) { /* * Поставим отметку о том, что файл загружен напрямую. * Если этого не случится, то в функции автоподключение это * будет переопределено. */ $this->INCLUDED[$name] = 'Directly'; include_once $path; } } /* * Отключим обработчки ошибок, так как он нам больше не нужен. */ spl_autoload_unregister(array($this, '_autoload')); /* * Теперь можно использовать логгер для вывода информации о логировании */ if (PsLogger::isEnabled()) { $time = microtime(true) - $time; PsLogger::inst(__FILE__)->info('File pathes: ' . print_r($this->PATHES, true)); PsLogger::inst(__FILE__)->info('Include order: ' . print_r($this->INCLUDED, true)); PsLogger::inst(__FILE__)->info('Total time: ' . $time); } /* * Освободим память */ unset($this->PATHES); unset($this->INCLUDED); }
protected function __construct() { $this->LOGGER = PsLogger::inst(get_called_class()); $this->DISCUSSION = new CommentsDiscussionController($this); }
protected function _construct() { $this->LOGGER = PsLogger::inst(get_called_class()); $this->TLPARAMS = $this->getTimeLineBuilderParams(); $this->TLPARAMS = $this->TLPARAMS ? $this->TLPARAMS : new TimeLineBuilderParams(); }
/** * В конструкторе зарегистрируем все страницы */ protected final function __construct() { $class = get_called_class(); $basic = __CLASS__ == $class; //Логгер $this->LOGGER = PsLogger::inst(__CLASS__); $this->LOGGER->info('USING {} PLUGIN PROVIDER: {}', $basic ? 'SDK' : 'CUSTOM', $class); //Стартуем профайлер $this->PROFILER = PsProfiler::inst(__CLASS__); $this->PROFILER->start('Loading plugins'); //Регистрируем фолдинги SDK $this->LOGGER->info(); $this->LOGGER->info('PLUGINS SDK:'); $this->registerSdkSmartyPlugins(); //Если используем не SDK провайдер, вызываем регистратор if (!$basic) { $this->LOGGER->info(); $this->LOGGER->info('PLUGINS PROJECT:'); $this->registerProjectSmartyPlugins(); } //Останавливаем профайлер $sec = $this->PROFILER->stop(); //Логируем $this->LOGGER->info(); $this->LOGGER->info('COLLECTING TIME: {} sec', $sec->getTotalTime()); }
protected function __construct() { $this->LOGGER = PsLogger::inst(__CLASS__); }