Esempio n. 1
0
 /** @return PsProfilerInterface */
 private function getProfiler($profilerId)
 {
     //Не будем выполнять get_file_name($profilerId), так как нужно вернуть профайлер максимально быстро
     if ($this->CAHCE->has($profilerId)) {
         return $this->CAHCE->get($profilerId);
     }
     check_condition($profilerId, 'Profiler id cannot be empty.');
     if (!$this->enabled) {
         return $this->CAHCE->set($profilerId, new PsProfilerEmpty($profilerId));
     }
     $di = $this->getProfilerDi($profilerId);
     $pr = null;
     //Проверим текущий размер профайлера
     if ($di->isMaxSize(ConfigIni::profilingMaxFileSize())) {
         $locked = PsLock::lock(__CLASS__ . "::compressProfiler({$profilerId})", false);
         if ($locked) {
             $this->compressProfiler($di);
             PsLock::unlock();
         } else {
             //Разимер превышен и мы не смогли получить лок для дампа профайлера. Не будем в этот раз вести профайлинг.
             $pr = new PsProfilerEmpty($profilerId);
         }
     }
     return $this->CAHCE->set($profilerId, $pr ? $pr : new PsProfilerImpl($profilerId));
 }
Esempio n. 2
0
function executeProcess(array $argv)
{
    dolog('try to get lock');
    $taken = PsLock::lock('mylock-wait', true);
    dolog('lock ' . ($taken ? 'taken' : 'not taken'));
    if ($taken) {
        sleep(10);
        PsLock::unlock();
        dolog('lock released');
    }
}
Esempio n. 3
0
 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;
 }
Esempio n. 4
0
 public function CreateSprite(CssSprite $sprite)
 {
     if ($sprite->exists()) {
         return;
         //--- Спрайт существует
     }
     $this->LOGGER->info("Waiting to make {$sprite}");
     PsLock::lockMethod(__CLASS__, __FUNCTION__);
     try {
         if ($sprite->exists()) {
             $this->LOGGER->info('Sprite was created in another thread, skipping');
         } else {
             $this->PROFILER->start('Sprite creation');
             $this->CssSpriteGen->CreateSprite($sprite);
             $this->LOGGER->info('Sprite was successfully created, path: ' . $sprite->getCssDi()->getAbsPath());
             $this->PROFILER->stop();
         }
     } catch (Exception $ex) {
         PsLock::unlock();
         throw $ex;
     }
     PsLock::unlock();
 }
Esempio n. 5
0
<?php

require_once '../ToolsResources.php';
$CALLED_FILE = __FILE__;
dolog('try to get lock');
$taken = PsLock::lock('mylock-nowait', false);
dolog('lock ' . ($taken ? 'taken' : 'not taken'));
if ($taken) {
    sleep(10);
    PsLock::unlock();
    dolog('lock released');
}
Esempio n. 6
0
 /**
  * Метод открывает на картинке все ячейки, которые может открыть пользователь
  */
 public function bindAllUserCells($userId = null)
 {
     $userId = AuthManager::extractUserId($userId);
     $canOpenCnt = $this->getUserCanOpenCellsCnt($userId);
     if ($canOpenCnt <= 0) {
         return;
         //---
     }
     $this->LOGGER->info("Binding all cells of user {$userId} to img {$this->id}, can open {$canOpenCnt} cells.");
     PsLock::lock(__CLASS__ . $this->id);
     try {
         //Запросим ячейки снова, так как пока мы ждали блокировку, могло что-то случиться...
         $canOpenCnt = $this->getUserCanOpenCellsCnt($userId);
         if ($canOpenCnt > 0) {
             $this->copyCells($this->BEAN->getCells4UserBind($this->id, $canOpenCnt), $userId);
         }
     } catch (Exception $ex) {
         PsLock::unlock();
         throw $ex;
     }
     PsLock::unlock();
 }
