Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

51 files changed, 6832 insertions, 0 deletions

diff --git a/library/Graphite/Graphing/Chart.php b/library/Graphite/Graphing/Chart.php
new file mode 100644
index 0000000..ded8ae8
--- /dev/null
+++ b/library/Graphite/Graphing/Chart.php
@@ -0,0 +1,385 @@
+<?php
+
+namespace Icinga\Module\Graphite\Graphing;
+
+use Icinga\Module\Graphite\Util\MacroTemplate;
+use Icinga\Module\Graphite\Web\Widget\GraphImage;
+use Icinga\Web\Response;
+
+class Chart
+{
+    /**
+     * Used to render the chart
+     *
+     * @var GraphiteWebClient
+     */
+    protected $graphiteWebClient;
+
+    /** @var ?string This chart's background color */
+    protected $bgcolor;
+
+    /** @var ?string This chart's foreground color */
+    protected $fgcolor;
+
+    /** @var ?string This chart's major grid line color */
+    protected $majorGridLineColor;
+
+    /** @var ?string This chart's minor grid line color */
+    protected $minorGridLineColor;
+
+    /**
+     * This chart's base
+     *
+     * @var Template
+     */
+    protected $template;
+
+    /**
+     * Target metrics by curve name
+     *
+     * @var string[]
+     */
+    protected $metrics;
+
+    /**
+     * The chart's begin
+     *
+     * @var string
+     */
+    protected $from = '-14400';
+
+    /**
+     * The chart's end
+     *
+     * @var string
+     */
+    protected $until;
+
+    /**
+     * The chart's width
+     *
+     * @var int
+     */
+    protected $width = 350;
+
+    /**
+     * The chart's height
+     *
+     * @var int
+     */
+    protected $height = 200;
+
+    /**
+     * Whether to show the chart's legend
+     *
+     * @var bool
+     */
+    protected $showLegend = true;
+
+    /**
+     * Constructor
+     *
+     * @param   GraphiteWebClient   $graphiteWebClient  Used to render the chart
+     * @param   Template            $template           This chart's base
+     * @param   string[]            $metrics            Target metrics by curve name
+     */
+    public function __construct(GraphiteWebClient $graphiteWebClient, Template $template, array $metrics)
+    {
+        $this->graphiteWebClient = $graphiteWebClient;
+        $this->template = $template;
+        $this->metrics = $metrics;
+    }
+
+    /**
+     * Let Graphite Web render this chart and serve the result immediately to the user agent (via the given response)
+     *
+     * Does not return.
+     *
+     * @param   Response    $response
+     */
+    public function serveImage(Response $response)
+    {
+        $image = new GraphImage($this);
+
+        // Errors should occur now or not at all
+        $image->render();
+
+        $response
+            ->setHeader('Content-Type', 'image/png', true)
+            ->setHeader('Content-Disposition', 'inline; filename="graph.png"', true)
+            ->setHeader('Cache-Control', null, true)
+            ->setHeader('Expires', null, true)
+            ->setHeader('Pragma', null, true)
+            ->setBody($image)
+            ->sendResponse();
+
+        exit;
+    }
+
+    /**
+     * Extract the values of the template's metrics filters' variables from the target metrics
+     *
+     * @return string[]
+     */
+    public function getMetricVariables()
+    {
+        /** @var MacroTemplate[][] $curves */
+        $curves = $this->template->getFullCurves();
+        $variables = [];
+
+        foreach ($this->metrics as $curveName => $metric) {
+            $vars = $curves[$curveName][0]->reverseResolve($metric);
+            if ($vars !== false) {
+                $variables = array_merge($variables, $vars);
+            }
+        }
+
+        return $variables;
+    }
+
+    /**
+     * Get Graphite Web client
+     *
+     * @return GraphiteWebClient
+     */
+    public function getGraphiteWebClient()
+    {
+        return $this->graphiteWebClient;
+    }
+
+    /**
+     * Get this chart's background color
+     *
+     * @return string|null
+     */
+    public function getBackgroundColor(): ?string
+    {
+        return $this->bgcolor;
+    }
+
+    /**
+     * Set this chart's background color
+     *
+     * @param string|null $color
+     *
+     * @return $this
+     */
+    public function setBackgroundColor(?string $color): self
+    {
+        $this->bgcolor = $color;
+
+        return $this;
+    }
+
+    /**
+     * Get this chart's foreground color
+     *
+     * @return string|null
+     */
+    public function getForegroundColor(): ?string
+    {
+        return $this->fgcolor;
+    }
+
+    /**
+     * Set this chart's foreground color
+     *
+     * @param string|null $color
+     *
+     * @return $this
+     */
+    public function setForegroundColor(?string $color): self
+    {
+        $this->fgcolor = $color;
+
+        return $this;
+    }
+
+    /**
+     * Get this graph's major grid line color
+     *
+     * @return string|null
+     */
+    public function getMajorGridLineColor(): ?string
+    {
+        return $this->majorGridLineColor;
+    }
+
+    /**
+     * Set this graph's major grid line color
+     *
+     * @param string|null $color
+     *
+     * @return $this
+     */
+    public function setMajorGridLineColor(?string $color): self
+    {
+        $this->majorGridLineColor = $color;
+
+        return $this;
+    }
+
+    /**
+     * Get this graph's minor grid line color
+     *
+     * @return string|null
+     */
+    public function getMinorGridLineColor(): ?string
+    {
+        return $this->minorGridLineColor;
+    }
+
+    /**
+     * Set this graph's minor grid line color
+     *
+     * @param string|null $color
+     *
+     * @return $this
+     */
+    public function setMinorGridLineColor(?string $color): self
+    {
+        $this->minorGridLineColor = $color;
+
+        return $this;
+    }
+
+    /**
+     * Get template
+     *
+     * @return Template
+     */
+    public function getTemplate()
+    {
+        return $this->template;
+    }
+
+    /**
+     * Get metrics
+     *
+     * @return string[]
+     */
+    public function getMetrics()
+    {
+        return $this->metrics;
+    }
+
+    /**
+     * Get begin
+     *
+     * @return string
+     */
+    public function getFrom()
+    {
+        return $this->from;
+    }
+
+    /**
+     * Set begin
+     *
+     * @param string $from
+     *
+     * @return $this
+     */
+    public function setFrom($from)
+    {
+        $this->from = $from;
+
+        return $this;
+    }
+
+    /**
+     * Get end
+     *
+     * @return string
+     */
+    public function getUntil()
+    {
+        return $this->until;
+    }
+
+    /**
+     * Set end
+     *
+     * @param string $until
+     *
+     * @return $this
+     */
+    public function setUntil($until)
+    {
+        $this->until = $until;
+
+        return $this;
+    }
+
+    /**
+     * Get width
+     *
+     * @return int
+     */
+    public function getWidth()
+    {
+        return $this->width;
+    }
+
+    /**
+     * Set width
+     *
+     * @param int $width
+     *
+     * @return $this
+     */
+    public function setWidth($width)
+    {
+        $this->width = $width;
+
+        return $this;
+    }
+
+    /**
+     * Get height
+     *
+     * @return int
+     */
+    public function getHeight()
+    {
+        return $this->height;
+    }
+
+    /**
+     * Set height
+     *
+     * @param int $height
+     *
+     * @return $this
+     */
+    public function setHeight($height)
+    {
+        $this->height = $height;
+
+        return $this;
+    }
+
+    /**
+     * Get whether to show the chart's legend
+     *
+     * @return bool
+     */
+    public function getShowLegend()
+    {
+        return $this->showLegend;
+    }
+
+    /**
+     * Set whether to show the chart's legend
+     *
+     * @param bool $showLegend
+     *
+     * @return $this
+     */
+    public function setShowLegend($showLegend)
+    {
+        $this->showLegend = $showLegend;
+
+        return $this;
+    }
+}
diff --git a/library/Graphite/Graphing/GraphingTrait.php b/library/Graphite/Graphing/GraphingTrait.php
new file mode 100644
index 0000000..e32a52a
--- /dev/null
+++ b/library/Graphite/Graphing/GraphingTrait.php
@@ -0,0 +1,79 @@
+<?php
+
+namespace Icinga\Module\Graphite\Graphing;
+
+use Icinga\Application\Config;
+use Icinga\Application\Icinga;
+use Icinga\Exception\ConfigurationError;
+use Icinga\Module\Graphite\Web\FakeSchemeRequest;
+use Icinga\Web\Url;
+
+trait GraphingTrait
+{
+    /**
+     * All loaded templates
+     *
+     * @var Templates
+     */
+    protected static $allTemplates;
+
+    /**
+     * Metrics data source
+     *
+     * @var MetricsDataSource
+     */
+    protected static $metricsDataSource;
+
+    /**
+     * Load and get all templates
+     *
+     * @return Templates
+     */
+    protected static function getAllTemplates()
+    {
+        if (static::$allTemplates === null) {
+            $allTemplates = (new Templates())->loadDir(
+                Icinga::app()
+                    ->getModuleManager()
+                    ->getModule('graphite')
+                    ->getBaseDir() . DIRECTORY_SEPARATOR . 'templates'
+            );
+
+            $path = Config::resolvePath('modules/graphite/templates');
+            if (file_exists($path)) {
+                $allTemplates->loadDir($path);
+            }
+
+            static::$allTemplates = $allTemplates;
+        }
+
+        return static::$allTemplates;
+    }
+
+    /**
+     * Get metrics data source
+     *
+     * @return MetricsDataSource
+     *
+     * @throws ConfigurationError
+     */
+    public static function getMetricsDataSource()
+    {
+        if (static::$metricsDataSource === null) {
+            $config = Config::module('graphite');
+            $graphite = $config->getSection('graphite');
+            if (! isset($graphite->url)) {
+                throw new ConfigurationError('Missing "graphite.url" in "%s"', $config->getConfigFile());
+            }
+
+            static::$metricsDataSource = new MetricsDataSource(
+                (new GraphiteWebClient(Url::fromPath($graphite->url, [], new FakeSchemeRequest())))
+                    ->setUser($graphite->user)
+                    ->setPassword($graphite->password)
+                    ->setInsecure($graphite->insecure)
+            );
+        }
+
+        return static::$metricsDataSource;
+    }
+}
diff --git a/library/Graphite/Graphing/GraphiteWebClient.php b/library/Graphite/Graphing/GraphiteWebClient.php
new file mode 100644
index 0000000..b06b6ce
--- /dev/null
+++ b/library/Graphite/Graphing/GraphiteWebClient.php
@@ -0,0 +1,198 @@
+<?php
+
+namespace Icinga\Module\Graphite\Graphing;
+
+use Icinga\Web\Url;
+use iplx\Http\Client;
+use iplx\Http\ClientInterface;
+use iplx\Http\Request;
+
+/**
+ * HTTP interface to Graphite Web
+ */
+class GraphiteWebClient
+{
+    /**
+     * Base URL of every Graphite Web HTTP request
+     *
+     * @var Url
+     */
+    protected $baseUrl;
+
+    /**
+     * HTTP basic auth user for every Graphite Web HTTP request
+     *
+     * @var string|null
+     */
+    protected $user;
+
+    /**
+     * The above user's password
+     *
+     * @var string|null
+     */
+    protected $password;
+
+    /**
+     * Don't verify the remote's TLS certificate
+     *
+     * @var bool
+     */
+    protected $insecure = false;
+
+    /**
+     * HTTP client
+     *
+     * @var ClientInterface
+     */
+    protected $httpClient;
+
+    /**
+     * Constructor
+     *
+     * @param   Url $baseUrl    Base URL of every Graphite Web HTTP request
+     */
+    public function __construct(Url $baseUrl)
+    {
+        $this->httpClient = new Client();
+
+        $this->setBaseUrl($baseUrl);
+    }
+
+    /**
+     * Send an HTTP request to the configured Graphite Web and return the response's body
+     *
+     * @param   Url         $url
+     * @param   string      $method
+     * @param   string[]    $headers
+     * @param   string      $body
+     *
+     * @return  string
+     */
+    public function request(Url $url, $method = 'GET', array $headers = [], $body = null)
+    {
+        $headers['User-Agent'] = 'icingaweb2-module-graphite';
+        if ($this->user !== null) {
+            $headers['Authorization'] = 'Basic ' . base64_encode("{$this->user}:{$this->password}");
+        }
+
+        // TODO(ak): keep connections alive (TCP handshakes are a bit expensive and TLS handshakes are very expensive)
+        return (string) $this->httpClient->send(
+            new Request($method, $this->completeUrl($url)->getAbsoluteUrl(), $headers, $body),
+            ['curl' => [
+                CURLOPT_SSL_VERIFYPEER => ! $this->insecure
+            ]]
+        )->getBody();
+    }
+
+    /**
+     * Complete the given relative URL according to the base URL
+     *
+     * @param   Url $url
+     *
+     * @return  Url
+     */
+    public function completeUrl(Url $url)
+    {
+        $completeUrl = clone $this->baseUrl;
+        return $completeUrl
+            ->setPath(ltrim(rtrim($completeUrl->getPath(), '/') . '/' . ltrim($url->getPath(), '/'), '/'))
+            ->setParams($url->getParams());
+    }
+
+    /**
+     * Get the base URL of every Graphite Web HTTP request
+     *
+     * @return Url
+     */
+    public function getBaseUrl()
+    {
+        return $this->baseUrl;
+    }
+
+    /**
+     * Set the base URL of every Graphite Web HTTP request
+     *
+     * @param Url $baseUrl
+     *
+     * @return $this
+     */
+    public function setBaseUrl(Url $baseUrl)
+    {
+        $this->baseUrl = $baseUrl;
+
+        return $this;
+    }
+
+    /**
+     * Get the HTTP basic auth user
+     *
+     * @return null|string
+     */
+    public function getUser()
+    {
+        return $this->user;
+    }
+
+    /**
+     * Set the HTTP basic auth user
+     *
+     * @param null|string $user
+     *
+     * @return $this
+     */
+    public function setUser($user)
+    {
+        $this->user = $user;
+
+        return $this;
+    }
+
+    /**
+     * Get the HTTP basic auth password
+     *
+     * @return null|string
+     */
+    public function getPassword()
+    {
+        return $this->password;
+    }
+
+    /**
+     * Set the HTTP basic auth password
+     *
+     * @param null|string $password
+     *
+     * @return $this
+     */
+    public function setPassword($password)
+    {
+        $this->password = $password;
+
+        return $this;
+    }
+
+    /**
+     * Get whether not to verify the remote's TLS certificate
+     *
+     * @return bool
+     */
+    public function getInsecure()
+    {
+        return $this->insecure;
+    }
+
+    /**
+     * Set whether not to verify the remote's TLS certificate
+     *
+     * @param bool $insecure
+     *
+     * @return $this
+     */
+    public function setInsecure($insecure = true)
+    {
+        $this->insecure = $insecure;
+
+        return $this;
+    }
+}
diff --git a/library/Graphite/Graphing/MetricsDataSource.php b/library/Graphite/Graphing/MetricsDataSource.php
new file mode 100644
index 0000000..19787da
--- /dev/null
+++ b/library/Graphite/Graphing/MetricsDataSource.php
@@ -0,0 +1,48 @@
+<?php
+
+namespace Icinga\Module\Graphite\Graphing;
+
+use Icinga\Data\Selectable;
+
+/**
+ * Provides an interface to Graphite Web's metrics list
+ */
+class MetricsDataSource implements Selectable
+{
+    /**
+     * HTTP interface to Graphite Web
+     *
+     * @var GraphiteWebClient
+     */
+    private $client;
+
+    /**
+     * Constructor
+     *
+     * @param   GraphiteWebClient   $client HTTP interface to Graphite Web
+     */
+    public function __construct(GraphiteWebClient $client)
+    {
+        $this->client = $client;
+    }
+
+    /**
+     * Initiate a new query
+     *
+     * @return MetricsQuery
+     */
+    public function select()
+    {
+        return new MetricsQuery($this);
+    }
+
+    /**
+     * Get the client passed to the constructor
+     *
+     * @return GraphiteWebClient
+     */
+    public function getClient()
+    {
+        return $this->client;
+    }
+}
diff --git a/library/Graphite/Graphing/MetricsQuery.php b/library/Graphite/Graphing/MetricsQuery.php
new file mode 100644
index 0000000..da05c17
--- /dev/null
+++ b/library/Graphite/Graphing/MetricsQuery.php
@@ -0,0 +1,219 @@
+<?php
+
+namespace Icinga\Module\Graphite\Graphing;
+
+use Icinga\Data\Fetchable;
+use Icinga\Data\Filter\Filter;
+use Icinga\Data\Filterable;
+use Icinga\Data\Queryable;
+use Icinga\Exception\NotImplementedError;
+use Icinga\Module\Graphite\GraphiteUtil;
+use Icinga\Module\Graphite\Util\IcingadbUtils;
+use Icinga\Module\Graphite\Util\MacroTemplate;
+use Icinga\Module\Graphite\Util\InternalProcessTracker as IPT;
+use Icinga\Module\Icingadb\Compat\UrlMigrator;
+use Icinga\Module\Icingadb\Model\Host;
+use Icinga\Module\Monitoring\Object\Macro;
+use Icinga\Module\Monitoring\Object\MonitoredObject;
+use Icinga\Util\Json;
+use Icinga\Web\Url;
+use InvalidArgumentException;
+use ipl\Orm\Model;
+use ipl\Stdlib\Filter as IplFilter;
+
+/**
+ * Queries a {@link MetricsDataSource}
+ */
+class MetricsQuery implements Queryable, Filterable, Fetchable
+{
+    /**
+     * @var MetricsDataSource
+     */
+    protected $dataSource;
+
+    /**
+     * The base metrics pattern
+     *
+     * @var MacroTemplate
+     */
+    protected $base;
+
+    /**
+     * Extension of {@link base}
+     *
+     * @var string[]
+     */
+    protected $filter = [];
+
+    /**
+     * The object to render the graphs for
+     *
+     * @var MonitoredObject|Model
+     */
+    protected $object;
+
+    /**
+     * Constructor
+     *
+     * @param   MetricsDataSource   $dataSource
+     */
+    public function __construct(MetricsDataSource $dataSource)
+    {
+        $this->dataSource = $dataSource;
+    }
+
+    public function from($target, array $fields = null)
+    {
+        if ($fields !== null) {
+            throw new InvalidArgumentException('Fields are not applicable to this kind of query');
+        }
+
+        try {
+            $this->base = $target instanceof MacroTemplate ? $target : new MacroTemplate((string) $target);
+        } catch (InvalidArgumentException $e) {
+            throw new InvalidArgumentException('Bad target', $e);
+        }
+
+        return $this;
+    }
+
+    public function applyFilter(Filter $filter)
+    {
+        throw new NotImplementedError(__METHOD__);
+    }
+
+    public function setFilter(Filter $filter)
+    {
+        throw new NotImplementedError(__METHOD__);
+    }
+
+    public function getFilter()
+    {
+        throw new NotImplementedError(__METHOD__);
+    }
+
+    public function addFilter(Filter $filter)
+    {
+        throw new NotImplementedError(__METHOD__);
+    }
+
+    public function where($condition, $value = null)
+    {
+        $this->filter[$condition] = $this->escapeMetricStep($value);
+
+        return $this;
+    }
+
+    public function fetchAll()
+    {
+        $result = [];
+        foreach ($this->fetchColumn() as $metric) {
+            $result[] = (object) ['metric' => $metric];
+        }
+
+        return $result;
+    }
+
+    public function fetchRow()
+    {
+        $result = $this->fetchColumn();
+        return empty($result) ? false : (object) ['metric' => $result[0]];
+    }
+
+    public function fetchColumn()
+    {
+        $filter = [];
+        foreach ($this->base->getMacros() as $macro) {
+            if (isset($this->filter[$macro])) {
+                $filter[$macro] = $this->filter[$macro];
+                continue;
+            }
+
+            if (strpos($macro, '.') === false) {
+                continue;
+            }
+
+            $workaroundMacro = str_replace('.', '_', $macro);
+            if ($this->object instanceof Model) {
+                // icingadb macro
+                $tranformFilter = UrlMigrator::transformFilter(
+                    IplFilter::equal($workaroundMacro, ''),
+                    $this->object instanceof Host ? 'hosts' : 'services'
+                );
+
+                if ($tranformFilter === false) {
+                    continue;
+                }
+
+                $migratedMacro = $tranformFilter->getColumn();
+
+                if ($migratedMacro === $workaroundMacro) {
+                    $workaroundMacro = $macro;
+                } else {
+                    $workaroundMacro = $migratedMacro;
+                }
+
+                $icingadbMacros = IcingadbUtils::getInstance();
+                $result = $icingadbMacros->resolveMacro($workaroundMacro, $this->object);
+            } else {
+                if ($workaroundMacro === 'service_name') {
+                    $workaroundMacro = 'service_description';
+                }
+
+                $result = Macro::resolveMacro($workaroundMacro, $this->object);
+            }
+
+            if ($result !== $workaroundMacro) {
+                $filter[$macro] = $this->escapeMetricStep($result);
+            }
+        }
+
+        $client = $this->dataSource->getClient();
+        $url = Url::fromPath('metrics/expand', [
+            'query' => $this->base->resolve($filter, '*')
+        ]);
+        $res = Json::decode($client->request($url));
+        natsort($res->results);
+
+        IPT::recordf('Fetched %s metric(s) from %s', count($res->results), (string) $client->completeUrl($url));
+
+        return array_values($res->results);
+    }
+
+    public function fetchOne()
+    {
+        $result = $this->fetchColumn();
+        return empty($result) ? false : $result[0];
+    }
+
+    public function fetchPairs()
+    {
+        throw new NotImplementedError(__METHOD__);
+    }
+
+    /**
+     * Set the object to render the graphs for
+     *
+     * @param MonitoredObject|Model $object
+     *
+     * @return $this
+     */
+    public function setObject($object)
+    {
+        $this->object = $object;
+
+        return $this;
+    }
+
+    /**
+     * Escapes a string for usage in a Graphite metric path between two dots
+     *
+     * @param   string  $step
+     *
+     * @return  string
+     */
+    protected function escapeMetricStep($step)
+    {
+        return preg_replace('/[^a-zA-Z0-9\*\-:^[\]$#%\']/', '_', $step);
+    }
+}
diff --git a/library/Graphite/Graphing/Template.php b/library/Graphite/Graphing/Template.php
new file mode 100644
index 0000000..a030fb7
--- /dev/null
+++ b/library/Graphite/Graphing/Template.php
@@ -0,0 +1,364 @@
+<?php
+
+namespace Icinga\Module\Graphite\Graphing;
+
+use Icinga\Application\Config;
+use Icinga\Exception\ConfigurationError;
+use Icinga\Module\Graphite\Util\MacroTemplate;
+use Icinga\Module\Graphite\Util\InternalProcessTracker as IPT;
+use Icinga\Module\Monitoring\Object\MonitoredObject;
+use InvalidArgumentException;
+use ipl\Orm\Model;
+
+class Template
+{
+    /**
+     * The configured icinga.graphite_writer_host_name_template
+     *
+     * @var MacroTemplate
+     */
+    protected static $hostNameTemplate;
+
+    /**
+     * The configured icinga.graphite_writer_service_name_template
+     *
+     * @var MacroTemplate
+     */
+    protected static $serviceNameTemplate;
+
+    /**
+     * All curves to show in a chart by name with Graphite Web metric filters and Graphite functions
+     *
+     * [$curve => [$metricFilter, $function], ...]
+     *
+     * @var MacroTemplate[][]
+     */
+    protected $curves = [];
+
+    /**
+     * All curves to show in a chart by name with full Graphite Web metric filters and Graphite functions
+     *
+     * [$curve => [$metricFilter, $function], ...]
+     *
+     * @var MacroTemplate[][]
+     */
+    protected $fullCurves;
+
+    /**
+     * Additional URL parameters for rendering via Graphite Web
+     *
+     * [$key => $value, ...]
+     *
+     * @var MacroTemplate[]
+     */
+    protected $urlParams = [];
+
+    /**
+     * Constructor
+     */
+    public function __construct()
+    {
+    }
+
+    /**
+     * Get all charts based on this template and applicable to the metrics
+     * from the given data source restricted by the given filter
+     *
+     * @param   MetricsDataSource       $dataSource
+     * @param   MonitoredObject|Model   $object    The object to render the graphs for
+     * @param   string[]                $filter
+     * @param   MacroTemplate[]         $excludeMetrics
+     *
+     * @return  Chart[]
+     */
+    public function getCharts(
+        MetricsDataSource $dataSource,
+        $object,
+        array $filter,
+        array &$excludeMetrics = []
+    ) {
+        $metrics = [];
+        $metricsUsed = 0;
+        $metricsExcluded = 0;
+
+        foreach ($this->getFullCurves() as $curveName => $curve) {
+            $fullMetricTemplate = $curve[0];
+
+            $query = $dataSource->select()->setObject($object)->from($fullMetricTemplate);
+
+            foreach ($filter as $key => $value) {
+                $query->where($key, $value);
+            }
+
+            foreach ($query->fetchColumn() as $metric) {
+                foreach ($excludeMetrics as $excludeMetric) {
+                    if ($excludeMetric->reverseResolve($metric) !== false) {
+                        ++$metricsExcluded;
+                        continue 2;
+                    }
+                }
+
+                $vars = $curve[0]->reverseResolve($metric);
+                if ($vars !== false) {
+                    $metrics[$curveName][$metric] = $vars;
+                    ++$metricsUsed;
+                }
+            }
+        }
+
+        switch (count($metrics)) {
+            case 0:
+                $metricsCombinations = [];
+                break;
+
+            case 1:
+                $metricsCombinations = [];
+
+                foreach ($metrics as $curveName => & $curveMetrics) {
+                    foreach ($curveMetrics as $metric => & $_) {
+                        $metricsCombinations[] = [$curveName => $metric];
+                    }
+                    unset($_);
+                }
+                unset($curveMetrics);
+
+                break;
+
+            default:
+                $possibleCombinations = [];
+                $handledCurves = [];
+                foreach ($metrics as $curveName1 => & $metrics1) {
+                    $handledCurves[$curveName1] = true;
+
+                    foreach ($metrics as $curveName2 => & $metrics2) {
+                        if (! isset($handledCurves[$curveName2])) {
+                            foreach ($metrics1 as $metric1 => & $vars1) {
+                                foreach ($metrics2 as $metric2 => & $vars2) {
+                                    if (
+                                        count(array_intersect_assoc($vars1, $vars2))
+                                        === count(array_intersect_key($vars1, $vars2))
+                                    ) {
+                                        $possibleCombinations[$curveName1][$curveName2][$metric1][$metric2] = true;
+                                    }
+                                }
+                                unset($vars2);
+                            }
+                            unset($vars1);
+                        }
+                    }
+                    unset($metrics2);
+                }
+                unset($metrics1);
+
+                $metricsCombinations = [];
+                $this->combineMetrics($metrics, $possibleCombinations, $metricsCombinations);
+        }
+
+        $charts = [];
+        foreach ($metricsCombinations as $metricsCombination) {
+            $charts[] = new Chart($dataSource->getClient(), $this, $metricsCombination);
+        }
+
+        IPT::recordf('Excluded %s metric(s)', $metricsExcluded);
+        IPT::recordf('Combined %s metric(s) to %s chart(s)', $metricsUsed, count($charts));
+
+        return $charts;
+    }
+
+    /**
+     * Fill the given metrics combinations from the given metrics as restricted by the given possible combinations
+     *
+     * @param   string[][][]    $metrics
+     * @param   bool[][][][]    $possibleCombinations
+     * @param   string[][]      $metricsCombinations
+     * @param   string[]        $currentCombination
+     */
+    protected function combineMetrics(
+        array &$metrics,
+        array &$possibleCombinations,
+        array &$metricsCombinations,
+        array $currentCombination = []
+    ) {
+        if (empty($currentCombination)) {
+            foreach ($metrics as $curveName => & $curveMetrics) {
+                foreach ($curveMetrics as $metric => & $_) {
+                    $this->combineMetrics(
+                        $metrics,
+                        $possibleCombinations,
+                        $metricsCombinations,
+                        [$curveName => $metric]
+                    );
+                }
+                unset($_);
+
+                break;
+            }
+            unset($curveMetrics);
+        } elseif (count($currentCombination) === count($metrics)) {
+            $metricsCombinations[] = $currentCombination;
+        } else {
+            foreach ($metrics as $nextCurveName => & $_) {
+                if (! isset($currentCombination[$nextCurveName])) {
+                    break;
+                }
+            }
+            unset($_);
+
+            $allowedNextCurveMetricsPerCurrentCurveName = [];
+            foreach ($currentCombination as $currentCurveName => $currentCurveMetric) {
+                $allowedNextCurveMetricsPerCurrentCurveName[$currentCurveName]
+                    = $possibleCombinations[$currentCurveName][$nextCurveName][$currentCurveMetric];
+            }
+
+            $allowedNextCurveMetrics = $allowedNextCurveMetricsPerCurrentCurveName[$currentCurveName];
+            unset($allowedNextCurveMetricsPerCurrentCurveName[$currentCurveName]);
+
+            foreach ($allowedNextCurveMetricsPerCurrentCurveName as & $allowedMetrics) {
+                $allowedNextCurveMetrics = array_intersect_key($allowedNextCurveMetrics, $allowedMetrics);
+            }
+            unset($allowedMetrics);
+
+            foreach ($allowedNextCurveMetrics as $allowedNextCurveMetric => $_) {
+                $nextCombination = $currentCombination;
+                $nextCombination[$nextCurveName] = $allowedNextCurveMetric;
+
+                $this->combineMetrics($metrics, $possibleCombinations, $metricsCombinations, $nextCombination);
+            }
+        }
+    }
+
+    /**
+     * Get curves to show in a chart by name with Graphite Web metric filters and Graphite functions
+     *
+     * @return MacroTemplate[][]
+     */
+    public function getCurves()
+    {
+        return $this->curves;
+    }
+
+    /**
+     * Get curves to show in a chart by name with full Graphite Web metric filters and Graphite functions
+     *
+     * @return MacroTemplate[][]
+     */
+    public function getFullCurves()
+    {
+        if ($this->fullCurves === null) {
+            $curves = $this->curves;
+
+            foreach ($curves as &$curve) {
+                $curve[0] = new MacroTemplate($curve[0]->resolve([
+                    'host_name_template'    => static::getHostNameTemplate(),
+                    'service_name_template' => static::getServiceNameTemplate(),
+                    ''                      => '$$'
+                ]));
+            }
+            unset($curve);
+
+            $this->fullCurves = $curves;
+        }
+
+        return $this->fullCurves;
+    }
+
+    /**
+     * Set curves to show in a chart by name with Graphite Web metric filters and Graphite functions
+     *
+     * @param MacroTemplate[][] $curves
+     *
+     * @return $this
+     */
+    public function setCurves(array $curves)
+    {
+        $this->curves = $curves;
+
+        return $this;
+    }
+
+    /**
+     * Get additional URL parameters for Graphite Web
+     *
+     * @return MacroTemplate[]
+     */
+    public function getUrlParams()
+    {
+        return $this->urlParams;
+    }
+
+    /**
+     * Set additional URL parameters for Graphite Web
+     *
+     * @param MacroTemplate[]  $urlParams
+     *
+     * @return $this
+     */
+    public function setUrlParams(array $urlParams)
+    {
+        $this->urlParams = $urlParams;
+
+        return $this;
+    }
+
+    /**
+     * Get {@link hostNameTemplate}
+     *
+     * @return MacroTemplate
+     *
+     * @throws  ConfigurationError  If the configuration is invalid
+     */
+    protected static function getHostNameTemplate()
+    {
+        if (static::$hostNameTemplate === null) {
+            $config = Config::module('graphite');
+            $template = $config->get(
+                'icinga',
+                'graphite_writer_host_name_template',
+                'icinga2.$host.name$.host.$host.check_command$'
+            );
+
+            try {
+                static::$hostNameTemplate = new MacroTemplate($template);
+            } catch (InvalidArgumentException $e) {
+                throw new ConfigurationError(
+                    'Bad icinga.graphite_writer_host_name_template in "%s": %s',
+                    $config->getConfigFile(),
+                    $e->getMessage()
+                );
+            }
+        }
+
+        return static::$hostNameTemplate;
+    }
+
+    /**
+     * Get {@link serviceNameTemplate}
+     *
+     * @return MacroTemplate
+     *
+     * @throws  ConfigurationError  If the configuration is invalid
+     */
+    protected static function getServiceNameTemplate()
+    {
+        if (static::$serviceNameTemplate === null) {
+            $config = Config::module('graphite');
+            $template = $config->get(
+                'icinga',
+                'graphite_writer_service_name_template',
+                'icinga2.$host.name$.services.$service.name$.$service.check_command$'
+            );
+
+            try {
+                static::$serviceNameTemplate = new MacroTemplate($template);
+            } catch (InvalidArgumentException $e) {
+                throw new ConfigurationError(
+                    'Bad icinga.graphite_writer_service_name_template in "%s": %s',
+                    $config->getConfigFile(),
+                    $e->getMessage()
+                );
+            }
+        }
+
+        return static::$serviceNameTemplate;
+    }
+}
diff --git a/library/Graphite/Graphing/Templates.php b/library/Graphite/Graphing/Templates.php
new file mode 100644
index 0000000..0765e46
--- /dev/null
+++ b/library/Graphite/Graphing/Templates.php
@@ -0,0 +1,321 @@
+<?php
+
+namespace Icinga\Module\Graphite\Graphing;
+
+use Icinga\Application\Config;
+use Icinga\Data\ConfigObject;
+use Icinga\Exception\ConfigurationError;
+use Icinga\Module\Graphite\Util\MacroTemplate;
+use Icinga\Web\UrlParams;
+use InvalidArgumentException;
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
+use SplFileInfo;
+
+/**
+ * Templates collection
+ */
+class Templates
+{
+    /**
+     * All templates by their check command and name
+     *
+     * @var Template[][]
+     */
+    protected $templates = [];
+
+    /**
+     * All default templates by their name
+     *
+     * @var Template[]
+     */
+    protected $defaultTemplates = [];
+
+    /**
+     * Default URL params for all templates
+     *
+     * @var string[]
+     */
+    protected $defaultUrlParams = [];
+
+    /**
+     * Constructor
+     */
+    public function __construct()
+    {
+        $config = Config::module('graphite');
+
+        foreach ($config->getSection('default_url_params') as $param => $value) {
+            try {
+                $this->defaultUrlParams[$param] = new MacroTemplate($value);
+            } catch (InvalidArgumentException $e) {
+                throw new ConfigurationError(
+                    'Invalid URL parameter "%s" ("%s") in file "%s"',
+                    $param,
+                    $value,
+                    $config->getConfigFile(),
+                    $e
+                );
+            }
+        }
+    }
+
+    /**
+     * Load templates as configured inside the given directory
+     *
+     * @param   string  $path
+     *
+     * @return  $this
+     *
+     * @throws  ConfigurationError  If the configuration is invalid
+     */
+    public function loadDir($path)
+    {
+        foreach (
+            new RecursiveIteratorIterator(
+                new RecursiveDirectoryIterator(
+                    $path,
+                    RecursiveDirectoryIterator::KEY_AS_PATHNAME | RecursiveDirectoryIterator::CURRENT_AS_FILEINFO
+                    | RecursiveDirectoryIterator::SKIP_DOTS | RecursiveDirectoryIterator::FOLLOW_SYMLINKS
+                ),
+                RecursiveIteratorIterator::LEAVES_ONLY
+            ) as $filepath => $fileinfo
+        ) {
+            /** @var SplFileInfo $fileinfo */
+
+            if ($fileinfo->isFile() && preg_match('/\A[^.].*\.ini\z/si', $fileinfo->getFilename())) {
+                $this->loadIni($filepath);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Load templates as configured in the given INI file
+     *
+     * @param   string  $path
+     *
+     * @return  $this
+     *
+     * @throws  ConfigurationError  If the configuration is invalid
+     */
+    public function loadIni($path)
+    {
+        /** @var string[][][] $templates */
+        $templates = [];
+
+        foreach (Config::fromIni($path) as $section => $options) {
+            /** @var ConfigObject $options */
+
+            $matches = [];
+            if (! preg_match('/\A(.+)\.(graph|metrics_filters|urlparams|functions)\z/', $section, $matches)) {
+                throw new ConfigurationError('Bad section name "%s" in file "%s"', $section, $path);
+            }
+
+            $templates[$matches[1]][$matches[2]] = $options->toArray();
+        }
+
+        $checkCommands = [];
+
+        foreach ($templates as $templateName => $template) {
+            $checkCommands[$templateName] = isset($template['graph']['check_command'])
+                ? array_unique(preg_split('/\s*,\s*/', $template['graph']['check_command'], -1, PREG_SPLIT_NO_EMPTY))
+                : [];
+            unset($template['graph']['check_command']);
+
+            if (isset($template['graph'])) {
+                switch (count($template['graph'])) {
+                    case 0:
+                        break;
+
+                    case 1:
+                        throw new ConfigurationError(
+                            'Bad option for template "%s" in file "%s": "graph.%s"',
+                            $templateName,
+                            $path,
+                            array_keys($template['graph'])[0]
+                        );
+
+                    default:
+                        $standalone = array_keys($template['graph']);
+                        sort($standalone);
+
+                        throw new ConfigurationError(
+                            'Bad options for template "%s" in file "%s": %s',
+                            $templateName,
+                            $path,
+                            implode(', ', array_map(
+                                function ($option) {
+                                    return "\"graph.$option\"";
+                                },
+                                $standalone
+                            ))
+                        );
+                }
+            }
+
+            /** @var MacroTemplate[][] $curves */
+            $curves = [];
+
+            if (isset($template['metrics_filters'])) {
+                foreach ($template['metrics_filters'] as $curve => $metricsFilter) {
+                    try {
+                        $curves[$curve][0] = new MacroTemplate($metricsFilter);
+                    } catch (InvalidArgumentException $e) {
+                        throw new ConfigurationError(
+                            'Bad metrics filter "%s" for curve "%s" of template "%s" in file "%s": %s',
+                            $metricsFilter,
+                            $curve,
+                            $templateName,
+                            $path,
+                            $e->getMessage()
+                        );
+                    }
+
+                    if (
+                        count(array_intersect(
+                            $curves[$curve][0]->getMacros(),
+                            ['host_name_template', 'service_name_template']
+                        )) !== 1
+                    ) {
+                        throw new ConfigurationError(
+                            'Bad metrics filter "%s" for curve "%s" of template "%s" in file "%s": must include'
+                            . ' either the macro $host_name_template$ or $service_name_template$, but not both',
+                            $metricsFilter,
+                            $curve,
+                            $templateName,
+                            $path
+                        );
+                    }
+
+                    if (isset($template['functions'][$curve])) {
+                        try {
+                            $curves[$curve][1] = new MacroTemplate($template['functions'][$curve]);
+                        } catch (InvalidArgumentException $e) {
+                            throw new ConfigurationError(
+                                'Bad function "%s" for curve "%s" of template "%s" in file "%s": %s',
+                                $template['functions'][$curve],
+                                $curve,
+                                $templateName,
+                                $path,
+                                $e->getMessage()
+                            );
+                        }
+
+                        unset($template['functions'][$curve]);
+                    } else {
+                        $curves[$curve][1] = new MacroTemplate('$metric$');
+                    }
+                }
+            }
+
+            if (isset($template['functions'])) {
+                switch (count($template['functions'])) {
+                    case 0:
+                        break;
+
+                    case 1:
+                        throw new ConfigurationError(
+                            'Metrics filter for curve "%s" of template "%s" in file "%s" missing',
+                            array_keys($template['functions'])[0],
+                            $templateName,
+                            $path
+                        );
+
+                    default:
+                        $standalone = array_keys($template['functions']);
+                        sort($standalone);
+
+                        throw new ConfigurationError(
+                            'Metrics filter for curves of template "%s" in file "%s" missing: "%s"',
+                            $templateName,
+                            $path,
+                            implode('", "', $standalone)
+                        );
+                }
+            }
+
+            $urlParams = $this->defaultUrlParams;
+
+            if (isset($template['urlparams'])) {
+                foreach ($template['urlparams'] as $key => $value) {
+                    try {
+                        $urlParams[$key] = new MacroTemplate($value);
+                    } catch (InvalidArgumentException $e) {
+                        throw new ConfigurationError(
+                            'Invalid URL parameter "%s" ("%s") for template "%s" in file "%s": %s',
+                            $key,
+                            $value,
+                            $templateName,
+                            $path,
+                            $e->getMessage()
+                        );
+                    }
+                }
+            }
+
+            $templates[$templateName] = empty($curves) ? null : (new Template())
+                ->setCurves($curves)
+                ->setUrlParams($urlParams);
+        }
+
+        foreach ($templates as $templateName => $template) {
+            if ($template === null) {
+                if (empty($checkCommands[$templateName])) {
+                    unset($this->defaultTemplates[$templateName]);
+                } else {
+                    foreach ($checkCommands[$templateName] as $checkCommand) {
+                        unset($this->templates[$checkCommand][$templateName]);
+
+                        if (empty($this->templates[$checkCommand])) {
+                            unset($this->templates[$checkCommand]);
+                        }
+                    }
+                }
+            } else {
+                if (empty($checkCommands[$templateName])) {
+                    $this->defaultTemplates[$templateName] = $template;
+                } else {
+                    foreach ($checkCommands[$templateName] as $checkCommand) {
+                        $this->templates[$checkCommand][$templateName] = $template;
+                    }
+                }
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Get all loaded templates for the given check command by their names
+     *
+     * @param   string  $checkCommand
+     *
+     * @return  Template[]
+     */
+    public function getTemplates($checkCommand)
+    {
+        return isset($this->templates[$checkCommand]) ? $this->templates[$checkCommand] : [];
+    }
+
+    /**
+     * Get all loaded templates for all check commands
+     *
+     * @return  Template[][]
+     */
+    public function getAllTemplates()
+    {
+        return $this->templates;
+    }
+
+    /**
+     * Get all loaded default templates by their names
+     *
+     * @return  Template[]
+     */
+    public function getDefaultTemplates()
+    {
+        return $this->defaultTemplates;
+    }
+}
diff --git a/library/Graphite/ProvidedHook/Icingadb/HostDetailExtension.php b/library/Graphite/ProvidedHook/Icingadb/HostDetailExtension.php
new file mode 100644
index 0000000..31e4e6c
--- /dev/null
+++ b/library/Graphite/ProvidedHook/Icingadb/HostDetailExtension.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace Icinga\Module\Graphite\ProvidedHook\Icingadb;
+
+use Icinga\Application\Icinga;
+use Icinga\Module\Graphite\Util\InternalProcessTracker as IPT;
+use Icinga\Module\Graphite\Web\Controller\TimeRangePickerTrait;
+use Icinga\Module\Graphite\Web\Widget\Graphs;
+use Icinga\Module\Icingadb\Hook\HostDetailExtensionHook;
+use Icinga\Module\Icingadb\Model\Host;
+use ipl\Html\Html;
+use ipl\Html\HtmlString;
+use ipl\Html\ValidHtml;
+
+class HostDetailExtension extends HostDetailExtensionHook
+{
+    use TimeRangePickerTrait;
+
+    public function getHtmlForObject(Host $host): ValidHtml
+    {
+        if (Icinga::app()->getRequest()->getUrl()->getParam('graph_debug')) {
+            IPT::enable();
+        }
+
+        $graphs = (string) Graphs::forIcingadbObject($host)
+            ->setWidth(440)
+            ->setHeight(220)
+            ->setClasses(['object-detail-view'])
+            ->setPreloadDummy()
+            ->setShowNoGraphsFound(false)
+            ->handleRequest();
+
+        if (! empty($graphs)) {
+            $this->handleTimeRangePickerRequest();
+
+            $header = Html::tag('h2', [], 'Graphs');
+            $timepicker = HtmlString::create($this->renderTimeRangePicker(Icinga::app()->getViewRenderer()->view));
+            $graphColorRegistry = Html::tag('div', ['class' => 'graphite-graph-color-registry']);
+            $graphs = HtmlString::create($graphs);
+
+            return HtmlString::create($header . $timepicker . $graphColorRegistry . $graphs);
+        }
+
+        return HtmlString::create('');
+    }
+}
diff --git a/library/Graphite/ProvidedHook/Icingadb/IcingadbSupport.php b/library/Graphite/ProvidedHook/Icingadb/IcingadbSupport.php
new file mode 100644
index 0000000..8f0f38e
--- /dev/null
+++ b/library/Graphite/ProvidedHook/Icingadb/IcingadbSupport.php
@@ -0,0 +1,9 @@
+<?php
+
+namespace Icinga\Module\Graphite\ProvidedHook\Icingadb;
+
+use Icinga\Module\Icingadb\Hook\IcingadbSupportHook;
+
+class IcingadbSupport extends IcingadbSupportHook
+{
+}
diff --git a/library/Graphite/ProvidedHook/Icingadb/ServiceDetailExtension.php b/library/Graphite/ProvidedHook/Icingadb/ServiceDetailExtension.php
new file mode 100644
index 0000000..63c2b79
--- /dev/null
+++ b/library/Graphite/ProvidedHook/Icingadb/ServiceDetailExtension.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace Icinga\Module\Graphite\ProvidedHook\Icingadb;
+
+use Icinga\Application\Icinga;
+use Icinga\Module\Graphite\Util\InternalProcessTracker as IPT;
+use Icinga\Module\Graphite\Web\Controller\TimeRangePickerTrait;
+use Icinga\Module\Graphite\Web\Widget\Graphs;
+use Icinga\Module\Icingadb\Hook\ServiceDetailExtensionHook;
+use Icinga\Module\Icingadb\Model\Service;
+use ipl\Html\Html;
+use ipl\Html\HtmlString;
+use ipl\Html\ValidHtml;
+
+class ServiceDetailExtension extends ServiceDetailExtensionHook
+{
+    use TimeRangePickerTrait;
+
+    public function getHtmlForObject(Service $service): ValidHtml
+    {
+        if (Icinga::app()->getRequest()->getUrl()->getParam('graph_debug')) {
+            IPT::enable();
+        }
+
+        $graphs = (string) Graphs::forIcingadbObject($service)
+            ->setWidth(440)
+            ->setHeight(220)
+            ->setClasses(['object-detail-view'])
+            ->setPreloadDummy()
+            ->setShowNoGraphsFound(false)
+            ->handleRequest();
+
+        if (! empty($graphs)) {
+            $this->handleTimeRangePickerRequest();
+
+            $header = Html::tag('h2', [], 'Graphs');
+            $timepicker = HtmlString::create($this->renderTimeRangePicker(Icinga::app()->getViewRenderer()->view));
+            $graphColorRegistry = Html::tag('div', ['class' => 'graphite-graph-color-registry']);
+            $graphs = HtmlString::create($graphs);
+
+            return HtmlString::create($header . $timepicker . $graphColorRegistry . $graphs);
+        }
+
+        return HtmlString::create('');
+    }
+}
diff --git a/library/Graphite/ProvidedHook/Monitoring/DetailviewExtension.php b/library/Graphite/ProvidedHook/Monitoring/DetailviewExtension.php
new file mode 100644
index 0000000..d6a4673
--- /dev/null
+++ b/library/Graphite/ProvidedHook/Monitoring/DetailviewExtension.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Icinga\Module\Graphite\ProvidedHook\Monitoring;
+
+use Icinga\Application\Icinga;
+use Icinga\Module\Graphite\Util\InternalProcessTracker as IPT;
+use Icinga\Module\Graphite\Web\Controller\TimeRangePickerTrait;
+use Icinga\Module\Graphite\Web\Widget\Graphs;
+use Icinga\Module\Monitoring\Hook\DetailviewExtensionHook;
+use Icinga\Module\Monitoring\Object\MonitoredObject;
+
+class DetailviewExtension extends DetailviewExtensionHook
+{
+    use TimeRangePickerTrait;
+
+    public function getHtmlForObject(MonitoredObject $object)
+    {
+        if (Icinga::app()->getRequest()->getUrl()->getParam('graph_debug')) {
+            IPT::enable();
+        }
+
+        $graphs = (string) Graphs::forMonitoredObject($object)
+            ->setWidth(440)
+            ->setHeight(220)
+            ->setClasses(['object-detail-view'])
+            ->setPreloadDummy()
+            ->setShowNoGraphsFound(false)
+            ->handleRequest();
+
+        if ($graphs !== '') {
+            $this->handleTimeRangePickerRequest();
+            return '<h2>' . mt('graphite', 'Graphs') . '</h2>'
+                . $this->renderTimeRangePicker($this->getView())
+                . '<div class="graphite-graph-color-registry"></div>'
+                . $graphs;
+        }
+
+        return '';
+    }
+}
diff --git a/library/Graphite/Util/IcingadbUtils.php b/library/Graphite/Util/IcingadbUtils.php
new file mode 100644
index 0000000..43334e5
--- /dev/null
+++ b/library/Graphite/Util/IcingadbUtils.php
@@ -0,0 +1,49 @@
+<?php
+
+/* Icinga Graphite Web | (c) 2022 Icinga GmbH | GPLv2 */
+
+namespace Icinga\Module\Graphite\Util;
+
+use Icinga\Module\Icingadb\Common\Auth;
+use Icinga\Module\Icingadb\Common\Database;
+use Icinga\Module\Icingadb\Common\Macros;
+
+/**
+* Class for initialising icingadb utils
+ */
+class IcingadbUtils
+{
+    use Macros;
+    use Database;
+    use Auth;
+
+    protected static $instance;
+
+    /**
+     * @see getInstance()
+     */
+    private function __construct()
+    {
+    }
+
+    /**
+     * Get the IcingadbUtils instance
+     *
+     * @return IcingadbUtils
+     */
+    public static function getInstance(): IcingadbUtils
+    {
+        if (self::$instance === null) {
+            self::$instance = new self();
+        }
+
+        return static::$instance;
+    }
+
+    /**
+     * Prevent the instance from being cloned (which would create a second instance of it)
+     */
+    private function __clone()
+    {
+    }
+}
diff --git a/library/Graphite/Util/InternalProcessTracker.php b/library/Graphite/Util/InternalProcessTracker.php
new file mode 100644
index 0000000..f7f2df6
--- /dev/null
+++ b/library/Graphite/Util/InternalProcessTracker.php
@@ -0,0 +1,126 @@
+<?php
+
+namespace Icinga\Module\Graphite\Util;
+
+use Icinga\Authentication\Auth;
+use Icinga\Security\SecurityException;
+
+/**
+ * A record about what happened during a specific action
+ */
+class InternalProcessTracker
+{
+    /**
+     * Whether to record anything
+     *
+     * @var bool
+     */
+    private static $enabled = false;
+
+    /**
+     * How many '+'es to prepend to each new record
+     *
+     * @var int
+     */
+    private static $indentation = 1;
+
+    /**
+     * The recorded happenings
+     *
+     * @var string[]
+     */
+    private static $records = [];
+
+    /**
+     * Get whether recording is enabled
+     *
+     * @return bool
+     */
+    public static function enabled()
+    {
+        return self::$enabled;
+    }
+
+    /**
+     * Enable recording
+     *
+     * @throws SecurityException
+     */
+    public static function enable()
+    {
+        if (! Auth::getInstance()->hasPermission('graphite/debug')) {
+            throw new SecurityException('No permission for graphite/debug');
+        }
+
+        self::$enabled = true;
+    }
+
+    /**
+     * Introduce a "sub-process"
+     */
+    public static function indent()
+    {
+        if (self::$enabled) {
+            ++self::$indentation;
+        }
+    }
+
+    /**
+     * Record a happening
+     *
+     * Behaves like {@link sprintf()} if additional arguments given, but {@link var_export()}s the arguments first
+     * (so always use %s instead of e.g. %d).
+     *
+     * @param   string  $format
+     */
+    public static function recordf($format)
+    {
+        if (self::$enabled) {
+            if (func_num_args() > 1) {
+                $args = [];
+                foreach (array_slice(func_get_args(), 1) as $arg) {
+                    $args[] = var_export($arg, true);
+                }
+
+                $format = vsprintf($format, $args);
+            }
+
+            self::$records[] = str_repeat('+', self::$indentation) . " $format";
+        }
+    }
+
+    /**
+     * Terminate a "sub-process"
+     */
+    public static function unindent()
+    {
+        if (self::$enabled) {
+            --self::$indentation;
+        }
+    }
+
+    /**
+     * Dump everything recorded as plain text
+     *
+     * @return string
+     */
+    public static function dump()
+    {
+        return implode("\n", self::$records);
+    }
+
+    /**
+     * Reset records
+     */
+    public static function clear()
+    {
+        if (self::$enabled) {
+            self::$indentation = 1;
+            self::$records = [];
+        }
+    }
+
+    final private function __construct()
+    {
+    }
+}
diff --git a/library/Graphite/Util/MacroTemplate.php b/library/Graphite/Util/MacroTemplate.php
new file mode 100644
index 0000000..23a171a
--- /dev/null
+++ b/library/Graphite/Util/MacroTemplate.php
@@ -0,0 +1,239 @@
+<?php
+
+namespace Icinga\Module\Graphite\Util;
+
+use InvalidArgumentException;
+
+/**
+ * A macro-based template for strings
+ */
+class MacroTemplate
+{
+    /**
+     * Macros' start and end character
+     *
+     * @var string
+     */
+    protected $macroCharacter;
+
+    /**
+     * The parsed template
+     *
+     * @var string[]
+     */
+    protected $template;
+
+    /**
+     * Regex for reverse resolving patterns
+     *
+     * @var string
+     */
+    protected $reverseResolvePattern;
+
+    /**
+     * Wildcards
+     *
+     * @var string[]
+     */
+    protected $wildCards;
+
+    /**
+     * The original raw template
+     *
+     * @var string
+     */
+    protected $orgTemplate;
+
+    /**
+     * Constructor
+     *
+     * @param   string  $template           The raw template
+     * @param   string  $macroCharacter     Macros' start and end character
+     */
+    public function __construct($template, $macroCharacter = '$')
+    {
+        $this->orgTemplate = $template;
+        $this->macroCharacter = $macroCharacter;
+        $this->template = explode($macroCharacter, $template);
+        foreach ($this->template as $key => $value) {
+            if (preg_match('/([^:]+):(.+)/', $value, $match)) {
+                $wildCardKey = $match[1];
+                $this->template[$key] = $wildCardKey;
+                $this->wildCards[$wildCardKey] = $match[2];
+            }
+        }
+
+        if (! (count($this->template) % 2)) {
+            throw new InvalidArgumentException(
+                'template contains odd number of ' . var_export($macroCharacter, true)
+                    . 's: ' . var_export($template, true)
+            );
+        }
+    }
+
+    /**
+     * Return a string based on this template with the macros resolved from the given variables
+     *
+     * @param   string[]  $variables
+     * @param   string          $default    The default value for missing variables.
+     *                                      By default the macro just isn't replaced.
+     *
+     * @return  string
+     */
+    public function resolve(array $variables, $default = null)
+    {
+        $macro = false;
+        $result = []; // kind of string builder
+
+        foreach ($this->template as $part) {
+            if ($macro) {
+                if (isset($variables[$part])) {
+                    $result[] = $variables[$part];
+                } elseif ($part === '') {
+                    $result[] = $this->macroCharacter;
+                } elseif ($default === null) {
+                    $result[] = $this->macroCharacter;
+                    $result[] = $part;
+                    // add wildcards to result before they are
+                    // overwritten from Template::getFullCurves()
+                    if (isset($this->wildCards[$part])) {
+                        $result[] = ':' . $this->wildCards[$part];
+                    }
+
+                    $result[] = $this->macroCharacter;
+                } else {
+                    if (isset($this->wildCards[$part])) {
+                        $result[] = $this->wildCards[$part];
+                    } else {
+                        $result[] = $default;
+                    }
+                }
+            } else {
+                $result[] = $part;
+            }
+
+            $macro = ! $macro;
+        }
+
+        return implode($result);
+    }
+
+    /**
+     * Try to reverse-resolve the given string
+     *
+     * @param   string  $resolved       A result of {@link resolve()}
+     *
+     * @return  string[]|false    Variables as passed to {@link resolve()} if successful
+     */
+    public function reverseResolve($resolved)
+    {
+        $matches = [];
+        if (! preg_match($this->getReverseResolvePattern(), $resolved, $matches)) {
+            return false;
+        }
+
+        $macro = false;
+        $macros = [];
+        $currentCapturedSubPatternIndex = 0;
+
+        foreach ($this->template as $part) {
+            if ($macro && ! isset($macros[$part])) {
+                $macros[$part] = ++$currentCapturedSubPatternIndex;
+            }
+
+            $macro = ! $macro;
+        }
+
+        $macros = array_flip($macros);
+
+        $result = [];
+        foreach ($matches as $index => $match) {
+            if ($index > 0) {
+                $result[$macros[$index]] = $match;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Return the raw template string this instance was constructed from
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->orgTemplate;
+    }
+
+    /**
+     * Return the macros of this template
+     *
+     * @return string[]
+     */
+    public function getMacros()
+    {
+        $macro = false;
+        $macros = [];
+
+        foreach ($this->template as $part) {
+            if ($macro) {
+                $macros[$part] = null;
+            }
+
+            $macro = ! $macro;
+        }
+
+        unset($macros['']);
+
+        return array_keys($macros);
+    }
+
+    /**
+     * Get macros' start and end character
+     *
+     * @return string
+     */
+    public function getMacroCharacter()
+    {
+        return $this->macroCharacter;
+    }
+
+    /**
+     * Get {@link reverseResolvePattern}
+     *
+     * @return string
+     */
+    protected function getReverseResolvePattern()
+    {
+        if ($this->reverseResolvePattern === null) {
+            $result = ['/\A']; // kind of string builder
+            $macro = false;
+            $macros = [];
+            $currentCapturedSubPatternIndex = 0;
+
+            foreach ($this->template as $part) {
+                if ($macro) {
+                    if (isset($macros[$part])) {
+                        $result[] = '\g{';
+                        $result[] = $macros[$part];
+                        $result[] = '}';
+                    } else {
+                        $macros[$part] = ++$currentCapturedSubPatternIndex;
+                        $result[] = '(.*)';
+                    }
+                } else {
+                    $result[] = preg_quote($part, '/');
+                }
+
+                $macro = ! $macro;
+            }
+
+            $result[] = '\z/s';
+
+            $this->reverseResolvePattern = implode($result);
+        }
+
+        return $this->reverseResolvePattern;
+    }
+}
diff --git a/library/Graphite/Util/TimeRangePickerTools.php b/library/Graphite/Util/TimeRangePickerTools.php
new file mode 100644
index 0000000..d1ebc75
--- /dev/null
+++ b/library/Graphite/Util/TimeRangePickerTools.php
@@ -0,0 +1,111 @@
+<?php
+
+namespace Icinga\Module\Graphite\Util;
+
+use Icinga\Application\Config;
+use Icinga\Exception\ConfigurationError;
+use Icinga\Web\Url;
+use Icinga\Web\UrlParams;
+
+final class TimeRangePickerTools
+{
+    /**
+     * @return string
+     */
+    public static function getRelativeRangeParameter()
+    {
+        return 'graph_range';
+    }
+
+    /**
+     * @return string[]
+     */
+    public static function getAbsoluteRangeParameters()
+    {
+        return ['start' => 'graph_start', 'end' => 'graph_end'];
+    }
+
+    /**
+     * @return string[]
+     */
+    public static function getAllRangeParameters()
+    {
+        return array_values(array_merge([static::getRelativeRangeParameter()], static::getAbsoluteRangeParameters()));
+    }
+
+    /**
+     * Copy {@link getAllRangeParameters()} from one {@link UrlParams} instance to another
+     *
+     * @param   UrlParams|null  $copy   Defaults to a new instance
+     * @param   UrlParams|null  $origin Defaults to the current request's params
+     *
+     * @return  UrlParams               The copy
+     */
+    public static function copyAllRangeParameters(UrlParams $copy = null, UrlParams $origin = null)
+    {
+        if ($origin === null) {
+            $origin = Url::fromRequest()->getParams();
+        }
+        if ($copy === null) {
+            $copy = new UrlParams();
+        }
+
+        foreach (self::getAllRangeParameters() as $param) {
+            $value = $origin->get($param);
+            if ($value !== null) {
+                $copy->set($param, $value);
+            }
+        }
+
+        return $copy;
+    }
+
+    /**
+     * Extract the relative time range (if any) from the given URL parameters
+     *
+     * @param   UrlParams   $params
+     *
+     * @return  bool|int|null
+     */
+    public static function getRelativeSeconds(UrlParams $params)
+    {
+        $seconds = $params->get(self::getRelativeRangeParameter());
+        if ($seconds === null) {
+            return null;
+        }
+
+        return preg_match('/^(?:0|[1-9]\d*)$/', $seconds) ? (int) $seconds : false;
+    }
+
+    /**
+     * Get the default relative time range for graphs
+     *
+     * @return int
+     *
+     * @throws ConfigurationError
+     */
+    public static function getDefaultRelativeTimeRange()
+    {
+        $rangeFactors = [
+            'minutes'   => 60,
+            'hours'     => 3600,
+            'days'      => 86400,
+            'weeks'     => 604800,
+            'months'    => 2592000,
+            'years'     => 31557600
+        ];
+
+        $config = Config::module('graphite');
+        $unit = $config->get('ui', 'default_time_range_unit', 'hours');
+
+        if (! isset($rangeFactors[$unit])) {
+            throw new ConfigurationError(
+                'Bad ui.default_time_range_unit %s in file %s',
+                var_export($unit, true),
+                var_export($config->getConfigFile(), true)
+            );
+        }
+
+        return (int) $config->get('ui', 'default_time_range', 1) * $rangeFactors[$unit];
+    }
+}
diff --git a/library/Graphite/Web/Controller/IcingadbGraphiteController.php b/library/Graphite/Web/Controller/IcingadbGraphiteController.php
new file mode 100644
index 0000000..36bc026
--- /dev/null
+++ b/library/Graphite/Web/Controller/IcingadbGraphiteController.php
@@ -0,0 +1,110 @@
+<?php
+
+/* Icinga Graphite Web | (c) 2022 Icinga GmbH | GPLv2 */
+
+namespace Icinga\Module\Graphite\Web\Controller;
+
+use Icinga\Application\Modules\Module;
+use Icinga\Module\Graphite\ProvidedHook\Icingadb\IcingadbSupport;
+use Icinga\Module\Icingadb\Common\Auth;
+use Icinga\Module\Icingadb\Common\Database;
+use Icinga\Module\Icingadb\Common\SearchControls;
+use ipl\Orm\Query;
+use ipl\Stdlib\Contract\Paginatable;
+use ipl\Web\Compat\CompatController;
+use ipl\Web\Control\LimitControl;
+use ipl\Web\Control\PaginationControl;
+use ipl\Web\Control\SortControl;
+use ipl\Web\Filter\QueryString;
+use ipl\Stdlib\Filter;
+use ipl\Web\Url;
+
+class IcingadbGraphiteController extends CompatController
+{
+    use Auth;
+    use Database;
+    use SearchControls;
+
+    /** @var bool Whether to use icingadb as the backend */
+    protected $useIcingadbAsBackend;
+
+    /** @var string[] Graph parameters */
+    protected $graphParams = ['graphs_limit', 'graph_range', 'graph_start', 'graph_end', 'legacyParams'];
+
+    /** @var Filter\Rule Filter from query string parameters */
+    private $filter;
+
+    protected function moduleInit()
+    {
+        $this->useIcingadbAsBackend = Module::exists('icingadb') && IcingadbSupport::useIcingaDbAsBackend();
+    }
+
+    /**
+     * Get the filter created from query string parameters
+     *
+     * @return Filter\Rule
+     */
+    public function getFilter(): Filter\Rule
+    {
+        if ($this->filter === null) {
+            $this->filter = QueryString::parse((string) $this->params);
+        }
+
+        return $this->filter;
+    }
+
+    /**
+     * Create and return the LimitControl
+     *
+     * This automatically shifts the limit URL parameter from {@link $params}.
+     *
+     * @return LimitControl
+     */
+    public function createLimitControl(): LimitControl
+    {
+        $limitControl = new LimitControl(Url::fromRequest());
+        $limitControl->setDefaultLimit($this->getPageSize(null));
+
+        $this->params->shift($limitControl->getLimitParam());
+
+        return $limitControl;
+    }
+
+    /**
+     * Create and return the PaginationControl
+     *
+     * This automatically shifts the pagination URL parameters from {@link $params}.
+     *
+     * @return PaginationControl
+     */
+    public function createPaginationControl(Paginatable $paginatable): PaginationControl
+    {
+        $paginationControl = new PaginationControl($paginatable, Url::fromRequest());
+        $paginationControl->setDefaultPageSize($this->getPageSize(null));
+        $paginationControl->setAttribute('id', $this->getRequest()->protectId('pagination-control'));
+
+        $this->params->shift($paginationControl->getPageParam());
+        $this->params->shift($paginationControl->getPageSizeParam());
+
+        return $paginationControl->apply();
+    }
+
+    /**
+     * Create and return the SortControl
+     *
+     * This automatically shifts the sort URL parameter from {@link $params}.
+     *
+     * @param Query $query
+     * @param array $columns Possible sort columns as sort string-label pairs
+     *
+     * @return SortControl
+     */
+    public function createSortControl(Query $query, array $columns): SortControl
+    {
+        $sortControl = SortControl::create($columns);
+
+        $this->params->shift($sortControl->getSortParam());
+
+        return $sortControl->apply($query);
+    }
+}
diff --git a/library/Graphite/Web/Controller/MonitoringAwareController.php b/library/Graphite/Web/Controller/MonitoringAwareController.php
new file mode 100644
index 0000000..dca2ebd
--- /dev/null
+++ b/library/Graphite/Web/Controller/MonitoringAwareController.php
@@ -0,0 +1,175 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web\Controller;
+
+use ArrayIterator;
+use Icinga\Application\Modules\Module;
+use Icinga\Data\Filter\Filter;
+use Icinga\Data\Filterable;
+use Icinga\Exception\ConfigurationError;
+use Icinga\Exception\QueryException;
+use Icinga\Module\Graphite\ProvidedHook\Icingadb\IcingadbSupport;
+use Icinga\Module\Monitoring\Backend\MonitoringBackend;
+use Icinga\Module\Monitoring\Data\CustomvarProtectionIterator;
+use Icinga\Module\Monitoring\DataView\DataView;
+use Icinga\Util\Json;
+use Icinga\File\Csv;
+use Icinga\Web\Controller;
+use Icinga\Web\Url;
+
+abstract class MonitoringAwareController extends Controller
+{
+    /** @var bool Whether to use icingadb as the backend */
+    protected $useIcingadbAsBackend = false;
+
+    /**
+     * Restrict the given monitored object query for the currently authenticated user
+     *
+     * @param   DataView    $dataView
+     *
+     * @return  DataView                The given data view
+     */
+    protected function applyMonitoringRestriction(DataView $dataView)
+    {
+        $this->applyRestriction('monitoring/filter/objects', $dataView);
+
+        return $dataView;
+    }
+
+    protected function moduleInit()
+    {
+        if (Module::exists('icingadb') && IcingadbSupport::useIcingaDbAsBackend()) {
+            $this->useIcingadbAsBackend = true;
+
+            return;
+        }
+
+        $this->backend = MonitoringBackend::instance($this->_getParam('backend'));
+        $this->view->url = Url::fromRequest();
+    }
+
+
+    protected function handleFormatRequest($query)
+    {
+        $desiredContentType = $this->getRequest()->getHeader('Accept');
+        if ($desiredContentType === 'application/json') {
+            $desiredFormat = 'json';
+        } elseif ($desiredContentType === 'text/csv') {
+            $desiredFormat = 'csv';
+        } else {
+            $desiredFormat = strtolower($this->params->get('format', 'html'));
+        }
+
+        if ($desiredFormat !== 'html' && ! $this->params->has('limit')) {
+            $query->limit();  // Resets any default limit and offset
+        }
+
+        switch ($desiredFormat) {
+            case 'sql':
+                echo '<pre>'
+                    . htmlspecialchars(wordwrap($query->dump()))
+                    . '</pre>';
+                exit;
+            case 'json':
+                $response = $this->getResponse();
+                $response
+                    ->setHeader('Content-Type', 'application/json')
+                    ->setHeader('Cache-Control', 'no-store')
+                    ->setHeader(
+                        'Content-Disposition',
+                        'inline; filename=' . $this->getRequest()->getActionName() . '.json'
+                    )
+                    ->appendBody(
+                        Json::sanitize(
+                            iterator_to_array(
+                                new CustomvarProtectionIterator(
+                                    new ArrayIterator($query->fetchAll())
+                                )
+                            )
+                        )
+                    )
+                    ->sendResponse();
+                exit;
+            case 'csv':
+                $response = $this->getResponse();
+                $response
+                    ->setHeader('Content-Type', 'text/csv')
+                    ->setHeader('Cache-Control', 'no-store')
+                    ->setHeader(
+                        'Content-Disposition',
+                        'attachment; filename=' . $this->getRequest()->getActionName() . '.csv'
+                    )
+                    ->appendBody((string) Csv::fromQuery(new CustomvarProtectionIterator($query)))
+                    ->sendResponse();
+                exit;
+        }
+    }
+
+    /**
+     * Apply a restriction of the authenticated on the given filterable
+     *
+     * @param   string      $name       Name of the restriction
+     * @param   Filterable  $filterable Filterable to restrict
+     *
+     * @return  Filterable  The filterable having the restriction applied
+     */
+    protected function applyRestriction($name, Filterable $filterable)
+    {
+        $filterable->applyFilter($this->getRestriction($name));
+        return $filterable;
+    }
+
+    /**
+     * Get a restriction of the authenticated
+     *
+     * @param   string $name        Name of the restriction
+     *
+     * @return  Filter              Filter object
+     * @throws  ConfigurationError  If the restriction contains invalid filter columns
+     */
+    protected function getRestriction($name)
+    {
+        $restriction = Filter::matchAny();
+        $restriction->setAllowedFilterColumns(array(
+            'host_name',
+            'hostgroup_name',
+            'instance_name',
+            'service_description',
+            'servicegroup_name',
+            function ($c) {
+                return preg_match('/^_(?:host|service)_/i', $c);
+            }
+        ));
+        foreach ($this->getRestrictions($name) as $filter) {
+            if ($filter === '*') {
+                return Filter::matchAll();
+            }
+            try {
+                $restriction->addFilter(Filter::fromQueryString($filter));
+            } catch (QueryException $e) {
+                throw new ConfigurationError(
+                    $this->translate(
+                        'Cannot apply restriction %s using the filter %s. You can only use the following columns: %s'
+                    ),
+                    $name,
+                    $filter,
+                    implode(', ', array(
+                        'instance_name',
+                        'host_name',
+                        'hostgroup_name',
+                        'service_description',
+                        'servicegroup_name',
+                        '_(host|service)_<customvar-name>'
+                    )),
+                    $e
+                );
+            }
+        }
+
+        if ($restriction->isEmpty()) {
+            return Filter::matchAll();
+        }
+
+        return $restriction;
+    }
+}
diff --git a/library/Graphite/Web/Controller/TimeRangePickerTrait.php b/library/Graphite/Web/Controller/TimeRangePickerTrait.php
new file mode 100644
index 0000000..7352b1b
--- /dev/null
+++ b/library/Graphite/Web/Controller/TimeRangePickerTrait.php
@@ -0,0 +1,115 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web\Controller;
+
+use Icinga\Module\Graphite\Forms\TimeRangePicker\CommonForm;
+use Icinga\Module\Graphite\Forms\TimeRangePicker\CustomForm;
+use Icinga\Web\Request;
+use Icinga\Web\Url;
+use Icinga\Web\View;
+
+trait TimeRangePickerTrait
+{
+    /**
+     * @var CommonForm
+     */
+    protected $timeRangePickerCommonForm;
+
+    /**
+     * @var CustomForm
+     */
+    protected $timeRangePickerCustomForm;
+
+    /**
+     * Process the given request using the forms
+     *
+     * @param   Request $request    The request to be processed
+     *
+     * @return  Request             The request supposed to be processed
+     */
+    protected function handleTimeRangePickerRequest(Request $request = null)
+    {
+        $this->getTimeRangePickerCommonForm()->handleRequest($request);
+        return $this->getTimeRangePickerCustomForm()->handleRequest($request);
+    }
+
+    /**
+     * Render all needed forms and links
+     *
+     * @param   View    $view
+     *
+     * @return  string
+     */
+    protected function renderTimeRangePicker(View $view)
+    {
+        $url = Url::fromRequest()->getAbsoluteUrl();
+
+        return '<div class="timerangepicker-container">'
+            . $this->getTimeRangePickerCommonForm()
+            . '<div class="flyover flyover-arrow-top" data-flyover-suspends-auto-refresh id="'
+            . $view->protectId('graphite-customrange')
+            . '">'
+            . $view->qlink(null, '#', null, [
+                'title' => $view->translate('Specify custom time range'),
+                'class' => 'button-link flyover-toggle',
+                'icon'  => 'service'
+            ])
+            . '<div class="flyover-content">' . $this->getTimeRangePickerCustomForm() . '</div>'
+            . '</div>'
+            . '</div>';
+    }
+
+    /**
+     * Get {@link timeRangePickerCommonForm}
+     *
+     * @return CommonForm
+     */
+    public function getTimeRangePickerCommonForm()
+    {
+        if ($this->timeRangePickerCommonForm === null) {
+            $this->timeRangePickerCommonForm = new CommonForm();
+        }
+
+        return $this->timeRangePickerCommonForm;
+    }
+
+    /**
+     * Set {@link timeRangePickerCommonForm}
+     *
+     * @param CommonForm $timeRangePickerCommonForm
+     *
+     * @return $this
+     */
+    public function setTimeRangePickerCommonForm(CommonForm $timeRangePickerCommonForm)
+    {
+        $this->timeRangePickerCommonForm = $timeRangePickerCommonForm;
+        return $this;
+    }
+
+    /**
+     * Get {@link timeRangePickerCustomForm}
+     *
+     * @return CustomForm
+     */
+    public function getTimeRangePickerCustomForm()
+    {
+        if ($this->timeRangePickerCustomForm === null) {
+            $this->timeRangePickerCustomForm = new CustomForm();
+        }
+
+        return $this->timeRangePickerCustomForm;
+    }
+
+    /**
+     * Set {@link timeRangePickerCustomForm}
+     *
+     * @param CustomForm $timeRangePickerCustomForm
+     *
+     * @return $this
+     */
+    public function setTimeRangePickerCustomForm(CustomForm $timeRangePickerCustomForm)
+    {
+        $this->timeRangePickerCustomForm = $timeRangePickerCustomForm;
+        return $this;
+    }
+}
diff --git a/library/Graphite/Web/FakeSchemeRequest.php b/library/Graphite/Web/FakeSchemeRequest.php
new file mode 100644
index 0000000..dc415cd
--- /dev/null
+++ b/library/Graphite/Web/FakeSchemeRequest.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web;
+
+use Icinga\Web\Request;
+
+/**
+ * Rationale:
+ *
+ * {@link Url::fromPath()} doesn't preserve URLs which seem to be internal as they are.
+ */
+class FakeSchemeRequest extends Request
+{
+    public function getScheme()
+    {
+        return 'a random url scheme which always differs from the current request\'s one';
+    }
+}
diff --git a/library/Graphite/Web/Form/Decorator/Proxy.php b/library/Graphite/Web/Form/Decorator/Proxy.php
new file mode 100644
index 0000000..63d339c
--- /dev/null
+++ b/library/Graphite/Web/Form/Decorator/Proxy.php
@@ -0,0 +1,47 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web\Form\Decorator;
+
+use Zend_Form_Decorator_Abstract;
+use Zend_Form_Decorator_Interface;
+
+/**
+ * Wrap a decorator and use it only for rendering
+ */
+class Proxy extends Zend_Form_Decorator_Abstract
+{
+    /**
+     * The actual decorator being proxied
+     *
+     * @var Zend_Form_Decorator_Interface
+     */
+    protected $actualDecorator;
+
+    public function render($content)
+    {
+        return $this->actualDecorator->render($content);
+    }
+
+    /**
+     * Get {@link actualDecorator}
+     *
+     * @return Zend_Form_Decorator_Interface
+     */
+    public function getActualDecorator()
+    {
+        return $this->actualDecorator;
+    }
+
+    /**
+     * Set {@link actualDecorator}
+     *
+     * @param Zend_Form_Decorator_Interface $actualDecorator
+     *
+     * @return $this
+     */
+    public function setActualDecorator($actualDecorator)
+    {
+        $this->actualDecorator = $actualDecorator;
+        return $this;
+    }
+}
diff --git a/library/Graphite/Web/Form/Validator/CustomErrorMessagesValidator.php b/library/Graphite/Web/Form/Validator/CustomErrorMessagesValidator.php
new file mode 100644
index 0000000..893a5b7
--- /dev/null
+++ b/library/Graphite/Web/Form/Validator/CustomErrorMessagesValidator.php
@@ -0,0 +1,42 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web\Form\Validator;
+
+use Zend_Validate_Abstract;
+
+/**
+ * Provides an easy way to implement validators with custom error messages
+ *
+ * TODO(ak): move to framework(?)
+ */
+abstract class CustomErrorMessagesValidator extends Zend_Validate_Abstract
+{
+    /**
+     * Constructor
+     */
+    public function __construct()
+    {
+        $this->_messageTemplates = ['CUSTOM_ERROR' => ''];
+    }
+
+    public function isValid($value)
+    {
+        $errorMessage = $this->validate($value);
+        if ($errorMessage === null) {
+            return true;
+        }
+
+        $this->setMessage($errorMessage, 'CUSTOM_ERROR');
+        $this->_error('CUSTOM_ERROR');
+        return false;
+    }
+
+    /**
+     * Validate the given value and return an error message if it's invalid
+     *
+     * @param   string  $value
+     *
+     * @return  string|null
+     */
+    abstract protected function validate($value);
+}
diff --git a/library/Graphite/Web/Form/Validator/HttpUserValidator.php b/library/Graphite/Web/Form/Validator/HttpUserValidator.php
new file mode 100644
index 0000000..d5f4a86
--- /dev/null
+++ b/library/Graphite/Web/Form/Validator/HttpUserValidator.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web\Form\Validator;
+
+use Zend_Validate_Abstract;
+
+/**
+ * Validates http basic authn user names
+ *
+ * TODO(ak): move to Icinga Web 2
+ */
+class HttpUserValidator extends Zend_Validate_Abstract
+{
+    /**
+     * Constructor
+     */
+    public function __construct()
+    {
+        $this->_messageTemplates = ['HAS_COLON' => mt('graphite', 'The username must not contain colons.')];
+    }
+
+    public function isValid($value)
+    {
+        $hasColon = false !== strpos($value, ':');
+        if ($hasColon) {
+            $this->_error('HAS_COLON');
+        }
+        return ! $hasColon;
+    }
+}
diff --git a/library/Graphite/Web/Form/Validator/MacroTemplateValidator.php b/library/Graphite/Web/Form/Validator/MacroTemplateValidator.php
new file mode 100644
index 0000000..8ff4e3c
--- /dev/null
+++ b/library/Graphite/Web/Form/Validator/MacroTemplateValidator.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web\Form\Validator;
+
+use Icinga\Module\Graphite\Util\MacroTemplate;
+use InvalidArgumentException;
+
+/**
+ * Validates Icinga-style macro templates
+ */
+class MacroTemplateValidator extends CustomErrorMessagesValidator
+{
+    protected function validate($value)
+    {
+        try {
+            new MacroTemplate($value);
+        } catch (InvalidArgumentException $e) {
+            return $e->getMessage();
+        }
+    }
+}
diff --git a/library/Graphite/Web/Widget/GraphImage.php b/library/Graphite/Web/Widget/GraphImage.php
new file mode 100644
index 0000000..af64e69
--- /dev/null
+++ b/library/Graphite/Web/Widget/GraphImage.php
@@ -0,0 +1,143 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web\Widget;
+
+use Icinga\Module\Graphite\Graphing\Chart;
+use Icinga\Web\Url;
+use Icinga\Web\UrlParams;
+use Icinga\Web\Widget\AbstractWidget;
+use RuntimeException;
+
+class GraphImage extends AbstractWidget
+{
+    /**
+     * The chart to be rendered
+     *
+     * @var Chart
+     */
+    protected $chart;
+
+    /**
+     * The rendered PNG image
+     *
+     * @var string|null
+     */
+    protected $rendered;
+
+    /**
+     * Constructor
+     *
+     * @param   Chart   $chart  The chart to be rendered
+     */
+    public function __construct(Chart $chart)
+    {
+        $this->chart = $chart;
+    }
+
+    /**
+     * Render the graph lazily
+     *
+     * @return string
+     */
+    public function render()
+    {
+        if ($this->rendered === null) {
+            $now = time();
+
+            $from = (int) $this->chart->getFrom();
+            if ($from < 0) {
+                $from += $now;
+            }
+
+            $until = (string) $this->chart->getUntil();
+
+            if ($until === '') {
+                $until = $now;
+            } else {
+                $until = (int) $until;
+                if ($until < 0) {
+                    $until += $now;
+                }
+            }
+
+            $variables = $this->chart->getMetricVariables();
+            $template = $this->chart->getTemplate();
+            $graphiteWebClient = $this->chart->getGraphiteWebClient();
+            $params = (new UrlParams())->addValues([
+                'from'                  => $from,
+                'until'                 => $until,
+                'bgcolor'               => $this->chart->getBackgroundColor() ?? 'black',
+                'fgcolor'               => $this->chart->getForegroundColor() ?? 'white',
+                'majorGridLineColor'    => $this->chart->getMajorGridLineColor() ?? '0000003F',
+                'minorGridLineColor'    => $this->chart->getMinorGridLineColor() ?? 'black',
+                'width'                 => $this->chart->getWidth(),
+                'height'                => $this->chart->getHeight(),
+                'hideLegend'            => (string) ! $this->chart->getShowLegend(),
+                'tz'                    => date_default_timezone_get(),
+                '_salt'                 => "$now.000",
+                'vTitle'                => 'Percent',
+                'lineMode'              => 'connected',
+                'drawNullAsZero'        => 'false',
+                'graphType'             => 'line',
+                '_ext'                  => 'whatever.svg'
+            ]);
+
+            foreach ($template->getUrlParams() as $key => $value) {
+                $params->set($key, $value->resolve($variables));
+            }
+
+            $metrics = $this->chart->getMetrics();
+            $allVars = [];
+
+            foreach ($template->getCurves() as $curveName => $curve) {
+                if (!isset($metrics[$curveName])) {
+                    continue;
+                }
+
+                $vars = $curve[0]->reverseResolve($metrics[$curveName]);
+
+                if ($vars !== false) {
+                    $allVars = array_merge($allVars, $vars);
+                }
+            }
+
+            foreach ($metrics as $curveName => $metric) {
+                $allVars['metric'] = $metric;
+                $params->add('target', $template->getCurves()[$curveName][1]->resolve($allVars));
+            }
+
+            $url = Url::fromPath('/render')->setParams($params);
+            $headers = [
+                'Accept-language'   => 'en',
+                'Content-type'      => 'application/x-www-form-urlencoded'
+            ];
+
+            for (;;) {
+                try {
+                    $this->rendered = $graphiteWebClient->request($url, 'GET', $headers);
+                } catch (RuntimeException $e) {
+                    if (preg_match('/\b500\b/', $e->getMessage())) {
+                        // A 500 Internal Server Error, probably because of
+                        // a division by zero because of a too low time range to render.
+
+                        $until = (int) $url->getParam('until');
+                        $diff = $until - (int) $url->getParam('from');
+
+                        // Try to render a higher time range, but give up
+                        // once our default (1h) has been reached (non successfully).
+                        if ($diff < 3600) {
+                            $url->setParam('from', $until - $diff * 2);
+                            continue;
+                        }
+                    }
+
+                    throw $e;
+                }
+
+                break;
+            }
+        }
+
+        return $this->rendered;
+    }
+}
diff --git a/library/Graphite/Web/Widget/Graphs.php b/library/Graphite/Web/Widget/Graphs.php
new file mode 100644
index 0000000..e18b8da
--- /dev/null
+++ b/library/Graphite/Web/Widget/Graphs.php
@@ -0,0 +1,688 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web\Widget;
+
+use Icinga\Application\Config;
+use Icinga\Application\Icinga;
+use Icinga\Authentication\Auth;
+use Icinga\Exception\ConfigurationError;
+use Icinga\Module\Graphite\Graphing\Chart;
+use Icinga\Module\Graphite\Graphing\GraphingTrait;
+use Icinga\Module\Graphite\Graphing\Template;
+use Icinga\Module\Graphite\Util\InternalProcessTracker as IPT;
+use Icinga\Module\Graphite\Util\TimeRangePickerTools;
+use Icinga\Module\Graphite\Web\Widget\Graphs\Host as HostGraphs;
+use Icinga\Module\Graphite\Web\Widget\Graphs\Service as ServiceGraphs;
+use Icinga\Module\Monitoring\Object\Host;
+use Icinga\Module\Monitoring\Object\MonitoredObject;
+use Icinga\Module\Monitoring\Object\Service;
+use Icinga\Web\Request;
+use Icinga\Web\Url;
+use Icinga\Web\View;
+use Icinga\Web\Widget\AbstractWidget;
+use ipl\Orm\Model;
+use Icinga\Module\Icingadb\Model\Host as IcingadbHost;
+use Icinga\Module\Graphite\Web\Widget\Graphs\Icingadb\IcingadbHost as IcingadbHostGraphs;
+use Icinga\Module\Graphite\Web\Widget\Graphs\Icingadb\IcingadbService as IcingadbServiceGraphs;
+
+abstract class Graphs extends AbstractWidget
+{
+    use GraphingTrait;
+
+    /**
+     * The Icinga custom variable with the "real" check command (if any) of objects we display graphs for
+     *
+     * @var string
+     */
+    protected static $obscuredCheckCommandCustomVar;
+
+    /**
+     * The type of the object to render the graphs for
+     *
+     * @var string
+     */
+    protected $objectType;
+
+    /**
+     * The object to render the graphs for
+     *
+     * @var MonitoredObject|Model
+     */
+    protected $object;
+
+    /**
+     * Graph image width
+     *
+     * @var string
+     */
+    protected $width = '350';
+
+    /**
+     * Graph image height
+     *
+     * @var string
+     */
+    protected $height = '200';
+
+    /**
+     * Graph range start
+     *
+     * @var string
+     */
+    protected $start;
+
+    /**
+     * Graph range end
+     *
+     * @var string
+     */
+    protected $end;
+
+    /**
+     * Whether to render as compact as possible
+     *
+     * @var bool
+     */
+    protected $compact = false;
+
+    /**
+     * The check command of the monitored object we display graphs for
+     *
+     * @var string
+     */
+    protected $checkCommand;
+
+    /**
+     * The "real" check command (if any) of the monitored object we display graphs for
+     *
+     * E.g. the command executed remotely via check_by_ssh
+     *
+     * @var string|null
+     */
+    protected $obscuredCheckCommand;
+
+    /**
+     * Additional CSS classes for the <div/>s around the images
+     *
+     * @var string[]
+     */
+    protected $classes = [];
+
+    /**
+     * Whether to serve a transparent dummy image first and let the JS code load the actual graph
+     *
+     * @var bool
+     */
+    protected $preloadDummy = false;
+
+    /**
+     * Whether to render the graphs inline
+     *
+     * @var bool
+     */
+    protected $renderInline;
+
+    /**
+     * Whether to explicitly display that no graphs were found
+     *
+     * @var bool|null
+     */
+    protected $showNoGraphsFound;
+
+    /**
+     * Factory, based on the given monitoring object
+     *
+     * @param   MonitoredObject $object
+     *
+     * @return  static
+     */
+    public static function forMonitoredObject(MonitoredObject $object)
+    {
+        switch ($object->getType()) {
+            case 'host':
+                /** @var Host $object */
+                return new HostGraphs($object);
+
+            case 'service':
+                /** @var Service $object */
+                return new ServiceGraphs($object);
+        }
+    }
+
+    /**
+     * Factory, based on the given icingadb object
+     *
+     * @param Model $object
+     *
+     * @return static
+     */
+    public static function forIcingadbObject(Model $object)
+    {
+        if ($object instanceof IcingadbHost) {
+            return new IcingadbHostGraphs($object);
+        }
+
+        return new IcingadbServiceGraphs($object);
+    }
+
+    /**
+     * Get the Icinga custom variable with the "real" check command (if any) of monitored objects we display graphs for
+     *
+     * @return string
+     */
+    public static function getObscuredCheckCommandCustomVar()
+    {
+        if (static::$obscuredCheckCommandCustomVar === null) {
+            static::$obscuredCheckCommandCustomVar = Config::module('graphite')
+                ->get('icinga', 'customvar_obscured_check_command', 'check_command');
+        }
+
+        return static::$obscuredCheckCommandCustomVar;
+    }
+
+    /**
+     * Constructor
+     *
+     * @param MonitoredObject|Model $object    The object to render the graphs for
+     */
+    public function __construct($object)
+    {
+        $this->object = $object;
+        $this->renderInline = Url::fromRequest()->getParam('format') === 'pdf';
+
+        if ($object instanceof Model) {
+            $this->checkCommand = $object->checkcommand_name;
+            $this->obscuredCheckCommand = $object->vars[Graphs::getObscuredCheckCommandCustomVar()] ?? null;
+        } else {
+            $this->checkCommand = $object->{"{$this->objectType}_check_command"};
+            $this->obscuredCheckCommand = $object->{
+                "_{$this->objectType}_" . Graphs::getObscuredCheckCommandCustomVar()
+            };
+        }
+    }
+
+    /**
+     * Process the given request using this widget
+     *
+     * @param   Request $request    The request to be processed
+     *
+     * @return  $this
+     */
+    public function handleRequest(Request $request = null)
+    {
+        if ($request === null) {
+            $request = Icinga::app()->getRequest();
+        }
+
+        $params = $request->getUrl()->getParams();
+        list($this->start, $this->end) = $this->getRangeFromTimeRangePicker($request);
+        $this->width  = $params->shift('width', $this->width);
+        $this->height = $params->shift('height', $this->height);
+
+        return $this;
+    }
+
+    /**
+     * Render the graphs list
+     *
+     * @return string
+     */
+    protected function getGraphsList()
+    {
+        $result = []; // kind of string builder
+        $imageBaseUrl = $this->getImageBaseUrl();
+        $allTemplates = $this->getAllTemplates();
+        $actualCheckCommand = $this->obscuredCheckCommand === null ? $this->checkCommand : $this->obscuredCheckCommand;
+        $concreteTemplates = $allTemplates->getTemplates($actualCheckCommand);
+
+        $excludedMetrics = [];
+
+        foreach ($concreteTemplates as $concreteTemplate) {
+            foreach ($concreteTemplate->getCurves() as $curve) {
+                $excludedMetrics[] = $curve[0];
+            }
+        }
+
+        IPT::recordf("Icinga check command: %s", $this->checkCommand);
+        IPT::recordf("Obscured check command: %s", $this->obscuredCheckCommand);
+
+        foreach (
+            [
+            ['template', $concreteTemplates, []],
+            ['default_template', $allTemplates->getDefaultTemplates(), $excludedMetrics],
+            ] as $templateSet
+        ) {
+            list($urlParam, $templates, $excludeMetrics) = $templateSet;
+
+            if ($urlParam === 'template') {
+                IPT::recordf('Applying templates for check command %s', $actualCheckCommand);
+            } else {
+                IPT::recordf('Applying default templates, excluding previously used metrics');
+            }
+
+            IPT::indent();
+
+            foreach ($templates as $templateName => $template) {
+                if ($this->designedForObjectType($template)) {
+                    IPT::recordf('Applying template %s', $templateName);
+                    IPT::indent();
+
+                    $charts = $template->getCharts(
+                        static::getMetricsDataSource(),
+                        $this->object,
+                        [],
+                        $excludeMetrics
+                    );
+
+                    if (! empty($charts)) {
+                        $currentGraphs = [];
+
+                        foreach ($charts as $chart) {
+                            /** @var Chart $chart */
+
+                            $metricVariables = $chart->getMetricVariables();
+                            $bestIntersect = -1;
+                            $bestPos = count($result);
+
+                            foreach ($result as $graphPos => & $graph) {
+                                $currentIntersect = count(array_intersect_assoc($graph[1], $metricVariables));
+
+                                if ($currentIntersect >= $bestIntersect) {
+                                    $bestIntersect = $currentIntersect;
+                                    $bestPos = $graphPos + 1;
+                                }
+                            }
+                            unset($graph);
+
+                            $urlParams = $template->getUrlParams();
+                            if (array_key_exists("height", $urlParams)) {
+                                $actheight = $urlParams["height"]->resolve(['height']);
+                                if ($actheight < $this->height) {
+                                    $actheight = $this->height;
+                                }
+                            } else {
+                                $actheight = $this->height;
+                            }
+                            $actwidth = $this->width;
+                            $actwidthfix = "";
+                            if (array_key_exists("width", $urlParams)) {
+                                $actwidth = $urlParams["width"]->resolve(['width']);
+                                $actwidthfix = "width: {$actwidth}px; ";
+                            }
+
+                            if ($this->renderInline) {
+                                $chart->setFrom($this->start)
+                                    ->setUntil($this->end)
+                                    ->setWidth($actwidth)
+                                    ->setHeight($actheight)
+                                    ->setBackgroundColor('white')
+                                    ->setForegroundColor('black')
+                                    ->setMajorGridLineColor('grey')
+                                    ->setMinorGridLineColor('white')
+                                    ->setShowLegend(! $this->compact);
+
+                                $img = new InlineGraphImage($chart);
+                            } else {
+                                $imageUrl = $this->filterImageUrl($imageBaseUrl->with($metricVariables))
+                                    ->setParam($urlParam, $templateName)
+                                    ->setParam('start', $this->start)
+                                    ->setParam('end', $this->end)
+                                    ->setParam('width', $actwidth)
+                                    ->setParam('height', $actheight);
+
+                                if (! $this->compact) {
+                                    $imageUrl->setParam('legend', 1);
+                                }
+
+                                if ($this->preloadDummy) {
+                                    $src = 'data:image/png;base64,' // 1x1 dummy
+                                        . 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAAACnej3aAAAAAXRS'
+                                        . 'TlMAQObYZgAAAApJREFUeAFjZAAAAAQAAhq+CAMAAAAASUVORK5CYII=';
+                                } else {
+                                    $src = $imageUrl;
+                                }
+
+                                $img = '<img id="graphiteImg-' . md5((string) $imageUrl) . '"'
+                                    . " src=\"$src\" data-actualimageurl=\"$imageUrl\" class=\"detach graphiteImg\""
+                                    . " alt=\"\" width=\"$actwidth\" height=\"$actheight\""
+                                    . " style=\"min-width: {$actwidth}px; $actwidthfix min-height: {$actheight}px;\">";
+                            }
+
+                            $currentGraphs[] = [$img, $metricVariables, $bestPos];
+                        }
+
+                        foreach (array_reverse($currentGraphs) as $graph) {
+                            list($img, $metricVariables, $bestPos) = $graph;
+                            array_splice($result, $bestPos, 0, [[$img, $metricVariables]]);
+                        }
+                    }
+
+                    IPT::unindent();
+                } else {
+                    IPT::recordf('Not applying template %s', $templateName);
+                }
+            }
+
+            IPT::unindent();
+        }
+
+        if (! empty($result)) {
+            foreach ($result as & $graph) {
+                $graph = $graph[0];
+            }
+            unset($graph);
+
+            $currentUrl = Icinga::app()->getRequest()->getUrl();
+            $limit = (int) $currentUrl->getParam('graphs_limit', 2);
+            $total = count($result);
+
+            if ($limit < 1) {
+                $limit = -1;
+            }
+
+            if ($limit !== -1 && $total > $limit) {
+                $result = array_slice($result, 0, $limit);
+
+                if (! $this->compact) {
+                    /** @var View $view */
+                    $view = $this->view();
+
+                    $url = $this->getGraphsListBaseUrl();
+                    TimeRangePickerTools::copyAllRangeParameters($url->getParams(), $currentUrl->getParams());
+
+                    $result[] = "<p class='load-more'>{$view->qlink(
+                        sprintf($view->translate('Load all %d graphs'), $total),
+                        $url->setParam('graphs_limit', '-1'),
+                        null,
+                        ['class' => 'action-link']
+                    )}</p>";
+                }
+            }
+
+            $classes = $this->classes;
+            $classes[] = 'images';
+
+            array_unshift($result, '<div class="' . implode(' ', $classes) . '">');
+            $result[] = '</div>';
+        }
+
+        if ($this->renderInline) {
+            foreach ($result as $html) {
+                if ($html instanceof InlineGraphImage) {
+                    // Errors should occur now or not at all
+                    $html->render();
+                }
+            }
+        }
+
+        return implode($result);
+    }
+
+    public function render()
+    {
+        IPT::clear();
+
+        try {
+            $result = $this->getGraphsList();
+        } catch (ConfigurationError $e) {
+            $view = $this->view();
+
+            return "<p>{$view->escape($e->getMessage())}</p>"
+                . '<p>' . vsprintf(
+                    $view->escape($view->translate('Please %scorrect%s the configuration of the Graphite module.')),
+                    Auth::getInstance()->hasPermission('config/modules')
+                        ? explode(
+                            '$LINK_TEXT$',
+                            $view->qlink('$LINK_TEXT$', 'graphite/config/backend', null, ['class' => 'action-link'])
+                        )
+                        : ['', '']
+                ) . '</p>';
+        }
+
+        $view = $this->view();
+
+        if ($result === '' && $this->getShowNoGraphsFound()) {
+            $result = "<p>{$view->escape($view->translate('No graphs found'))}</p>";
+        }
+
+        if (IPT::enabled()) {
+            $result .= "<h3>{$view->escape($view->translate('Graphs assembling process record'))}</h3>"
+                . "<pre>{$view->escape(IPT::dump())}</pre>";
+        }
+
+        return $result;
+    }
+
+    /**
+     * Get time range parameters for Graphite from the URL
+     *
+     * @param   Request $request    The request to be used
+     *
+     * @return  string[]
+     */
+    protected function getRangeFromTimeRangePicker(Request $request)
+    {
+        $params = $request->getUrl()->getParams();
+        $relative = $params->get(TimeRangePickerTools::getRelativeRangeParameter());
+        if ($relative !== null) {
+            return ["-$relative", null];
+        }
+
+        $absolute = TimeRangePickerTools::getAbsoluteRangeParameters();
+        $start = $params->get($absolute['start']);
+        return [
+            $start === null ? -TimeRangePickerTools::getDefaultRelativeTimeRange() : $start,
+            $params->get($absolute['end'])
+        ];
+    }
+
+    /**
+     * Return a identifier specifying the monitored object we display graphs for
+     *
+     * @return  string
+     */
+    abstract protected function getMonitoredObjectIdentifier();
+
+    /**
+     * Get the base URL to a graph specifying just the monitored object kind
+     *
+     * @return Url
+     */
+    abstract protected function getImageBaseUrl();
+
+    /**
+     * Get the base URL to the monitored object's graphs list
+     *
+     * @return Url
+     */
+    abstract protected function getGraphsListBaseUrl();
+
+    /**
+     * Extend the {@link getImageBaseUrl()}'s result's parameters with the concrete monitored object
+     *
+     * @param   Url $url    The URL to extend
+     *
+     * @return  Url         The given URL
+     */
+    abstract protected function filterImageUrl(Url $url);
+
+    /**
+     * Return whether the given template is designed for the type of the object we display graphs for
+     *
+     * @param   Template    $template
+     *
+     * @return  bool
+     */
+    abstract protected function designedForObjectType(Template $template);
+
+    /**
+     * Get {@link compact}
+     *
+     * @return bool
+     */
+    public function getCompact()
+    {
+        return $this->compact;
+    }
+
+    /**
+     * Set {@link compact}
+     *
+     * @param bool $compact
+     *
+     * @return $this
+     */
+    public function setCompact($compact = true)
+    {
+        $this->compact = $compact;
+        return $this;
+    }
+
+    /**
+     * Get the graph image width
+     *
+     * @return string
+     */
+    public function getWidth()
+    {
+        return $this->width;
+    }
+
+    /**
+     * Set the graph image width
+     *
+     * @param string $width
+     *
+     * @return $this
+     */
+    public function setWidth($width)
+    {
+        $this->width = $width;
+
+        return $this;
+    }
+
+    /**
+     * Get the graph image height
+     *
+     * @return string
+     */
+    public function getHeight()
+    {
+        return $this->height;
+    }
+
+    /**
+     * Set the graph image height
+     *
+     * @param string $height
+     *
+     * @return $this
+     */
+    public function setHeight($height)
+    {
+        $this->height = $height;
+
+        return $this;
+    }
+
+    /**
+     * Get additional CSS classes for the <div/>s around the images
+     *
+     * @return string[]
+     */
+    public function getClasses()
+    {
+        return $this->classes;
+    }
+
+    /**
+     * Set additional CSS classes for the <div/>s around the images
+     *
+     * @param string[] $classes
+     *
+     * @return $this
+     */
+    public function setClasses($classes)
+    {
+        $this->classes = $classes;
+
+        return $this;
+    }
+
+    /**
+     * Get whether to serve a transparent dummy image first and let the JS code load the actual graph
+     *
+     * @return bool
+     */
+    public function getPreloadDummy()
+    {
+        return $this->preloadDummy;
+    }
+
+    /**
+     * Set whether to serve a transparent dummy image first and let the JS code load the actual graph
+     *
+     * @param bool $preloadDummy
+     *
+     * @return $this
+     */
+    public function setPreloadDummy($preloadDummy = true)
+    {
+        $this->preloadDummy = $preloadDummy;
+
+        return $this;
+    }
+
+    /**
+     * Get whether to render the graphs inline
+     *
+     * @return bool
+     */
+    public function getRenderInline()
+    {
+        return $this->renderInline;
+    }
+
+    /**
+     * Set whether to render the graphs inline
+     *
+     * @param bool $renderInline
+     *
+     * @return $this
+     */
+    public function setRenderInline($renderInline = true)
+    {
+        $this->renderInline = $renderInline;
+
+        return $this;
+    }
+
+    /**
+     * Get whether to explicitly display that no graphs were found
+     *
+     * @return bool
+     */
+    public function getShowNoGraphsFound()
+    {
+        if ($this->showNoGraphsFound === null) {
+            $this->showNoGraphsFound = ! Config::module('graphite')->get('ui', 'disable_no_graphs_found');
+        }
+
+        return $this->showNoGraphsFound;
+    }
+
+    /**
+     * Set whether to explicitly display that no graphs were found
+     *
+     * @param bool $showNoGraphsFound
+     *
+     * @return $this
+     */
+    public function setShowNoGraphsFound($showNoGraphsFound = true)
+    {
+        $this->showNoGraphsFound = $showNoGraphsFound;
+
+        return $this;
+    }
+}
diff --git a/library/Graphite/Web/Widget/Graphs/Host.php b/library/Graphite/Web/Widget/Graphs/Host.php
new file mode 100644
index 0000000..2247bcc
--- /dev/null
+++ b/library/Graphite/Web/Widget/Graphs/Host.php
@@ -0,0 +1,51 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web\Widget\Graphs;
+
+use Icinga\Module\Graphite\Graphing\Template;
+use Icinga\Module\Graphite\Web\Widget\Graphs;
+use Icinga\Module\Monitoring\Object\Host as MonitoredHost;
+use Icinga\Web\Url;
+
+class Host extends Graphs
+{
+    protected $objectType = 'host';
+
+    /**
+     * The host to render the graphs of
+     *
+     * @var MonitoredHost
+     */
+    protected $object;
+
+    protected function getImageBaseUrl()
+    {
+        return Url::fromPath('graphite/graph/host');
+    }
+
+    protected function getGraphsListBaseUrl()
+    {
+        return Url::fromPath('graphite/list/hosts', ['host' => $this->object->getName()]);
+    }
+
+    protected function filterImageUrl(Url $url)
+    {
+        return $url->setParam('host.name', $this->object->getName());
+    }
+
+    protected function getMonitoredObjectIdentifier()
+    {
+        return $this->object->getName();
+    }
+
+    protected function designedForObjectType(Template $template)
+    {
+        foreach ($template->getCurves() as $curve) {
+            if (in_array('host_name_template', $curve[0]->getMacros())) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/library/Graphite/Web/Widget/Graphs/Icingadb/IcingadbHost.php b/library/Graphite/Web/Widget/Graphs/Icingadb/IcingadbHost.php
new file mode 100644
index 0000000..2b0a614
--- /dev/null
+++ b/library/Graphite/Web/Widget/Graphs/Icingadb/IcingadbHost.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web\Widget\Graphs\Icingadb;
+
+use Icinga\Module\Graphite\Graphing\Template;
+use Icinga\Module\Graphite\Web\Widget\Graphs;
+use Icinga\Web\Url;
+use Icinga\Module\Icingadb\Model\Host;
+
+class IcingadbHost extends Graphs
+{
+    protected $objectType = 'host';
+
+    /**
+     * The Icingadb host to render the graphs for
+     *
+     * @var Host
+     */
+    protected $object;
+
+    protected function getGraphsListBaseUrl()
+    {
+        return Url::fromPath('graphite/hosts', ['host.name' => $this->object->name]);
+    }
+
+    protected function filterImageUrl(Url $url)
+    {
+        return $url->setParam('host.name', $this->object->name);
+    }
+
+    public function createHostTitle()
+    {
+        return $this->object->name;
+    }
+
+    public function getObjectType()
+    {
+        return $this->objectType;
+    }
+
+    protected function getMonitoredObjectIdentifier()
+    {
+        return $this->object->name;
+    }
+
+    protected function getImageBaseUrl()
+    {
+        return Url::fromPath('graphite/graph/host');
+    }
+
+    protected function designedForObjectType(Template $template)
+    {
+        foreach ($template->getCurves() as $curve) {
+            if (in_array('host_name_template', $curve[0]->getMacros())) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/library/Graphite/Web/Widget/Graphs/Icingadb/IcingadbService.php b/library/Graphite/Web/Widget/Graphs/Icingadb/IcingadbService.php
new file mode 100644
index 0000000..7827e86
--- /dev/null
+++ b/library/Graphite/Web/Widget/Graphs/Icingadb/IcingadbService.php
@@ -0,0 +1,71 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web\Widget\Graphs\Icingadb;
+
+use Icinga\Module\Graphite\Graphing\Template;
+use Icinga\Module\Graphite\Web\Widget\Graphs;
+use Icinga\Web\Url;
+use Icinga\Module\Icingadb\Model\Service;
+
+class IcingadbService extends Graphs
+{
+    protected $objectType = 'service';
+
+    /**
+     * The icingadb service to render the graphs for
+     *
+     * @var Service
+     */
+    protected $object;
+
+    protected function getGraphsListBaseUrl()
+    {
+        return Url::fromPath(
+            'graphite/services',
+            ['service.name' => $this->object->name, 'host.name' => $this->object->host->name]
+        );
+    }
+
+    protected function filterImageUrl(Url $url)
+    {
+        return $url
+            ->setParam('host.name', $this->object->host->name)
+            ->setParam('service.name', $this->object->name);
+    }
+
+    public function createHostTitle()
+    {
+        return $this->object->host->name;
+    }
+
+    public function createServiceTitle()
+    {
+        return ' : ' . $this->object->name;
+    }
+
+    public function getObjectType()
+    {
+        return $this->objectType;
+    }
+
+    protected function getMonitoredObjectIdentifier()
+    {
+        return $this->object->host->name . ':' . $this->object->name;
+    }
+
+    protected function getImageBaseUrl()
+    {
+        return Url::fromPath('graphite/graph/service');
+    }
+
+    protected function designedforObjectType(Template $template)
+    {
+        foreach ($template->getCurves() as $curve) {
+            if (in_array('service_name_template', $curve[0]->getMacros())) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/library/Graphite/Web/Widget/Graphs/Service.php b/library/Graphite/Web/Widget/Graphs/Service.php
new file mode 100644
index 0000000..5fc0143
--- /dev/null
+++ b/library/Graphite/Web/Widget/Graphs/Service.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web\Widget\Graphs;
+
+use Icinga\Module\Graphite\Graphing\Template;
+use Icinga\Module\Graphite\Web\Widget\Graphs;
+use Icinga\Module\Monitoring\Object\Service as MonitoredService;
+use Icinga\Web\Url;
+
+class Service extends Graphs
+{
+    protected $objectType = 'service';
+
+    /**
+     * The service to render the graphs for
+     *
+     * @var MonitoredService
+     */
+    protected $object;
+
+    protected function getImageBaseUrl()
+    {
+        return Url::fromPath('graphite/graph/service');
+    }
+
+    protected function getGraphsListBaseUrl()
+    {
+        return Url::fromPath(
+            'graphite/list/services',
+            ['host' => $this->object->getHost()->getName(), 'service' => $this->object->getName()]
+        );
+    }
+
+    protected function filterImageUrl(Url $url)
+    {
+        return $url
+            ->setParam('host.name', $this->object->getHost()->getName())
+            ->setParam('service.name', $this->object->getName());
+    }
+
+    protected function getMonitoredObjectIdentifier()
+    {
+        return $this->object->getHost()->getName() . ':' . $this->object->getName();
+    }
+
+    protected function designedForObjectType(Template $template)
+    {
+        foreach ($template->getCurves() as $curve) {
+            if (in_array('service_name_template', $curve[0]->getMacros())) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/library/Graphite/Web/Widget/IcingadbGraphs.php b/library/Graphite/Web/Widget/IcingadbGraphs.php
new file mode 100644
index 0000000..e038e92
--- /dev/null
+++ b/library/Graphite/Web/Widget/IcingadbGraphs.php
@@ -0,0 +1,106 @@
+<?php
+
+/* Icinga Graphite Web | (c) 2022 Icinga GmbH | GPLv2 */
+
+namespace Icinga\Module\Graphite\Web\Widget;
+
+use Icinga\Data\Filter\Filter;
+use Icinga\Module\Graphite\Web\Widget\Graphs\Icingadb\IcingadbHost;
+use Icinga\Module\Graphite\Web\Widget\Graphs\Icingadb\IcingadbService;
+use Icinga\Module\Icingadb\Common\Links;
+use Icinga\Module\Icingadb\Widget\EmptyState;
+use Icinga\Module\Icingadb\Model\Host;
+use ipl\Html\BaseHtmlElement;
+use ipl\Html\Html;
+use ipl\Html\HtmlDocument;
+use ipl\Html\HtmlString;
+use ipl\Orm\ResultSet;
+use ipl\Stdlib\BaseFilter;
+use ipl\Web\Filter\QueryString;
+use ipl\Web\Widget\Link;
+
+/**
+* Class for creating graphs of icingadb objects
+*/
+class IcingadbGraphs extends BaseHtmlElement
+{
+    use BaseFilter;
+
+    protected $defaultAttributes = ['class' => 'grid'];
+
+    /** @var Iterable */
+    protected $objects;
+
+    protected $tag = 'div';
+
+    /**
+     * Create a new Graph item
+     *
+     * @param ResultSet $objects
+     */
+    public function __construct(ResultSet $objects)
+    {
+        $this->objects = $objects;
+    }
+
+    protected function assemble()
+    {
+        if (! $this->objects->hasResult()) {
+            $this->add(new EmptyState(t('No items found.')));
+        }
+
+        foreach ($this->objects as $object) {
+            $this->add($this->createGridItem($object));
+        }
+
+        $document = new HtmlDocument();
+        $document->addHtml(Html::tag('div', ['class' => 'graphite-graph-color-registry']), $this);
+        $this->prependWrapper($document);
+    }
+
+    protected function createGridItem($object)
+    {
+        if ($object instanceof Host) {
+            $graph = new IcingadbHost($object);
+            $hostObj = $object;
+        } else {
+            $graph = new IcingadbService($object);
+            $hostObj = $object->host;
+        }
+
+        $hostUrl = Links::host($hostObj);
+
+        if ($this->hasBaseFilter()) {
+            $hostUrl->addFilter(Filter::fromQueryString(QueryString::render($this->getBaseFilter())));
+        }
+
+        $hostLink =  new Link(
+            $graph->createHostTitle(),
+            $hostUrl,
+            ['data-base-target' => '_next']
+        );
+
+        $serviceLink = null;
+        if ($graph->getObjectType() === 'service') {
+            $serviceUrl = Links::service($object, $hostObj);
+
+            if ($this->hasBaseFilter()) {
+                $serviceUrl->addFilter(Filter::fromQueryString(QueryString::render($this->getBaseFilter())));
+            }
+
+            $serviceLink = new Link(
+                $graph->createServiceTitle(),
+                $serviceUrl,
+                ['data-base-target' => '_next']
+            );
+        }
+
+        $gridItem = Html::tag('div', ['class' => 'grid-item']);
+        $header = Html::tag('h2');
+
+        $header->add([$hostLink, $serviceLink]);
+        $gridItem->add($header);
+
+        return $gridItem->add(HtmlString::create($graph->setPreloadDummy()->handleRequest()));
+    }
+}
diff --git a/library/Graphite/Web/Widget/InlineGraphImage.php b/library/Graphite/Web/Widget/InlineGraphImage.php
new file mode 100644
index 0000000..881384d
--- /dev/null
+++ b/library/Graphite/Web/Widget/InlineGraphImage.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace Icinga\Module\Graphite\Web\Widget;
+
+use Icinga\Module\Graphite\Graphing\Chart;
+use Icinga\Web\Widget\AbstractWidget;
+
+class InlineGraphImage extends AbstractWidget
+{
+    /**
+     * The image to be rendered
+     *
+     * @var GraphImage
+     */
+    protected $image;
+
+    /**
+     * The rendered <img>
+     *
+     * @var string|null
+     */
+    protected $rendered;
+
+    /**
+     * Constructor
+     *
+     * @param   Chart   $chart  The chart to be rendered
+     */
+    public function __construct(Chart $chart)
+    {
+        $this->image = new GraphImage($chart);
+    }
+
+    /**
+     * Render the graph lazily
+     *
+     * @return string
+     */
+    public function render()
+    {
+        if ($this->rendered === null) {
+            $this->rendered = '<img src="data:image/png;base64,'
+                . implode("\n", str_split(base64_encode($this->image->render()), 76))
+                . '">';
+        }
+
+        return $this->rendered;
+    }
+}
diff --git a/library/vendor/Psr/Http/Message/MessageInterface.php b/library/vendor/Psr/Http/Message/MessageInterface.php
new file mode 100644
index 0000000..8f67a05
--- /dev/null
+++ b/library/vendor/Psr/Http/Message/MessageInterface.php
@@ -0,0 +1,187 @@
+<?php
+
+namespace Psr\Http\Message;
+
+/**
+ * HTTP messages consist of requests from a client to a server and responses
+ * from a server to a client. This interface defines the methods common to
+ * each.
+ *
+ * Messages are considered immutable; all methods that might change state MUST
+ * be implemented such that they retain the internal state of the current
+ * message and return an instance that contains the changed state.
+ *
+ * @link http://www.ietf.org/rfc/rfc7230.txt
+ * @link http://www.ietf.org/rfc/rfc7231.txt
+ */
+interface MessageInterface
+{
+    /**
+     * Retrieves the HTTP protocol version as a string.
+     *
+     * The string MUST contain only the HTTP version number (e.g., "1.1", "1.0").
+     *
+     * @return string HTTP protocol version.
+     */
+    public function getProtocolVersion();
+
+    /**
+     * Return an instance with the specified HTTP protocol version.
+     *
+     * The version string MUST contain only the HTTP version number (e.g.,
+     * "1.1", "1.0").
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * new protocol version.
+     *
+     * @param string $version HTTP protocol version
+     * @return self
+     */
+    public function withProtocolVersion($version);
+
+    /**
+     * Retrieves all message header values.
+     *
+     * The keys represent the header name as it will be sent over the wire, and
+     * each value is an array of strings associated with the header.
+     *
+     *     // Represent the headers as a string
+     *     foreach ($message->getHeaders() as $name => $values) {
+     *         echo $name . ": " . implode(", ", $values);
+     *     }
+     *
+     *     // Emit headers iteratively:
+     *     foreach ($message->getHeaders() as $name => $values) {
+     *         foreach ($values as $value) {
+     *             header(sprintf('%s: %s', $name, $value), false);
+     *         }
+     *     }
+     *
+     * While header names are not case-sensitive, getHeaders() will preserve the
+     * exact case in which headers were originally specified.
+     *
+     * @return array Returns an associative array of the message's headers. Each
+     *     key MUST be a header name, and each value MUST be an array of strings
+     *     for that header.
+     */
+    public function getHeaders();
+
+    /**
+     * Checks if a header exists by the given case-insensitive name.
+     *
+     * @param string $name Case-insensitive header field name.
+     * @return bool Returns true if any header names match the given header
+     *     name using a case-insensitive string comparison. Returns false if
+     *     no matching header name is found in the message.
+     */
+    public function hasHeader($name);
+
+    /**
+     * Retrieves a message header value by the given case-insensitive name.
+     *
+     * This method returns an array of all the header values of the given
+     * case-insensitive header name.
+     *
+     * If the header does not appear in the message, this method MUST return an
+     * empty array.
+     *
+     * @param string $name Case-insensitive header field name.
+     * @return string[] An array of string values as provided for the given
+     *    header. If the header does not appear in the message, this method MUST
+     *    return an empty array.
+     */
+    public function getHeader($name);
+
+    /**
+     * Retrieves a comma-separated string of the values for a single header.
+     *
+     * This method returns all of the header values of the given
+     * case-insensitive header name as a string concatenated together using
+     * a comma.
+     *
+     * NOTE: Not all header values may be appropriately represented using
+     * comma concatenation. For such headers, use getHeader() instead
+     * and supply your own delimiter when concatenating.
+     *
+     * If the header does not appear in the message, this method MUST return
+     * an empty string.
+     *
+     * @param string $name Case-insensitive header field name.
+     * @return string A string of values as provided for the given header
+     *    concatenated together using a comma. If the header does not appear in
+     *    the message, this method MUST return an empty string.
+     */
+    public function getHeaderLine($name);
+
+    /**
+     * Return an instance with the provided value replacing the specified header.
+     *
+     * While header names are case-insensitive, the casing of the header will
+     * be preserved by this function, and returned from getHeaders().
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * new and/or updated header and value.
+     *
+     * @param string $name Case-insensitive header field name.
+     * @param string|string[] $value Header value(s).
+     * @return self
+     * @throws \InvalidArgumentException for invalid header names or values.
+     */
+    public function withHeader($name, $value);
+
+    /**
+     * Return an instance with the specified header appended with the given value.
+     *
+     * Existing values for the specified header will be maintained. The new
+     * value(s) will be appended to the existing list. If the header did not
+     * exist previously, it will be added.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * new header and/or value.
+     *
+     * @param string $name Case-insensitive header field name to add.
+     * @param string|string[] $value Header value(s).
+     * @return self
+     * @throws \InvalidArgumentException for invalid header names or values.
+     */
+    public function withAddedHeader($name, $value);
+
+    /**
+     * Return an instance without the specified header.
+     *
+     * Header resolution MUST be done without case-sensitivity.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that removes
+     * the named header.
+     *
+     * @param string $name Case-insensitive header field name to remove.
+     * @return self
+     */
+    public function withoutHeader($name);
+
+    /**
+     * Gets the body of the message.
+     *
+     * @return StreamInterface Returns the body as a stream.
+     */
+    public function getBody();
+
+    /**
+     * Return an instance with the specified message body.
+     *
+     * The body MUST be a StreamInterface object.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return a new instance that has the
+     * new body stream.
+     *
+     * @param StreamInterface $body Body.
+     * @return self
+     * @throws \InvalidArgumentException When the body is not valid.
+     */
+    public function withBody(StreamInterface $body);
+}
diff --git a/library/vendor/Psr/Http/Message/RequestInterface.php b/library/vendor/Psr/Http/Message/RequestInterface.php
new file mode 100644
index 0000000..75c802e
--- /dev/null
+++ b/library/vendor/Psr/Http/Message/RequestInterface.php
@@ -0,0 +1,129 @@
+<?php
+
+namespace Psr\Http\Message;
+
+/**
+ * Representation of an outgoing, client-side request.
+ *
+ * Per the HTTP specification, this interface includes properties for
+ * each of the following:
+ *
+ * - Protocol version
+ * - HTTP method
+ * - URI
+ * - Headers
+ * - Message body
+ *
+ * During construction, implementations MUST attempt to set the Host header from
+ * a provided URI if no Host header is provided.
+ *
+ * Requests are considered immutable; all methods that might change state MUST
+ * be implemented such that they retain the internal state of the current
+ * message and return an instance that contains the changed state.
+ */
+interface RequestInterface extends MessageInterface
+{
+    /**
+     * Retrieves the message's request target.
+     *
+     * Retrieves the message's request-target either as it will appear (for
+     * clients), as it appeared at request (for servers), or as it was
+     * specified for the instance (see withRequestTarget()).
+     *
+     * In most cases, this will be the origin-form of the composed URI,
+     * unless a value was provided to the concrete implementation (see
+     * withRequestTarget() below).
+     *
+     * If no URI is available, and no request-target has been specifically
+     * provided, this method MUST return the string "/".
+     *
+     * @return string
+     */
+    public function getRequestTarget();
+
+    /**
+     * Return an instance with the specific request-target.
+     *
+     * If the request needs a non-origin-form request-target — e.g., for
+     * specifying an absolute-form, authority-form, or asterisk-form —
+     * this method may be used to create an instance with the specified
+     * request-target, verbatim.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * changed request target.
+     *
+     * @link http://tools.ietf.org/html/rfc7230#section-2.7 (for the various
+     *     request-target forms allowed in request messages)
+     * @param mixed $requestTarget
+     * @return self
+     */
+    public function withRequestTarget($requestTarget);
+
+    /**
+     * Retrieves the HTTP method of the request.
+     *
+     * @return string Returns the request method.
+     */
+    public function getMethod();
+
+    /**
+     * Return an instance with the provided HTTP method.
+     *
+     * While HTTP method names are typically all uppercase characters, HTTP
+     * method names are case-sensitive and thus implementations SHOULD NOT
+     * modify the given string.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * changed request method.
+     *
+     * @param string $method Case-sensitive method.
+     * @return self
+     * @throws \InvalidArgumentException for invalid HTTP methods.
+     */
+    public function withMethod($method);
+
+    /**
+     * Retrieves the URI instance.
+     *
+     * This method MUST return a UriInterface instance.
+     *
+     * @link http://tools.ietf.org/html/rfc3986#section-4.3
+     * @return UriInterface Returns a UriInterface instance
+     *     representing the URI of the request.
+     */
+    public function getUri();
+
+    /**
+     * Returns an instance with the provided URI.
+     *
+     * This method MUST update the Host header of the returned request by
+     * default if the URI contains a host component. If the URI does not
+     * contain a host component, any pre-existing Host header MUST be carried
+     * over to the returned request.
+     *
+     * You can opt-in to preserving the original state of the Host header by
+     * setting `$preserveHost` to `true`. When `$preserveHost` is set to
+     * `true`, this method interacts with the Host header in the following ways:
+     *
+     * - If the the Host header is missing or empty, and the new URI contains
+     *   a host component, this method MUST update the Host header in the returned
+     *   request.
+     * - If the Host header is missing or empty, and the new URI does not contain a
+     *   host component, this method MUST NOT update the Host header in the returned
+     *   request.
+     * - If a Host header is present and non-empty, this method MUST NOT update
+     *   the Host header in the returned request.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * new UriInterface instance.
+     *
+     * @link http://tools.ietf.org/html/rfc3986#section-4.3
+     * @param UriInterface $uri New request URI to use.
+     * @param bool $preserveHost Preserve the original state of the Host header.
+     * @return self
+     */
+    public function withUri(UriInterface $uri, $preserveHost = false);
+}
diff --git a/library/vendor/Psr/Http/Message/ResponseInterface.php b/library/vendor/Psr/Http/Message/ResponseInterface.php
new file mode 100644
index 0000000..6724809
--- /dev/null
+++ b/library/vendor/Psr/Http/Message/ResponseInterface.php
@@ -0,0 +1,68 @@
+<?php
+
+namespace Psr\Http\Message;
+
+/**
+ * Representation of an outgoing, server-side response.
+ *
+ * Per the HTTP specification, this interface includes properties for
+ * each of the following:
+ *
+ * - Protocol version
+ * - Status code and reason phrase
+ * - Headers
+ * - Message body
+ *
+ * Responses are considered immutable; all methods that might change state MUST
+ * be implemented such that they retain the internal state of the current
+ * message and return an instance that contains the changed state.
+ */
+interface ResponseInterface extends MessageInterface
+{
+    /**
+     * Gets the response status code.
+     *
+     * The status code is a 3-digit integer result code of the server's attempt
+     * to understand and satisfy the request.
+     *
+     * @return int Status code.
+     */
+    public function getStatusCode();
+
+    /**
+     * Return an instance with the specified status code and, optionally, reason phrase.
+     *
+     * If no reason phrase is specified, implementations MAY choose to default
+     * to the RFC 7231 or IANA recommended reason phrase for the response's
+     * status code.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * updated status and reason phrase.
+     *
+     * @link http://tools.ietf.org/html/rfc7231#section-6
+     * @link http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+     * @param int $code The 3-digit integer result code to set.
+     * @param string $reasonPhrase The reason phrase to use with the
+     *     provided status code; if none is provided, implementations MAY
+     *     use the defaults as suggested in the HTTP specification.
+     * @return self
+     * @throws \InvalidArgumentException For invalid status code arguments.
+     */
+    public function withStatus($code, $reasonPhrase = '');
+
+    /**
+     * Gets the response reason phrase associated with the status code.
+     *
+     * Because a reason phrase is not a required element in a response
+     * status line, the reason phrase value MAY be null. Implementations MAY
+     * choose to return the default RFC 7231 recommended reason phrase (or those
+     * listed in the IANA HTTP Status Code Registry) for the response's
+     * status code.
+     *
+     * @link http://tools.ietf.org/html/rfc7231#section-6
+     * @link http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+     * @return string Reason phrase; must return an empty string if none present.
+     */
+    public function getReasonPhrase();
+}
diff --git a/library/vendor/Psr/Http/Message/ServerRequestInterface.php b/library/vendor/Psr/Http/Message/ServerRequestInterface.php
new file mode 100644
index 0000000..916e065
--- /dev/null
+++ b/library/vendor/Psr/Http/Message/ServerRequestInterface.php
@@ -0,0 +1,261 @@
+<?php
+
+namespace Psr\Http\Message;
+
+/**
+ * Representation of an incoming, server-side HTTP request.
+ *
+ * Per the HTTP specification, this interface includes properties for
+ * each of the following:
+ *
+ * - Protocol version
+ * - HTTP method
+ * - URI
+ * - Headers
+ * - Message body
+ *
+ * Additionally, it encapsulates all data as it has arrived to the
+ * application from the CGI and/or PHP environment, including:
+ *
+ * - The values represented in $_SERVER.
+ * - Any cookies provided (generally via $_COOKIE)
+ * - Query string arguments (generally via $_GET, or as parsed via parse_str())
+ * - Upload files, if any (as represented by $_FILES)
+ * - Deserialized body parameters (generally from $_POST)
+ *
+ * $_SERVER values MUST be treated as immutable, as they represent application
+ * state at the time of request; as such, no methods are provided to allow
+ * modification of those values. The other values provide such methods, as they
+ * can be restored from $_SERVER or the request body, and may need treatment
+ * during the application (e.g., body parameters may be deserialized based on
+ * content type).
+ *
+ * Additionally, this interface recognizes the utility of introspecting a
+ * request to derive and match additional parameters (e.g., via URI path
+ * matching, decrypting cookie values, deserializing non-form-encoded body
+ * content, matching authorization headers to users, etc). These parameters
+ * are stored in an "attributes" property.
+ *
+ * Requests are considered immutable; all methods that might change state MUST
+ * be implemented such that they retain the internal state of the current
+ * message and return an instance that contains the changed state.
+ */
+interface ServerRequestInterface extends RequestInterface
+{
+    /**
+     * Retrieve server parameters.
+     *
+     * Retrieves data related to the incoming request environment,
+     * typically derived from PHP's $_SERVER superglobal. The data IS NOT
+     * REQUIRED to originate from $_SERVER.
+     *
+     * @return array
+     */
+    public function getServerParams();
+
+    /**
+     * Retrieve cookies.
+     *
+     * Retrieves cookies sent by the client to the server.
+     *
+     * The data MUST be compatible with the structure of the $_COOKIE
+     * superglobal.
+     *
+     * @return array
+     */
+    public function getCookieParams();
+
+    /**
+     * Return an instance with the specified cookies.
+     *
+     * The data IS NOT REQUIRED to come from the $_COOKIE superglobal, but MUST
+     * be compatible with the structure of $_COOKIE. Typically, this data will
+     * be injected at instantiation.
+     *
+     * This method MUST NOT update the related Cookie header of the request
+     * instance, nor related values in the server params.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * updated cookie values.
+     *
+     * @param array $cookies Array of key/value pairs representing cookies.
+     * @return self
+     */
+    public function withCookieParams(array $cookies);
+
+    /**
+     * Retrieve query string arguments.
+     *
+     * Retrieves the deserialized query string arguments, if any.
+     *
+     * Note: the query params might not be in sync with the URI or server
+     * params. If you need to ensure you are only getting the original
+     * values, you may need to parse the query string from `getUri()->getQuery()`
+     * or from the `QUERY_STRING` server param.
+     *
+     * @return array
+     */
+    public function getQueryParams();
+
+    /**
+     * Return an instance with the specified query string arguments.
+     *
+     * These values SHOULD remain immutable over the course of the incoming
+     * request. They MAY be injected during instantiation, such as from PHP's
+     * $_GET superglobal, or MAY be derived from some other value such as the
+     * URI. In cases where the arguments are parsed from the URI, the data
+     * MUST be compatible with what PHP's parse_str() would return for
+     * purposes of how duplicate query parameters are handled, and how nested
+     * sets are handled.
+     *
+     * Setting query string arguments MUST NOT change the URI stored by the
+     * request, nor the values in the server params.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * updated query string arguments.
+     *
+     * @param array $query Array of query string arguments, typically from
+     *     $_GET.
+     * @return self
+     */
+    public function withQueryParams(array $query);
+
+    /**
+     * Retrieve normalized file upload data.
+     *
+     * This method returns upload metadata in a normalized tree, with each leaf
+     * an instance of Psr\Http\Message\UploadedFileInterface.
+     *
+     * These values MAY be prepared from $_FILES or the message body during
+     * instantiation, or MAY be injected via withUploadedFiles().
+     *
+     * @return array An array tree of UploadedFileInterface instances; an empty
+     *     array MUST be returned if no data is present.
+     */
+    public function getUploadedFiles();
+
+    /**
+     * Create a new instance with the specified uploaded files.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * updated body parameters.
+     *
+     * @param array An array tree of UploadedFileInterface instances.
+     * @return self
+     * @throws \InvalidArgumentException if an invalid structure is provided.
+     */
+    public function withUploadedFiles(array $uploadedFiles);
+
+    /**
+     * Retrieve any parameters provided in the request body.
+     *
+     * If the request Content-Type is either application/x-www-form-urlencoded
+     * or multipart/form-data, and the request method is POST, this method MUST
+     * return the contents of $_POST.
+     *
+     * Otherwise, this method may return any results of deserializing
+     * the request body content; as parsing returns structured content, the
+     * potential types MUST be arrays or objects only. A null value indicates
+     * the absence of body content.
+     *
+     * @return null|array|object The deserialized body parameters, if any.
+     *     These will typically be an array or object.
+     */
+    public function getParsedBody();
+
+    /**
+     * Return an instance with the specified body parameters.
+     *
+     * These MAY be injected during instantiation.
+     *
+     * If the request Content-Type is either application/x-www-form-urlencoded
+     * or multipart/form-data, and the request method is POST, use this method
+     * ONLY to inject the contents of $_POST.
+     *
+     * The data IS NOT REQUIRED to come from $_POST, but MUST be the results of
+     * deserializing the request body content. Deserialization/parsing returns
+     * structured data, and, as such, this method ONLY accepts arrays or objects,
+     * or a null value if nothing was available to parse.
+     *
+     * As an example, if content negotiation determines that the request data
+     * is a JSON payload, this method could be used to create a request
+     * instance with the deserialized parameters.
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * updated body parameters.
+     *
+     * @param null|array|object $data The deserialized body data. This will
+     *     typically be in an array or object.
+     * @return self
+     * @throws \InvalidArgumentException if an unsupported argument type is
+     *     provided.
+     */
+    public function withParsedBody($data);
+
+    /**
+     * Retrieve attributes derived from the request.
+     *
+     * The request "attributes" may be used to allow injection of any
+     * parameters derived from the request: e.g., the results of path
+     * match operations; the results of decrypting cookies; the results of
+     * deserializing non-form-encoded message bodies; etc. Attributes
+     * will be application and request specific, and CAN be mutable.
+     *
+     * @return array Attributes derived from the request.
+     */
+    public function getAttributes();
+
+    /**
+     * Retrieve a single derived request attribute.
+     *
+     * Retrieves a single derived request attribute as described in
+     * getAttributes(). If the attribute has not been previously set, returns
+     * the default value as provided.
+     *
+     * This method obviates the need for a hasAttribute() method, as it allows
+     * specifying a default value to return if the attribute is not found.
+     *
+     * @see getAttributes()
+     * @param string $name The attribute name.
+     * @param mixed $default Default value to return if the attribute does not exist.
+     * @return mixed
+     */
+    public function getAttribute($name, $default = null);
+
+    /**
+     * Return an instance with the specified derived request attribute.
+     *
+     * This method allows setting a single derived request attribute as
+     * described in getAttributes().
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that has the
+     * updated attribute.
+     *
+     * @see getAttributes()
+     * @param string $name The attribute name.
+     * @param mixed $value The value of the attribute.
+     * @return self
+     */
+    public function withAttribute($name, $value);
+
+    /**
+     * Return an instance that removes the specified derived request attribute.
+     *
+     * This method allows removing a single derived request attribute as
+     * described in getAttributes().
+     *
+     * This method MUST be implemented in such a way as to retain the
+     * immutability of the message, and MUST return an instance that removes
+     * the attribute.
+     *
+     * @see getAttributes()
+     * @param string $name The attribute name.
+     * @return self
+     */
+    public function withoutAttribute($name);
+}
diff --git a/library/vendor/Psr/Http/Message/StreamInterface.php b/library/vendor/Psr/Http/Message/StreamInterface.php
new file mode 100644
index 0000000..f68f391
--- /dev/null
+++ b/library/vendor/Psr/Http/Message/StreamInterface.php
@@ -0,0 +1,158 @@
+<?php
+
+namespace Psr\Http\Message;
+
+/**
+ * Describes a data stream.
+ *
+ * Typically, an instance will wrap a PHP stream; this interface provides
+ * a wrapper around the most common operations, including serialization of
+ * the entire stream to a string.
+ */
+interface StreamInterface
+{
+    /**
+     * Reads all data from the stream into a string, from the beginning to end.
+     *
+     * This method MUST attempt to seek to the beginning of the stream before
+     * reading data and read the stream until the end is reached.
+     *
+     * Warning: This could attempt to load a large amount of data into memory.
+     *
+     * This method MUST NOT raise an exception in order to conform with PHP's
+     * string casting operations.
+     *
+     * @see http://php.net/manual/en/language.oop5.magic.php#object.tostring
+     * @return string
+     */
+    public function __toString();
+
+    /**
+     * Closes the stream and any underlying resources.
+     *
+     * @return void
+     */
+    public function close();
+
+    /**
+     * Separates any underlying resources from the stream.
+     *
+     * After the stream has been detached, the stream is in an unusable state.
+     *
+     * @return resource|null Underlying PHP stream, if any
+     */
+    public function detach();
+
+    /**
+     * Get the size of the stream if known.
+     *
+     * @return int|null Returns the size in bytes if known, or null if unknown.
+     */
+    public function getSize();
+
+    /**
+     * Returns the current position of the file read/write pointer
+     *
+     * @return int Position of the file pointer
+     * @throws \RuntimeException on error.
+     */
+    public function tell();
+
+    /**
+     * Returns true if the stream is at the end of the stream.
+     *
+     * @return bool
+     */
+    public function eof();
+
+    /**
+     * Returns whether or not the stream is seekable.
+     *
+     * @return bool
+     */
+    public function isSeekable();
+
+    /**
+     * Seek to a position in the stream.
+     *
+     * @link http://www.php.net/manual/en/function.fseek.php
+     * @param int $offset Stream offset
+     * @param int $whence Specifies how the cursor position will be calculated
+     *     based on the seek offset. Valid values are identical to the built-in
+     *     PHP $whence values for `fseek()`.  SEEK_SET: Set position equal to
+     *     offset bytes SEEK_CUR: Set position to current location plus offset
+     *     SEEK_END: Set position to end-of-stream plus offset.
+     * @throws \RuntimeException on failure.
+     */
+    public function seek($offset, $whence = SEEK_SET);
+
+    /**
+     * Seek to the beginning of the stream.
+     *
+     * If the stream is not seekable, this method will raise an exception;
+     * otherwise, it will perform a seek(0).
+     *
+     * @see seek()
+     * @link http://www.php.net/manual/en/function.fseek.php
+     * @throws \RuntimeException on failure.
+     */
+    public function rewind();
+
+    /**
+     * Returns whether or not the stream is writable.
+     *
+     * @return bool
+     */
+    public function isWritable();
+
+    /**
+     * Write data to the stream.
+     *
+     * @param string $string The string that is to be written.
+     * @return int Returns the number of bytes written to the stream.
+     * @throws \RuntimeException on failure.
+     */
+    public function write($string);
+
+    /**
+     * Returns whether or not the stream is readable.
+     *
+     * @return bool
+     */
+    public function isReadable();
+
+    /**
+     * Read data from the stream.
+     *
+     * @param int $length Read up to $length bytes from the object and return
+     *     them. Fewer than $length bytes may be returned if underlying stream
+     *     call returns fewer bytes.
+     * @return string Returns the data read from the stream, or an empty string
+     *     if no bytes are available.
+     * @throws \RuntimeException if an error occurs.
+     */
+    public function read($length);
+
+    /**
+     * Returns the remaining contents in a string
+     *
+     * @return string
+     * @throws \RuntimeException if unable to read or an error occurs while
+     *     reading.
+     */
+    public function getContents();
+
+    /**
+     * Get stream metadata as an associative array or retrieve a specific key.
+     *
+     * The keys returned are identical to the keys returned from PHP's
+     * stream_get_meta_data() function.
+     *
+     * @link http://php.net/manual/en/function.stream-get-meta-data.php
+     * @param string $key Specific metadata to retrieve.
+     * @return array|mixed|null Returns an associative array if no key is
+     *     provided. Returns a specific key value if a key is provided and the
+     *     value is found, or null if the key is not found.
+     */
+    public function getMetadata($key = null);
+}
diff --git a/library/vendor/Psr/Http/Message/UploadedFileInterface.php b/library/vendor/Psr/Http/Message/UploadedFileInterface.php
new file mode 100644
index 0000000..5ad288d
--- /dev/null
+++ b/library/vendor/Psr/Http/Message/UploadedFileInterface.php
@@ -0,0 +1,123 @@
+<?php
+
+namespace Psr\Http\Message;
+
+/**
+ * Value object representing a file uploaded through an HTTP request.
+ *
+ * Instances of this interface are considered immutable; all methods that
+ * might change state MUST be implemented such that they retain the internal
+ * state of the current instance and return an instance that contains the
+ * changed state.
+ */
+interface UploadedFileInterface
+{
+    /**
+     * Retrieve a stream representing the uploaded file.
+     *
+     * This method MUST return a StreamInterface instance, representing the
+     * uploaded file. The purpose of this method is to allow utilizing native PHP
+     * stream functionality to manipulate the file upload, such as
+     * stream_copy_to_stream() (though the result will need to be decorated in a
+     * native PHP stream wrapper to work with such functions).
+     *
+     * If the moveTo() method has been called previously, this method MUST raise
+     * an exception.
+     *
+     * @return StreamInterface Stream representation of the uploaded file.
+     * @throws \RuntimeException in cases when no stream is available or can be
+     *     created.
+     */
+    public function getStream();
+
+    /**
+     * Move the uploaded file to a new location.
+     *
+     * Use this method as an alternative to move_uploaded_file(). This method is
+     * guaranteed to work in both SAPI and non-SAPI environments.
+     * Implementations must determine which environment they are in, and use the
+     * appropriate method (move_uploaded_file(), rename(), or a stream
+     * operation) to perform the operation.
+     *
+     * $targetPath may be an absolute path, or a relative path. If it is a
+     * relative path, resolution should be the same as used by PHP's rename()
+     * function.
+     *
+     * The original file or stream MUST be removed on completion.
+     *
+     * If this method is called more than once, any subsequent calls MUST raise
+     * an exception.
+     *
+     * When used in an SAPI environment where $_FILES is populated, when writing
+     * files via moveTo(), is_uploaded_file() and move_uploaded_file() SHOULD be
+     * used to ensure permissions and upload status are verified correctly.
+     *
+     * If you wish to move to a stream, use getStream(), as SAPI operations
+     * cannot guarantee writing to stream destinations.
+     *
+     * @see http://php.net/is_uploaded_file
+     * @see http://php.net/move_uploaded_file
+     * @param string $targetPath Path to which to move the uploaded file.
+     * @throws \InvalidArgumentException if the $path specified is invalid.
+     * @throws \RuntimeException on any error during the move operation, or on
+     *     the second or subsequent call to the method.
+     */
+    public function moveTo($targetPath);
+    
+    /**
+     * Retrieve the file size.
+     *
+     * Implementations SHOULD return the value stored in the "size" key of
+     * the file in the $_FILES array if available, as PHP calculates this based
+     * on the actual size transmitted.
+     *
+     * @return int|null The file size in bytes or null if unknown.
+     */
+    public function getSize();
+    
+    /**
+     * Retrieve the error associated with the uploaded file.
+     *
+     * The return value MUST be one of PHP's UPLOAD_ERR_XXX constants.
+     *
+     * If the file was uploaded successfully, this method MUST return
+     * UPLOAD_ERR_OK.
+     *
+     * Implementations SHOULD return the value stored in the "error" key of
+     * the file in the $_FILES array.
+     *
+     * @see http://php.net/manual/en/features.file-upload.errors.php
+     * @return int One of PHP's UPLOAD_ERR_XXX constants.
+     */
+    public function getError();
+    
+    /**
+     * Retrieve the filename sent by the client.
+     *
+     * Do not trust the value returned by this method. A client could send
+     * a malicious filename with the intention to corrupt or hack your
+     * application.
+     *
+     * Implementations SHOULD return the value stored in the "name" key of
+     * the file in the $_FILES array.
+     *
+     * @return string|null The filename sent by the client or null if none
+     *     was provided.
+     */
+    public function getClientFilename();
+    
+    /**
+     * Retrieve the media type sent by the client.
+     *
+     * Do not trust the value returned by this method. A client could send
+     * a malicious media type with the intention to corrupt or hack your
+     * application.
+     *
+     * Implementations SHOULD return the value stored in the "type" key of
+     * the file in the $_FILES array.
+     *
+     * @return string|null The media type sent by the client or null if none
+     *     was provided.
+     */
+    public function getClientMediaType();
+}
diff --git a/library/vendor/Psr/Http/Message/UriInterface.php b/library/vendor/Psr/Http/Message/UriInterface.php
new file mode 100644
index 0000000..c51a64b
--- /dev/null
+++ b/library/vendor/Psr/Http/Message/UriInterface.php
@@ -0,0 +1,324 @@
+<?php
+
+namespace Psr\Http\Message;
+
+/**
+ * Value object representing a URI.
+ *
+ * This interface is meant to represent URIs according to RFC 3986 and to
+ * provide methods for most common operations. Additional functionality for
+ * working with URIs can be provided on top of the interface or externally.
+ * Its primary use is for HTTP requests, but may also be used in other
+ * contexts.
+ *
+ * Instances of this interface are considered immutable; all methods that
+ * might change state MUST be implemented such that they retain the internal
+ * state of the current instance and return an instance that contains the
+ * changed state.
+ *
+ * Typically the Host header will be also be present in the request message.
+ * For server-side requests, the scheme will typically be discoverable in the
+ * server parameters.
+ *
+ * @link http://tools.ietf.org/html/rfc3986 (the URI specification)
+ */
+interface UriInterface
+{
+    /**
+     * Retrieve the scheme component of the URI.
+     *
+     * If no scheme is present, this method MUST return an empty string.
+     *
+     * The value returned MUST be normalized to lowercase, per RFC 3986
+     * Section 3.1.
+     *
+     * The trailing ":" character is not part of the scheme and MUST NOT be
+     * added.
+     *
+     * @see https://tools.ietf.org/html/rfc3986#section-3.1
+     * @return string The URI scheme.
+     */
+    public function getScheme();
+
+    /**
+     * Retrieve the authority component of the URI.
+     *
+     * If no authority information is present, this method MUST return an empty
+     * string.
+     *
+     * The authority syntax of the URI is:
+     *
+     * <pre>
+     * [user-info@]host[:port]
+     * </pre>
+     *
+     * If the port component is not set or is the standard port for the current
+     * scheme, it SHOULD NOT be included.
+     *
+     * @see https://tools.ietf.org/html/rfc3986#section-3.2
+     * @return string The URI authority, in "[user-info@]host[:port]" format.
+     */
+    public function getAuthority();
+
+    /**
+     * Retrieve the user information component of the URI.
+     *
+     * If no user information is present, this method MUST return an empty
+     * string.
+     *
+     * If a user is present in the URI, this will return that value;
+     * additionally, if the password is also present, it will be appended to the
+     * user value, with a colon (":") separating the values.
+     *
+     * The trailing "@" character is not part of the user information and MUST
+     * NOT be added.
+     *
+     * @return string The URI user information, in "username[:password]" format.
+     */
+    public function getUserInfo();
+
+    /**
+     * Retrieve the host component of the URI.
+     *
+     * If no host is present, this method MUST return an empty string.
+     *
+     * The value returned MUST be normalized to lowercase, per RFC 3986
+     * Section 3.2.2.
+     *
+     * @see http://tools.ietf.org/html/rfc3986#section-3.2.2
+     * @return string The URI host.
+     */
+    public function getHost();
+
+    /**
+     * Retrieve the port component of the URI.
+     *
+     * If a port is present, and it is non-standard for the current scheme,
+     * this method MUST return it as an integer. If the port is the standard port
+     * used with the current scheme, this method SHOULD return null.
+     *
+     * If no port is present, and no scheme is present, this method MUST return
+     * a null value.
+     *
+     * If no port is present, but a scheme is present, this method MAY return
+     * the standard port for that scheme, but SHOULD return null.
+     *
+     * @return null|int The URI port.
+     */
+    public function getPort();
+
+    /**
+     * Retrieve the path component of the URI.
+     *
+     * The path can either be empty or absolute (starting with a slash) or
+     * rootless (not starting with a slash). Implementations MUST support all
+     * three syntaxes.
+     *
+     * Normally, the empty path "" and absolute path "/" are considered equal as
+     * defined in RFC 7230 Section 2.7.3. But this method MUST NOT automatically
+     * do this normalization because in contexts with a trimmed base path, e.g.
+     * the front controller, this difference becomes significant. It's the task
+     * of the user to handle both "" and "/".
+     *
+     * The value returned MUST be percent-encoded, but MUST NOT double-encode
+     * any characters. To determine what characters to encode, please refer to
+     * RFC 3986, Sections 2 and 3.3.
+     *
+     * As an example, if the value should include a slash ("/") not intended as
+     * delimiter between path segments, that value MUST be passed in encoded
+     * form (e.g., "%2F") to the instance.
+     *
+     * @see https://tools.ietf.org/html/rfc3986#section-2
+     * @see https://tools.ietf.org/html/rfc3986#section-3.3
+     * @return string The URI path.
+     */
+    public function getPath();
+
+    /**
+     * Retrieve the query string of the URI.
+     *
+     * If no query string is present, this method MUST return an empty string.
+     *
+     * The leading "?" character is not part of the query and MUST NOT be
+     * added.
+     *
+     * The value returned MUST be percent-encoded, but MUST NOT double-encode
+     * any characters. To determine what characters to encode, please refer to
+     * RFC 3986, Sections 2 and 3.4.
+     *
+     * As an example, if a value in a key/value pair of the query string should
+     * include an ampersand ("&") not intended as a delimiter between values,
+     * that value MUST be passed in encoded form (e.g., "%26") to the instance.
+     *
+     * @see https://tools.ietf.org/html/rfc3986#section-2
+     * @see https://tools.ietf.org/html/rfc3986#section-3.4
+     * @return string The URI query string.
+     */
+    public function getQuery();
+
+    /**
+     * Retrieve the fragment component of the URI.
+     *
+     * If no fragment is present, this method MUST return an empty string.
+     *
+     * The leading "#" character is not part of the fragment and MUST NOT be
+     * added.
+     *
+     * The value returned MUST be percent-encoded, but MUST NOT double-encode
+     * any characters. To determine what characters to encode, please refer to
+     * RFC 3986, Sections 2 and 3.5.
+     *
+     * @see https://tools.ietf.org/html/rfc3986#section-2
+     * @see https://tools.ietf.org/html/rfc3986#section-3.5
+     * @return string The URI fragment.
+     */
+    public function getFragment();
+
+    /**
+     * Return an instance with the specified scheme.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified scheme.
+     *
+     * Implementations MUST support the schemes "http" and "https" case
+     * insensitively, and MAY accommodate other schemes if required.
+     *
+     * An empty scheme is equivalent to removing the scheme.
+     *
+     * @param string $scheme The scheme to use with the new instance.
+     * @return self A new instance with the specified scheme.
+     * @throws \InvalidArgumentException for invalid or unsupported schemes.
+     */
+    public function withScheme($scheme);
+
+    /**
+     * Return an instance with the specified user information.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified user information.
+     *
+     * Password is optional, but the user information MUST include the
+     * user; an empty string for the user is equivalent to removing user
+     * information.
+     *
+     * @param string $user The user name to use for authority.
+     * @param null|string $password The password associated with $user.
+     * @return self A new instance with the specified user information.
+     */
+    public function withUserInfo($user, $password = null);
+
+    /**
+     * Return an instance with the specified host.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified host.
+     *
+     * An empty host value is equivalent to removing the host.
+     *
+     * @param string $host The hostname to use with the new instance.
+     * @return self A new instance with the specified host.
+     * @throws \InvalidArgumentException for invalid hostnames.
+     */
+    public function withHost($host);
+
+    /**
+     * Return an instance with the specified port.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified port.
+     *
+     * Implementations MUST raise an exception for ports outside the
+     * established TCP and UDP port ranges.
+     *
+     * A null value provided for the port is equivalent to removing the port
+     * information.
+     *
+     * @param null|int $port The port to use with the new instance; a null value
+     *     removes the port information.
+     * @return self A new instance with the specified port.
+     * @throws \InvalidArgumentException for invalid ports.
+     */
+    public function withPort($port);
+
+    /**
+     * Return an instance with the specified path.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified path.
+     *
+     * The path can either be empty or absolute (starting with a slash) or
+     * rootless (not starting with a slash). Implementations MUST support all
+     * three syntaxes.
+     *
+     * If the path is intended to be domain-relative rather than path relative then
+     * it must begin with a slash ("/"). Paths not starting with a slash ("/")
+     * are assumed to be relative to some base path known to the application or
+     * consumer.
+     *
+     * Users can provide both encoded and decoded path characters.
+     * Implementations ensure the correct encoding as outlined in getPath().
+     *
+     * @param string $path The path to use with the new instance.
+     * @return self A new instance with the specified path.
+     * @throws \InvalidArgumentException for invalid paths.
+     */
+    public function withPath($path);
+
+    /**
+     * Return an instance with the specified query string.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified query string.
+     *
+     * Users can provide both encoded and decoded query characters.
+     * Implementations ensure the correct encoding as outlined in getQuery().
+     *
+     * An empty query string value is equivalent to removing the query string.
+     *
+     * @param string $query The query string to use with the new instance.
+     * @return self A new instance with the specified query string.
+     * @throws \InvalidArgumentException for invalid query strings.
+     */
+    public function withQuery($query);
+
+    /**
+     * Return an instance with the specified URI fragment.
+     *
+     * This method MUST retain the state of the current instance, and return
+     * an instance that contains the specified URI fragment.
+     *
+     * Users can provide both encoded and decoded fragment characters.
+     * Implementations ensure the correct encoding as outlined in getFragment().
+     *
+     * An empty fragment value is equivalent to removing the fragment.
+     *
+     * @param string $fragment The fragment to use with the new instance.
+     * @return self A new instance with the specified fragment.
+     */
+    public function withFragment($fragment);
+
+    /**
+     * Return the string representation as a URI reference.
+     *
+     * Depending on which components of the URI are present, the resulting
+     * string is either a full URI or relative reference according to RFC 3986,
+     * Section 4.1. The method concatenates the various components of the URI,
+     * using the appropriate delimiters:
+     *
+     * - If a scheme is present, it MUST be suffixed by ":".
+     * - If an authority is present, it MUST be prefixed by "//".
+     * - The path can be concatenated without delimiters. But there are two
+     *   cases where the path has to be adjusted to make the URI reference
+     *   valid as PHP does not allow to throw an exception in __toString():
+     *     - If the path is rootless and an authority is present, the path MUST
+     *       be prefixed by "/".
+     *     - If the path is starting with more than one "/" and no authority is
+     *       present, the starting slashes MUST be reduced to one.
+     * - If a query is present, it MUST be prefixed by "?".
+     * - If a fragment is present, it MUST be prefixed by "#".
+     *
+     * @see http://tools.ietf.org/html/rfc3986#section-4.1
+     * @return string
+     */
+    public function __toString();
+}
diff --git a/library/vendor/Psr/LICENSE b/library/vendor/Psr/LICENSE
new file mode 100644
index 0000000..c2d8e45
--- /dev/null
+++ b/library/vendor/Psr/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2014 PHP Framework Interoperability Group
+
+Permission is hereby granted, free of charge, to any person obtaining a copy 
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights 
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in 
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/library/vendor/Psr/Loader.php b/library/vendor/Psr/Loader.php
new file mode 100644
index 0000000..45c78af
--- /dev/null
+++ b/library/vendor/Psr/Loader.php
@@ -0,0 +1,21 @@
+<?php
+/* Icinga Web 2 Elasticsearch Module (c) 2017 Icinga Development Team | GPLv2+ */
+
+spl_autoload_register(function ($class) {
+    $prefix = 'Psr\\';
+    $len = strlen($prefix);
+
+    $baseDir = __DIR__ . '/';
+
+    if (strncmp($prefix, $class, $len) !== 0) {
+        return;
+    }
+
+    $relative = substr($class, $len);
+
+    $file = $baseDir . str_replace('\\', '/', $relative) . '.php';
+
+    if (file_exists($file)) {
+        require $file;
+    }
+});
diff --git a/library/vendor/iplx/Http/Client.php b/library/vendor/iplx/Http/Client.php
new file mode 100644
index 0000000..39d8905
--- /dev/null
+++ b/library/vendor/iplx/Http/Client.php
@@ -0,0 +1,199 @@
+<?php
+
+namespace iplx\Http;
+
+use RuntimeException;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * HTTP client that uses cURL
+ */
+class Client implements ClientInterface
+{
+    /**
+     * Client version
+     *
+     * @var string
+     */
+    const VERSION = '1.0.0';
+
+    /**
+     * Maximum number of internal cURL handles
+     *
+     * @var int
+     */
+    const MAX_HANDLES = 4;
+
+    /**
+     * Internal cURL handles
+     *
+     * @var array
+     */
+    protected $handles = [];
+
+    /**
+     * Return user agent
+     *
+     * @return  string
+     */
+    protected function getAgent()
+    {
+        $defaultAgent = 'ipl/' . self::VERSION;
+        $defaultAgent .= ' curl/' . curl_version()['version'];
+        $defaultAgent .= ' PHP/' . PHP_VERSION;
+
+        return $defaultAgent;
+    }
+
+    /**
+     * Create and return a cURL handle based on the given request
+     *
+     * @param   RequestInterface    $request
+     * @param   array               $options
+     *
+     * @return  Handle
+     *
+     * @throws  RuntimeException
+     */
+    protected function createHandle(RequestInterface $request, array $options)
+    {
+        $headers = [];
+        foreach ($request->getHeaders() as $name => $values) {
+            $headers[] = $name . ': ' . implode(', ', $values);
+        }
+
+        $curlOptions = [
+            CURLOPT_FOLLOWLOCATION  => true,
+            CURLOPT_FAILONERROR     => true,
+            CURLOPT_USERAGENT       => $this->getAgent()
+        ];
+
+        if (isset($options['curl'])) {
+            $curlOptions += $options['curl'];
+        }
+
+        $curlOptions += [
+            CURLOPT_CUSTOMREQUEST   => $request->getMethod(),
+            CURLOPT_HTTPHEADER      => $headers,
+            CURLOPT_RETURNTRANSFER  => false,
+            CURLOPT_URL             => (string) $request->getUri()->withFragment('')
+        ];
+
+        if (! $request->hasHeader('Accept')) {
+            $curlOptions[CURLOPT_HTTPHEADER][] = 'Accept:';
+        }
+
+        if (! $request->hasHeader('Content-Type')) {
+            $curlOptions[CURLOPT_HTTPHEADER][] = 'Content-Type:';
+        }
+
+        if (! $request->hasHeader('Expect')) {
+            $curlOptions[CURLOPT_HTTPHEADER][] = 'Expect:';
+        }
+
+        if ($request->getBody()->getSize() !== 0) {
+            $curlOptions[CURLOPT_UPLOAD] = true;
+
+            $body = $request->getBody();
+            if ($body->isSeekable()) {
+                $body->seek(0);
+            }
+
+            $curlOptions[CURLOPT_READFUNCTION] = function ($ch, $infile, $length) use ($body) {
+                return $body->read($length);
+            };
+        }
+
+        if ($request->getProtocolVersion()) {
+            $protocolVersion = null;
+            switch ($request->getProtocolVersion()) {
+                case '2.0':
+                    if (version_compare(phpversion(), '7.0.7', '<')) {
+                        throw new RuntimeException('You need at least PHP 7.0.7 to use HTTP 2.0');
+                    }
+                    $protocolVersion = CURL_HTTP_VERSION_2;
+                    break;
+                case '1.1':
+                    $protocolVersion = CURL_HTTP_VERSION_1_1;
+                    break;
+                default:
+                    $protocolVersion = CURL_HTTP_VERSION_1_0;
+            }
+
+            $curlOptions[CURLOPT_HTTP_VERSION] = $protocolVersion;
+        }
+
+        $handle = new Handle();
+
+        $curlOptions[CURLOPT_HEADERFUNCTION] = function($ch, $header) use ($handle) {
+            $size = strlen($header);
+
+            if (! trim($header) || strpos($header, 'HTTP/') === 0) {
+                return $size;
+            }
+
+            list($key, $value) = explode(': ', $header, 2);
+            $handle->responseHeaders[$key] = rtrim($value, "\r\n");
+
+            return $size;
+        };
+
+        $handle->responseBody = Stream::open();
+
+        $curlOptions[CURLOPT_WRITEFUNCTION] = function ($ch, $string) use ($handle) {
+            return $handle->responseBody->write($string);
+        };
+
+        $ch = ! empty($this->handles) ? array_pop($this->handles) : curl_init();
+
+        curl_setopt_array($ch, $curlOptions);
+
+        $handle->handle = $ch;
+
+        return $handle;
+    }
+
+    /**
+     * Execute a cURL handle and return the response
+     *
+     * @param   Handle  $handle
+     *
+     * @return  ResponseInterface
+     *
+     * @throws  RuntimeException
+     */
+    protected function executeHandle(Handle $handle)
+    {
+        $ch = $handle->handle;
+
+        $success = curl_exec($ch);
+
+        if ($success === false) {
+            throw new RuntimeException(curl_error($ch));
+        }
+
+        $response = new Response(
+            curl_getinfo($ch, CURLINFO_HTTP_CODE), $handle->responseHeaders, $handle->responseBody
+        );
+
+        if (count($this->handles) >= self::MAX_HANDLES) {
+            curl_close($ch);
+        } else {
+            curl_reset($ch);
+
+            $this->handles[] = $ch;
+        }
+
+        return $response;
+    }
+
+    public function send(RequestInterface $request, array $options = [])
+    {
+        $handle = $this->createHandle($request, $options);
+
+        $response = $this->executeHandle($handle);
+
+        return $response;
+    }
+}
diff --git a/library/vendor/iplx/Http/ClientInterface.php b/library/vendor/iplx/Http/ClientInterface.php
new file mode 100644
index 0000000..e7765a7
--- /dev/null
+++ b/library/vendor/iplx/Http/ClientInterface.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace iplx\Http;
+
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Interface for HTTP clients which send HTTP requests
+ */
+interface ClientInterface
+{
+    /**
+     * Send a HTTP request
+     *
+     * @param   RequestInterface    $request    Request to send
+     * @param   array               $options    Request options
+     *
+     * @return  ResponseInterface               The response
+     */
+    public function send(RequestInterface $request, array $options = []);
+}
diff --git a/library/vendor/iplx/Http/Handle.php b/library/vendor/iplx/Http/Handle.php
new file mode 100644
index 0000000..490b5c5
--- /dev/null
+++ b/library/vendor/iplx/Http/Handle.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace iplx\Http;
+
+use Psr\Http\Message\StreamInterface;
+
+/**
+ * Internal cURL handle representation
+ */
+class Handle
+{
+    /**
+     * cURL handle
+     *
+     * @var resource
+     */
+    public $handle;
+
+    /**
+     * Response body
+     *
+     * @var StreamInterface
+     */
+    public $responseBody;
+
+    /**
+     * Received response headers
+     *
+     * @var array
+     */
+    public $responseHeaders = [];
+}
diff --git a/library/vendor/iplx/Http/MessageTrait.php b/library/vendor/iplx/Http/MessageTrait.php
new file mode 100644
index 0000000..c8dc9b3
--- /dev/null
+++ b/library/vendor/iplx/Http/MessageTrait.php
@@ -0,0 +1,174 @@
+<?php
+
+namespace iplx\Http;
+
+use Psr\Http\Message\StreamInterface;
+
+trait MessageTrait
+{
+    /**
+     * Case sensitive header names with lowercase header names as keys
+     *
+     * @var array
+     */
+    protected $headerNames = [];
+
+    /**
+     * Header values with lowercase header names as keys
+     *
+     * @var array
+     */
+    protected $headerValues = [];
+
+    /**
+     * The body of this request
+     *
+     * @var StreamInterface
+     */
+    protected $body;
+
+    /**
+     * Protocol version
+     *
+     * @var string
+     */
+    protected $protocolVersion;
+
+    public function getProtocolVersion()
+    {
+        return $this->protocolVersion;
+    }
+
+    public function withProtocolVersion($version)
+    {
+        $message = clone $this;
+        $message->protocolVersion = $version;
+
+        return $message;
+    }
+
+    public function getHeaders()
+    {
+        return array_combine($this->headerNames, $this->headerValues);
+    }
+
+    public function hasHeader($header)
+    {
+        return isset($this->headerValues[strtolower($header)]);
+    }
+
+    public function getHeader($header)
+    {
+        $header = strtolower($header);
+
+        if (! isset($this->headerValues[$header])) {
+            return [];
+        }
+
+        return $this->headerValues[$header];
+    }
+
+    public function getHeaderLine($name)
+    {
+        $name = strtolower($name);
+
+        if (! isset($this->headerValues[$name])) {
+            return '';
+        }
+
+        return implode(', ', $this->headerValues[$name]);
+    }
+
+    public function withHeader($name, $value)
+    {
+        $name = rtrim($name);
+
+        $value = $this->normalizeHeaderValues($value);
+
+        $normalized = strtolower($name);
+
+        $message = clone $this;
+        $message->headerNames[$normalized] = $name;
+        $message->headerValues[$normalized] = $value;
+
+        return $message;
+    }
+
+    public function withAddedHeader($name, $value)
+    {
+        $name = rtrim($name);
+
+        $value = $this->normalizeHeaderValues($value);
+
+        $normalized = strtolower($name);
+
+        $message = clone $this;
+        if (isset($message->headerNames[$normalized])) {
+            $message->headerValues[$normalized] = array_merge($message->headerValues[$normalized], $value);
+        } else {
+            $message->headerNames[$normalized] = $name;
+            $message->headerValues[$normalized] = $value;
+        }
+
+        return $message;
+    }
+
+    public function withoutHeader($name)
+    {
+        $normalized = strtolower(rtrim($name));
+
+        $message = clone $this;
+        unset($message->headerNames[$normalized]);
+        unset($message->headerValues[$normalized]);
+
+        return $message;
+    }
+
+    public function getBody()
+    {
+        return $this->body;
+    }
+
+    public function withBody(StreamInterface $body)
+    {
+        $message = clone $this;
+        $message->body = $body;
+
+        return $message;
+    }
+
+    protected function setHeaders(array $headers)
+    {
+        // Prepare header field names and header field values according to
+        // https://tools.ietf.org/html/rfc7230#section-3.2.4
+        $names = array_map('rtrim', array_keys($headers));
+        $values = $this->normalizeHeaderValues($headers);
+
+        $normalized = array_map('strtolower', $names);
+
+        $this->headerNames = array_combine(
+            $normalized,
+            $names
+        );
+
+        $this->headerValues = array_combine(
+            $normalized,
+            $values
+        );
+    }
+
+    protected function normalizeHeaderValues(array $values)
+    {
+        // Prepare header field names and header field values according to
+        // https://tools.ietf.org/html/rfc7230#section-3.2.4
+        return array_map(function ($value) {
+            if (! is_array($value)) {
+                $value = [$value];
+            }
+
+            return array_map(function ($value) {
+                return trim($value, " \t");
+            }, $value);
+        }, $values);
+    }
+}
diff --git a/library/vendor/iplx/Http/Request.php b/library/vendor/iplx/Http/Request.php
new file mode 100644
index 0000000..b9fae7d
--- /dev/null
+++ b/library/vendor/iplx/Http/Request.php
@@ -0,0 +1,143 @@
+<?php
+
+namespace iplx\Http;
+
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\UriInterface;
+
+/**
+ * A HTTP request
+ */
+class Request implements RequestInterface
+{
+    use MessageTrait;
+
+    /**
+     * HTTP method of the request
+     *
+     * @var string
+     */
+    protected $method;
+
+    /**
+     * The request target
+     *
+     * @var string|null
+     */
+    protected $requestTarget;
+
+    /**
+     * URI of the request
+     *
+     * @var UriInterface
+     */
+    protected $uri;
+
+    /**
+     * Create a new HTTP request
+     *
+     * @param   string      $method             HTTP method
+     * @param   string      $uri                URI
+     * @param   array       $headers            Request headers
+     * @param   string      $body               Request body
+     * @param   string      $protocolVersion    Protocol version
+     */
+    public function __construct($method, $uri, array $headers = [], $body = null, $protocolVersion = '1.1')
+    {
+        $this->method = $method;
+        $this->uri = new Uri($uri);
+        $this->setHeaders($headers);
+        $this->body = Stream::create($body);
+        $this->protocolVersion = $protocolVersion;
+
+        $this->provideHostHeader();
+    }
+
+    public function getRequestTarget()
+    {
+        if ($this->requestTarget !== null) {
+            return $this->requestTarget;
+        }
+
+        $requestTarget = $this->uri->getPath();
+
+        // Weak type checks to also check null
+
+        if ($requestTarget == '') {
+            $requestTarget = '/';
+        }
+
+        if ($this->uri->getQuery() != '') {
+            $requestTarget .= '?' . $this->uri->getQuery();
+        }
+
+        return $requestTarget;
+    }
+
+    public function withRequestTarget($requestTarget)
+    {
+        $request = clone $this;
+        $request->requestTarget = $requestTarget;
+
+        return $request;
+    }
+
+    public function getMethod()
+    {
+        return $this->method;
+    }
+
+    public function withMethod($method)
+    {
+        $request = clone $this;
+        $request->method = $method;
+
+        return $this;
+    }
+
+    public function getUri()
+    {
+        return $this->uri;
+    }
+
+    public function withUri(UriInterface $uri, $preserveHost = false)
+    {
+        $request = clone $this;
+        $request->uri = $uri;
+
+        if (! $preserveHost) {
+            $this->provideHostHeader(true);
+        }
+
+        return $this;
+    }
+
+    protected function provideHostHeader($force = false)
+    {
+        if ($this->hasHeader('host')) {
+            if (! $force) {
+                return;
+            }
+
+            $header = $this->headerNames['host'];
+        } else {
+            $header = 'Host';
+        }
+
+        $host = $this->uri->getHost();
+
+        // Weak type check to also check null
+        if ($host == '') {
+            $host = '';
+        } else {
+            $port = $this->uri->getPort();
+
+            if ($port !== null) {
+                $host .= ":$port";
+            }
+        }
+
+        $this->headerNames['host'] = $header;
+        $this->headerValues['host'] = [$host];
+    }
+}
diff --git a/library/vendor/iplx/Http/Response.php b/library/vendor/iplx/Http/Response.php
new file mode 100644
index 0000000..25448b1
--- /dev/null
+++ b/library/vendor/iplx/Http/Response.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace iplx\Http;
+
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * A HTTP response
+ */
+class Response implements ResponseInterface
+{
+    use MessageTrait;
+
+    /**
+     * Status code of the response
+     *
+     * @var int
+     */
+    protected $statusCode;
+
+    /**
+     * Response status reason phrase
+     *
+     * @var string
+     */
+    protected $reasonPhrase = '';
+
+    /**
+     * Create a new HTTP response
+     *
+     * @param   int     $statusCode         Response status code
+     * @param   array   $headers            Response headers
+     * @param   string  $body               Response body
+     * @param   string  $protocolVersion    Protocol version
+     * @param   string  $reasonPhrase       Response status reason phrase
+     */
+    public function __construct($statusCode = 200, array $headers = [], $body = null, $protocolVersion = '1.1', $reasonPhrase = '')
+    {
+        $this->statusCode = $statusCode;
+        $this->setHeaders($headers);
+        $this->body = Stream::create($body);
+        $this->protocolVersion = $protocolVersion;
+        $this->reasonPhrase = $reasonPhrase;
+    }
+
+    public function getStatusCode()
+    {
+        return $this->statusCode;
+    }
+
+    public function withStatus($code, $reasonPhrase = '')
+    {
+        $response = clone $this;
+        $response->statusCode = $code;
+        $response->reasonPhrase = $reasonPhrase;
+
+        return $response;
+    }
+
+    public function getReasonPhrase()
+    {
+        return $this->reasonPhrase;
+    }
+}
diff --git a/library/vendor/iplx/Http/Stream.php b/library/vendor/iplx/Http/Stream.php
new file mode 100644
index 0000000..a113312
--- /dev/null
+++ b/library/vendor/iplx/Http/Stream.php
@@ -0,0 +1,283 @@
+<?php
+
+namespace iplx\Http;
+
+use Exception;
+use InvalidArgumentException;
+use RuntimeException;
+use Psr\Http\Message\StreamInterface;
+
+class Stream implements StreamInterface
+{
+    protected $stream;
+
+    protected $size;
+
+    protected $seekable;
+
+    protected $readable;
+
+    protected $writable;
+
+    public function __construct($stream)
+    {
+        if (! is_resource($stream)) {
+            throw new InvalidArgumentException('Invalid stream resource');
+        }
+
+        $this->stream = $stream;
+
+        $meta = stream_get_meta_data($this->stream);
+        $this->seekable = $meta['seekable'];
+        $this->readable = preg_match('/[r+]/', $meta['mode']) === 1;
+        $this->writable = preg_match('/[waxc+]/', $meta['mode']) === 1;
+    }
+
+    public function __destruct()
+    {
+        $this->close();
+    }
+
+    public function __toString()
+    {
+        try {
+            $this->seek(0);
+            $contents = stream_get_contents($this->stream);
+        } catch (Exception $e) {
+            $contents = '';
+        }
+
+        return $contents;
+    }
+
+    public function close()
+    {
+        if (isset($this->stream)) {
+            if (is_resource($this->stream)) {
+                fclose($this->stream);
+            }
+            $this->detach();
+        }
+    }
+
+    public function detach()
+    {
+        if (! isset($this->stream)) {
+            return null;
+        }
+
+        $stream = $this->stream;
+
+        $this->stream = null;
+        $this->size = null;
+        $this->seekable = false;
+        $this->readable = false;
+        $this->writable = false;
+
+        return $stream;
+    }
+
+    public function getSize()
+    {
+        if ($this->size !== null) {
+            return $this->size;
+        }
+
+        if (! isset($this->stream)) {
+            return null;
+        }
+
+        $stats = fstat($this->stream);
+        $this->size = $stats['size'];
+
+        return $this->size;
+    }
+
+    public function tell()
+    {
+        $this->assertAttached();
+
+        $position = ftell($this->stream);
+
+        if ($position === false) {
+            throw new RuntimeException('Unable to determine stream position');
+        }
+
+        return $position;
+    }
+
+    public function eof()
+    {
+        $this->assertAttached();
+
+        return feof($this->stream);
+    }
+
+    public function isSeekable()
+    {
+        return $this->seekable;
+    }
+
+    public function seek($offset, $whence = SEEK_SET)
+    {
+        $this->assertSeekable();
+
+        if (fseek($this->stream, $offset, $whence) === -1) {
+            throw new RuntimeException('Unable to seek to stream position');
+        }
+    }
+
+    public function rewind()
+    {
+        $this->seek(0);
+    }
+
+    public function isWritable()
+    {
+        return $this->writable;
+    }
+
+    public function write($string)
+    {
+        $this->assertWritable();
+
+        $written = fwrite($this->stream, $string);
+
+        if ($written === false) {
+            throw new RuntimeException('Unable to write to stream');
+        }
+
+        return $written;
+    }
+
+    public function isReadable()
+    {
+        return $this->readable;
+    }
+
+    public function read($length)
+    {
+        $this->assertReadable();
+
+        $data = fread($this->stream, $length);
+
+        if ($data === false) {
+            throw new RuntimeException('Unable to read from stream');
+        }
+
+        return $data;
+    }
+
+    public function getContents()
+    {
+        $this->assertReadable();
+
+        $contents = stream_get_contents($this->stream);
+
+        if ($contents === false) {
+            throw new RuntimeException('Unable to read stream contents');
+        }
+
+        return $contents;
+    }
+
+    public function getMetadata($key = null)
+    {
+        if (! isset($this->stream)) {
+            return $key === null ? [] : null;
+        }
+
+        $meta = stream_get_meta_data($this->stream);
+
+        if ($key === null) {
+            return $meta;
+        }
+
+        if (isset($meta[$key])) {
+            return $meta[$key];
+        }
+
+        return null;
+    }
+
+    public function assertAttached()
+    {
+        if (! isset($this->stream)) {
+            throw new RuntimeException('Stream is detached');
+        }
+    }
+
+    public function assertSeekable()
+    {
+        $this->assertAttached();
+
+        if (! $this->isSeekable()) {
+            throw new RuntimeException('Stream is not seekable');
+        }
+    }
+
+    public function assertReadable()
+    {
+        $this->assertAttached();
+
+        if (! $this->isReadable()) {
+            throw new RuntimeException('Stream is not readable');
+        }
+    }
+
+    public function assertWritable()
+    {
+        $this->assertAttached();
+
+        if (! $this->isWritable()) {
+            throw new RuntimeException('Stream is not writable');
+        }
+    }
+
+    /**
+     * Open a stream
+     *
+     * @param   string  $filename
+     * @param   string  $mode
+     *
+     * @return  static
+     */
+    public static function open($filename = 'php://temp', $mode = 'r+')
+    {
+        $stream = fopen($filename, $mode);
+
+        return new static($stream);
+    }
+
+    /**
+     * Create a stream
+     *
+     * @param   StreamInterface|string|resource $resource
+     *
+     * @return  StreamInterface
+     */
+    public static function create($resource)
+    {
+        if ($resource instanceof StreamInterface) {
+            return $resource;
+        }
+
+        if (is_scalar($resource)) {
+            $stream = fopen('php://temp', 'r+');
+
+            if ($resource !== '') {
+                fwrite($stream, $resource);
+                fseek($stream, 0);
+            }
+
+            return new static($stream);
+        }
+
+        if (is_resource($resource)) {
+            return new static($resource);
+        }
+
+        return static::open();
+    }
+
+}
diff --git a/library/vendor/iplx/Http/Uri.php b/library/vendor/iplx/Http/Uri.php
new file mode 100644
index 0000000..044fb17
--- /dev/null
+++ b/library/vendor/iplx/Http/Uri.php
@@ -0,0 +1,202 @@
+<?php
+
+namespace iplx\Http;
+
+use InvalidArgumentException;
+use Psr\Http\Message\UriInterface;
+
+class Uri implements UriInterface
+{
+    protected $scheme;
+
+    protected $host;
+
+    protected $port;
+
+    protected $user;
+
+    protected $pass;
+
+    protected $path;
+
+    protected $query;
+
+    protected $fragment;
+
+    public function __construct($uri = null)
+    {
+        $parts = parse_url($uri);
+
+        if ($parts === false) {
+            throw new InvalidArgumentException();
+        }
+
+        foreach ($parts as $component => $value) {
+            $this->$component = $value;
+        }
+    }
+
+    public function getScheme()
+    {
+        return $this->scheme;
+    }
+
+    public function getAuthority()
+    {
+        // Weak type check to also check null
+        if ($this->host == '') {
+            return '';
+        }
+
+        $authority = $this->host;
+
+        $userInfo = $this->getUserInfo();
+        $port = $this->getPort();
+
+        if ($userInfo) {
+            $authority = "$userInfo@$authority";
+        }
+
+        if ($port !== null) {
+            $authority .= ":$port";
+        }
+
+        return $authority;
+    }
+
+    public function getUserInfo()
+    {
+        $userInfo = $this->user;
+
+        if ($this->pass !== null) {
+            $userInfo .= ":{$this->pass}";
+        }
+
+        return $userInfo;
+    }
+
+    public function getHost()
+    {
+        return $this->host;
+    }
+
+    public function getPort()
+    {
+        return $this->port;
+    }
+
+    public function getPath()
+    {
+        return $this->path;
+    }
+
+    public function getQuery()
+    {
+        return $this->query;
+    }
+
+    public function getFragment()
+    {
+        return $this->fragment;
+    }
+
+    public function withScheme($scheme)
+    {
+        $uri = clone $this;
+        $uri->scheme = $scheme;
+
+        return $uri;
+    }
+
+    public function withUserInfo($user, $password = null)
+    {
+        $uri = clone $this;
+        $uri->user = $user;
+        $uri->pass = $password;
+
+        return $uri;
+    }
+
+    public function withHost($host)
+    {
+        $uri = clone $this;
+        $uri->host = $host;
+
+        return $uri;
+    }
+
+    public function withPort($port)
+    {
+        $uri = clone $this;
+        $uri->port = $port;
+
+        return $uri;
+    }
+
+    public function withPath($path)
+    {
+        $uri = clone $this;
+        $uri->path = $path;
+
+        return $uri;
+    }
+
+    public function withQuery($query)
+    {
+        $uri = clone $this;
+        $uri->query = $query;
+
+        return $uri;
+    }
+
+    public function withFragment($fragment)
+    {
+        $uri = clone $this;
+        $uri->fragment = $fragment;
+
+        return $uri;
+    }
+
+    public function __toString()
+    {
+        $scheme = $this->getScheme();
+        $authority = $this->getAuthority();
+        $path = $this->getPath();
+        $query = $this->getQuery();
+        $fragment = $this->getFragment();
+
+        $uri = '';
+
+        // Weak type checks to also check null
+
+        if ($scheme != '') {
+            $uri = "$scheme:";
+        }
+
+        if ($authority != '') {
+            $uri .= "//$authority";
+        }
+
+        if ($path != '') {
+            if ($path[0] === '/') {
+                if ($authority == '') {
+                    $path = ltrim($path, '/');
+                }
+            } else {
+                $path = "/$path";
+            }
+
+            $uri .= $path;
+        }
+
+        if ($query != '') {
+            $uri .= "?$query";
+        }
+
+        if ($fragment != '') {
+            $uri .= "#$fragment";
+        }
+
+        return $uri;
+    }
+}
diff --git a/library/vendor/iplx/LICENSE b/library/vendor/iplx/LICENSE
new file mode 100644
index 0000000..ecbc059
--- /dev/null
+++ b/library/vendor/iplx/LICENSE
@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
\ No newline at end of file
diff --git a/library/vendor/iplx/Loader.php b/library/vendor/iplx/Loader.php
new file mode 100644
index 0000000..5a6c9c0
--- /dev/null
+++ b/library/vendor/iplx/Loader.php
@@ -0,0 +1,20 @@
+<?php
+
+spl_autoload_register(function ($class) {
+    $prefix = 'iplx\\';
+    $len = strlen($prefix);
+
+    $baseDir = __DIR__ . '/';
+
+    if (strncmp($prefix, $class, $len) !== 0) {
+        return;
+    }
+
+    $relative = substr($class, $len);
+
+    $file = $baseDir . str_replace('\\', '/', $relative) . '.php';
+
+    if (file_exists($file)) {
+        require $file;
+    }
+});
diff --git a/library/vendor/iplx/README b/library/vendor/iplx/README
new file mode 100644
index 0000000..aa0b11e
--- /dev/null
+++ b/library/vendor/iplx/README
@@ -0,0 +1 @@
+Experimental version of the not released Icinga PHP Library (ipl). Do not use.