MISCONF Redis is configured to save RDB snapshots, but it is currently not able to persist on disk. Commands that may modify the data set are disabled, because this instance is configured to report errors during writes if RDB snapshotting fails (stop-writes-on-bgsave-error option). Please check the Redis logs for details about the RDB error. search►

375:    
376:        /**
377:         * {@inheritdoc}
378:         */
379:        public function executeCommand(CommandInterface $command)
380:        {
381:            $response = $this->connection->executeCommand($command);
382:    
383:            if ($response instanceof ResponseInterface) {
384:                if ($response instanceof ErrorResponseInterface) {
385:                    $response = $this->onErrorResponse($command, $response);
386:                }
387:    
388:                return $response;
389:            }

326:    
327:            return $response;
328:        }
329:    
330:        /**
331:         * {@inheritdoc}
332:         */
333:        public function __call($commandID, $arguments)
334:        {
335:            return $this->executeCommand(
336:                $this->createCommand($commandID, $arguments)
337:            );
338:        }
339:    
340:        /**

184:                $this->remove($key);
185:                throw new Nette\InvalidStateException($e->getMessage(), $e->getCode(), $e);
186:            }
187:        }
188:    
189:        /**
190:         * Removes item from the cache.
191:         * @param string $key
192:         */
193:        public function remove($key): void {
194:            $this->client->del($this->formatEntryKey($key));
195:        }
196:    
197:        /**
198:         * Removes items from the cache by conditions & garbage collector.

'del'

198:                $this->storage->lock($key);
199:                try {
200:                    $data = $data(...[&$dependencies]);
201:                } catch (\Throwable $e) {
202:                    $this->storage->remove($key);
203:                    throw $e;
204:                }
205:            }
206:    
207:            if ($data === null) {
208:                $this->storage->remove($key);
209:                return null;
210:            } else {
211:                $dependencies = $this->completeDependencies($dependencies);
212:                if (isset($dependencies[self::Expire]) && $dependencies[self::Expire] <= 0) {

 89:    
 90:                if ($row) {
 91:                    $row->image = $this->imageService->getImageById((int)$row->header_promo_image_id);
 92:                }
 93:    
 94:                $cacheString = (isset($row->datetime_end) && strtotime((string) $row->datetime_end) > time()) ? (string) $row->datetime_end : self::CACHE_EXPIRE_DEFAULT;
 95:    
 96:                $this->cache->save($cacheKey, $row, [Cache::TAGS => [
 97:                        'db/header_promo',
 98:                    ],
 99:                    Cache::EXPIRE => $cacheString,
100:                ]);
101:            }
102:    
103:            return ($promo instanceof Row) ? $promo : null;

null

10:        private $headerPromoService;
11:    
12:        /** @var Row|null */
13:        private $promo;
14:    
15:    
16:        public function __construct(HeaderPromoService $headerPromoService) {
17:            $this->headerPromoService = $headerPromoService;
18:    
19:            $this->monitor(Presenter::class, function ($presenter): void {
20:                $this->promo = $this->headerPromoService->getActivePromo();
21:            });
22:        }
23:    
24:        public function hasActivePromo(): bool {

260:    
261:                        $this->monitors[$type][3] = $rec[3]; // mark as monitored
262:                    }
263:                }
264:            }
265:    
266:            if ($depth === 0) { // call listeners
267:                $prev = [];
268:                foreach ($listeners as $item) {
269:                    if ($item[0] && !in_array($item, $prev, true)) {
270:                        $item[0]($item[1]);
271:                        $prev[] = $item;
272:                    }
273:                }
274:            }

185:                $this->parent = null;
186:    
187:            } else { // add to parent
188:                $this->validateParent($parent);
189:                $this->parent = $parent;
190:                if ($name !== null) {
191:                    $this->name = $name;
192:                }
193:    
194:                $tmp = [];
195:                $this->refreshMonitors(0, $tmp);
196:            }
197:    
198:            return $this;
199:        }

0

array (0)

75:    
76:                    $tmp[$k] = $v;
77:                }
78:    
79:                $this->components = $tmp;
80:            } else {
81:                $this->components[$name] = $component;
82:            }
83:    
84:            try {
85:                $component->setParent($this, $name);
86:            } catch (\Throwable $e) {
87:                unset($this->components[$name]); // undo
88:                throw $e;
89:            }