Esempio n. 7
0
 /**
  * Метод вызывается для выполнения периодических задач cron
  * 
  * @return type
  */
 public function execute()
 {
     if ($this->called) {
         return $this->executed;
         //---
     }
     $this->called = true;
     $LOGGER = PsLogger::inst(__CLASS__);
     $LOGGER->info('Executing {}', __CLASS__);
     /*
      * Получим список классов, которые нужно выполнить
      */
     $processes = ConfigIni::cronProcesses();
     if (empty($processes)) {
         $LOGGER->info('No cron processes configured, fast return...');
         return $this->executed;
         //---
     }
     $processes = array_unique($processes);
     $LOGGER->info('Configured processes: {}', array_to_string($processes));
     foreach ($processes as $class) {
         if (!PsUtil::isInstanceOf($class, 'PsCronProcess')) {
             PsUtil::raise("Class {$class} cannot be executed as cron process, it should be instance of PsCronProcess");
         }
     }
     $locked = PsLock::lock(__CLASS__, false);
     $LOGGER->info('Lock accured ? {}', var_export($locked, true));
     if (!$locked) {
         return $this->executed;
         //---
     }
     $LOCKFILE = DirManager::autoNoDel(DirManager::DIR_SERVICE)->getDirItem(null, __CLASS__, PsConst::EXT_LOCK);
     $LOCKFILE_LIFETIME = $LOCKFILE->getFileLifetime();
     $MAX_LIFETIME = 5 * 60;
     $NED_PROCESS = $LOCKFILE_LIFETIME === null || $LOCKFILE_LIFETIME > $MAX_LIFETIME;
     $LOGGER->info("Lock file {}: {}", $LOCKFILE_LIFETIME === null ? 'NOT EXISTS' : 'EXISTS', $LOCKFILE->getRelPath());
     if ($LOCKFILE_LIFETIME !== null) {
         $LOGGER->info('Last modified: {} seconds ago. Max process delay: {} seconds.', $LOCKFILE_LIFETIME, $MAX_LIFETIME);
         //
     }
     if (!$NED_PROCESS) {
         $LOGGER->info('Skip execution.');
         //Отпустим лок
         PsLock::unlock();
         //Выходим
         return $this->executed;
         //---
     }
     //Обновим время последнего выполнения
     $LOCKFILE->touch();
     //Отпустим лок, так как внутри он может потребоваться для выполнения других действий, например для перестройки спрайтов
     PsLock::unlock();
     $LOGGER->info();
     $LOGGER->info('External process execution started...');
     //Запускаем режим неограниченного выполнения
     PsUtil::startUnlimitedMode();
     //Начинаем выполнение
     $this->executed = true;
     //Создаём профайлер
     $PROFILER = PsProfiler::inst(__CLASS__);
     //Создадим конфиг выполнения процесса
     $config = new PsCronProcessConfig();
     //Пробегаемся по процессам и выполняем. При первой ошибке - выходим.
     foreach ($processes as $class) {
         $LOGGER->info('Executing cron process {}', $class);
         $PROFILER->start($class);
         try {
             $inst = new $class();
             $inst->onCron($config);
             $secundomer = $PROFILER->stop();
             $LOGGER->info(" > Cron process '{}' executed in {} seconds", $class, $secundomer->getTotalTime());
         } catch (Exception $ex) {
             $PROFILER->stop();
             $LOGGER->info(" > Cron process '{}' execution error: '{}'", $class, $ex->getMessage());
         }
     }
     $LOGGER->info('Removing cron lock file.');
     $LOCKFILE->remove();
     return $this->executed;
 }
