public function __invoke(Request $req, Response $res, callable $next) { $res = $next($req, $res); $identity = $this->authService->getIdentity(); if (!$identity) { return $res; } try { $user = R::findOne('user', 'mail = ?', [$identity->mail]); if (!$user) { $user = R::dispense('user'); $user->uid = $identity->uid; $user->mail = $identity->mail; $user->display_name = $identity->displayName; $user->office_name = $identity->officeName; $user->authentication_source = $identity->authenticationSource; $user->password = ''; $user->created = time(); $user->role = 'school'; $this->logger->info(sprintf('User %s imported from sso.sch.gr to database', $identity->mail)); } $user->last_login = time(); $user_id = R::store($user); $identityClass = get_class($identity); $newIdentity = new $identityClass($user_id, $user->uid, $user->mail, $user->display_name, $user->office_name, $user->authentication_source); $this->authService->getStorage()->write($newIdentity); } catch (\Exception $e) { $this->authService->clearIdentity(); $this->flash->addMessage('danger', 'A problem occured storing user in database. <a href="%s" title="SSO logout">SSO Logout</a>'); $this->logger->error('Problem inserting user form CAS in database', $identity->toArray()); $this->logger->debug('Exception', [$e->getMessage(), $e->getTraceAsString()]); return $res->withRedirect($this->userErrorRedirectUrl); } return $res; }
/** * {@inheritdoc} */ public function submitForm(array &$form, FormStateInterface $form_state) { $this->getEntity()->delete(); $this->logger->info('Payment status %label (@id) has been deleted.', ['@id' => $this->getEntity()->id(), '%label' => $this->getEntity()->label()]); drupal_set_message($this->t('%label has been deleted.', array('%label' => $this->getEntity()->label()))); $form_state->setRedirectUrl($this->getEntity()->urlInfo('collection')); }
/** * Request the page from IMDb * @param $url * @return string Page html. Empty string on failure * @throws Exception\Http */ protected function requestPage($url) { $this->logger->info("[Page] Requesting [{$url}]"); $req = $this->buildRequest($url); if (!$req->sendRequest()) { $this->logger->error("[Page] Failed to connect to server when requesting url [{$url}]"); if ($this->config->throwHttpExceptions) { throw new Exception\Http("Failed to connect to server when requesting url [{$url}]"); } else { return ''; } } if (200 == $req->getStatus()) { return $req->getResponseBody(); } elseif ($redirectUrl = $req->getRedirect()) { $this->logger->debug("[Page] Following redirect from [{$url}] to [{$redirectUrl}]"); return $this->requestPage($redirectUrl); } else { $this->logger->error("[Page] Failed to retrieve url [{url}]. Response headers:{headers}", array('url' => $url, 'headers' => $req->getLastResponseHeaders())); if ($this->config->throwHttpExceptions) { $exception = new Exception\Http("Failed to retrieve url [{$url}]. Status code [{$req->getStatus()}]"); $exception->HTTPStatusCode = $req->getStatus(); throw new $exception(); } else { return ''; } } }
/** * Process a single group. * * Without queuedjobs, it's necessary to shell this out to a background task as this is * very memory intensive. * * The sub-process will then invoke $processor->runGroup() in {@see Solr_Reindex::doReindex} * * @param LoggerInterface $logger * @param SolrIndex $indexInstance Index instance * @param array $state Variant state * @param string $class Class to index * @param int $groups Total groups * @param int $group Index of group to process * @param string $taskName Name of task script to run */ protected function processGroup(LoggerInterface $logger, SolrIndex $indexInstance, $state, $class, $groups, $group, $taskName) { // Build state $statevar = json_encode($state); if (strpos(PHP_OS, "WIN") !== false) { $statevar = '"' . str_replace('"', '\\"', $statevar) . '"'; } else { $statevar = "'" . $statevar . "'"; } // Build script $indexName = $indexInstance->getIndexName(); $scriptPath = sprintf("%s%sframework%scli-script.php", BASE_PATH, DIRECTORY_SEPARATOR, DIRECTORY_SEPARATOR); $scriptTask = "php {$scriptPath} dev/tasks/{$taskName}"; $cmd = "{$scriptTask} index={$indexName} class={$class} group={$group} groups={$groups} variantstate={$statevar}"; $cmd .= " verbose=1 2>&1"; $logger->info("Running '{$cmd}'"); // Execute script via shell $res = $logger ? passthru($cmd) : `{$cmd}`; if ($logger) { $logger->info(preg_replace('/\\r\\n|\\n/', '$0 ', $res)); } // If we're in dev mode, commit more often for fun and profit if (Director::isDev()) { Solr::service($indexName)->commit(); } // This will slow down things a tiny bit, but it is done so that we don't timeout to the database during a reindex DB::query('SELECT 1'); }
/** * @param Request $request * * @Rest\View(statusCode=204) * @Rest\Post("/webhook", defaults={"_format": "json"}) * * @throws ResourceConflictException * @throws \Exception * @return null */ public function handleWebHookAction(Request $request) { $this->logger->info($request->getContent()); try { $event = null; $store = $this->storeService->getStoreByRequest($request); $eventId = $this->shopifyEventRetriever->verifyWebhookRequest($request, $store); $event = $this->shopifyEventRetriever->retrieve($eventId); if ($event) { throw new EventAlreadyProcessed(sprintf('Event Id %s has already been processed', $eventId)); } //Save the event so we don't process this again $event = Event::createFromRequest($request, $eventId); $this->eventRepository->save($event); $cmd = $this->commandFactory->create($event, $store); $handler = $this->handlerFactory->create($event); $handler->execute($cmd); $event->updateStatus(Event::STATUS_PROCESSED); $this->logger->alert(sprintf('Completed Processing event id %s', $eventId)); } catch (\Exception $e) { if ($event instanceof Event) { $event->updateStatus(Event::STATUS_FAILED); } $this->logger->alert($e->getMessage()); } finally { if ($event instanceof Event) { $this->eventRepository->update($event); } return new Response('', 201); } }
/** * Execute the next task on the queue * * @param string $queue * @param int $timeout * @throws \Exception * @throws \mcfedr\Queue\JobManagerBundle\Exception\UnrecoverableException * @throws \mcfedr\Queue\JobManagerBundle\Exception\ExecuteException */ public function execute($queue = null, $timeout = null) { $job = $this->manager->get($queue, $timeout); if (!$job) { return; } $task = json_decode($job->getData(), true); $this->logger->info('Got task', ['task' => $task['name'], 'options' => $task['options']]); try { /** @var Worker $worker */ $worker = $this->container->get($task['name']); foreach ($this->preListeners as $listener) { $listener->preTask($worker, $task['options']); } $worker->execute($task['options']); foreach ($this->postListeners as $listener) { $listener->postTask($worker, $task['options']); } $this->manager->delete($job); } catch (ServiceNotFoundException $e) { $this->manager->delete($job); $throw = new UnrecoverableException("Service for job not found", 0, $e); $throw->setJob($job); throw $throw; } catch (UnrecoverableException $e) { $this->manager->delete($job); $e->setJob($job); throw $e; } catch (\Exception $e) { throw new ExecuteException($job, $e); } }
/** * Create an express view from the given XML view, will utilize the cache directory * to dump and load a template compiled into plain PHP code. * * @param ExpressViewRenderer $renderer * @param string $resource The resource to be compiled into a view. * @return string The fully-qualified name of the compiled view. * * @throws \RuntimeException When the given resource could not be found. */ public function createView(ExpressViewRenderer $renderer, $resource) { $resource = (string) $resource; if (!is_file($resource)) { throw new \RuntimeException(sprintf('Express view not found: "%s"', $resource)); } $key = $this->createKey($resource); $typeName = $this->createTypeName($resource); if (class_exists($typeName, false)) { return $typeName; } $file = $this->cachePath . '/' . $key . '.php'; if (!is_file($file) || filemtime($file) < filemtime($resource)) { $time = microtime(true); try { $code = $this->parseView($renderer, file_get_contents($resource), $resource)->generateCode($key); } catch (\Exception $e) { throw new \RuntimeException(sprintf('Unable to parse express view "%s"', $resource), 0, $e); } Filesystem::writeFile($file, $code); $diff = sprintf('%.2f', microtime(true) - $time); if ($this->logger) { $this->logger->info('Compiled express view {view}, time spent {time} seconds', ['view' => $resource, 'time' => $diff]); } } require_once $file; if (!class_exists($typeName, false)) { throw new \RuntimeException(sprintf('Unable to load compiled express view "%s"', $resource)); } return $typeName; }
/** * Create new depended period and calculation or return existing data. * * This function is created for CRAP reducing and is used from this class only. * * @param \Praxigento\BonusBase\Service\Period\Response\GetForDependentCalc $result * @param string $baseCalcTypeCode * @param string $baseDsBegin * @param string $baseDsEnd * @param string $dependentCalcTypeCode * @param int $dependentCalcTypeId * @param string $dependentDsBegin * @param string $dependentDsEnd */ public function _getDependedCalcForExistingPeriod(\Praxigento\BonusBase\Service\Period\Response\GetForDependentCalc $result, $baseCalcTypeCode, $baseDsBegin, $baseDsEnd, $dependentCalcTypeCode, $dependentCalcTypeId, $dependentDsBegin, $dependentDsEnd) { if ($dependentDsBegin == $baseDsBegin && $dependentDsEnd == $baseDsEnd) { /* dependent period has the same begin/end as related base period, get calc data */ $this->_logger->info("There is base '{$baseCalcTypeCode}' period for dependent '{$dependentCalcTypeCode}' period ({$dependentDsBegin}-{$dependentDsEnd})."); $this->_analyzeDependedCalc($result, $dependentCalcTypeCode, $dependentCalcTypeId, $dependentDsBegin, $dependentDsEnd); } else { /* dependent period has different begin/end than related base period */ $this->_logger->warning("There is no period for '{$dependentCalcTypeCode}' calculation based on '{$baseCalcTypeCode}' ({$baseDsBegin}-{$baseDsEnd}). New period and related calculation will be created."); /* create new depended period & calc */ $period = new EPeriod(); $period->setCalcTypeId($dependentCalcTypeId); $period->setDstampBegin($baseDsBegin); $period->setDstampEnd($baseDsEnd); $periodId = $this->_repoPeriod->create($period); $period->setId($periodId); /* create related calculation */ $calc = new ECalculation(); $calc->setPeriodId($periodId); $dateStarted = $this->_toolDate->getUtcNowForDb(); $calc->setDateStarted($dateStarted); $calc->setState(Cfg::CALC_STATE_STARTED); $calcId = $this->_repoCalc->create($calc); $calc->setId($calcId); /* place new objects into response */ $result->setDependentPeriodData($period); $result->setDependentCalcData($calc); } }
/** * updates Activity Document Link * @param array $documentLink * @param ActivityDocumentLink $activityDocumentLink * @return bool */ public function update(array $documentLink, ActivityDocumentLink $activityDocumentLink) { try { $this->database->beginTransaction(); $documentLinkExists = $activityDocumentLink->exists; $activityId = $activityDocumentLink->activity_id; $documentManager = app(DocumentManager::class); if ($documentLinkExists) { $url = $activityDocumentLink->document_link['url']; $document = $documentManager->getDocument(session('org_id'), $url); $activities = (array) $document->activities; unset($activities[$activityId]); $document->activities = $activities; $documentManager->update($document); } $url = $documentLink[0]['url']; $document = $documentManager->getDocument(session('org_id'), $url); $activities = (array) $document->activities; $identifier = $activityDocumentLink->activity->identifier['activity_identifier']; $activities[$activityId] = $identifier; $document->activities = $activities; $documentManager->update($document); $this->DocumentLinkRepo->update($documentLink, $activityDocumentLink); $this->database->commit(); $this->logger->info(sprintf('Activity Document Link %s!', $documentLinkExists ? 'updated' : 'saved'), ['for' => $documentLink]); $this->dbLogger->activity(sprintf("activity.document_link_%s", $documentLinkExists ? 'updated' : 'saved'), ['activity_id' => $activityDocumentLink->activity_id, 'document_link_id' => $activityDocumentLink->id, 'organization' => $this->auth->user()->organization->name, 'organization_id' => $this->auth->user()->organization->id]); return true; } catch (\Exception $exception) { $this->database->rollback(); $this->logger->error($exception, ['documentLink' => $documentLink]); } return false; }
protected function r4_add_record(CreatedDomain $domain, Record $record) { if ($this->logger) { $this->logger->info("Adding " . $record->name); } return $domain->add_record($record, $this->api); }
/** * @param $message * @param $context */ private function log($message, $context = []) { if ($this->logger instanceof LoggerInterface) { $context['class'] = self::class; $this->logger->info($message, $context); } }
/** * Run the daemon. * * @return int */ public function run() { $this->logger->info("Status: starting up."); while (true) { $this->taskPersist->begin(); $tasks = $this->tasksFinder->findDueTasks(); foreach ($tasks as $task) { try { $handlerClass = $task->getHandlerClass(); /** @var TaskHandlerInterface $handler */ $handler = new $handlerClass(...$task->getArguments()); $this->decorate($handler); $this->logger->info("Handle {$handlerClass}"); $handler->handle(); if ($task->isReoccurring()) { $task->reoccur(); $this->taskPersist->persist($task); } else { $this->taskPersist->remove($task); } } catch (Exception $e) { $this->logger->error("{$e->getMessage()}\n{$e->getTraceAsString()}"); $task->setDisabled(); $this->taskPersist->persist($task); } } $this->taskPersist->commit(); sleep(1); } }
public static function info($msg, $context = array()) { if (!self::$_impl) { return; } self::$_impl->info($msg, $context); }
public function runCrons() { $entityManager = $this->managerRegistry->getManagerForClass('DspSoftsCronManagerBundle:CronTask'); $cronTaskRepo = $entityManager->getRepository('DspSoftsCronManagerBundle:CronTask'); $cronTasks = $cronTaskRepo->findCronsToLaunch(); foreach ($cronTasks as $cronTask) { $run = true; if (!$cronTask->getRelaunch()) { $run = $this->planificationChecker->isExecutionDue($cronTask->getPlanification()); } if ($run) { if ($this->logger !== null) { $this->logger->info(sprintf('Running Cron Task <info>%s</info>', $cronTask->getName())); } $cli = 'exec ' . $this->kernelRootDir . DIRECTORY_SEPARATOR . 'console dsp:cron:runjob -c ' . $cronTask->getId() . ' &'; if ($this->logger !== null) { $this->logger->info(sprintf('Command line : <info>%s</info>', $cli)); } $process = new Process($cli); $process->setTimeout(0); $process->start(); } else { if ($this->logger !== null) { $this->logger->info(sprintf('Skipping Cron Task <info>%s</info>', $cronTask->getName())); } } } }
public function inlineQuery(Update $update) : unreal4uBot { $this->logger->info(sprintf('Received inline query. User id %d (username: %s). Query: "%s", inline query id: %s', $update->inline_query->from->id, $update->inline_query->from->username, $update->inline_query->query, $update->inline_query->id)); $query = $update->inline_query->query; if (empty($query)) { $query = 'What is lmgtfy?'; } // Number of results $i = 1; $inlineQueryResultArticle = new Article(); $inlineQueryResultArticle->url = 'http://lmgtfy.com/?q=' . urlencode($query); $inlineQueryResultArticle->title = $inlineQueryResultArticle->url; //'Forward this message to anyone you would like (Title)'; $inlineQueryResultArticle->hide_url = true; $inputMessageContentText = new Text(); $inputMessageContentText->message_text = $inlineQueryResultArticle->url; $inputMessageContentText->disable_web_page_preview = true; $inlineQueryResultArticle->input_message_content = $inputMessageContentText; // @TODO find a way to compress this all into an identifiable 64bit ascii string, maybe with pack()? $inlineQueryResultArticle->id = md5(json_encode(['uid' => $update->inline_query->from->id, 'iqid' => $update->inline_query->id, 'rid' => $i])); $answerInlineQuery = new AnswerInlineQuery(); $answerInlineQuery->inline_query_id = $update->inline_query->id; $answerInlineQuery->addResult($inlineQueryResultArticle); $tgLog = new TgLog($this->token, $this->logger); //$tgLog->logger = $this->logger; $tgLog->performApiRequest($answerInlineQuery); $this->logger->info(sprintf('Sent API response to Telegram, all done')); return $this; }
public function sendSms(SendSmsCommand $command) { $this->logger->info('Requesting Gateway to send SMS'); $body = ['requester' => ['institution' => $command->institution, 'identity' => $command->identity], 'message' => ['originator' => $command->originator, 'recipient' => $command->recipient, 'body' => $command->body]]; $response = $this->guzzleClient->post('api/send-sms', ['json' => $body, 'exceptions' => false]); $statusCode = $response->getStatusCode(); if ($statusCode != 200) { $this->logger->error(sprintf('SMS sending failed, error: [%s] %s', $response->getStatusCode(), $response->getReasonPhrase()), ['http-body' => $response->getBody() ? $response->getBody()->getContents() : '']); return false; } try { $result = $response->json(); } catch (\RuntimeException $e) { $this->logger->error('SMS sending failed; server responded with malformed JSON.'); return false; } if (!isset($result['status'])) { $this->logger->error('SMS sending failed; server responded without status report.'); return false; } if ($result['status'] !== 'OK') { $this->logger->error('SMS sending failed; server responded with non-OK status report.'); return false; } return true; }
public function triggerWebtreesAdminTasks() { $settings = new Settings(); $this->logger = \Piwik\Container\StaticContainer::get('Psr\\Log\\LoggerInterface'); $this->logger->info('Webtrees Admin Task triggered'); $rooturl = $settings->getSetting('webtreesRootUrl'); if (!$rooturl || strlen($rooturl->getValue()) === 0) { return; } $token = $settings->getSetting('webtreesToken'); if (!$token || strlen($token->getValue()) === 0) { return; } $taskname = $settings->getSetting('webtreesTaskName'); if (!$taskname || strlen($taskname->getValue()) === 0) { return; } $url = sprintf('%1$s/module.php?mod=perso_admintasks&mod_action=trigger&force=%2$s&task=%3$s', $rooturl->getValue(), $token->getValue(), $taskname->getValue()); $this->logger->info('webtrees url : {url}', array('url' => $url)); try { \Piwik\Http::sendHttpRequest($url, Webtrees::SOCKET_TIMEOUT); } catch (Exception $e) { $this->logger->warning('an error occured', array('exception' => $e)); } }
/** * @param \ErrorException $exception * * @return bool */ protected function handleErrorException(\ErrorException $exception) { switch ($exception->getSeverity()) { case E_ERROR: case E_RECOVERABLE_ERROR: case E_CORE_ERROR: case E_COMPILE_ERROR: case E_USER_ERROR: case E_PARSE: $this->logger->error($this->buildLogMessage($exception)); break; case E_WARNING: case E_USER_WARNING: case E_CORE_WARNING: case E_COMPILE_WARNING: $this->logger->warning($this->buildLogMessage($exception)); break; case E_NOTICE: case E_USER_NOTICE: $this->logger->notice($this->buildLogMessage($exception)); break; case E_STRICT: case E_DEPRECATED: case E_USER_DEPRECATED: $this->logger->info($this->buildLogMessage($exception)); break; } return true; }
/** * Start the backup. * * @return bool */ public function execute() { $successful = true; try { // Dump all databases $this->dbm->dump(); // Backup folders if specified $this->logger->info('[dizda-backup] Copying folders.'); $this->processor->copyFolders(); // Compress everything $this->logger->info(sprintf('[dizda-backup] Compressing to archive using %s', $this->processor->getName())); $this->processor->compress(); // Transfer with all clients $this->cm->upload($this->processor->getArchivePath()); } catch (\Exception $e) { // Write log $this->logger->critical('[dizda-backup] Unexpected exception.', array('exception' => $e)); $successful = false; } try { // If we catch an exception or not, we would still like to try cleaning up after us $this->logger->info('[dizda-backup] Cleaning up after us.'); $this->processor->cleanUp(); } catch (IOException $e) { $this->logger->error('[dizda-backup] Cleaning up failed.'); return false; } return $successful; }
/** * {@inheritdoc} */ public function log($message, $level) { $message .= ' ' . $this->request->getRequestUri(); if ($this->logLevel >= $level) { switch ($level) { case self::EMERGENCY: $this->logger->emergency($message); break; case self::ALERT: $this->logger->alert($message); break; case self::CRITICAL: $this->logger->critical($message); break; case self::ERROR: $this->logger->error($message); break; case self::WARNING: $this->logger->warning($message); break; case self::NOTICE: $this->logger->notice($message); break; case self::INFO: $this->logger->info($message); break; default: $this->logger->debug($message); } } }
/** * check $configuration, get client related to connection config, create vhost, then process exchange and queue * @param $vhostName * @param array $configuration */ public function processVhost($vhostName, array $configuration) { $client = $this->clientPool->getClientByName($configuration['connection']); $vhostName = urlencode($vhostName); $client->query(ClientInterface::METHOD_PUT, sprintf('/api/vhosts/%s', $vhostName), []); $this->logger->info(sprintf('Create vhost: <info>%s</info>', urldecode($vhostName))); //process parameters if (isset($configuration['parameters']) && count($configuration['parameters'])) { $this->parameterManager->setClient($client)->setVhost($vhostName); foreach ($configuration['parameters'] as $paramType => $parameters) { foreach ($parameters as $paramName => $paramOptions) { $this->parameterManager->create($paramType, $paramName, $paramOptions); } } } //process exchanges if (isset($configuration['exchanges']) && count($configuration['exchanges'])) { $this->process($this->exchangeManager, $client, $vhostName, $configuration['exchanges']); } //process queues if (isset($configuration['queues']) && count($configuration['queues'])) { $this->process($this->queueManager, $client, $vhostName, $configuration['queues']); } //process policies if (isset($configuration['policies']) && count($configuration['policies'])) { $this->process($this->policyManager, $client, $vhostName, $configuration['policies']); } }
/** * @param VerifyYubikeyOtpCommand $command * @return YubikeyVerificationResult */ public function verify(VerifyYubikeyOtpCommand $command) { $this->logger->info('Verifying Yubikey OTP'); $body = ['requester' => ['institution' => $command->institution, 'identity' => $command->identity], 'otp' => ['value' => $command->otp]]; $response = $this->guzzleClient->post('api/verify-yubikey', ['json' => $body, 'exceptions' => false]); $statusCode = $response->getStatusCode(); if ($statusCode != 200) { $type = $statusCode >= 400 && $statusCode < 500 ? 'client' : 'server'; $this->logger->info(sprintf('Yubikey OTP verification failed; %s error', $type)); return new YubikeyVerificationResult(true, false); } try { $result = $response->json(); } catch (\RuntimeException $e) { $this->logger->error('Yubikey OTP verification failed; server responded with malformed JSON.'); return new YubikeyVerificationResult(false, true); } if (!isset($result['status'])) { $this->logger->error('Yubikey OTP verification failed; server responded without status report.'); return new YubikeyVerificationResult(false, true); } if ($result['status'] !== 'OK') { $this->logger->error('Yubikey OTP verification failed; server responded with non-OK status report.'); return new YubikeyVerificationResult(false, true); } return new YubikeyVerificationResult(false, false); }
/** * @param VerifyYubikeyPublicIdCommand $command * @return VerificationResult */ public function verifyYubikeyPublicId(VerifyYubikeyPublicIdCommand $command) { $verifyOtpCommand = new VerifyYubikeyOtpCommand(); $verifyOtpCommand->otp = $command->otp; $verifyOtpCommand->identityId = $command->identityId; $verifyOtpCommand->institution = $command->institution; $verificationResult = $this->yubikeyService->verify($verifyOtpCommand); if (YubikeyOtp::isValid($command->otp)) { $otp = YubikeyOtp::fromString($command->otp); $publicId = YubikeyPublicId::fromOtp($otp); } else { $publicId = null; } if ($verificationResult->isServerError()) { return new VerificationResult(VerificationResult::RESULT_OTP_VERIFICATION_FAILED, $publicId); } elseif ($verificationResult->isClientError()) { return new VerificationResult(VerificationResult::RESULT_OTP_INVALID, $publicId); } if ($publicId->getYubikeyPublicId() !== $command->expectedPublicId) { $this->logger->notice('Yubikey used by registrant during vetting did not match the one used during registration.'); return new VerificationResult(VerificationResult::RESULT_PUBLIC_ID_DID_NOT_MATCH, $publicId); } $this->logger->info('Yubikey used by registrant during vetting matches the one used during registration.'); return new VerificationResult(VerificationResult::RESULT_PUBLIC_ID_MATCHED, $publicId); }
/** * @param callable $migration Closure that receives the table to operate on. * * <example> * $migration->execute(function($table) { * $table * ->removeColumn('name') * ->save(); * }); * </example> */ public function execute(callable $migration) { $this->logger->info("Starting LHM run on table={$this->origin->getName()}"); $sqlHelper = new SqlHelper($this->adapter); if (!isset($options['atomic_switch'])) { if ($sqlHelper->supportsAtomicSwitch()) { $this->options['atomic_switch'] = true; } else { $version = $sqlHelper->versionString(); throw new \RuntimeException("Using mysql {$version}. You must explicitly set `options['atomic_switch']` (re SqlHelper::supportsAtomicSwitch)"); } } if (!$this->destination) { $this->destination = $this->temporaryTable(); } $this->setSessionLockWaitTimeouts(); $entangler = new Entangler($this->adapter, $this->origin, $this->destination, $sqlHelper); $entangler->setLogger($this->logger); if ($this->options['atomic_switch']) { $switcher = new AtomicSwitcher($this->adapter, $this->origin, $this->destination, $this->options); } else { $switcher = new LockedSwitcher($this->adapter, $this->origin, $this->destination, $this->options); } $switcher->setLogger($this->logger); $chunker = new Chunker($this->adapter, $this->origin, $this->destination, $sqlHelper, $this->options); $chunker->setLogger($this->logger); $migration($this->destination); $entangler->run(function () use($chunker, $switcher) { $chunker->run(); $switcher->run(); }); }
/** * @param bool $dryRun */ public function execute($dryRun = false) { if ($this->logger === null) { throw new \RuntimeException('No logger defined'); } $this->processor->setCurrentWorkingDirectory($this->getCurrentWorkingDirectory()); if (!isset($this->getConfig()->path) || !isset($this->getConfig()->match)) { throw new ConfigurationException('Config `path` and `match` are required to cleanup directories'); } $path = $this->getConfig()->path; $match = $this->getConfig()->match; if (isset($this->getConfig()->recursive) && $this->getConfig()->recursive === true) { $recursive = true; } else { $recursive = false; } $shouldBeRemoved = $this->getListForRemoval($path, $match, $recursive); foreach ($shouldBeRemoved as $item) { if (file_exists($item->getPathname())) { $date = date('Y-m-d H:i:s', $item->getMTime()); $this->logger->info("[Removing] {$item->getPathname()} (Modified At: {$date})"); if (!$dryRun) { $this->processor->execute("rm -Rf {$item->getPathname()}"); } } } }
/** * Returns the archives IDs that have already been invalidated and have been since re-processed. * * These archives { archive name (includes segment hash) , idsite, date, period } will be deleted. * * @param string $archiveTable * @param array $idSites * @return array * @throws Exception */ public function getInvalidatedArchiveIdsSafeToDelete($archiveTable, array $idSites) { try { Db::get()->query('SET SESSION group_concat_max_len=' . 128 * 1024); } catch (\Exception $ex) { $this->logger->info("Could not set group_concat_max_len MySQL session variable."); } $idSites = array_map(function ($v) { return (int) $v; }, $idSites); $sql = "SELECT idsite, date1, date2, period, name,\n GROUP_CONCAT(idarchive, '.', value ORDER BY ts_archived DESC) as archives\n FROM `{$archiveTable}`\n WHERE name LIKE 'done%'\n AND value IN (" . ArchiveWriter::DONE_INVALIDATED . ',' . ArchiveWriter::DONE_OK . ',' . ArchiveWriter::DONE_OK_TEMPORARY . ")\n AND idsite IN (" . implode(',', $idSites) . ")\n GROUP BY idsite, date1, date2, period, name"; $archiveIds = array(); $rows = Db::fetchAll($sql); foreach ($rows as $row) { $duplicateArchives = explode(',', $row['archives']); $firstArchive = array_shift($duplicateArchives); list($firstArchiveId, $firstArchiveValue) = explode('.', $firstArchive); // if the first archive (ie, the newest) is an 'ok' or 'ok temporary' archive, then // all invalidated archives after it can be deleted if ($firstArchiveValue == ArchiveWriter::DONE_OK || $firstArchiveValue == ArchiveWriter::DONE_OK_TEMPORARY) { foreach ($duplicateArchives as $pair) { if (strpos($pair, '.') === false) { $this->logger->info("GROUP_CONCAT cut off the query result, you may have to purge archives again."); break; } list($idarchive, $value) = explode('.', $pair); if ($value == ArchiveWriter::DONE_INVALIDATED) { $archiveIds[] = $idarchive; } } } } return $archiveIds; }
/** * @param string $name * @param mixed $data * @param int $priority * @param string $unique * @return string $jobHandle */ public function background($name, $data = null, $priority = self::NORMAL, $unique = null) { $client = $this->getClient()->getClient(); if (null !== $this->logger) { $this->logger->debug("Sent background job \"{$name}\" to GearmanClient"); } $jobHandle = null; switch ($priority) { case self::LOW: $jobHandle = $client->doLowBackground($name, self::serialize($data), $unique); break; case self::HIGH: $jobHandle = $client->doHighBackground($name, self::serialize($data), $unique); break; default: $jobHandle = $client->doBackground($name, self::serialize($data), $unique); break; } if ($client->returnCode() !== GEARMAN_SUCCESS) { if (null !== $this->logger) { $this->logger->error("Bad return code"); } } if (null !== $this->logger) { $this->logger->info("Sent job \"{$jobHandle}\" to GearmanWorker"); } return $jobHandle; }
/** * {@inheritdoc} */ public function render(BlockContextInterface $blockContext, Response $response = null) { $block = $blockContext->getBlock(); if ($this->logger) { $this->logger->info(sprintf('[cms::renderBlock] block.id=%d, block.type=%s ', $block->getId(), $block->getType())); } try { $service = $this->blockServiceManager->get($block); $service->load($block); $response = $service->execute($blockContext, $this->createResponse($blockContext, $response)); if (!$response instanceof Response) { $response = null; throw new \RuntimeException('A block service must return a Response object'); } $response = $this->addMetaInformation($response, $blockContext, $service); } catch (\Exception $exception) { if ($this->logger) { $this->logger->critical(sprintf('[cms::renderBlock] block.id=%d - error while rendering block - %s', $block->getId(), $exception->getMessage())); } // reseting the state object $this->lastResponse = null; $response = $this->exceptionStrategyManager->handleException($exception, $blockContext->getBlock(), $response); } return $response; }
/** * logs request api call including options * * @param string $scope * @param string $name * @param array $opts * @return boolean */ public function log($scope, $name, $opts) { // stop measure the response time $this->stop(); $this->logger->info(sprintf('%s to %s (%2.4fs)', Config::getInstance()->http_post ? 'POST' : 'GET', $this->formatUrl($scope, $name, $opts), $this->responseTime)); return true; }
private function subscribePlatform($platform, $topic) { foreach ($this->sns->getListEndpointsByPlatformApplicationIterator(['PlatformApplicationArn' => $this->arns[$platform]]) as $endpoint) { $this->logger && $this->logger->info('Subscribing device to topic', ['device' => $endpoint['EndpointArn'], 'topic' => $topic, 'platform' => $platform]); $this->topics->registerDeviceOnTopic($endpoint['EndpointArn'], $topic); } }