'headerPromo'

119:                if (!preg_match(self::NameRegexp, $name)) {
120:                    if ($throw) {
121:                        throw new Nette\InvalidArgumentException("Component name must be non-empty alphanumeric string, '$name' given.");
122:                    }
123:    
124:                    return null;
125:                }
126:    
127:                $component = $this->createComponent($name);
128:                if ($component && !isset($this->components[$name])) {
129:                    $this->addComponent($component, $name);
130:                }
131:            }
132:    
133:            $component = $this->components[$name] ?? null;

'headerPromo'

41:        }
42:    
43:    
44:        /**
45:         * Does component specified by name exists?
46:         * @param  string|int  $name
47:         */
48:        public function offsetExists($name): bool
49:        {
50:            $name = is_int($name) ? (string) $name : $name;
51:            return $this->getComponent($name, false) !== null;
52:        }
53:    
54:    
55:        /**

'headerPromo'

false

191:            }
192:            Filters::$xhtml = (bool) preg_match('#xml|xhtml#', static::CONTENT_TYPE);
193:    
194:            if ($this->referenceType === 'import') {
195:                if ($this->parentName) {
196:                    throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
197:                }
198:    
199:            } elseif ($this->parentName) { // extends
200:                ob_start(function () {});
201:                $this->params = $this->main();
202:                ob_end_clean();
203:                $this->createTemplate($this->parentName, $this->params, 'extends')->render($block);
204:    
205:            } elseif ($block !== null) { // single block rendering

160:    
161:        /**
162:         * Renders template.
163:         * @internal
164:         */
165:        public function render(?string $block = null): void
166:        {
167:            $level = ob_get_level();
168:            try {
169:                $this->prepare();
170:                if (!$this->doRender($block)) {
171:                    $this->main();
172:                }
173:    
174:            } catch (\Throwable $e) {

null

299:    
300:            if (!$block) {
301:                $hint = ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
302:                    ? ", did you mean '$t'?"
303:                    : '.';
304:                $name = $layer ? "$layer $name" : $name;
305:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
306:            }
307:    
308:            $this->filter(
309:                function () use ($block, $params): void { reset($block->functions)($params); },
310:                $mod,
311:                $block->contentType,
312:                "block $name"
313:            );

null

354:            $block->functions = array_merge($block->functions, $functions);
355:        }
356:    
357:    
358:        /**
359:         * @param  string|\Closure|null  $mod  content-type name or modifier closure
360:         */
361:        private function filter(callable $function, $mod, string $contentType, string $name): void
362:        {
363:            if ($mod === null || $mod === $contentType) {
364:                $function();
365:    
366:            } elseif ($mod instanceof \Closure) {
367:                echo $mod($this->capture($function), $contentType);
368:    

302:                    ? ", did you mean '$t'?"
303:                    : '.';
304:                $name = $layer ? "$layer $name" : $name;
305:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
306:            }
307:    
308:            $this->filter(
309:                function () use ($block, $params): void { reset($block->functions)($params); },
310:                $mod,
311:                $block->contentType,
312:                "block $name"
313:            );
314:        }
315:    
316:    

null

'html'

'block commonHeader__shared--outside-page-content'

161:        /**
162:         * Renders template.
163:         * @internal
164:         */
165:        public function render(?string $block = null): void
166:        {
167:            $level = ob_get_level();
168:            try {
169:                $this->prepare();
170:                if (!$this->doRender($block)) {
171:                    $this->main();
172:                }
173:    
174:            } catch (\Throwable $e) {
175:                while (ob_get_level() > $level) {

193:    
194:            if ($this->referenceType === 'import') {
195:                if ($this->parentName) {
196:                    throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
197:                }
198:    
199:            } elseif ($this->parentName) { // extends
200:                ob_start(function () {});
201:                $this->params = $this->main();
202:                ob_end_clean();
203:                $this->createTemplate($this->parentName, $this->params, 'extends')->render($block);
204:    
205:            } elseif ($block !== null) { // single block rendering
206:                $this->renderBlock($block, $this->params);
207:    

null

160:    
161:        /**
162:         * Renders template.
163:         * @internal
164:         */
165:        public function render(?string $block = null): void
166:        {
167:            $level = ob_get_level();
168:            try {
169:                $this->prepare();
170:                if (!$this->doRender($block)) {
171:                    $this->main();
172:                }
173:    
174:            } catch (\Throwable $e) {

null

161:        /**
162:         * Renders template.
163:         * @internal
164:         */
165:        public function render(?string $block = null): void
166:        {
167:            $level = ob_get_level();
168:            try {
169:                $this->prepare();
170:                if (!$this->doRender($block)) {
171:                    $this->main();
172:                }
173:    
174:            } catch (\Throwable $e) {
175:                while (ob_get_level() > $level) {

193:    
194:            if ($this->referenceType === 'import') {
195:                if ($this->parentName) {
196:                    throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
197:                }
198:    
199:            } elseif ($this->parentName) { // extends
200:                ob_start(function () {});
201:                $this->params = $this->main();
202:                ob_end_clean();
203:                $this->createTemplate($this->parentName, $this->params, 'extends')->render($block);
204:    
205:            } elseif ($block !== null) { // single block rendering
206:                $this->renderBlock($block, $this->params);
207:    

null

160:    
161:        /**
162:         * Renders template.
163:         * @internal
164:         */
165:        public function render(?string $block = null): void
166:        {
167:            $level = ob_get_level();
168:            try {
169:                $this->prepare();
170:                if (!$this->doRender($block)) {
171:                    $this->main();
172:                }
173:    
174:            } catch (\Throwable $e) {

null

 92:    
 93:        /**
 94:         * Renders template to output.
 95:         * @param  object|mixed[]  $params
 96:         */
 97:        public function render(string $name, $params = [], ?string $block = null): void
 98:        {
 99:            $template = $this->createTemplate($name, $this->processParams($params));
100:            $template->global->coreCaptured = false;
101:            ($this->probe)($template);
102:            $template->render($block);
103:        }
104:    
105:    
106:        /**

null

40:        /**
41:         * Renders template to output.
42:         */
43:        public function render(?string $file = null, array $params = []): void
44:        {
45:            Nette\Utils\Arrays::toObject($params, $this);
46:            if (\cfg::$debug['tmplDump']) {
47:                $filePath = strstr($file ? : $this->file, "templates/");
48:                echo '<pre class="nette-dump"><span class="nette-dump-object">' . get_class($this->control) . ": $filePath" . '</span></pre>';
49:            }
50:            $this->latte->render($file ?: $this->file, $this);
51:        }
52:    
53:    
54:        /**

'/www/virtual/martin/stable/lupa/app/templates/TextModule/ViewPressNews/default.latte'

40:            return $this->source;
41:        }
42:    
43:    
44:        /**
45:         * Sends response to output.
46:         */
47:        public function send(Nette\Http\IRequest $httpRequest, Nette\Http\IResponse $httpResponse): void
48:        {
49:            if ($this->source instanceof Nette\Application\UI\Template) {
50:                $this->source->render();
51:    
52:            } else {
53:                echo $this->source;
54:            }

161:    
162:            Arrays::invoke($this->onPresenter, $this, $this->presenter);
163:            $response = $this->presenter->run(clone $request);
164:    
165:            if ($response instanceof Responses\ForwardResponse) {
166:                $request = $response->getRequest();
167:                goto process;
168:            }
169:    
170:            Arrays::invoke($this->onResponse, $this, $response);
171:            $response->send($this->httpRequest, $this->httpResponse);
172:        }
173:    
174:    
175:        public function processException(\Throwable $e): void

80:        }
81:    
82:    
83:        /**
84:         * Dispatch a HTTP request to a front controller.
85:         */
86:        public function run(): void
87:        {
88:            try {
89:                Arrays::invoke($this->onStartup, $this);
90:                $this->processRequest($this->createInitialRequest());
91:                Arrays::invoke($this->onShutdown, $this);
92:    
93:            } catch (\Throwable $e) {
94:                Arrays::invoke($this->onError, $this, $e);

13:        !empty($_SERVER["HTTPS"]),
14:        'http://forum.lupa.cz/',
15:        trim(AppConfig::$modulesUrl['blogs'], '/'),
16:        true
17:    );
18:    $redirector->injectDibiConnections($bootstrap->getContext()->getService('dibiConnections'));
19:    $redirector->redirectUrl();
20:    unset($redirector);
21:    
22:    $bootstrap->setupRouting();
23:    $bootstrap->getApplication()->run();
24: