This is an automated email from the ASF dual-hosted git repository.
gancho pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/trafficserver.git
The following commit(s) were added to refs/heads/master by this push:
new 18e67bd Prefetch plugin
18e67bd is described below
commit 18e67bd9e9790543e2872741d48b61571ef5408c
Author: Gancho Tenev <gan...@apache.org>
AuthorDate: Sat Jun 30 00:48:24 2018 -0700
Prefetch plugin
The purpose of the plugin is to increase the cache-hit ratio
for a sequence of objects which URL paths follow a common pattern.
---
doc/admin-guide/plugins/index.en.rst | 1 +
doc/admin-guide/plugins/prefetch.en.rst | 278 ++++++++
.../images/admin/prefetch_plugin_deployment.png | Bin 0 -> 222757 bytes
plugins/Makefile.am | 1 +
plugins/experimental/prefetch/Makefile.inc | 28 +
plugins/experimental/prefetch/README.md | 8 +
plugins/experimental/prefetch/common.cc | 59 ++
plugins/experimental/prefetch/common.h | 68 ++
plugins/experimental/prefetch/configs.cc | 172 +++++
plugins/experimental/prefetch/configs.h | 202 ++++++
plugins/experimental/prefetch/fetch.cc | 739 ++++++++++++++++++++
plugins/experimental/prefetch/fetch.h | 202 ++++++
plugins/experimental/prefetch/fetch_policy.cc | 57 ++
plugins/experimental/prefetch/fetch_policy.h | 66 ++
plugins/experimental/prefetch/fetch_policy_lru.cc | 141 ++++
plugins/experimental/prefetch/fetch_policy_lru.h | 105 +++
.../experimental/prefetch/fetch_policy_simple.cc | 80 +++
.../experimental/prefetch/fetch_policy_simple.h | 46 ++
plugins/experimental/prefetch/headers.cc | 213 ++++++
plugins/experimental/prefetch/headers.h | 31 +
plugins/experimental/prefetch/pattern.cc | 463 +++++++++++++
plugins/experimental/prefetch/pattern.h | 92 +++
plugins/experimental/prefetch/plugin.cc | 751 +++++++++++++++++++++
23 files changed, 3803 insertions(+)
diff --git a/doc/admin-guide/plugins/index.en.rst
b/doc/admin-guide/plugins/index.en.rst
index 566eecf..2a37ea6 100644
--- a/doc/admin-guide/plugins/index.en.rst
+++ b/doc/admin-guide/plugins/index.en.rst
@@ -161,6 +161,7 @@ directory of the |TS| source tree. Experimental plugins can
be compiled by passi
Stale While Revalidate <stale_while_revalidate.en>
System Statistics <system_stats.en>
WebP Transform <webp_transform.en>
+ Prefetch <prefetch.en>
:doc:`Access Control <access_control.en>`
Access control plugin that handles various access control use-cases.
diff --git a/doc/admin-guide/plugins/prefetch.en.rst
b/doc/admin-guide/plugins/prefetch.en.rst
new file mode 100644
index 0000000..93a7e3c
--- /dev/null
+++ b/doc/admin-guide/plugins/prefetch.en.rst
@@ -0,0 +1,278 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+
+
+.. include:: ../../common.defs
+
+.. _admin-plugins-prefetch:
+
+
+Prefetch Plugin
+***************
+
+Description
+===========
+
+The purpose of the plugin is to increase the cache-hit ratio for a sequence of
+objects which URL paths follow a common pattern.
+
+On every **incoming** URL request, the plugin can decide to pre-fetch the
+**next object** or more objects based on the common URL path pattern and a
+pre-defined pre-fetch policy.
+
+Currently, most HLS video urls follow a predictable pattern, with most URLs
+containing a segment number. Since the segments are ~10s of content, the normal
+usage pattern is to fetch the incremental segment every few seconds. The CDN
+has its best chance of delivering a good user experience if the requests are
+served from cache. Since we can predict the **next object** fetched, we should
be
+able to dramatically increase the chance of it being a cache hit.
+
+This is primarily useful for:
+
+* less popular content. Popular movies' segments are constantly being refreshed
+ in cache by user requests. Less popular content is less likely to be in
cache.
+* device failures. There can be a significant time gap between a seeding
request
+ and the user request. During this time, devices can fail, which cause cache
+ misses. The time gap between the plugin's request and the user's request can
be
+ used to smooth over the failures.
+
+
+Why do this? Isn't seeding sufficient?
+--------------------------------------
+
+In practice the cache hit rate for the user facing HLS video content is never
perfect 100%.
+This plugin should increase the cache hit rate.
+
+* The caches will eventually wrap. The unpopular content/tiers will be evicted,
+ and not repopulated.
+* Disks fail. Content on these disk will become cache misses at least at that
layer.
+* Machines fail.
+ * Content seeded on those machines will become misses
+ * Content seeded while a machine is down will be seeded to the "wrong"
machine
+* Bugs.
+ * The content is usually managed by another organization which could have
+ * issues determining all the content (especially international)
+ * issues getting every asset on the storage service (i.e. AWS S3)
+ * issues sending us the assets in time
+ * ATS has had 5xx errors preventing seeding of assets
+* The process of seeding sometimes wastes significantly more resources then
the normal usage.
+
+
+How well it works
+-----------------
+
+The Prefetch plugin was initially designed to assist the seeding performed by
a separate subsystem / process which suffered the problems mentioned above.
+
+The initial Prefetch plugin deployment graph below shows the per-POP
cache-hit-ratio before and after its full deployment.
+It is worth mentioning that a small percentage of the requests did not follow
a predictable pattern and were not handled by the plugin.
+
+.. figure:: ../../static/images/admin/prefetch_plugin_deployment.png
+ :align: center
+ :alt: prefetch plugin initial deployment
+
+ Prefetch plugin initial deployment.
+
+* All POPs were seeded periodically except for POP #1 and the plugin was
deployed in the following order: POP #0, #1, #2, #3 and then to the rest at
once.
+* POP #0 was the first plugin deployment and was used to tune its
configuration for better results.
+* POP #1 was a "testing ground" for the “worst case” (no seeding at all,
imperfect conditions like low traffic and poorer connectivity to origin) and
relying only on the Prefetch plugin.
+* POP #2 and POP #3 experienced seeding problems (at times it reached ~60%,
not shown here).
+
+
+How does it work?
+-----------------
+
+The primary use-case for the plugin is to work in a multi-tier (child-parent)
+environment where a consistent hashing of the URI is used to choose the next
+tier parent but a single-tier use case is also supported (should work w/o
+any code changes).
+
+When a request comes to the child (only), the url is checked in an LRU. If the
+object exists in the LRU, we assume that we've pre-fetched the following object
+recently, and thus do not need to take any further action. If, however, the
+object is **not** found, we proceed with prefetching.
+
+The plugin calculates the URI of the next segment, ATS performs the consistent
+hash calculation on it to find the appropriate parent, and sends that parent
+a request for it, including a special header. When the parent receives the
+request, it will either find it in cache or begin the fetch from its next tier.
+Since the request from the child has the special header, the parent will only
+send the headers of the object back to the client, saving network and
processing
+bytes. The child thus does not cache the pre-fetched object which is ok since
+the user may not hit that same child for the subsquent object.
+
+Then, when the user makes their next request for the pre-fetched object, the
+child that handles the request will perform the consistent-hash, find the
+same parent that got the pre-fetch request, and be served from its cache.
+
+Usage
+-----
+
+* Dual-tiered usage - the plugin runs in 2 modes (2 instances)
+ * the **front-tier** instance decides if the "next" object needs
prefetching
+ based on the pre-fetch policy and only sends a signal to the
**back-tier**
+ * the **back-tier** instance responds quickly w/o returning any objects to
+ the **front-tier** and actually performs the background fetch.
+* Single-tier usage - the plugin runs on the first user facing tier.
+
+
+How the "next" object path is calculated
+----------------------------------------
+
+* The cache key of an incoming URL is checked against the fetching policy
defined by ``--fetch-policy``.
+* If the **next object** is to be pre-fetched the
``--fetch-path-pattern=/regex/capture/`` is used to transform the **incoming**
URL path into the **next**
+* The number of prefetched objects is specified by ``—fetch-count``
+* The hostname of the prefetch request can be replaced by using
``--replace-host``
+
+Let say we have the following setup ::
+
+ map http://example.com http://origin.com \
+ @plugin=cachekey.so @pparam=--remove-all-params=true \
+ @plugin=prefetch.so \
+ @pparam=--fetch-policy=simple \
+ @pparam=--fetch-path-pattern=/(.*-)(\d+)(.*)/$1{$2+2}$3/ \
+ @pparam=--fetch-count=3 \
+ @pparam=--replace-host=example-seed.com
+
+
+If the "incoming" URL is ::
+
+ http://example.com/path/file-104.mov?a=a&b=b
+
+
+the the following URLs will be requested to be prefetched ::
+
+ http://example-seed.com/path/file-106.mov?a=a&b=b
+ http://example-seed.com/path/file-108.mov?a=a&b=b
+ http://example-seed.com/path/file-110.mov?a=a&b=b
+
+
+Note ``--fetch-path-pattern`` is a PCRE regex/capture pattern and
+``{$2+2}`` is a mechanism to calculate the next path by adding or
+subtracting integer numbers.
+
+
+Overhead from **next object** prefetch
+--------------------------------------
+
+Consuming extra resources
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The plugin uses more CDN resources to improve the user experience. The plugin
+attempts to minimize the extraneous resources used.
+
+* The prefetch policy (LRU) attempts to minimize the URLs fetched. The popular
video segments
+ (which represent the majority of the requests) will quickly populate the LRU,
+ preventing their pre-fetching.
+* If the original request is for the last segment in the video, the plugin will
+ make our system have a frivolous request to origin for the next non-existent
+ segment.
+* If the user stops watching the video, the plugin may (if not popular) make a
+ request for a single segment that goes un-requested.
+
+Minimizing **next object** prefetch overhead
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The current implementation relies on the following assumptions and egnineering
+compromises:
+
+* **First match the next object pattern** defined by ``--fetch-path-pattern``
+ plugin parameter, not matching requests are ignored (prefetch is never
triggered)
+* **Define a prefetch policy** which tries to suppress uneccessary **next
object**
+ prefetches for the most recently used requests which are assumed should be
already
+ in cache. Currently only ``lru:n`` policy is supported, it is using an
URI-hash LRU
+ cache which evicts the least recently used elements first. Every request's
**cache key**
+ is checked against it and if found the **next object** prefetch is
skipped/cancelled.
+ (**side note**: the ``lru:n`` **is not** the same as cache_promote plugin
`lru`,
+ the latter is rather a frequency divider for the most recently used URIs).
+* **Always use request's cache key** instead of request's URI and also **remove
+ the query parameters** from the key which guarantees that multiple different
+ requests which would result in using the same **cache key** are not
considered as
+ separate requests (which could bloat/dilute the LRU cache
+ if not normalized)
+* **Check if the the fetch request is unique**. A ``simple`` prefetching
policy is
+ always used to make sure prefetches for the same object (same cache key) are
+ never triggered simultaneously.
+* **Check if already cached**. Before triggering the prefetch request to the
+ next tier it is always checked if the **incoming** object is already cached,
+ assuming that if already cached there is a good change the **next
+ object** would be cached as well.
+* **Don't fetch the response body** and **never cache** at the **front-tier**.
+ The **front-tier** marks the prefetch request with a special API header
defined
+ by ``--api-header`` plugin parameter. When recieved the **back-tier**
responds
+ right away before actually fetching the object (without a body), it just
+ schedules the real prefetch at the **back-tier**. ``Cache-Control: no-store``
+ is used to make sure the prefetch request response is never cached at the
**front-tier**.
+ In such a way resources are saved (time, memory, CPU, bandwidth, etc) and
also
+ unnecessary caching at the **front-tier** is avoided (where currently
cache_promote
+ plugin is already being used to alleviate the load on the disks).
+* **Throttle the prefetch activity** - if necessary a limit can by imposed on
the
+ number of concurrent prefetch requests by using ``--fetch-max`` plugin
parameter.
+
+Plugin parameters
+=================
+
+* ``--front``
+ - ``true`` - configures the plugin run on the **front-tier**,
+ - ``false`` - to be run on the **back-tier**.
+* ``--api-header`` - the header used by the plugin internally, also used to
mark a prefetch request to the next tier in dual-tier usage.
+* ``--fetch-policy`` - fetch policy
+ - ``simple`` - this policy just makes sure there are no same concurrent
prefetches triggered (default and always used in combination with any other
policy)
+ - ``lru:n`` - this policy uses LRU to identify “hot” objects and triggers
prefetch if the object is not found. `n` is the size of the LRU
+* ``--fetch-count`` - how many objects to be prefetched.
+* ``--fetch-path-pattern`` - regex/capture pattern that would transform the
**incoming** into the **next object** path.
+* ``--fetch-max`` - maximum concurrent fetches allowed, this would allow to
throttle the prefetch activity if necessary
+* ``--replace-host`` - allows the prefetch requests to be forwarded to a
different host or remap rule (replaces the host in the prefetch request)
+* ``--name-space`` - by default all plugin instances used for all remap use a
single background fetch state, this parameter allows to specify a separate
state per remap rule of per group of remap rules.
+* ``--metrics-prefix`` - prefix for the metrics generated by the plugin.
+* ``--exact-match``
+ * if ``false`` (default) the fetch policy would use the **incoming** URL's
cache key to find out if the **next object** should be prefetched or not,
+ * if ``true`` the fetch policy would use the **next** URL's cache key that
to find out if the **next object** should be prefetched or not
+* ``--log-name`` - specifies a custom log name (if not specified a log is not
created)
+
+Metrics
+=======
+
+The plugin maintains the following metrics:
+
+* Prefetch request status related
+ * ``fetch.active`` - number of currently active prefetch requests (counter)
+ * ``fetch.completed``- number of succesfully completed prefetch requests
(counter)
+ * ``fetch.errors`` - number of failed prefetch requests (counter)
+ * ``fetch.timeouts`` - number of timed-out prefetch requests (counter)
+ * ``fetch.throttled`` - number of throttled prefetch requests (counter),
throttle limit defined by ``--fetch-max``
+ * ``fetch.total``- total number of prefetch requests (counter).
+* Fetch policy related:
+ * all **incoming** request URIs are first matched against the next object
pattern defined in ``--fetch-path-pattern``
+ * ``fetch.match.yes`` - number of requests matched the pattern
(counter), eligible for triggering prefetch request
+ * ``fetch.match.no`` - number of requests not matching the pattern
(counter), ignored by the plugin, will never trigger prefetch request
+ * prefetch policy related (i.e. ``--fetch-policy=lru:n``)
+ * ``fetch.policy.yes`` - number of times (counter) the policy allowed
scheduling of the prefetch request (for ``lru:n`` policy cachekey **was not**
found in the LRU)
+ * ``fetch.policy.no`` - number of times (counter) the policy
disallowed scheduling of the prefetch request (for ``lru:n`` policy cachekey
**was** found in the LRU)
+ * ``fetch.policy.maxsize`` - size of the prefetch policy (gauge, i.e
for ``lru:n`` policy the max size is ``n``)
+ * ``fetch.policy.size`` - current size of the prefetch policy (gauge,
i.e for ``lru:n`` policy the max size is a number <= ``n``)
+ * before sending any new prefetch request plugin makes sure the object is
not currently being prefetched (unique).
+ * ``fetch.unique.yes`` - number of unique requests (counter), for
which there are no current prefetch requests for the same object (cache key is
used for this check).
+ * ``fetch.unique.no`` - number of not unique request (counter), for
which there is currently prefetch running for the same object (cache key is
used for this check).
+ * before sending any new prefetch request plugin makes sure the object is
not already cached.
+ * ``fetch.already_cached`` - number of prefetch requests not sent
(cancelled) because the object was already in cache (likely no prefetch needed)
+
+The exact metric name is defined by the following plugin parameters:
+
+* ``—metrics-prefix=<sample-prefix>``
+* ``—name-space=<sample-name-space>``
+
+For instance the final ``fetch.active`` metric will be called
``<sample-prefix>.<sample-name-space>.fetch.active``
diff --git a/doc/static/images/admin/prefetch_plugin_deployment.png
b/doc/static/images/admin/prefetch_plugin_deployment.png
new file mode 100644
index 0000000..4b218de
Binary files /dev/null and
b/doc/static/images/admin/prefetch_plugin_deployment.png differ
diff --git a/plugins/Makefile.am b/plugins/Makefile.am
index b955a71..6115b21 100644
--- a/plugins/Makefile.am
+++ b/plugins/Makefile.am
@@ -83,6 +83,7 @@ include experimental/system_stats/Makefile.inc
include experimental/traffic_dump/Makefile.inc
include experimental/tls_bridge/Makefile.inc
include experimental/url_sig/Makefile.inc
+include experimental/prefetch/Makefile.inc
if BUILD_URI_SIGNING_PLUGIN
include experimental/uri_signing/Makefile.inc
diff --git a/plugins/experimental/prefetch/Makefile.inc
b/plugins/experimental/prefetch/Makefile.inc
new file mode 100644
index 0000000..566ba82
--- /dev/null
+++ b/plugins/experimental/prefetch/Makefile.inc
@@ -0,0 +1,28 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+pkglib_LTLIBRARIES += experimental/prefetch/prefetch.la
+experimental_prefetch_prefetch_la_SOURCES = \
+ experimental/prefetch/plugin.cc \
+ experimental/prefetch/common.cc \
+ experimental/prefetch/configs.cc \
+ experimental/prefetch/fetch.cc \
+ experimental/prefetch/headers.cc \
+ experimental/prefetch/pattern.cc \
+ experimental/prefetch/fetch_policy.cc \
+ experimental/prefetch/fetch_policy_simple.cc \
+ experimental/prefetch/fetch_policy_lru.cc
+
diff --git a/plugins/experimental/prefetch/README.md
b/plugins/experimental/prefetch/README.md
new file mode 100644
index 0000000..86e9b6a
--- /dev/null
+++ b/plugins/experimental/prefetch/README.md
@@ -0,0 +1,8 @@
+# Description
+
+The purpose of the plugin is to increase the cache-hit ratio for a sequence of
+objects which URL paths follow a common pattern.
+
+# Documentation
+Details and examples can be found in [prefetch plugin
documentation](../../doc/admin-guide/plugins/prefetch.en.rst).
+
diff --git a/plugins/experimental/prefetch/common.cc
b/plugins/experimental/prefetch/common.cc
new file mode 100644
index 0000000..fa2c9cf
--- /dev/null
+++ b/plugins/experimental/prefetch/common.cc
@@ -0,0 +1,59 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file common.cc
+ * @brief Common declarations and definitions.
+ * @see common.h
+ */
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "common.h"
+
+#ifdef PREFETCH_UNIT_TEST
+
+void
+PrintToStdErr(const char *fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ vfprintf(stderr, fmt, args);
+ va_end(args);
+}
+
+#endif /* PREFETCH_UNIT_TEST */
+
+size_t
+getValue(const String &str)
+{
+ char buffer[str.length() + 1];
+ strncpy(buffer, str.c_str(), str.length());
+ buffer[str.length()] = 0;
+ return static_cast<size_t>(strtoul(buffer, nullptr, 10));
+}
+
+size_t
+getValue(const char *str, size_t len)
+{
+ char buffer[len + 1];
+ strncpy(buffer, str, len);
+ buffer[len] = 0;
+ return static_cast<size_t>(strtoul(buffer, nullptr, 10));
+}
diff --git a/plugins/experimental/prefetch/common.h
b/plugins/experimental/prefetch/common.h
new file mode 100644
index 0000000..35bbab0
--- /dev/null
+++ b/plugins/experimental/prefetch/common.h
@@ -0,0 +1,68 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file common.h
+ * @brief Common declarations and definitions (header file).
+ */
+
+#pragma once
+
+#define PLUGIN_NAME "prefetch"
+
+#include <list>
+#include <set>
+#include <string>
+#include <vector>
+
+typedef std::string String;
+typedef std::set<std::string> StringSet;
+typedef std::list<std::string> StringList;
+typedef std::vector<std::string> StringVector;
+
+#ifdef PREFETCH_UNIT_TEST
+#include <assert.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#define PrefetchDebug(fmt, ...) PrintToStdErr("(%s) %s:%d:%s() " fmt "\n",
PLUGIN_NAME, __FILE__, __LINE__, __func__, ##__VA_ARGS__)
+#define PrefetchError(fmt, ...) PrintToStdErr("(%s) %s:%d:%s() " fmt "\n",
PLUGIN_NAME, __FILE__, __LINE__, __func__, ##__VA_ARGS__)
+void PrintToStdErr(const char *fmt, ...);
+#define PrefetchAssert assert
+
+#else /* PREFETCH_UNIT_TEST */
+
+#include "ts/ts.h"
+
+#define PrefetchDebug(fmt, ...)
\
+ do {
\
+ TSDebug(PLUGIN_NAME, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__,
##__VA_ARGS__); \
+ } while (0)
+
+#define PrefetchError(fmt, ...)
\
+ do {
\
+ TSError("(%s) " fmt, PLUGIN_NAME, ##__VA_ARGS__);
\
+ TSDebug(PLUGIN_NAME, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__,
##__VA_ARGS__); \
+ } while (0)
+
+#define PrefetchAssert TSAssert
+
+#endif /* PREFETCH_UNIT_TEST */
+
+size_t getValue(const String &str);
+size_t getValue(const char *str, size_t len);
diff --git a/plugins/experimental/prefetch/configs.cc
b/plugins/experimental/prefetch/configs.cc
new file mode 100644
index 0000000..721acd3
--- /dev/null
+++ b/plugins/experimental/prefetch/configs.cc
@@ -0,0 +1,172 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file configs.cc
+ * @brief Plugin configuration.
+ */
+
+#include <fstream> /* std::ifstream */
+#include <getopt.h> /* getopt_long() */
+#include <sstream> /* std::istringstream */
+#include <strings.h> /* strncasecmp() */
+
+#include "configs.h"
+
+template <typename ContainerType>
+static void
+commaSeparateString(ContainerType &c, const String &input)
+{
+ std::istringstream istr(input);
+ String token;
+
+ while (std::getline(istr, token, ',')) {
+ c.insert(c.end(), token);
+ }
+}
+
+static bool
+isTrue(const char *arg)
+{
+ return (0 == strncasecmp("true", arg, 4) || 0 == strncasecmp("1", arg, 1) ||
0 == strncasecmp("yes", arg, 3));
+}
+
+/**
+ * @brief initializes plugin configuration.
+ * @param argc number of plugin parameters
+ * @param argv plugin parameters
+ */
+bool
+PrefetchConfig::init(int argc, char *argv[])
+{
+ static const struct option longopt[] = {{const_cast<char *>("front"),
optional_argument, 0, 'f'},
+ {const_cast<char *>("api-header"),
optional_argument, 0, 'h'},
+ {const_cast<char *>("next-header"),
optional_argument, 0, 'n'},
+ {const_cast<char *>("fetch-policy"),
optional_argument, 0, 'p'},
+ {const_cast<char *>("fetch-count"),
optional_argument, 0, 'c'},
+ {const_cast<char
*>("fetch-path-pattern"), optional_argument, 0, 'e'},
+ {const_cast<char *>("fetch-max"),
optional_argument, 0, 'x'},
+ {const_cast<char *>("replace-host"),
optional_argument, 0, 'r'},
+ {const_cast<char *>("name-space"),
optional_argument, 0, 's'},
+ {const_cast<char
*>("metrics-prefix"), optional_argument, 0, 'm'},
+ {const_cast<char *>("exact-match"),
optional_argument, 0, 'y'},
+ {const_cast<char *>("log-name"),
optional_argument, 0, 'l'},
+ {0, 0, 0, 0}};
+
+ bool status = true;
+ optind = 0;
+
+ /* argv contains the "to" and "from" URLs. Skip the first so that the second
one poses as the program name. */
+ argc--;
+ argv++;
+
+ for (;;) {
+ int opt;
+ opt = getopt_long(argc, (char *const *)argv, "", longopt, nullptr);
+
+ if (opt == -1) {
+ break;
+ }
+
+ PrefetchDebug("processing %s", argv[optind - 1]);
+
+ switch (opt) {
+ case 'f': /* --front */
+ _front = ::isTrue(optarg);
+ break;
+
+ case 'h': /* --api-header */
+ setApiHeader(optarg);
+ break;
+
+ case 'n': /* --next-header */
+ setNextHeader(optarg);
+ break;
+
+ case 'p': /* --fetch-policy */
+ setFetchPolicy(optarg);
+ break;
+
+ case 'c': /* --fetch-count */
+ setFetchCount(optarg);
+ break;
+
+ case 'e': /* --fetch-path-pattern */ {
+ Pattern *pattern = new Pattern();
+ if (nullptr != pattern) {
+ if (pattern->init(optarg)) {
+ _nextPaths.add(pattern);
+ } else {
+ PrefetchError("failed to initialize next object pattern");
+ delete pattern;
+ }
+ }
+ } break;
+
+ case 'x': /* --fetch-max */
+ setFetchMax(optarg);
+ break;
+
+ case 'r': /* --replace-host */
+ setReplaceHost(optarg);
+ break;
+
+ case 's': /* --name-space */
+ setNameSpace(optarg);
+ break;
+
+ case 'm': /* --metrics-prefix */
+ setMetricsPrefix(optarg);
+ break;
+
+ case 'y': /* --exact-match */
+ _exactMatch = ::isTrue(optarg);
+ break;
+
+ case 'l': /* --log-name */
+ setLogName(optarg);
+ break;
+ }
+ }
+
+ status &= finalize();
+
+ return status;
+}
+
+/**
+ * @brief provides means for post-processing of the plugin parameters to
finalize the configuration or to "cache" some of the
+ * decisions for later use.
+ * @return true if successful, false if failure.
+ */
+bool
+PrefetchConfig::finalize()
+{
+ PrefetchDebug("front-end: %s", (_front ? "true" : "false"));
+ PrefetchDebug("exact match: %s", (_exactMatch ? "true" : "false"));
+ PrefetchDebug("API header name: %s", _apiHeader.c_str());
+ PrefetchDebug("next object header name: %s", _nextHeader.c_str());
+ PrefetchDebug("fetch policy parameters: %s", _fetchPolicy.c_str());
+ PrefetchDebug("fetch count: %d", _fetchCount);
+ PrefetchDebug("fetch concurrently max: %d", _fetchMax);
+ PrefetchDebug("replace host name: %s", _replaceHost.c_str());
+ PrefetchDebug("name space: %s", _namespace.c_str());
+ PrefetchDebug("log name: %s", _logName.c_str());
+
+ return true;
+}
diff --git a/plugins/experimental/prefetch/configs.h
b/plugins/experimental/prefetch/configs.h
new file mode 100644
index 0000000..2552c36
--- /dev/null
+++ b/plugins/experimental/prefetch/configs.h
@@ -0,0 +1,202 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file configs.h
+ * @brief Plugin configuration (header file).
+ */
+
+#pragma once
+
+#include <string>
+
+#include "common.h"
+#include "pattern.h"
+
+/**
+ * @brief Prefetch configuration instance
+ */
+class PrefetchConfig
+{
+public:
+ PrefetchConfig()
+ : _apiHeader("X-AppleCDN-Prefetch"),
+ _nextHeader("X-AppleCDN-Prefetch-Next"),
+ _replaceHost(),
+ _namespace("default"),
+ _metricsPrefix("prefetch.stats"),
+ _fetchCount(1),
+ _fetchMax(0),
+ _front(false),
+ _exactMatch(false)
+ {
+ }
+
+ /**
+ * @brief initializes plugin configuration.
+ * @param argc number of plugin parameters
+ * @param argv plugin parameters
+ */
+ bool init(int argc, char *argv[]);
+
+ void
+ setApiHeader(const char *optarg)
+ {
+ _apiHeader.assign(optarg);
+ }
+
+ const std::string &
+ getApiHeader() const
+ {
+ return _apiHeader;
+ }
+
+ void
+ setNextHeader(const char *optarg)
+ {
+ _nextHeader.assign(optarg);
+ }
+
+ const std::string &
+ getNextHeader() const
+ {
+ return _nextHeader;
+ }
+
+ void
+ setFetchPolicy(const char *optarg)
+ {
+ _fetchPolicy.assign(optarg);
+ }
+
+ const std::string &
+ getFetchPolicy() const
+ {
+ return _fetchPolicy;
+ }
+
+ void
+ setReplaceHost(const char *optarg)
+ {
+ _replaceHost.assign(optarg);
+ }
+
+ const std::string &
+ getReplaceHost() const
+ {
+ return _replaceHost;
+ }
+
+ bool
+ isFront() const
+ {
+ return _front;
+ }
+
+ bool
+ isExactMatch() const
+ {
+ return _exactMatch;
+ }
+
+ void
+ setFetchCount(const char *optarg)
+ {
+ _fetchCount = getValue(optarg);
+ }
+
+ unsigned
+ getFetchCount() const
+ {
+ return _fetchCount;
+ }
+
+ void
+ setFetchMax(const char *optarg)
+ {
+ _fetchMax = getValue(optarg);
+ }
+
+ unsigned
+ getFetchMax() const
+ {
+ return _fetchMax;
+ }
+
+ void
+ setNameSpace(const char *optarg)
+ {
+ _namespace.assign(optarg);
+ }
+
+ const String &
+ getNameSpace() const
+ {
+ return _namespace;
+ }
+
+ void
+ setMetricsPrefix(const char *optarg)
+ {
+ _metricsPrefix.assign(optarg);
+ }
+
+ const String &
+ getMetricsPrefix() const
+ {
+ return _metricsPrefix;
+ }
+
+ MultiPattern &
+ getNextPath()
+ {
+ return _nextPaths;
+ }
+
+ void
+ setLogName(const char *optarg)
+ {
+ _logName.assign(optarg);
+ }
+
+ const String &
+ getLogName() const
+ {
+ return _logName;
+ }
+
+ /**
+ * @brief provides means for post-processing of the plugin parameters to
finalize the configuration.
+ * @return true if successful, false if failure.
+ */
+ bool finalize();
+
+private:
+ std::string _apiHeader;
+ std::string _nextHeader;
+ std::string _fetchPolicy;
+ std::string _replaceHost;
+ std::string _namespace;
+ std::string _metricsPrefix;
+ std::string _logName;
+ unsigned _fetchCount;
+ unsigned _fetchMax;
+ bool _front;
+ bool _exactMatch;
+ MultiPattern _nextPaths;
+};
diff --git a/plugins/experimental/prefetch/fetch.cc
b/plugins/experimental/prefetch/fetch.cc
new file mode 100644
index 0000000..ca7daf0
--- /dev/null
+++ b/plugins/experimental/prefetch/fetch.cc
@@ -0,0 +1,739 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file bg_fetch.cpp
+ * @brief Background fetch related classes (header file).
+ */
+
+#include <arpa/inet.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <inttypes.h>
+
+#include "ts/ts.h" /* ATS API */
+#include "fetch.h"
+#include "headers.h"
+
+const char *
+getPrefetchMetricsNames(int metric)
+{
+ switch (metric) {
+ case FETCH_ACTIVE:
+ return "fetch.active";
+ break;
+ case FETCH_COMPLETED:
+ return "fetch.completed";
+ break;
+ case FETCH_ERRORS:
+ return "fetch.errors";
+ break;
+ case FETCH_TIMEOOUTS:
+ return "fetch.timeouts";
+ break;
+ case FETCH_THROTTLED:
+ return "fetch.throttled";
+ break;
+ case FETCH_ALREADY_CACHED:
+ return "fetch.already_cached";
+ break;
+ case FETCH_TOTAL:
+ return "fetch.total";
+ break;
+ case FETCH_UNIQUE_YES:
+ return "fetch.unique.yes";
+ break;
+ case FETCH_UNIQUE_NO:
+ return "fetch.unique.no";
+ break;
+ case FETCH_MATCH_YES:
+ return "fetch.match.yes";
+ break;
+ case FETCH_MATCH_NO:
+ return "fetch.match.no";
+ break;
+ case FETCH_POLICY_YES:
+ return "fetch.policy.yes";
+ break;
+ case FETCH_POLICY_NO:
+ return "fetch.policy.no";
+ break;
+ case FETCH_POLICY_SIZE:
+ return "fetch.policy.size";
+ break;
+ case FETCH_POLICY_MAXSIZE:
+ return "fetch.policy.maxsize";
+ break;
+ default:
+ return "unknown";
+ break;
+ }
+}
+
+static bool
+createStat(const String &prefix, const String &space, const char *module,
const char *statName, TSRecordDataType statType,
+ int &statId)
+{
+ String name(prefix);
+ name.append(".").append(space);
+ if (nullptr != module) {
+ name.append(".").append(module);
+ }
+ name.append(".").append(statName);
+
+ if (TSStatFindName(name.c_str(), &statId) == TS_ERROR) {
+ statId = TSStatCreate(name.c_str(), TS_RECORDDATATYPE_INT,
TS_STAT_NON_PERSISTENT, TS_STAT_SYNC_SUM);
+ if (statId == TS_ERROR) {
+ PrefetchError("failed to register '%s'", name.c_str());
+ return false;
+ }
+
+ TSStatIntSet(statId, 0);
+ }
+
+ PrefetchDebug("created metric '%s (id:%d)'", name.c_str(), statId);
+
+ return true;
+}
+
+BgFetchState::BgFetchState() : _policy(nullptr), _unique(nullptr),
_concurrentFetches(0), _concurrentFetchesMax(0), _log(nullptr)
+{
+ _policyLock = TSMutexCreate();
+ if (nullptr == _policyLock) {
+ PrefetchError("failed to initialize lock");
+ } else {
+ PrefetchDebug("initialized lock");
+ }
+
+ _lock = TSMutexCreate();
+ if (nullptr == _lock) {
+ PrefetchError("failed to initialize lock");
+ } else {
+ PrefetchDebug("initialized lock");
+ }
+}
+
+BgFetchState::~BgFetchState()
+{
+ TSMutexLock(_policyLock);
+ delete _policy;
+ TSMutexUnlock(_policyLock);
+
+ TSMutexLock(_lock);
+ delete _unique;
+ TSMutexUnlock(_lock);
+
+ TSMutexDestroy(_policyLock);
+ TSMutexDestroy(_lock);
+
+ TSTextLogObjectFlush(_log);
+ TSTextLogObjectDestroy(_log);
+}
+
+static bool
+initializePolicy(FetchPolicy *&policy, const char *policyName)
+{
+ bool status = true;
+ if (nullptr == policy) {
+ policy = FetchPolicy::getInstance(policyName);
+ if (nullptr == policy) {
+ PrefetchError("failed to initialize the %s policy", policyName);
+ status = false;
+ }
+ } else {
+ PrefetchDebug("state already initialized");
+ }
+ return status;
+}
+
+bool
+initializeMetrics(PrefetchMetricInfo metrics[], const PrefetchConfig &config)
+{
+ bool status = true;
+ for (int i = FETCH_ACTIVE; i < FETCHES_MAX_METRICS; i++) {
+ if (-1 == metrics[i].id) {
+ status = createStat(config.getMetricsPrefix(), config.getNameSpace(),
nullptr, getPrefetchMetricsNames(i), metrics[i].type,
+ metrics[i].id);
+ } else {
+ PrefetchDebug("metric %s already initialized",
getPrefetchMetricsNames(i));
+ }
+ }
+ return status;
+}
+
+bool
+initializeLog(TSTextLogObject &log, const PrefetchConfig &config)
+{
+ bool status = true;
+ if (!config.getLogName().empty()) {
+ if (nullptr == log) {
+ TSReturnCode error = TSTextLogObjectCreate(config.getLogName().c_str(),
TS_LOG_MODE_ADD_TIMESTAMP, &log);
+ if (error != TS_SUCCESS) {
+ PrefetchError("failed to create log file");
+ status = false;
+ } else {
+ PrefetchDebug("initialized log file '%s'",
config.getLogName().c_str());
+ }
+ } else {
+ PrefetchDebug("log file '%s' already initialized",
config.getLogName().c_str());
+ }
+ } else {
+ PrefetchDebug("skip creating log file");
+ }
+ return status;
+}
+
+bool
+BgFetchState::init(const PrefetchConfig &config)
+{
+ int status = true;
+
+ /* Is throttling configured, 0 - don't throttle */
+ _concurrentFetchesMax = config.getFetchMax();
+
+ /* Initialize the state */
+ TSMutexLock(_lock);
+
+ /* Initialize 'simple' policy used to avoid concurrent fetches of the same
object */
+ status &= initializePolicy(_unique, "simple");
+
+ /* Initialize the fetch metrics */
+ status &= initializeMetrics(_metrics, config);
+
+ /* Initialize the "pre-fetch" log */
+ status &= initializeLog(_log, config);
+
+ TSMutexUnlock(_lock);
+
+ /* Initialize fetching policy */
+ TSMutexLock(_policyLock);
+
+ if (!config.getFetchPolicy().empty() && 0 !=
config.getFetchPolicy().compare("simple")) {
+ status &= initializePolicy(_policy, config.getFetchPolicy().c_str());
+ if (nullptr != _policy) {
+ setMetric(FETCH_POLICY_MAXSIZE, _policy->getMaxSize());
+ }
+ } else {
+ PrefetchDebug("Policy not specified or 'simple' policy chosen (skipping)");
+ }
+
+ TSMutexUnlock(_policyLock);
+
+ return status;
+}
+
+bool
+BgFetchState::acquire(const String &url)
+{
+ bool permitted = true;
+ if (nullptr != _policy) {
+ TSMutexLock(_policyLock);
+ permitted = _policy->acquire(url);
+ TSMutexUnlock(_policyLock);
+ }
+
+ if (permitted) {
+ incrementMetric(FETCH_POLICY_YES);
+ } else {
+ incrementMetric(FETCH_POLICY_NO);
+ }
+
+ if (nullptr != _policy) {
+ setMetric(FETCH_POLICY_SIZE, _policy->getSize());
+ }
+
+ return permitted;
+}
+
+bool
+BgFetchState::release(const String &url)
+{
+ bool ret = true;
+ if (nullptr != _policy) {
+ TSMutexLock(_policyLock);
+ ret &= _policy->release(url);
+ TSMutexUnlock(_policyLock);
+ }
+
+ if (nullptr != _policy) {
+ setMetric(FETCH_POLICY_SIZE, _policy->getSize());
+ }
+
+ return ret;
+}
+
+bool
+BgFetchState::uniqueAcquire(const String &url)
+{
+ bool permitted = true;
+ bool throttled = false;
+ size_t cachedCounter = 0;
+
+ TSMutexLock(_lock);
+ if (0 == _concurrentFetchesMax || _concurrentFetches <
_concurrentFetchesMax) {
+ permitted = _unique->acquire(url);
+ if (permitted) {
+ cachedCounter = ++_concurrentFetches;
+ }
+ } else {
+ throttled = true;
+ }
+ TSMutexUnlock(_lock);
+
+ /* Update the metrics, no need to lock? */
+ if (throttled) {
+ incrementMetric(FETCH_THROTTLED);
+ }
+
+ if (permitted && !throttled) {
+ incrementMetric(FETCH_UNIQUE_YES);
+ incrementMetric(FETCH_TOTAL);
+ setMetric(FETCH_ACTIVE, cachedCounter);
+ } else {
+ incrementMetric(FETCH_UNIQUE_NO);
+ }
+
+ return permitted;
+}
+
+bool
+BgFetchState::uniqueRelease(const String &url)
+{
+ bool permitted = true;
+ ssize_t cachedCounter = 0;
+
+ TSMutexLock(_lock);
+ cachedCounter = --_concurrentFetches;
+ permitted = _unique->release(url);
+ TSMutexUnlock(_lock);
+
+ TSAssert(cachedCounter < 0);
+
+ /* Update the metrics, no need to lock? */
+ if (permitted) {
+ setMetric(FETCH_ACTIVE, cachedCounter);
+ }
+ return permitted;
+}
+
+void
+BgFetchState::incrementMetric(PrefetchMetric m)
+{
+ if (-1 != _metrics[m].id) {
+ TSStatIntIncrement(_metrics[m].id, 1);
+ }
+}
+
+void
+BgFetchState::setMetric(PrefetchMetric m, size_t value)
+{
+ if (-1 != _metrics[m].id) {
+ TSStatIntSet(_metrics[m].id, value);
+ }
+}
+
+inline TSTextLogObject
+BgFetchState::getLog()
+{
+ return _log;
+}
+BgFetchStates *BgFetchStates::_prefetchStates = nullptr;
+
+BgFetch::BgFetch(BgFetchState *state, const PrefetchConfig &config, bool lock)
+ : _headerLoc(TS_NULL_MLOC),
+ _urlLoc(TS_NULL_MLOC),
+ vc(nullptr),
+ req_io_buf(nullptr),
+ resp_io_buf(nullptr),
+ req_io_buf_reader(nullptr),
+ resp_io_buf_reader(nullptr),
+ r_vio(nullptr),
+ w_vio(nullptr),
+ _bytes(0),
+ _cont(nullptr),
+ _state(state),
+ _config(config),
+ _askPermission(lock),
+ _startTime(0)
+{
+ _mbuf = TSMBufferCreate();
+ memset(&client_ip, 0, sizeof(client_ip));
+}
+
+BgFetch::~BgFetch()
+{
+ TSHandleMLocRelease(_mbuf, TS_NULL_MLOC, _headerLoc);
+ TSHandleMLocRelease(_mbuf, TS_NULL_MLOC, _urlLoc);
+
+ TSMBufferDestroy(_mbuf);
+
+ if (vc) {
+ PrefetchError("Destroyed BgFetch while VC was alive");
+ TSVConnClose(vc);
+ vc = nullptr;
+ }
+
+ if (nullptr != _cont) {
+ if (_askPermission) {
+ _state->release(_cachekey);
+ _state->uniqueRelease(_cachekey);
+ }
+
+ TSContDestroy(_cont);
+ _cont = nullptr;
+
+ TSIOBufferReaderFree(req_io_buf_reader);
+ TSIOBufferDestroy(req_io_buf);
+ TSIOBufferReaderFree(resp_io_buf_reader);
+ TSIOBufferDestroy(resp_io_buf);
+ }
+}
+
+bool
+BgFetch::schedule(BgFetchState *state, const PrefetchConfig &config, bool
askPermission, TSMBuffer requestBuffer,
+ TSMLoc requestHeaderLoc, TSHttpTxn txnp, const char *path,
size_t pathLen, const String &cachekey)
+{
+ bool ret = false;
+ BgFetch *fetch = new BgFetch(state, config, askPermission);
+ if (fetch->init(requestBuffer, requestHeaderLoc, txnp, path, pathLen,
cachekey)) {
+ fetch->schedule();
+ ret = true;
+ } else {
+ delete fetch;
+ }
+ return ret;
+}
+
+bool
+BgFetch::saveIp(TSHttpTxn txnp)
+{
+ struct sockaddr const *ip = TSHttpTxnClientAddrGet(txnp);
+ if (ip) {
+ if (ip->sa_family == AF_INET) {
+ memcpy(&client_ip, ip, sizeof(sockaddr_in));
+ } else if (ip->sa_family == AF_INET6) {
+ memcpy(&client_ip, ip, sizeof(sockaddr_in6));
+ } else {
+ PrefetchError("unknown address family %d", ip->sa_family);
+ }
+ } else {
+ PrefetchError("failed to get client host info");
+ return false;
+ }
+ return true;
+}
+
+inline void
+BgFetch::addBytes(int64_t b)
+{
+ _bytes += b;
+}
+/**
+ * Initialize the background fetch
+ */
+bool
+BgFetch::init(TSMBuffer reqBuffer, TSMLoc reqHdrLoc, TSHttpTxn txnp, const
char *fetchPath, size_t fetchPathLen,
+ const String &cachekey)
+{
+ TSAssert(TS_NULL_MLOC == _headerLoc);
+ TSAssert(TS_NULL_MLOC == _urlLoc);
+
+ if (_askPermission) {
+ if (!_state->acquire(cachekey)) {
+ PrefetchDebug("request is not fetchable");
+ return false;
+ }
+
+ if (!_state->uniqueAcquire(cachekey)) {
+ PrefetchDebug("already fetching the object");
+ _state->release(cachekey);
+ return false;
+ }
+ }
+
+ _cachekey.assign(cachekey);
+
+ /* Save the IP info */
+ if (!saveIp(txnp)) {
+ return false;
+ }
+
+ /* Create HTTP header */
+ _headerLoc = TSHttpHdrCreate(_mbuf);
+
+ /* Copy the headers to the new marshal buffer */
+ if (TS_SUCCESS != TSHttpHdrCopy(_mbuf, _headerLoc, reqBuffer, reqHdrLoc)) {
+ PrefetchError("header copy failed");
+ }
+
+ /* Copy the pristine request URL into fetch marshal buffer */
+ TSMLoc pristineUrlLoc;
+ if (TS_SUCCESS == TSHttpTxnPristineUrlGet(txnp, &reqBuffer,
&pristineUrlLoc)) {
+ if (TS_SUCCESS != TSUrlClone(_mbuf, reqBuffer, pristineUrlLoc, &_urlLoc)) {
+ PrefetchError("failed to clone URL");
+ TSHandleMLocRelease(reqBuffer, TS_NULL_MLOC, pristineUrlLoc);
+ return false;
+ }
+ TSHandleMLocRelease(reqBuffer, TS_NULL_MLOC, pristineUrlLoc);
+ } else {
+ PrefetchError("failed to get pristine URL");
+ return false;
+ }
+
+ /* Save the path before changing */
+ int pathLen;
+ const char *path = TSUrlPathGet(_mbuf, _urlLoc, &pathLen);
+ if (nullptr == path) {
+ PrefetchError("failed to get a URL path");
+ return false;
+ }
+
+ /* Now set or remove the prefetch API header */
+ const String &header = _config.getApiHeader();
+ if (_config.isFront()) {
+ if (setHeader(_mbuf, _headerLoc, header.c_str(), (int)header.length(),
path, pathLen)) {
+ PrefetchDebug("set header '%.*s: %.*s'", (int)header.length(),
header.c_str(), (int)fetchPathLen, fetchPath);
+ }
+ } else {
+ if (removeHeader(_mbuf, _headerLoc, header.c_str(), header.length())) {
+ PrefetchDebug("remove header '%.*s'", (int)header.length(),
header.c_str());
+ }
+ }
+
+ /* Make sure we remove the RANGE header to avoid 416 "Request Range Not
Satisfiable" response when
+ * the current request is a RANGE request and its range turns out invalid
for the "next" object */
+ if (removeHeader(_mbuf, _headerLoc, TS_MIME_FIELD_RANGE, TS_MIME_LEN_RANGE))
{
+ PrefetchDebug("remove header '%.*s'", TS_MIME_LEN_RANGE,
TS_MIME_FIELD_RANGE);
+ }
+
+ /* Overwrite the path if required */
+ if (nullptr != fetchPath && 0 != fetchPathLen) {
+ if (TS_SUCCESS == TSUrlPathSet(_mbuf, _urlLoc, fetchPath, fetchPathLen)) {
+ PrefetchDebug("setting URL path to %.*s", (int)fetchPathLen, fetchPath);
+ } else {
+ PrefetchError("failed to set a URL path %.*s", (int)fetchPathLen,
fetchPath);
+ }
+ }
+
+ /* Come up with the host name to be used in the fetch request */
+ const char *hostName = nullptr;
+ int hostNameLen = 0;
+ if (_config.getReplaceHost().empty()) {
+ hostName = TSUrlHostGet(_mbuf, _urlLoc, &hostNameLen);
+ } else {
+ hostName = _config.getReplaceHost().c_str();
+ hostNameLen = _config.getReplaceHost().length();
+ }
+
+ /* Set the URI host */
+ if (TS_SUCCESS == TSUrlHostSet(_mbuf, _urlLoc, hostName, hostNameLen)) {
+ PrefetchDebug("setting URL host: %.*s", hostNameLen, hostName);
+ } else {
+ PrefetchError("failed to set URL host: %.*s", hostNameLen, hostName);
+ }
+
+ /* Set the host header */
+ if (setHeader(_mbuf, _headerLoc, TS_MIME_FIELD_HOST, TS_MIME_LEN_HOST,
hostName, hostNameLen)) {
+ PrefetchDebug("setting Host header: %.*s", hostNameLen, hostName);
+ } else {
+ PrefetchError("failed to set Host header: %.*s", hostNameLen, hostName);
+ }
+
+ /* Save the URL to be fetched with this fetch for debugging purposes,
expensive TSUrlStringGet()
+ * but really helpful when debugging multi-remap / host-replacement use
cases */
+ int urlLen = 0;
+ char *url = TSUrlStringGet(_mbuf, _urlLoc, &urlLen);
+ if (nullptr != url) {
+ _url.assign(url, urlLen);
+ TSfree(static_cast<void *>(url));
+ }
+
+ /* TODO: TBD is this the right place? */
+ if (TS_SUCCESS != TSHttpHdrUrlSet(_mbuf, _headerLoc, _urlLoc)) {
+ return false;
+ }
+
+ /* Initialization is success */
+ return true;
+}
+
+/**
+ * @brief Create, setup and schedule the background fetch continuation.
+ */
+void
+BgFetch::schedule()
+{
+ TSAssert(nullptr == _cont);
+
+ /* Setup the continuation */
+ _cont = TSContCreate(handler, TSMutexCreate());
+ TSContDataSet(_cont, static_cast<void *>(this));
+
+ /* Initialize the VIO (for the fetch) */
+ req_io_buf = TSIOBufferCreate();
+ req_io_buf_reader = TSIOBufferReaderAlloc(req_io_buf);
+ resp_io_buf = TSIOBufferCreate();
+ resp_io_buf_reader = TSIOBufferReaderAlloc(resp_io_buf);
+
+ /* Schedule */
+ PrefetchDebug("schedule fetch: %s", _url.c_str());
+ _startTime = TShrtime();
+ TSContSchedule(_cont, 0, TS_THREAD_POOL_NET);
+}
+
+/* Log format is: name-space bytes status url */
+void
+BgFetch::logAndMetricUpdate(TSEvent event) const
+{
+ const char *status;
+
+ switch (event) {
+ case TS_EVENT_VCONN_EOS:
+ status = "EOS";
+ _state->incrementMetric(FETCH_COMPLETED);
+ break;
+ case TS_EVENT_VCONN_INACTIVITY_TIMEOUT:
+ status = "TIMEOUT";
+ _state->incrementMetric(FETCH_TIMEOOUTS);
+ break;
+ case TS_EVENT_ERROR:
+ _state->incrementMetric(FETCH_ERRORS);
+ status = "ERROR";
+ break;
+ case TS_EVENT_VCONN_READ_COMPLETE:
+ _state->incrementMetric(FETCH_COMPLETED);
+ status = "READ_COMP";
+ break;
+ default:
+ status = "UNKNOWN";
+ break;
+ }
+
+ if (TSIsDebugTagSet(PLUGIN_NAME "_log")) {
+ TSHRTime now = TShrtime();
+ double elapsed = (double)(now - _startTime) / 1000000.0;
+
+ PrefetchDebug("ns=%s bytes=%" PRId64 " time=%1.3lf status=%s url=%s
key=%s", _config.getNameSpace().c_str(), _bytes, elapsed,
+ status, _url.c_str(), _cachekey.c_str());
+ if (_state->getLog()) {
+ TSTextLogObjectWrite(_state->getLog(), "ns=%s bytes=%" PRId64 "
time=%1.3lf status=%s url=%s key=%s",
+ _config.getNameSpace().c_str(), _bytes, elapsed,
status, _url.c_str(), _cachekey.c_str());
+ }
+ }
+}
+
+/**
+ * @brief Continuation to perform a background fill of a URL.
+ *
+ * This is pretty expensive (memory allocations etc.)
+ */
+int
+BgFetch::handler(TSCont contp, TSEvent event, void * /* edata ATS_UNUSED */)
+{
+ BgFetch *fetch = static_cast<BgFetch *>(TSContDataGet(contp));
+ int64_t avail;
+
+ PrefetchDebug("event: %s (%d)", TSHttpEventNameLookup(event), event);
+
+ switch (event) {
+ case TS_EVENT_IMMEDIATE:
+ case TS_EVENT_TIMEOUT:
+ // Debug info for this particular bg fetch (put all debug in here please)
+ if (TSIsDebugTagSet(PLUGIN_NAME)) {
+ char buf[INET6_ADDRSTRLEN];
+ const sockaddr *sockaddress = (const sockaddr *)&fetch->client_ip;
+
+ switch (sockaddress->sa_family) {
+ case AF_INET:
+ inet_ntop(AF_INET, &(((struct sockaddr_in *)sockaddress)->sin_addr),
buf, INET_ADDRSTRLEN);
+ PrefetchDebug("client IPv4 = %s", buf);
+ break;
+ case AF_INET6:
+ inet_ntop(AF_INET6, &(((struct sockaddr_in6
*)sockaddress)->sin6_addr), buf, INET6_ADDRSTRLEN);
+ PrefetchDebug("client IPv6 = %s", buf);
+ break;
+ default:
+ TSError("[%s] Unknown address family %d", PLUGIN_NAME,
sockaddress->sa_family);
+ break;
+ }
+ PrefetchDebug("Starting background fetch.");
+ dumpHeaders(fetch->_mbuf, fetch->_headerLoc);
+ }
+
+ // Setup the NetVC for background fetch
+ TSAssert(nullptr == fetch->vc);
+ if ((fetch->vc = TSHttpConnect((sockaddr *)&fetch->client_ip)) != nullptr)
{
+ TSHttpHdrPrint(fetch->_mbuf, fetch->_headerLoc, fetch->req_io_buf);
+ // We never send a body with the request. ToDo: Do we ever need to
support that ?
+ TSIOBufferWrite(fetch->req_io_buf, "\r\n", 2);
+
+ fetch->r_vio = TSVConnRead(fetch->vc, contp, fetch->resp_io_buf,
INT64_MAX);
+ fetch->w_vio = TSVConnWrite(fetch->vc, contp, fetch->req_io_buf_reader,
TSIOBufferReaderAvail(fetch->req_io_buf_reader));
+ } else {
+ delete fetch;
+ PrefetchError("Failed to connect to internal process, major
malfunction");
+ }
+ break;
+
+ case TS_EVENT_VCONN_WRITE_COMPLETE:
+ // TSVConnShutdown(data->vc, 0, 1);
+ // TSVIOReenable(data->w_vio);
+ PrefetchDebug("write complete");
+ break;
+
+ case TS_EVENT_VCONN_READ_READY:
+ avail = TSIOBufferReaderAvail(fetch->resp_io_buf_reader);
+ fetch->addBytes(avail);
+ TSIOBufferReaderConsume(fetch->resp_io_buf_reader, avail);
+ TSVIONDoneSet(fetch->r_vio, TSVIONDoneGet(fetch->r_vio) + avail);
+ TSVIOReenable(fetch->r_vio);
+ break;
+
+ case TS_EVENT_VCONN_READ_COMPLETE:
+ case TS_EVENT_VCONN_EOS:
+ case TS_EVENT_VCONN_INACTIVITY_TIMEOUT:
+ case TS_EVENT_ERROR:
+ if (event == TS_EVENT_VCONN_INACTIVITY_TIMEOUT) {
+ PrefetchDebug("encountered Inactivity Timeout");
+ TSVConnAbort(fetch->vc, TS_VC_CLOSE_ABORT);
+ } else {
+ TSVConnClose(fetch->vc);
+ }
+
+ PrefetchDebug("closing background transaction");
+ avail = TSIOBufferReaderAvail(fetch->resp_io_buf_reader);
+ fetch->addBytes(avail);
+ TSIOBufferReaderConsume(fetch->resp_io_buf_reader, avail);
+ TSVIONDoneSet(fetch->r_vio, TSVIONDoneGet(fetch->r_vio) + avail);
+ fetch->logAndMetricUpdate(event);
+
+ /* Close, release and cleanup */
+ fetch->vc = nullptr;
+ delete fetch;
+ break;
+
+ default:
+ PrefetchDebug("unhandled event");
+ break;
+ }
+
+ return 0;
+}
diff --git a/plugins/experimental/prefetch/fetch.h
b/plugins/experimental/prefetch/fetch.h
new file mode 100644
index 0000000..4d73a7b
--- /dev/null
+++ b/plugins/experimental/prefetch/fetch.h
@@ -0,0 +1,202 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file bg_fetch.h
+ * @brief Background fetch related classes (header file).
+ */
+
+#pragma once
+
+#include <list>
+#include <map>
+#include <unordered_map>
+#include <vector>
+
+#include "ts/ts.h"
+#include "ts/experimental.h"
+#include "common.h"
+#include "configs.h"
+#include "fetch_policy.h"
+
+enum PrefetchMetric {
+ FETCH_ACTIVE = 0,
+ FETCH_COMPLETED,
+ FETCH_ERRORS,
+ FETCH_TIMEOOUTS,
+ FETCH_THROTTLED,
+ FETCH_ALREADY_CACHED, /*metric if for counting how many times fetch was not
scheduled because of cache-hit */
+ FETCH_TOTAL,
+ FETCH_UNIQUE_YES,
+ FETCH_UNIQUE_NO,
+ FETCH_MATCH_YES, /* metric id for URL path pattern match successes */
+ FETCH_MATCH_NO, /* metric id for URL path pattern match failures */
+ FETCH_POLICY_YES, /* metric id for counting fetch policy successes */
+ FETCH_POLICY_NO, /* metric id for counting fetch policy failures */
+ FETCH_POLICY_SIZE,
+ FETCH_POLICY_MAXSIZE,
+ FETCHES_MAX_METRICS,
+};
+
+struct PrefetchMetricInfo {
+ PrefetchMetric index;
+ TSRecordDataType type;
+ int id;
+};
+
+/**
+ * @brief to store background fetch state, metrics, logs etc (shared between
all scheduled fetches).
+ *
+ * @todo: reconsider the locks (tried to be granular but it feels too crowded,
remove unnecessary locks)
+ */
+class BgFetchState
+{
+public:
+ BgFetchState();
+ virtual ~BgFetchState();
+ bool init(const PrefetchConfig &config);
+
+ /* Fetch policy */
+ bool acquire(const String &url);
+ bool release(const String &url);
+
+ /* De-duplication of requests */
+ bool uniqueAcquire(const String &url);
+ bool uniqueRelease(const String &url);
+
+ /* Metrics and logs */
+ void incrementMetric(PrefetchMetric m);
+ void setMetric(PrefetchMetric m, size_t value);
+ TSTextLogObject getLog();
+
+private:
+ BgFetchState(BgFetchState const &); /* never implement */
+ void operator=(BgFetchState const &); /* never implement */
+
+ /* Fetch policy related */
+ FetchPolicy *_policy; /* fetch policy */
+ TSMutex _policyLock; /* protects the policy object only */
+
+ /* Mechanisms to avoid concurrent fetches and applying limits */
+ FetchPolicy *_unique; /* make sure we never download same object multiple
times at the same time */
+ TSMutex _lock; /* protects the deduplication object only */
+ size_t _concurrentFetches;
+ size_t _concurrentFetchesMax;
+ PrefetchMetricInfo _metrics[FETCHES_MAX_METRICS] = {
+ {FETCH_ACTIVE, TS_RECORDDATATYPE_INT, -1}, {FETCH_COMPLETED,
TS_RECORDDATATYPE_COUNTER, -1},
+ {FETCH_ERRORS, TS_RECORDDATATYPE_COUNTER, -1}, {FETCH_TIMEOOUTS,
TS_RECORDDATATYPE_COUNTER, -1},
+ {FETCH_THROTTLED, TS_RECORDDATATYPE_COUNTER, -1}, {FETCH_ALREADY_CACHED,
TS_RECORDDATATYPE_COUNTER, -1},
+ {FETCH_TOTAL, TS_RECORDDATATYPE_COUNTER, -1}, {FETCH_UNIQUE_YES,
TS_RECORDDATATYPE_COUNTER, -1},
+ {FETCH_UNIQUE_NO, TS_RECORDDATATYPE_COUNTER, -1}, {FETCH_MATCH_YES,
TS_RECORDDATATYPE_COUNTER, -1},
+ {FETCH_MATCH_NO, TS_RECORDDATATYPE_COUNTER, -1}, {FETCH_POLICY_YES,
TS_RECORDDATATYPE_COUNTER, -1},
+ {FETCH_POLICY_NO, TS_RECORDDATATYPE_COUNTER, -1}, {FETCH_POLICY_SIZE,
TS_RECORDDATATYPE_INT, -1},
+ {FETCH_POLICY_MAXSIZE, TS_RECORDDATATYPE_INT, -1}};
+
+ /* plugin specific fetch logging */
+ TSTextLogObject _log;
+};
+
+/**
+ * @brief Contains all background states to be shared between different plugin
instances (grouped in namespaces)
+ */
+class BgFetchStates
+{
+public:
+ /* Initialize on first use */
+ static BgFetchStates *
+ get()
+ {
+ if (nullptr == _prefetchStates) {
+ _prefetchStates = new BgFetchStates();
+ }
+ return _prefetchStates;
+ }
+
+ BgFetchState *
+ getStateByName(const String &space)
+ {
+ BgFetchState *state;
+ std::map<String, BgFetchState *>::iterator it;
+
+ TSMutexLock(_prefetchStates->_lock);
+ it = _prefetchStates->_states.find(space);
+ if (it != _prefetchStates->_states.end()) {
+ state = it->second;
+ } else {
+ state = new BgFetchState();
+ _prefetchStates->_states[space] = state;
+ }
+ TSMutexUnlock(_prefetchStates->_lock);
+ return state;
+ }
+
+private:
+ BgFetchStates() : _lock(TSMutexCreate()) {}
+ ~BgFetchStates() { TSMutexDestroy(_lock); }
+ static BgFetchStates *_prefetchStates;
+
+ std::map<String, BgFetchState *> _states; /* stores pointers to states per
namespace */
+ TSMutex _lock;
+};
+
+/**
+ * @brief Represents a single background fetch.
+ */
+class BgFetch
+{
+public:
+ static bool schedule(BgFetchState *state, const PrefetchConfig &config, bool
askPermission, TSMBuffer requestBuffer,
+ TSMLoc requestHeaderLoc, TSHttpTxn txnp, const char
*path, size_t pathLen, const String &cachekey);
+
+private:
+ BgFetch(BgFetchState *state, const PrefetchConfig &config, bool lock);
+ ~BgFetch();
+ bool init(TSMBuffer requestBuffer, TSMLoc requestHeaderLoc, TSHttpTxn txnp,
const char *fetchPath, size_t fetchPathLen,
+ const String &cacheKey);
+ void schedule();
+ static int handler(TSCont contp, TSEvent event, void * /* edata ATS_UNUSED
*/);
+ bool saveIp(TSHttpTxn txnp);
+ void addBytes(int64_t b);
+ void logAndMetricUpdate(TSEvent event) const;
+
+ /* Request related */
+ TSMBuffer _mbuf;
+ TSMLoc _headerLoc;
+ TSMLoc _urlLoc;
+ struct sockaddr_storage client_ip;
+
+ /* This is for the actual background fetch / NetVC */
+ TSVConn vc;
+ TSIOBuffer req_io_buf, resp_io_buf;
+ TSIOBufferReader req_io_buf_reader, resp_io_buf_reader;
+ TSVIO r_vio, w_vio;
+ int64_t _bytes;
+
+ /* Background fetch continuation */
+ TSCont _cont;
+
+ /* Pointers and cache */
+ String _cachekey; /* saving the cache key for later use */
+ String _url; /* saving the URL for later use */
+ BgFetchState *_state; /* pointer for access to the plugin state */
+ const PrefetchConfig &_config; /* reference for access to the configuration
*/
+
+ bool _askPermission; /* true - check with the fetch policies if we should
schedule the fetch */
+
+ TSHRTime _startTime; /* for calculation of downloadTime for this fetch */
+};
diff --git a/plugins/experimental/prefetch/fetch_policy.cc
b/plugins/experimental/prefetch/fetch_policy.cc
new file mode 100644
index 0000000..083257f
--- /dev/null
+++ b/plugins/experimental/prefetch/fetch_policy.cc
@@ -0,0 +1,57 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file fetch_policy.cc
+ * @brief Fetch policy interface.
+ */
+
+#include "fetch_policy.h"
+
+#include <string.h>
+
+#include "common.h"
+#include "fetch_policy_lru.h"
+#include "fetch_policy_simple.h"
+
+FetchPolicy *
+FetchPolicy::getInstance(const char *parameters)
+{
+ const char *name = parameters;
+ const char *delim = strchr(parameters, ':');
+ size_t len = (nullptr == delim ? strlen(name) : delim - name);
+ const char *params = (nullptr == delim ? nullptr : delim + 1);
+
+ PrefetchDebug("getting '%.*s' policy instance, params: %s", (int)len, name,
params);
+ FetchPolicy *p = nullptr;
+ if (6 == len && 0 == strncmp(name, "simple", 6)) {
+ p = new FetchPolicySimple();
+ } else if (3 == len && 0 == strncmp(name, "lru", 3)) {
+ p = new FetchPolicyLru();
+ } else {
+ PrefetchError("unrecognized fetch policy type: %.*s", (int)len, name);
+ return nullptr;
+ }
+
+ if (p->init(params)) {
+ return p;
+ }
+ delete p;
+
+ return nullptr;
+}
diff --git a/plugins/experimental/prefetch/fetch_policy.h
b/plugins/experimental/prefetch/fetch_policy.h
new file mode 100644
index 0000000..8594759
--- /dev/null
+++ b/plugins/experimental/prefetch/fetch_policy.h
@@ -0,0 +1,66 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file fetch_policy.h
+ * @brief Fetch policy interface (header file).
+ */
+
+#pragma once
+
+#include <list>
+#include <openssl/sha.h>
+#include <string.h>
+#include <string>
+#include <unordered_map>
+
+#include "common.h"
+
+class FetchPolicy;
+class SimplePolicy;
+class Prescaler;
+
+/**
+ * @brief Fetch policy interface.
+ */
+class FetchPolicy
+{
+public:
+ static FetchPolicy *getInstance(const char *name);
+ virtual ~FetchPolicy(){};
+
+ virtual bool init(const char *parameters) = 0;
+ virtual bool acquire(const std::string &url) = 0;
+ virtual bool release(const std::string &url) = 0;
+ virtual const char *name() = 0;
+ virtual size_t getSize() = 0;
+ virtual size_t getMaxSize() = 0;
+
+private:
+ FetchPolicy(const FetchPolicy &);
+ FetchPolicy &operator=(const FetchPolicy &);
+
+protected:
+ FetchPolicy(){};
+ void
+ log(const char *msg, const String &url, bool ret)
+ {
+ PrefetchDebug("%s::%s('%.*s%s'): %s", name(), msg, (int)(url.length() >
100 ? 100 : url.length()), url.c_str(),
+ url.length() > 100 ? "..." : "", ret ? "true" : "false");
+ }
+};
diff --git a/plugins/experimental/prefetch/fetch_policy_lru.cc
b/plugins/experimental/prefetch/fetch_policy_lru.cc
new file mode 100644
index 0000000..c0b0902
--- /dev/null
+++ b/plugins/experimental/prefetch/fetch_policy_lru.cc
@@ -0,0 +1,141 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file fetch_policy_lru.cc
+ * @brief LRU fetch policy.
+ */
+
+#include "fetch_policy_lru.h"
+#include "common.h"
+
+inline const char *
+FetchPolicyLru::name()
+{
+ return "lru";
+}
+
+bool
+FetchPolicyLru::init(const char *parameters)
+{
+ if (nullptr == parameters) {
+ /* Leave defaults */
+ } else {
+ size_t size = 0;
+
+ /* look for buckets first */
+ const char *sizeStr = parameters;
+ const char *delim = strchr(parameters, ',');
+
+ if (nullptr == delim) {
+ /* no divider specified, set the buckets */
+ size = getValue(sizeStr, strlen(sizeStr));
+ } else {
+ /* set the buckets */
+ size = getValue(sizeStr, delim - sizeStr);
+ }
+
+ /* Defaults are considered minimum */
+ static const char *defaultStr = " (default)";
+ bool useDefault = false;
+
+ /* Make sure size is not larger than what std::list is physically able to
hold */
+ LruList::size_type realMax = _list.max_size();
+ if (size > realMax) {
+ PrefetchDebug("size: %lu is not feasible, cutting to %lu", size,
realMax);
+ size = realMax;
+ }
+ /* Guarantee minimum value */
+ if (size > _maxSize) {
+ _maxSize = size;
+ } else {
+ useDefault = true;
+ PrefetchError("size: %lu is not a good value", size);
+ };
+
+ PrefetchDebug("initialized %s fetch policy: size: %lu%s", name(),
_maxSize, (useDefault ? defaultStr : ""));
+ }
+
+ return true;
+}
+
+inline size_t
+FetchPolicyLru::getMaxSize()
+{
+ return _maxSize;
+}
+
+inline size_t
+FetchPolicyLru::getSize()
+{
+ return _size;
+}
+
+bool
+FetchPolicyLru::acquire(const std::string &url)
+{
+ bool ret = false;
+
+ LruHash hash;
+ hash.init(url.c_str(), url.length());
+
+ LruMapIterator it = _map.find(&hash);
+
+ if (_map.end() != it) {
+ PrefetchDebug("recently used LRU entry, moving to front");
+
+ /* We have an entry in the LRU */
+ PrefetchAssert(_list.size() > 0);
+
+ /* Move to the front of the list */
+ _list.splice(_list.begin(), _list, it->second);
+
+ /* Don't trigger fetch if the url is found amongst the most recently used
ones */
+ ret = false;
+ } else {
+ /* New LRU entry */
+ if (_size >= _maxSize) {
+ /* Move the last (least recently used) element to the front and remove
it from the hash table. */
+ _list.splice(_list.begin(), _list, --_list.end());
+ _map.erase(&(*_list.begin()));
+ PrefetchDebug("reused the least recently used LRU entry");
+ } else {
+ /* With this implementation we are never removing LRU elements from the
list but just updating the front element of the list
+ * so the following addition should happen at most
FetchPolicyLru::_maxSize number of times */
+ _list.push_front(NULL_LRU_ENTRY);
+ _size++;
+ PrefetchDebug("created a new LRU entry, size=%d", (int)_size);
+ }
+ /* Update the "new" or the most recently used LRU entry and add it to the
hash */
+ *_list.begin() = hash;
+ _map[&(*_list.begin())] = _list.begin();
+
+ /* Trigger fetch since the URL is not amongst the most recently used ones
*/
+ ret = true;
+ }
+
+ log("acquire", url, ret);
+ return ret;
+}
+
+bool
+FetchPolicyLru::release(const std::string &url)
+{
+ log("release", url, true);
+ return true;
+}
diff --git a/plugins/experimental/prefetch/fetch_policy_lru.h
b/plugins/experimental/prefetch/fetch_policy_lru.h
new file mode 100644
index 0000000..2699647
--- /dev/null
+++ b/plugins/experimental/prefetch/fetch_policy_lru.h
@@ -0,0 +1,105 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file fetch_policy_lru.h
+ * @brief LRU fetch policy (header file).
+ */
+
+#pragma once
+
+#include "fetch_policy.h"
+
+/* Here reusing some of the classes used in cache_promote plugin.
+ * @todo: this was done in interest of time, see if LRU is what we really
need, can we do it differently / better? */
+class LruHash
+{
+ friend struct LruHashHasher;
+
+public:
+ LruHash() {}
+ ~LruHash() {}
+ LruHash &
+ operator=(const LruHash &h)
+ {
+ memcpy(_hash, h._hash, sizeof(_hash));
+ return *this;
+ }
+
+ void
+ init(const char *data, int len)
+ {
+ SHA_CTX sha;
+
+ SHA1_Init(&sha);
+ SHA1_Update(&sha, data, len);
+ SHA1_Final(_hash, &sha);
+ }
+
+private:
+ u_char _hash[SHA_DIGEST_LENGTH];
+};
+
+struct LruHashHasher {
+ bool
+ operator()(const LruHash *s1, const LruHash *s2) const
+ {
+ return 0 == memcmp(s1->_hash, s2->_hash, sizeof(s2->_hash));
+ }
+
+ size_t
+ operator()(const LruHash *s) const
+ {
+ return *((size_t *)s->_hash) ^ *((size_t *)(s->_hash + 9));
+ }
+};
+
+typedef LruHash LruEntry;
+typedef std::list<LruEntry> LruList;
+typedef std::unordered_map<const LruHash *, LruList::iterator, LruHashHasher,
LruHashHasher> LruMap;
+typedef LruMap::iterator LruMapIterator;
+
+static LruEntry NULL_LRU_ENTRY; // Used to create an "empty" new LRUEntry
+
+/**
+ * @brief Fetch policy that allows fetches only for not-"hot" objects.
+ *
+ * Trying to identify "hot" object by keeping track of most recently used
objects and
+ * allows fetches only when a URL is not found in the most recently used set.
+ */
+class FetchPolicyLru : public FetchPolicy
+{
+public:
+ /* Default size values are also considered minimum. TODO: find out if this
works OK. */
+ FetchPolicyLru() : _maxSize(10), _size(0){};
+ virtual ~FetchPolicyLru(){};
+
+ /* Fetch policy interface methods */
+ bool init(const char *parameters);
+ bool acquire(const std::string &url);
+ bool release(const std::string &url);
+ const char *name();
+ size_t getMaxSize();
+ size_t getSize();
+
+protected:
+ LruMap _map;
+ LruList _list;
+ LruList::size_type _maxSize;
+ LruList::size_type _size;
+};
diff --git a/plugins/experimental/prefetch/fetch_policy_simple.cc
b/plugins/experimental/prefetch/fetch_policy_simple.cc
new file mode 100644
index 0000000..aefd07f
--- /dev/null
+++ b/plugins/experimental/prefetch/fetch_policy_simple.cc
@@ -0,0 +1,80 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file fetch_policy_simple.cc
+ * @brief Simple fetch policy.
+ */
+
+#include "fetch_policy_simple.h"
+
+bool
+FetchPolicySimple::init(const char *parameters)
+{
+ PrefetchDebug("initialized %s fetch policy", name());
+ return true;
+}
+
+bool
+FetchPolicySimple::acquire(const std::string &url)
+{
+ bool ret;
+ if (_urls.end() == _urls.find(url)) {
+ _urls[url] = true;
+ ret = true;
+ } else {
+ ret = false;
+ }
+
+ log("acquire", url, ret);
+ return ret;
+}
+
+bool
+FetchPolicySimple::release(const std::string &url)
+{
+ bool ret;
+ if (_urls.end() == _urls.find(url)) {
+ ret = false;
+ } else {
+ _urls.erase(url);
+ ret = true;
+ }
+
+ log("release", url, ret);
+ return ret;
+}
+
+inline const char *
+FetchPolicySimple::name()
+{
+ return "simple";
+}
+
+inline size_t
+FetchPolicySimple::getSize()
+{
+ return _urls.size();
+}
+
+inline size_t
+FetchPolicySimple::getMaxSize()
+{
+ /* Unlimited */
+ return 0;
+}
diff --git a/plugins/experimental/prefetch/fetch_policy_simple.h
b/plugins/experimental/prefetch/fetch_policy_simple.h
new file mode 100644
index 0000000..be04d86
--- /dev/null
+++ b/plugins/experimental/prefetch/fetch_policy_simple.h
@@ -0,0 +1,46 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file fetch_policy_simple.h
+ * @brief Simple fetch policy (header file).
+ */
+
+#pragma once
+
+#include "fetch_policy.h"
+
+/**
+ * @brief Simple de-duplication fetch policy, used to make sure only one
background fetch is running at a time.
+ */
+
+class FetchPolicySimple : public FetchPolicy
+{
+public:
+ FetchPolicySimple() {}
+ virtual ~FetchPolicySimple(){};
+ bool init(const char *parameters);
+ bool acquire(const std::string &url);
+ bool release(const std::string &url);
+ const char *name();
+ size_t getSize();
+ size_t getMaxSize();
+
+private:
+ std::unordered_map<std::string, bool> _urls;
+};
diff --git a/plugins/experimental/prefetch/headers.cc
b/plugins/experimental/prefetch/headers.cc
new file mode 100644
index 0000000..8233dc5
--- /dev/null
+++ b/plugins/experimental/prefetch/headers.cc
@@ -0,0 +1,213 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file headers.cc
+ * @brief HTTP headers manipulation.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "configs.h"
+#include "headers.h"
+
+/**
+ * @brief Remove a header (fully) from an TSMLoc / TSMBuffer.
+ *
+ * @param bufp request's buffer
+ * @param hdrLoc request's header location
+ * @param header header name
+ * @param headerlen header name length
+ * @return the number of fields (header values) we removed.
+ */
+int
+removeHeader(TSMBuffer bufp, TSMLoc hdrLoc, const char *header, int headerlen)
+{
+ TSMLoc fieldLoc = TSMimeHdrFieldFind(bufp, hdrLoc, header, headerlen);
+ int cnt = 0;
+
+ while (fieldLoc) {
+ TSMLoc tmp = TSMimeHdrFieldNextDup(bufp, hdrLoc, fieldLoc);
+
+ ++cnt;
+ TSMimeHdrFieldDestroy(bufp, hdrLoc, fieldLoc);
+ TSHandleMLocRelease(bufp, hdrLoc, fieldLoc);
+ fieldLoc = tmp;
+ }
+
+ return cnt;
+}
+
+/**
+ * @brief Checks if the header exists.
+ *
+ * @param bufp request's buffer
+ * @param hdrLoc request's header location
+ * @return true - exists, false - does not exist
+ */
+bool
+headerExist(TSMBuffer bufp, TSMLoc hdrLoc, const char *header, int headerlen)
+{
+ TSMLoc fieldLoc = TSMimeHdrFieldFind(bufp, hdrLoc, header, headerlen);
+ if (TS_NULL_MLOC != fieldLoc) {
+ TSHandleMLocRelease(bufp, hdrLoc, fieldLoc);
+ return true;
+ }
+ return false;
+}
+
+/**
+ * @brief Get the header value
+ *
+ * @param bufp request's buffer
+ * @param hdrLoc request's header location
+ * @param header header name
+ * @param headerlen header name length
+ * @param value buffer for the value
+ * @param valuelen lenght of the buffer for the value
+ * @return pointer to the string with the value.
+ */
+char *
+getHeader(TSMBuffer bufp, TSMLoc hdrLoc, const char *header, int headerlen,
char *value, int *valuelen)
+{
+ TSMLoc fieldLoc = TSMimeHdrFieldFind(bufp, hdrLoc, header, headerlen);
+ char *dst = value;
+ while (fieldLoc) {
+ TSMLoc next = TSMimeHdrFieldNextDup(bufp, hdrLoc, fieldLoc);
+
+ int count = TSMimeHdrFieldValuesCount(bufp, hdrLoc, fieldLoc);
+ for (int i = 0; i < count; ++i) {
+ const char *v = nullptr;
+ int vlen = 0;
+ v = TSMimeHdrFieldValueStringGet(bufp, hdrLoc, fieldLoc, i,
&vlen);
+ if (v == nullptr || vlen == 0) {
+ continue;
+ }
+ /* append the field content to the output buffer if enough space, plus
space for ", " */
+ bool first = (dst == value);
+ int neededSpace = ((dst - value) + vlen + (dst == value ? 0 : 2));
+ if (neededSpace < *valuelen) {
+ if (!first) {
+ memcpy(dst, ", ", 2);
+ dst += 2;
+ }
+ memcpy(dst, v, vlen);
+ dst += vlen;
+ }
+ }
+ TSHandleMLocRelease(bufp, hdrLoc, fieldLoc);
+ fieldLoc = next;
+ }
+
+ *valuelen = dst - value;
+ return value;
+}
+
+/**
+ * @brief Set a header to a specific value.
+ *
+ * This will avoid going to through a remove / add sequence in case of an
existing header but clean.
+ *
+ * @param bufp request's buffer
+ * @param hdrLoc request's header location
+ * @param header header name
+ * @param headerlen header name len
+ * @param value the new value
+ * @param valuelen lenght of the value
+ * @return true - OK, false - failed
+ */
+bool
+setHeader(TSMBuffer bufp, TSMLoc hdrLoc, const char *header, int headerlen,
const char *value, int valuelen)
+{
+ if (!bufp || !hdrLoc || !header || headerlen <= 0 || !value || valuelen <=
0) {
+ return false;
+ }
+
+ bool ret = false;
+ TSMLoc fieldLoc = TSMimeHdrFieldFind(bufp, hdrLoc, header, headerlen);
+
+ if (!fieldLoc) {
+ // No existing header, so create one
+ if (TS_SUCCESS == TSMimeHdrFieldCreateNamed(bufp, hdrLoc, header,
headerlen, &fieldLoc)) {
+ if (TS_SUCCESS == TSMimeHdrFieldValueStringSet(bufp, hdrLoc, fieldLoc,
-1, value, valuelen)) {
+ TSMimeHdrFieldAppend(bufp, hdrLoc, fieldLoc);
+ ret = true;
+ }
+ TSHandleMLocRelease(bufp, hdrLoc, fieldLoc);
+ }
+ } else {
+ TSMLoc tmp = nullptr;
+ bool first = true;
+
+ while (fieldLoc) {
+ if (first) {
+ first = false;
+ if (TS_SUCCESS == TSMimeHdrFieldValueStringSet(bufp, hdrLoc, fieldLoc,
-1, value, valuelen)) {
+ ret = true;
+ }
+ } else {
+ TSMimeHdrFieldDestroy(bufp, hdrLoc, fieldLoc);
+ }
+ tmp = TSMimeHdrFieldNextDup(bufp, hdrLoc, fieldLoc);
+ TSHandleMLocRelease(bufp, hdrLoc, fieldLoc);
+ fieldLoc = tmp;
+ }
+ }
+
+ return ret;
+}
+
+/**
+ * @brief Dump a header on stderr
+ *
+ * Useful together with TSDebug().
+ *
+ * @param bufp request's buffer
+ * @param hdrLoc request's header location
+ */
+void
+dumpHeaders(TSMBuffer bufp, TSMLoc hdrLoc)
+{
+ TSIOBuffer output_buffer;
+ TSIOBufferReader reader;
+ TSIOBufferBlock block;
+ const char *block_start;
+ int64_t block_avail;
+
+ output_buffer = TSIOBufferCreate();
+ reader = TSIOBufferReaderAlloc(output_buffer);
+
+ /* This will print just MIMEFields and not the http request line */
+ TSMimeHdrPrint(bufp, hdrLoc, output_buffer);
+
+ /* We need to loop over all the buffer blocks, there can be more than 1 */
+ block = TSIOBufferReaderStart(reader);
+ do {
+ block_start = TSIOBufferBlockReadStart(block, reader, &block_avail);
+ if (block_avail > 0) {
+ PrefetchDebug("Headers are:\n%.*s", static_cast<int>(block_avail),
block_start);
+ }
+ TSIOBufferReaderConsume(reader, block_avail);
+ block = TSIOBufferReaderStart(reader);
+ } while (block && block_avail != 0);
+
+ /* Free up the TSIOBuffer that we used to print out the header */
+ TSIOBufferReaderFree(reader);
+ TSIOBufferDestroy(output_buffer);
+}
diff --git a/plugins/experimental/prefetch/headers.h
b/plugins/experimental/prefetch/headers.h
new file mode 100644
index 0000000..b6e0e1b
--- /dev/null
+++ b/plugins/experimental/prefetch/headers.h
@@ -0,0 +1,31 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file headers.h
+ * @brief HTTP headers manipulation (header file).
+ */
+
+#pragma once
+
+int removeHeader(TSMBuffer bufp, TSMLoc hdr_loc, const char *header, int len);
+bool headerExist(TSMBuffer bufp, TSMLoc hdr_loc, const char *header, int len);
+char *getHeader(TSMBuffer bufp, TSMLoc hdr_loc, const char *header, int
headerlen, char *value, int *valuelen);
+
+bool setHeader(TSMBuffer bufp, TSMLoc hdr_loc, const char *header, int len,
const char *val, int val_len);
+void dumpHeaders(TSMBuffer bufp, TSMLoc hdr_loc);
diff --git a/plugins/experimental/prefetch/pattern.cc
b/plugins/experimental/prefetch/pattern.cc
new file mode 100644
index 0000000..20e3b64
--- /dev/null
+++ b/plugins/experimental/prefetch/pattern.cc
@@ -0,0 +1,463 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file pattern.cc
+ * @brief PRCE related classes.
+ * @see pattern.h
+ */
+
+#include "pattern.h"
+
+static void
+replaceString(String &str, const String &from, const String &to)
+{
+ if (from.empty()) {
+ return;
+ }
+
+ String::size_type start_pos = 0;
+ while ((start_pos = str.find(from, start_pos)) != String::npos) {
+ str.replace(start_pos, from.length(), to);
+ start_pos += to.length();
+ }
+}
+
+Pattern::Pattern() : _re(nullptr), _extra(nullptr), _pattern(""),
_replacement(""), _tokenCount(0) {}
+
+/**
+ * @brief Initializes PCRE pattern by providing the subject and replacement
strings.
+ * @param pattern PCRE pattern, a string containing PCRE patterns, capturing
groups.
+ * @param replacement PCRE replacement, a string where $0 ... $9 will be
replaced with the corresponding capturing groups
+ * @return true if successful, false if failure
+ */
+bool
+Pattern::init(const String &pattern, const String &replacenemt)
+{
+ pcreFree();
+
+ _pattern.assign(pattern);
+ _replacement.assign(replacenemt);
+
+ _tokenCount = 0;
+
+ if (!compile()) {
+ PrefetchDebug("failed to initialize pattern:'%s', replacement:'%s'",
pattern.c_str(), replacenemt.c_str());
+ pcreFree();
+ return false;
+ }
+
+ return true;
+}
+
+/**
+ * @brief Initializes PCRE pattern by providing the pattern only or
pattern+replacement in a single configuration string.
+ * @see init()
+ * @param config PCRE pattern <pattern> or PCRE pattern + replacement in
format /<pattern>/<replacement>/
+ * @return true if successful, false if failure
+ */
+bool
+Pattern::init(const String &config)
+{
+ if (config[0] == '/') {
+ /* This is a config in format /regex/replacement/ */
+ String pattern;
+ String replacement;
+
+ size_t start = 1;
+ size_t current = 0;
+ size_t next = 1;
+ do {
+ current = next + 1;
+ next = config.find_first_of("/", current);
+ } while (next != String::npos && '\\' == config[next - 1]);
+
+ if (next != String::npos) {
+ pattern = config.substr(start, next - start);
+ } else {
+ /* Error, no closing '/' */
+ PrefetchError("failed to parse the pattern in '%s'", config.c_str());
+ return false;
+ }
+
+ start = next + 1;
+ do {
+ current = next + 1;
+ next = config.find_first_of("/", current);
+ } while (next != String::npos && '\\' == config[next - 1]);
+
+ if (next != String::npos) {
+ replacement = config.substr(start, next - start);
+ } else {
+ /* Error, no closing '/' */
+ PrefetchError("failed to parse the replacement in '%s'", config.c_str());
+ return false;
+ }
+
+ // Remove '\' which escaped '/' inside the pattern and replacement strings.
+ ::replaceString(pattern, "\\/", "/");
+ ::replaceString(replacement, "\\/", "/");
+
+ return this->init(pattern, replacement);
+ } else {
+ return this->init(config, "");
+ }
+
+ /* Should never get here. */
+ return false;
+}
+
+/**
+ * @brief Checks if the pattern object was initialized with a meaningful regex
pattern.
+ * @return true if initialized, false if not.
+ */
+bool
+Pattern::empty() const
+{
+ return _pattern.empty() || nullptr == _re;
+}
+
+/**
+ * @brief Frees PCRE library related resources.
+ */
+void
+Pattern::pcreFree()
+{
+ if (_re) {
+ pcre_free(_re);
+ _re = nullptr;
+ }
+
+ if (_extra) {
+ pcre_free(_extra);
+ _extra = nullptr;
+ }
+}
+
+/**
+ * @bried Destructor, frees PCRE related resources.
+ */
+Pattern::~Pattern()
+{
+ pcreFree();
+}
+
+/**
+ * @brief Capture or capture-and-replace depending on whether a replacement
string is specified.
+ * @see replace()
+ * @see capture()
+ * @param subject PCRE subject string
+ * @param result vector of strings where the result of captures or the
replacements will be returned.
+ * @return true if there was a match and capture or replacement succeeded,
false if failure.
+ */
+bool
+Pattern::process(const String &subject, StringVector &result)
+{
+ if (!_replacement.empty()) {
+ /* Replacement pattern was provided in the configuration - capture and
replace. */
+ String element;
+ if (replace(subject, element)) {
+ result.push_back(element);
+ } else {
+ return false;
+ }
+ } else {
+ /* Replacement was not provided so return all capturing groups except the
group zero. */
+ StringVector captures;
+ if (capture(subject, captures)) {
+ if (captures.size() == 1) {
+ result.push_back(captures[0]);
+ } else {
+ StringVector::iterator it = captures.begin() + 1;
+ for (; it != captures.end(); it++) {
+ result.push_back(*it);
+ }
+ }
+ } else {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+/**
+ * @brief PCRE matches a subject string against the the regex pattern.
+ * @param subject PCRE subject
+ * @return true - matched, false - did not.
+ */
+bool
+Pattern::match(const String &subject)
+{
+ int matchCount;
+ PrefetchDebug("matching '%s' to '%s'", _pattern.c_str(), subject.c_str());
+
+ if (!_re) {
+ return false;
+ }
+
+ matchCount = pcre_exec(_re, _extra, subject.c_str(), subject.length(), 0,
PCRE_NOTEMPTY, nullptr, 0);
+ if (matchCount < 0) {
+ if (matchCount != PCRE_ERROR_NOMATCH)
+ PrefetchError("matching error %d", matchCount);
+ return false;
+ }
+
+ return true;
+}
+
+/**
+ * @brief Return all PCRE capture groups that matched in the subject string
+ * @param subject PCRE subject string
+ * @param result reference to vector of strings containing all capture groups
+ */
+bool
+Pattern::capture(const String &subject, StringVector &result)
+{
+ int matchCount;
+ int ovector[OVECOUNT];
+
+ PrefetchDebug("matching '%s' to '%s'", _pattern.c_str(), subject.c_str());
+
+ if (!_re) {
+ return false;
+ }
+
+ matchCount = pcre_exec(_re, nullptr, subject.c_str(), subject.length(), 0,
PCRE_NOTEMPTY, ovector, OVECOUNT);
+ if (matchCount < 0) {
+ if (matchCount != PCRE_ERROR_NOMATCH)
+ PrefetchError("matching error %d", matchCount);
+ return false;
+ }
+
+ for (int i = 0; i < matchCount; i++) {
+ int start = ovector[2 * i];
+ int length = ovector[2 * i + 1] - ovector[2 * i];
+
+ String dst(subject, start, length);
+
+ PrefetchDebug("capturing '%s' %d[%d,%d]", dst.c_str(), i, ovector[2 * i],
ovector[2 * i + 1]);
+ result.push_back(dst);
+ }
+
+ return true;
+}
+
+/**
+ * @brief Replaces all replacements found in the replacement string with what
matched in the PCRE capturing groups.
+ * @param subject PCRE subject string
+ * @param result reference to A string where the result of the replacement
will be stored
+ * @return true - success, false - nothing matched or failure.
+ */
+bool
+Pattern::replace(const String &subject, String &result)
+{
+ int matchCount;
+ int ovector[OVECOUNT];
+
+ PrefetchDebug("matching '%s' to '%s'", _pattern.c_str(), subject.c_str());
+
+ if (!_re) {
+ return false;
+ }
+
+ matchCount = pcre_exec(_re, nullptr, subject.c_str(), subject.length(), 0,
PCRE_NOTEMPTY, ovector, OVECOUNT);
+ if (matchCount < 0) {
+ if (matchCount != PCRE_ERROR_NOMATCH)
+ PrefetchError("matching error %d", matchCount);
+ return false;
+ }
+
+ /* Verify the replacement has the right number of matching groups */
+ for (int i = 0; i < _tokenCount; i++) {
+ if (_tokens[i] >= matchCount) {
+ PrefetchError("invalid reference in replacement string: $%d",
_tokens[i]);
+ return false;
+ }
+ }
+
+ int previous = 0;
+ for (int i = 0; i < _tokenCount; i++) {
+ int replIndex = _tokens[i];
+ int start = ovector[2 * replIndex];
+ int length = ovector[2 * replIndex + 1] - ovector[2 * replIndex];
+
+ String src(_replacement, _tokenOffset[i], 2);
+ String dst(subject, start, length);
+
+ PrefetchDebug("replacing '%s' with '%s'", src.c_str(), dst.c_str());
+
+ result.append(_replacement, previous, _tokenOffset[i] - previous);
+ result.append(dst);
+
+ previous = _tokenOffset[i] + 2; /* 2 is the size of $0 or $1 or $2, ... or
$9 */
+ }
+
+ result.append(_replacement, previous, _replacement.length() - previous);
+
+ PrefetchDebug("replacing '%s' resulted in '%s'", _replacement.c_str(),
result.c_str());
+
+ return true;
+}
+
+/**
+ * @brief PCRE compiles the regex, called only during initialization.
+ * @return true if successful, false if not.
+ */
+bool
+Pattern::compile()
+{
+ const char *errPtr; /* PCRE error */
+ int errOffset; /* PCRE error offset */
+
+ PrefetchDebug("compiling pattern:'%s', replacement:'%s'", _pattern.c_str(),
_replacement.c_str());
+
+ _re = pcre_compile(_pattern.c_str(), /* the pattern */
+ 0, /* options */
+ &errPtr, /* for error message */
+ &errOffset, /* for error offset */
+ nullptr); /* use default character tables */
+
+ if (nullptr == _re) {
+ PrefetchError("compile of regex '%s' at char %d: %s", _pattern.c_str(),
errOffset, errPtr);
+
+ return false;
+ }
+
+ _extra = pcre_study(_re, 0, &errPtr);
+
+ if ((nullptr == _extra) && (nullptr != errPtr) && (0 != *errPtr)) {
+ PrefetchError("failed to study regex '%s': %s", _pattern.c_str(), errPtr);
+
+ pcre_free(_re);
+ _re = nullptr;
+ return false;
+ }
+
+ if (_replacement.empty()) {
+ /* No replacement necessary - we are done. */
+ return true;
+ }
+
+ _tokenCount = 0;
+ bool success = true;
+
+ for (unsigned i = 0; i < _replacement.length(); i++) {
+ if (_replacement[i] == '$') {
+ if (_tokenCount >= TOKENCOUNT) {
+ PrefetchError("too many tokens in replacement string: %s",
_replacement.c_str());
+
+ success = false;
+ break;
+ } else if (_replacement[i + 1] < '0' || _replacement[i + 1] > '9') {
+ PrefetchError("invalid replacement token $%c in %s: should be $0 -
$9", _replacement[i + 1], _replacement.c_str());
+
+ success = false;
+ break;
+ } else {
+ /* Store the location of the replacement */
+ /* Convert '0' to 0 */
+ _tokens[_tokenCount] = _replacement[i + 1] - '0';
+ _tokenOffset[_tokenCount] = i;
+ _tokenCount++;
+ /* Skip the next char */
+ i++;
+ }
+ }
+ }
+
+ if (!success) {
+ pcreFree();
+ }
+
+ return success;
+}
+
+/**
+ * @brief Destructor, deletes all patterns.
+ */
+MultiPattern::~MultiPattern()
+{
+ for (std::vector<Pattern *>::iterator p = this->_list.begin(); p !=
this->_list.end(); ++p) {
+ delete (*p);
+ }
+}
+
+/**
+ * @brief Check if empty.
+ * @return true if the classification contains any patterns, false otherwise
+ */
+bool
+MultiPattern::empty() const
+{
+ return _list.empty();
+}
+
+/**
+ * @brief Adds a pattern to the multi-pattern
+ *
+ * The order of addition matters during the classification
+ * @param pattern pattern pointer
+ */
+void
+MultiPattern::add(Pattern *pattern)
+{
+ this->_list.push_back(pattern);
+}
+
+/**
+ * @brief Matches the subject string against all patterns.
+ * @param subject subject string.
+ * @return true if any matches, false if nothing matches.
+ */
+bool
+MultiPattern::match(const String &subject) const
+{
+ for (std::vector<Pattern *>::const_iterator p = this->_list.begin(); p !=
this->_list.end(); ++p) {
+ if (nullptr != (*p) && (*p)->match(subject)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/**
+ * @brief Calls Pattern::replace() on all patterns in the multi-pattern one by
one until the first match.
+ * @param subject subject string.
+ * @param result vector of the result.
+ * @return true if any matches, false if nothing matches.
+ */
+bool
+MultiPattern::replace(const String &subject, String &result) const
+{
+ for (std::vector<Pattern *>::const_iterator p = this->_list.begin(); p !=
this->_list.end(); ++p) {
+ if (nullptr != (*p) && (*p)->replace(subject, result)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/**
+ * @brief Returns the name of the multi-pattern (set during the instantiation
only).
+ */
+const String &
+MultiPattern::name() const
+{
+ return _name;
+}
diff --git a/plugins/experimental/prefetch/pattern.h
b/plugins/experimental/prefetch/pattern.h
new file mode 100644
index 0000000..2db7665
--- /dev/null
+++ b/plugins/experimental/prefetch/pattern.h
@@ -0,0 +1,92 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file pattern.h
+ * @brief PRCE related classes (header file).
+ */
+
+#pragma once
+
+#ifdef HAVE_PCRE_PCRE_H
+#include <pcre/pcre.h>
+#else
+#include <pcre.h>
+#endif
+
+#include "common.h"
+
+/**
+ * @brief PCRE matching, capturing and replacing
+ */
+class Pattern
+{
+public:
+ static const int TOKENCOUNT = 10; /**< @brief Capturing groups
$0..$9 */
+ static const int OVECOUNT = TOKENCOUNT * 3; /**< @brief pcre_exec() array
count, handle 10 capture groups */
+
+ Pattern();
+ virtual ~Pattern();
+
+ bool init(const String &pattern, const String &replacenemt);
+ bool init(const String &config);
+ bool empty() const;
+ bool match(const String &subject);
+ bool capture(const String &subject, StringVector &result);
+ bool replace(const String &subject, String &result);
+ bool process(const String &subject, StringVector &result);
+
+private:
+ bool compile();
+ bool failed(const String &subject) const;
+ void pcreFree();
+
+ pcre *_re; /**< @brief PCRE compiled info structure, computed
during initialization */
+ pcre_extra *_extra; /**< @brief PCRE study data block, computed during
initialization */
+
+ String _pattern; /**< @brief PCRE pattern string, containing PCRE
patterns and capturing groups. */
+ String _replacement; /**< @brief PCRE replacement string, containing $0..$9
to be replaced with content of the capturing groups */
+
+ int _tokenCount; /**< @brief number of replacements $0..$9
found in the replacement string if not empty */
+ int _tokens[TOKENCOUNT]; /**< @brief replacement index 0..9, since they
can be used in the replacement string in any order */
+ int _tokenOffset[TOKENCOUNT]; /**< @brief replacement offset inside the
replacement string */
+};
+
+/**
+ * @brief Named list of regular expressions.
+ */
+class MultiPattern
+{
+public:
+ MultiPattern(const String name = "") : _name(name) {}
+ virtual ~MultiPattern();
+
+ bool empty() const;
+ void add(Pattern *pattern);
+ virtual bool match(const String &subject) const;
+ virtual bool replace(const String &subject, String &result) const;
+ const String &name() const;
+
+protected:
+ std::vector<Pattern *> _list; /**< @brief vector which dictates the order of
the pattern evaluation. */
+ String _name; /**< @brief multi-pattern name */
+
+private:
+ MultiPattern(const MultiPattern &); // disallow
+ MultiPattern &operator=(const MultiPattern &); // disallow
+};
diff --git a/plugins/experimental/prefetch/plugin.cc
b/plugins/experimental/prefetch/plugin.cc
new file mode 100644
index 0000000..1c16ae0
--- /dev/null
+++ b/plugins/experimental/prefetch/plugin.cc
@@ -0,0 +1,751 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+/**
+ * @file plugin.cc
+ * @brief traffic server plugin entry points.
+ */
+
+#include <sstream>
+#include <iomanip>
+
+#include "ts/ts.h" /* ATS API */
+
+#include "ts/remap.h" /* TSRemapInterface, TSRemapStatus, apiInfo */
+
+#include "common.h"
+#include "configs.h"
+#include "fetch.h"
+#include "fetch_policy.h"
+#include "headers.h"
+
+static const char *
+getEventName(TSEvent event)
+{
+ switch (event) {
+ case TS_EVENT_HTTP_CONTINUE:
+ return "TS_EVENT_HTTP_CONTINUE";
+ case TS_EVENT_HTTP_ERROR:
+ return "TS_EVENT_HTTP_ERROR";
+ case TS_EVENT_HTTP_READ_REQUEST_HDR:
+ return "TS_EVENT_HTTP_READ_REQUEST_HDR";
+ case TS_EVENT_HTTP_OS_DNS:
+ return "TS_EVENT_HTTP_OS_DNS";
+ case TS_EVENT_HTTP_SEND_REQUEST_HDR:
+ return "TS_EVENT_HTTP_SEND_REQUEST_HDR";
+ case TS_EVENT_HTTP_READ_CACHE_HDR:
+ return "TS_EVENT_HTTP_READ_CACHE_HDR";
+ case TS_EVENT_HTTP_READ_RESPONSE_HDR:
+ return "TS_EVENT_HTTP_READ_RESPONSE_HDR";
+ case TS_EVENT_HTTP_SEND_RESPONSE_HDR:
+ return "TS_EVENT_HTTP_SEND_RESPONSE_HDR";
+ case TS_EVENT_HTTP_REQUEST_TRANSFORM:
+ return "TS_EVENT_HTTP_REQUEST_TRANSFORM";
+ case TS_EVENT_HTTP_RESPONSE_TRANSFORM:
+ return "TS_EVENT_HTTP_RESPONSE_TRANSFORM";
+ case TS_EVENT_HTTP_SELECT_ALT:
+ return "TS_EVENT_HTTP_SELECT_ALT";
+ case TS_EVENT_HTTP_TXN_START:
+ return "TS_EVENT_HTTP_TXN_START";
+ case TS_EVENT_HTTP_TXN_CLOSE:
+ return "TS_EVENT_HTTP_TXN_CLOSE";
+ case TS_EVENT_HTTP_SSN_START:
+ return "TS_EVENT_HTTP_SSN_START";
+ case TS_EVENT_HTTP_SSN_CLOSE:
+ return "TS_EVENT_HTTP_SSN_CLOSE";
+ case TS_EVENT_HTTP_CACHE_LOOKUP_COMPLETE:
+ return "TS_EVENT_HTTP_CACHE_LOOKUP_COMPLETE";
+ case TS_EVENT_HTTP_PRE_REMAP:
+ return "TS_EVENT_HTTP_PRE_REMAP";
+ case TS_EVENT_HTTP_POST_REMAP:
+ return "TS_EVENT_HTTP_POST_REMAP";
+ default:
+ return "UNHANDLED";
+ }
+ return "UNHANDLED";
+}
+
+static const char *
+getCacheLookupResultName(TSCacheLookupResult result)
+{
+ switch (result) {
+ case TS_CACHE_LOOKUP_MISS:
+ return "TS_CACHE_LOOKUP_MISS";
+ break;
+ case TS_CACHE_LOOKUP_HIT_STALE:
+ return "TS_CACHE_LOOKUP_HIT_STALE";
+ break;
+ case TS_CACHE_LOOKUP_HIT_FRESH:
+ return "TS_CACHE_LOOKUP_HIT_FRESH";
+ break;
+ case TS_CACHE_LOOKUP_SKIPPED:
+ return "TS_CACHE_LOOKUP_SKIPPED";
+ break;
+ default:
+ return "UNKNOWN_CACHE_LOOKUP_EVENT";
+ break;
+ }
+ return "UNKNOWN_CACHE_LOOKUP_EVENT";
+}
+
+/**
+ * @brief Plugin initialization.
+ * @param apiInfo remap interface info pointer
+ * @param errBuf error message buffer
+ * @param errBufSize error message buffer size
+ * @return always TS_SUCCESS.
+ */
+TSReturnCode
+TSRemapInit(TSRemapInterface *apiInfo, char *errBuf, int erroBufSize)
+{
+ return TS_SUCCESS;
+}
+
+/**
+ * @brief Plugin instance data.
+ */
+
+struct PrefetchInstance {
+ PrefetchInstance() : _state(nullptr){};
+
+private:
+ PrefetchInstance(PrefetchInstance const &);
+ void operator=(BgFetchState const &);
+
+public:
+ PrefetchConfig _config;
+ BgFetchState *_state;
+};
+
+/**
+ * brief Plugin transaction data.
+ */
+class PrefetchTxnData
+{
+public:
+ PrefetchTxnData(PrefetchInstance *inst)
+ : _inst(inst), _front(true), _firstPass(true), _fetchable(false),
_status(TS_HTTP_STATUS_OK)
+ {
+ }
+
+ bool
+ firstPass() const
+ {
+ return _firstPass;
+ }
+
+ bool
+ secondPass() const
+ {
+ return !_firstPass;
+ }
+
+ bool
+ frontend() const
+ {
+ return _front;
+ }
+
+ bool
+ backend() const
+ {
+ return !_front;
+ }
+
+ PrefetchInstance *_inst; /* Pointer to the plugin instance */
+
+ bool _front; /* front-end vs back-end */
+ bool _firstPass; /* first vs second pass */
+
+ /* saves state between hooks */
+ String _cachekey; /* cache key */
+ bool _fetchable; /* saves the result of the attempt to fetch */
+ TSHttpStatus _status; /* status to return to the UA */
+ String _body; /* body to return to the UA */
+};
+
+/**
+ * @brief Evaluate a math addition or subtraction expression.
+ *
+ * @param v string containing an expression, i.e. "3 + 4"
+ * @return string containing the result, i.e. "7"
+ */
+static String
+evaluate(const String &v)
+{
+ if (v.empty()) {
+ return String("");
+ }
+
+ /* Find out if width is specified (hence leading zeros are required if the
width is bigger then the result width) */
+ String stmt;
+ size_t len = 0;
+ size_t pos = v.find_first_of(":");
+ if (String::npos != pos) {
+ stmt.assign(v.substr(0, pos));
+ len = getValue(v.substr(pos + 1));
+ } else {
+ stmt.assign(v);
+ }
+ PrefetchDebug("statement: '%s', formating length: %zu", stmt.c_str(), len);
+
+ int result = 0;
+ pos = stmt.find_first_of("+-");
+
+ if (String::npos == pos) {
+ result = getValue(stmt);
+ } else {
+ unsigned a = getValue(stmt.substr(0, pos));
+ unsigned b = getValue(stmt.substr(pos + 1));
+
+ if ('+' == stmt[pos]) {
+ result = a + b;
+ } else {
+ result = a - b;
+ }
+ }
+
+ std::ostringstream convert;
+ convert << std::setw(len) << std::setfill('0') << result;
+ PrefetchDebug("evaluation of '%s' resulted in '%s'", v.c_str(),
convert.str().c_str());
+ return convert.str();
+}
+
+/**
+ * @brief Expand+evaluate (in place) an expression surrounded with "{" and "}"
and uses evaluate() to evaluate the math expression.
+ *
+ * @param s string containing an expression, i.e. "{3 + 4}"
+ * @return void
+ */
+static void
+expand(String &s)
+{
+ size_t cur = 0;
+ while (String::npos != cur) {
+ size_t start = s.find_first_of("{", cur);
+ size_t stop = s.find_first_of("}", start);
+
+ if (String::npos != start && String::npos != stop) {
+ s.replace(start, stop - start + 1, evaluate(s.substr(start + 1, stop -
start - 1)));
+ cur = stop + 1;
+ } else {
+ cur = stop;
+ }
+ }
+}
+
+/**
+ * @brief Get the cachekey used for the particular object in this transaction.
+ *
+ * @param txnp HTTP transaction structure
+ * @param reqBuffer request TSMBuffer
+ * @param destination string reference to where the result is to be appended.
+ * @return true if success or false if failure
+ */
+bool
+appendCacheKey(const TSHttpTxn txnp, const TSMBuffer reqBuffer, String &key)
+{
+ bool ret = false;
+ TSMLoc keyLoc = TS_NULL_MLOC;
+ if (TS_SUCCESS == TSUrlCreate(reqBuffer, &keyLoc)) {
+ if (TS_SUCCESS == TSHttpTxnCacheLookupUrlGet(txnp, reqBuffer, keyLoc)) {
+ int urlLen = 0;
+ char *url = TSUrlStringGet(reqBuffer, keyLoc, &urlLen);
+ if (nullptr != url) {
+ key.append(url, urlLen);
+ PrefetchDebug("cache key: %s", key.c_str());
+ TSfree(static_cast<void *>(url));
+ ret = true;
+ }
+ }
+ TSHandleMLocRelease(reqBuffer, TS_NULL_MLOC, keyLoc);
+ }
+
+ if (!ret) {
+ PrefetchError("failed to get cache key");
+ }
+ return ret;
+}
+
+/**
+ * @brief Find out if the object was found fresh in cache.
+ *
+ * This function finaly controls if the pre-fetch should be scheduled or not.
+ * @param txnp HTTP transaction structure
+ * @return true - hit fresh, false - miss/stale/skipped or error
+ */
+static bool
+foundFresh(TSHttpTxn txnp)
+{
+ bool fresh = false;
+ int lookupStatus;
+ if (TS_SUCCESS == TSHttpTxnCacheLookupStatusGet(txnp, &lookupStatus)) {
+ PrefetchDebug("lookup status: %s",
getCacheLookupResultName((TSCacheLookupResult)lookupStatus));
+ if (TS_CACHE_LOOKUP_HIT_FRESH == lookupStatus) {
+ fresh = true;
+ }
+ } else {
+ /* Failed to get the lookup status, likely a previous plugin already
prepared the client response w/o a cache lookup,
+ * we don't really know if the cache has a fresh object, so just don't
trigger pre-fetch */
+ PrefetchDebug("failed to check cache-ability");
+ }
+ return fresh;
+}
+
+/**
+ * @brief Check if the response from origin for N-th object is success (200
and 206)
+ *
+ * and only then schedule a pre-fetch for the next
+ *
+ * @param txnp HTTP transaction structure
+ * @return true - yes, false - no
+ */
+bool
+isResponseGood(TSHttpTxn txnp)
+{
+ bool good = false;
+ TSMBuffer respBuffer;
+ TSMLoc respHdrLoc;
+ if (TS_SUCCESS == TSHttpTxnServerRespGet(txnp, &respBuffer, &respHdrLoc)) {
+ TSHttpStatus status = TSHttpHdrStatusGet(respBuffer, respHdrLoc);
+ PrefetchDebug("origin response code: %d", status);
+ if (TS_HTTP_STATUS_PARTIAL_CONTENT == status || TS_HTTP_STATUS_OK ==
status) {
+ good = true;
+ }
+ /* Release the response MLoc */
+ TSHandleMLocRelease(respBuffer, TS_NULL_MLOC, respHdrLoc);
+ } else {
+ /* Failed to get the origin response, possible cause could be a origin
connection problems or timeouts or
+ * a previous plugin could have already prepared the client response w/o
going to origin server */
+ PrefetchDebug("failed to get origin response");
+ }
+ return good;
+}
+
+/**
+ * @brief get the pristin URL path
+ *
+ * @param txnp HTTP transaction structure
+ * @return pristine URL path
+ */
+static String
+getPristineUrlPath(TSHttpTxn txnp)
+{
+ String pristinePath;
+ TSMLoc pristineUrlLoc;
+ TSMBuffer reqBuffer;
+
+ if (TS_SUCCESS == TSHttpTxnPristineUrlGet(txnp, &reqBuffer,
&pristineUrlLoc)) {
+ int pathLen = 0;
+ const char *path = TSUrlPathGet(reqBuffer, pristineUrlLoc, &pathLen);
+ if (nullptr != path) {
+ PrefetchDebug("path: '%.*s'", pathLen, path);
+ pristinePath.assign(path, pathLen);
+ } else {
+ PrefetchError("failed to get pristine URL path");
+ }
+ TSHandleMLocRelease(reqBuffer, TS_NULL_MLOC, pristineUrlLoc);
+ } else {
+ PrefetchError("failed to get pristine URL");
+ }
+ return pristinePath;
+}
+
+/**
+ * @brief short-cut to set the response .
+ */
+TSEvent
+shortcutResponse(PrefetchTxnData *data, TSHttpStatus status, const char *body,
TSEvent event)
+{
+ data->_status = status;
+ data->_body.assign(body);
+ return event;
+}
+
+/**
+ * @brief Checks if we are still supposed to schedule a background fetch based
on whether the object is in the cache.
+ * It is 'fetchable' only if not a fresh hit.
+ *
+ * @param txnp HTTP transaction structure
+ * @param data transaction data
+ * @return true if fetchable and false if not.
+ */
+static bool
+isFetchable(TSHttpTxn txnp, PrefetchTxnData *data)
+{
+ bool fetchable = false;
+ BgFetchState *state = data->_inst->_state;
+ if (!foundFresh(txnp)) {
+ /* Schedule fetch only if not in cache */
+ PrefetchDebug("object to be fetched");
+ fetchable = true;
+ } else {
+ PrefetchDebug("object already in cache or to be skipped");
+ state->incrementMetric(FETCH_ALREADY_CACHED);
+ state->incrementMetric(FETCH_TOTAL);
+ }
+ return fetchable;
+}
+
+/**
+ * @brief Find out if the current response to trigger a background prefetch.
+ *
+ * Pre-fetch only on HTTP codes 200 and 206 or object found in cache (previous
good response)
+ *
+ * @param txnp HTTP transaction structure
+ * @return true - trigger prefetch, false - don't trigger.
+ */
+static bool
+respToTriggerPrefetch(TSHttpTxn txnp)
+{
+ bool trigger = false;
+ if (foundFresh(txnp)) {
+ /* If found in cache and fresh trigger next (same as good response from
origin) */
+ PrefetchDebug("trigger background fetch (cached)");
+ trigger = true;
+ } else if (isResponseGood(txnp)) {
+ /* Trigger all necessary background fetches based on the next path pattern
*/
+ PrefetchDebug("trigger background fetch (good origin response)");
+ trigger = true;
+ } else {
+ PrefetchDebug("don't trigger background fetch");
+ }
+ return trigger;
+}
+
+/**
+ * @brief Callback function that handles necessary foreground / background
fetch operations.
+ *
+ * @param contp continuation associated with this function.
+ * @param event corresponding event triggered at different hooks.
+ * @param edata HTTP transaction structures.
+ * @return always 0
+ */
+int
+contHandleFetch(const TSCont contp, TSEvent event, void *edata)
+{
+ PrefetchTxnData *data = static_cast<PrefetchTxnData
*>(TSContDataGet(contp));
+ TSHttpTxn txnp = static_cast<TSHttpTxn>(edata);
+ PrefetchConfig &config = data->_inst->_config;
+ BgFetchState *state = data->_inst->_state;
+ TSMBuffer reqBuffer;
+ TSMLoc reqHdrLoc;
+
+ PrefetchDebug("event: %s (%d)", getEventName(event), event);
+
+ TSEvent retEvent = TS_EVENT_HTTP_CONTINUE;
+
+ if (TS_SUCCESS != TSHttpTxnClientReqGet(txnp, &reqBuffer, &reqHdrLoc)) {
+ PrefetchError("failed to get client request");
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_ERROR);
+ return 0;
+ }
+
+ switch (event) {
+ case TS_EVENT_HTTP_POST_REMAP: {
+ /* Use the cache key since this has better lookup behavior when using
plugins like the cachekey plugin,
+ * for example multiple URIs can match a single cache key */
+ if (data->frontend() && data->secondPass()) {
+ /* Create a separate cache key name space to be used only for front-end
and second-pass fetch policy checks. */
+ data->_cachekey.assign("/prefetch");
+ }
+ if (!appendCacheKey(txnp, reqBuffer, data->_cachekey)) {
+ PrefetchError("failed to get the cache key");
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_ERROR);
+ return 0;
+ }
+
+ if (data->frontend()) {
+ /* front-end instance */
+ if (data->firstPass()) {
+ /* first-pass */
+ if (!config.isExactMatch()) {
+ data->_fetchable = state->acquire(data->_cachekey);
+ PrefetchDebug("request is%sfetchable", data->_fetchable ? " " : "
not ");
+ }
+ }
+ }
+ } break;
+
+ case TS_EVENT_HTTP_CACHE_LOOKUP_COMPLETE: {
+ if (data->frontend()) {
+ /* front-end instance */
+ if (data->secondPass()) {
+ /* second-pass */
+ data->_fetchable = state->acquire(data->_cachekey);
+ data->_fetchable = data->_fetchable &&
state->uniqueAcquire(data->_cachekey);
+ PrefetchDebug("request is%sfetchable", data->_fetchable ? " " : " not
");
+
+ if (isFetchable(txnp, data)) {
+ if (!data->_fetchable) {
+ /* Cancel the requested fetch */
+ retEvent = shortcutResponse(data, TS_HTTP_STATUS_ALREADY_REPORTED,
"fetch not scheduled\n", TS_EVENT_HTTP_ERROR);
+ } else {
+ /* Fetch */
+ }
+ } else {
+ retEvent = shortcutResponse(data, TS_HTTP_STATUS_ALREADY_REPORTED,
"fetch not scheduled\n", TS_EVENT_HTTP_ERROR);
+ }
+ }
+ } else {
+ /* back-end instance */
+ if (data->firstPass()) {
+ if (isFetchable(txnp, data)) {
+ if (BgFetch::schedule(state, config, /* askPermission */ true,
reqBuffer, reqHdrLoc, txnp, nullptr, 0, data->_cachekey)) {
+ retEvent = shortcutResponse(data, TS_HTTP_STATUS_OK, "fetch
scheduled\n", TS_EVENT_HTTP_ERROR);
+ } else {
+ retEvent = shortcutResponse(data, TS_HTTP_STATUS_ALREADY_REPORTED,
"fetch not scheduled\n", TS_EVENT_HTTP_ERROR);
+ }
+ } else {
+ retEvent = shortcutResponse(data, TS_HTTP_STATUS_ALREADY_REPORTED,
"fetch not scheduled\n", TS_EVENT_HTTP_ERROR);
+ }
+ }
+ }
+ } break;
+
+ case TS_EVENT_HTTP_SEND_RESPONSE_HDR: {
+ if (data->frontend()) {
+ /* front-end instance */
+
+ if (data->firstPass() && data->_fetchable &&
!config.getNextPath().empty() && respToTriggerPrefetch(txnp)) {
+ /* Trigger all necessary background fetches based on the next path
pattern */
+
+ String currentPath = getPristineUrlPath(txnp);
+ if (!currentPath.empty()) {
+ unsigned total = config.getFetchCount();
+ for (unsigned i = 0; i < total; ++i) {
+ PrefetchDebug("generating prefetch request %d/%d", i + 1, total);
+ String expandedPath;
+
+ if (config.getNextPath().replace(currentPath, expandedPath)) {
+ PrefetchDebug("replaced: %s", expandedPath.c_str());
+ expand(expandedPath);
+ PrefetchDebug("expanded: %s", expandedPath.c_str());
+
+ BgFetch::schedule(state, config, /* askPermission */ false,
reqBuffer, reqHdrLoc, txnp, expandedPath.c_str(),
+ expandedPath.length(), data->_cachekey);
+ } else {
+ /* We should be here only if the pattern replacement fails
(match already checked) */
+ PrefetchError("failed to process the pattern");
+
+ /* If the first or any matches fails there must be something
wrong so don't continue */
+ break;
+ }
+ currentPath.assign(expandedPath);
+ }
+ } else {
+ PrefetchDebug("failed to get current path");
+ }
+ }
+ }
+
+ if ((data->backend() && data->firstPass()) || (data->frontend() &&
data->secondPass() && !data->_body.empty())) {
+ TSMBuffer bufp;
+ TSMLoc hdrLoc;
+
+ if (TS_SUCCESS == TSHttpTxnClientRespGet(txnp, &bufp, &hdrLoc)) {
+ const char *reason = TSHttpHdrReasonLookup(data->_status);
+ int reasonLen = strlen(reason);
+ TSHttpHdrStatusSet(bufp, hdrLoc, data->_status);
+ TSHttpHdrReasonSet(bufp, hdrLoc, reason, reasonLen);
+ PrefetchDebug("set response: %d %.*s '%s'", data->_status, reasonLen,
reason, data->_body.c_str());
+
+ char *buf = (char *)TSmalloc(data->_body.length() + 1);
+ sprintf(buf, "%s", data->_body.c_str());
+ TSHttpTxnErrorBodySet(txnp, buf, strlen(buf), nullptr);
+
+ setHeader(bufp, hdrLoc, TS_MIME_FIELD_CACHE_CONTROL,
TS_MIME_LEN_CACHE_CONTROL, TS_HTTP_VALUE_NO_STORE,
+ TS_HTTP_LEN_NO_STORE);
+
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdrLoc);
+ } else {
+ PrefetchError("failed to retrieve client response header");
+ }
+ }
+ } break;
+
+ case TS_EVENT_HTTP_TXN_CLOSE: {
+ if (data->_fetchable) {
+ if (data->frontend()) {
+ /* front-end */
+ if (data->firstPass()) {
+ /* first-pass */
+ if (!config.isExactMatch()) {
+ state->release(data->_cachekey);
+ }
+ } else {
+ /* second-pass */
+ state->uniqueRelease(data->_cachekey);
+ state->release(data->_cachekey);
+ }
+ }
+ }
+
+ /* Destroy the txn continuation and its data */
+ delete data;
+ TSContDestroy(contp);
+ } break;
+
+ default: {
+ PrefetchError("unhandled event: %s(%d)", getEventName(event), event);
+ } break;
+ }
+
+ /* Release the request MLoc */
+ TSHandleMLocRelease(reqBuffer, TS_NULL_MLOC, reqHdrLoc);
+
+ /* Reenable and continue with the state machine. */
+ TSHttpTxnReenable(txnp, retEvent);
+ return 0;
+}
+
+/**
+ * @brief Plugin new instance entry point.
+ *
+ * Processes the configuration and initializes the plugin instance.
+ * @param argc plugin arguments number
+ * @param argv plugin arguments
+ * @param instance new plugin instance pointer (initialized in this function)
+ * @param errBuf error message buffer
+ * @param errBufSize error message buffer size
+ * @return TS_SUCCES if success or TS_ERROR if failure
+ */
+TSReturnCode
+TSRemapNewInstance(int argc, char *argv[], void **instance, char *errBuf, int
errBufSize)
+{
+ bool failed = true;
+
+ PrefetchInstance *inst = new PrefetchInstance();
+ if (nullptr != inst) {
+ if (inst->_config.init(argc, argv)) {
+ inst->_state =
BgFetchStates::get()->getStateByName(inst->_config.getNameSpace());
+ if (nullptr != inst->_state) {
+ failed = !inst->_state->init(inst->_config);
+ }
+ }
+ }
+
+ if (failed) {
+ PrefetchError("failed to initialize the plugin");
+ delete inst;
+ *instance = nullptr;
+ return TS_ERROR;
+ }
+
+ *instance = inst;
+ return TS_SUCCESS;
+}
+
+/**
+ * @brief Plugin instance deletion clean-up entry point.
+ * @param plugin instance pointer.
+ */
+void
+TSRemapDeleteInstance(void *instance)
+{
+ PrefetchInstance *inst = (PrefetchInstance *)instance;
+ delete inst;
+}
+
+/**
+ * @brief Organizes the background fetch by registering necessary hooks, by
identifying front-end vs back-end, first vs second
+ * pass.
+ *
+ * Remap is never done, continue with next in chain.
+ * @param instance plugin instance pointer
+ * @param txnp transaction handle
+ * @param rri remap request info pointer
+ * @return always TSREMAP_NO_REMAP
+ */
+TSRemapStatus
+TSRemapDoRemap(void *instance, TSHttpTxn txnp, TSRemapRequestInfo *rri)
+{
+ PrefetchInstance *inst = (PrefetchInstance *)instance;
+
+ if (nullptr != inst) {
+ PrefetchConfig &config = inst->_config;
+
+ int methodLen = 0;
+ const char *method = TSHttpHdrMethodGet(rri->requestBufp,
rri->requestHdrp, &methodLen);
+ const String &header = config.getApiHeader();
+ if (nullptr != method && methodLen == TS_HTTP_LEN_GET && 0 ==
memcmp(TS_HTTP_METHOD_GET, method, TS_HTTP_LEN_GET)) {
+ bool front = config.isFront();
+ bool firstPass = false;
+ if (headerExist(rri->requestBufp, rri->requestHdrp, header.c_str(),
header.length())) {
+ PrefetchDebug("%s: found %.*s", front ? "front-end" : "back-end",
(int)header.length(), header.c_str());
+ /* On front-end: presence of header means second-pass, on back-end
means first-pass. */
+ firstPass = !front;
+ } else {
+ /* On front-end: lack of header means first-pass, on back-end means
second-pass. */
+ firstPass = front;
+ }
+
+ /* Make sure we handle only URLs that match the path pattern on the
front-end + first-pass, cancel otherwise */
+ bool handleFetch = true;
+ if (front && firstPass) {
+ /* Front-end plug-in instance + first pass. */
+ if (config.getNextPath().empty()) {
+ /* No next path pattern specified then pass this request untouched.
*/
+ PrefetchDebug("next object pattern not specified, skip");
+ handleFetch = false;
+ } else {
+ /* Next path pattern specified hence try to match. */
+ String pristinePath = getPristineUrlPath(txnp);
+ if (!pristinePath.empty()) {
+ if (config.getNextPath().match(pristinePath)) {
+ /* Matched - handle the request */
+ PrefetchDebug("matched next object pattern");
+ inst->_state->incrementMetric(FETCH_MATCH_YES);
+ } else {
+ /* Next path pattern specified but did not match. */
+ PrefetchDebug("failed to match next object pattern, skip");
+ inst->_state->incrementMetric(FETCH_MATCH_NO);
+ handleFetch = false;
+ }
+ } else {
+ PrefetchDebug("failed to get path to (pre)match");
+ }
+ }
+ }
+
+ if (handleFetch) {
+ PrefetchTxnData *data = new PrefetchTxnData(inst);
+ if (nullptr != data) {
+ data->_front = front;
+ data->_firstPass = firstPass;
+
+ TSCont cont = TSContCreate(contHandleFetch, TSMutexCreate());
+ TSContDataSet(cont, static_cast<void *>(data));
+
+ TSHttpTxnHookAdd(txnp, TS_HTTP_POST_REMAP_HOOK, cont);
+ TSHttpTxnHookAdd(txnp, TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK, cont);
+ TSHttpTxnHookAdd(txnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK, cont);
+ TSHttpTxnHookAdd(txnp, TS_HTTP_TXN_CLOSE_HOOK, cont);
+ } else {
+ PrefetchError("failed to allocate transaction data object");
+ }
+ }
+ } else {
+ PrefetchDebug("not a GET method (%.*s), skipping", methodLen, method);
+ }
+ } else {
+ PrefetchError("could not get prefetch instance");
+ }
+
+ return TSREMAP_NO_REMAP;
+}