Esempio n. 8
0
 /**
  * Метод выполняет дамп таблицы
  */
 public static function dumpTable($idColumn, $table, array $where = array(), $order = null)
 {
     //Стартуем секундомер
     $secundomer = Secundomer::startedInst("Снятие дампа {$table}");
     //Отключим ограничение по времени
     PsUtil::startUnlimitedMode();
     //Получим экземпляр логгера
     $LOGGER = PsLogger::inst(__CLASS__);
     //Текущий пользователь
     $userId = AuthManager::getUserIdOrNull();
     //Для логов, запросов и все остального
     $table = strtoupper(PsCheck::tableName($table));
     //Макс кол-во записей
     $limit = PsDefines::getTableDumpPortion();
     //Проверим наличие id
     $idColumn = PsCheck::tableColName($idColumn);
     $LOGGER->info('Dumping table {}. Id column: {}, limit: {}. User id: {}.', $table, $idColumn, $limit, $userId);
     //Получаем лок (без ожидания)
     $lockName = "DUMP table {$table}";
     $locked = PsLock::lock($lockName, false);
     $LOGGER->info('Lock name: {}, locked ? {}.', $lockName, var_export($locked, true));
     if (!$locked) {
         return false;
         //Не удалось получить лок
     }
     $zipDi = false;
     try {
         //ЗПРОСЫ:
         //1. Запрос на извлечение колва записей, подлежащих дампированию
         $queryCnt = Query::select("count({$idColumn}) as cnt", $table, $where);
         //2. Запрос на извлечение данных, подлежащих дампированию
         $queryDump = Query::select('*', $table, $where, null, $order, $limit);
         //3. Запрос на извлечение кодов дампируемых записей
         $selectIds = Query::select($idColumn, $table, $where, null, $order, $limit);
         //4. Запрос на удаление дампированных данных
         $queryDel = Query::delete($table, Query::plainParam("{$idColumn} in (select {$idColumn} from (" . $selectIds->build($delParams) . ') t )', $delParams));
         //Выполним запрос для получения кол-ва записей, подлежащих дампу
         $cnt = PsCheck::int(array_get_value('cnt', PSDB::getRec($queryCnt, null, true)));
         $LOGGER->info('Dump recs count allowed: {}.', $cnt);
         if ($cnt < $limit) {
             $LOGGER->info('SKIP dumping table, count allowed ({}) < limit ({})...', $cnt, $limit);
             $LOGGER->info("Query for extract dump records count: {$queryCnt}");
             PsLock::unlock($lockName);
             return false;
         }
         //Время дампа
         $date = PsUtil::fileUniqueTime(false);
         $time = time();
         //Название файлов
         $zipName = $date . ' ' . $table;
         //Элемент, указывающий на zip архив
         $zipDi = DirManager::stuff(null, array(self::DUMPS_TABLE, $table))->getDirItem(null, $zipName, PsConst::EXT_ZIP);
         $LOGGER->info('Dump to: [{}].', $zipDi->getAbsPath());
         if ($zipDi->isFile()) {
             $LOGGER->info('Dump file exists, skip dumping table...');
             PsLock::unlock($lockName);
             return false;
         }
         //Комментарий к таблице
         $commentToken[] = "Date: {$date}";
         $commentToken[] = "Time: {$time}";
         $commentToken[] = "Table: {$table}";
         $commentToken[] = "Manager: {$userId}";
         $commentToken[] = "Recs dumped: {$limit}";
         $commentToken[] = "Total allowed: {$cnt}";
         $commentToken[] = "Query dump cnt:   {$queryCnt}";
         $commentToken[] = "Query dump data:  {$queryDump}";
         $commentToken[] = "Query dump ids:   {$selectIds}";
         $commentToken[] = "Query del dumped: {$queryDel}";
         $comment = implode("\n", $commentToken);
         //Начинаем zip и сохраняем в него данные
         $zip = $zipDi->startZip();
         $zip->addFromString($zipName, serialize(PSDB::getArray($queryDump)));
         $zip->setArchiveComment($comment);
         $zip->close();
         $LOGGER->info('Data successfully dumped, zip comment:');
         $LOGGER->info("[\n{$comment}\n]");
         //Удалим те записи, дамп которых был снят
         $LOGGER->info('Clearing dumped table records...');
         $affected = PSDB::update($queryDel);
         $LOGGER->info('Rows deleted: {}.', $affected);
         $LOGGER->info('Dumping is SUCCESSFULLY finished. Total time: {} sec.', $secundomer->stop()->getAverage());
     } catch (Exception $ex) {
         PsLock::unlock($lockName);
         ExceptionHandler::dumpError($ex);
         $LOGGER->info('Error occured: {}', $ex->getMessage());
         throw $ex;
     }
     return $zipDi;
 }
Esempio n. 9
0
 private function doCopy(DirItem $from, DirItem $to)
 {
     $from->assertIsImg();
     PsLock::lockMethod(__CLASS__, __FUNCTION__);
     try {
         //Очистим нагенерённое для той картинки, В КОТОРУЮ копируем
         $this->doClean($to);
         //Картинка не была пересоздана в другом потоке
         SimpleImage::inst()->load($from)->save($to, SYSTEM_IMG_TYPE)->close();
     } catch (Exception $ex) {
         PsLock::unlock();
         throw $ex;
     }
     PsLock::unlock();
 }