Eternita Edge · development
GeoIP, log shipping, a check against your own fraud signals — as a jar of your own, loaded by the node in front of your app, without a fork. The API is Apache-2.0, and Pro is built on the same one you get.
plugins/ directory, enabled by name and pinned by its SHA-256.# META-INF/frontcache-plugin.properties
id = geo
class = com.example.GeoPlugin
version = 1.0.0
plugin-api = 1
kinds = decide
# conf/guard-rules.conf
checkout-eu | uri~^/checkout ; !ext:geo:country=DE,FR | reject:403 Forbidden
A plugin of your own adds a condition; your rule uses it. If the plugin is absent or has no answer, the rule simply does not match.
Tell us what your edge should do. An engineer who worked on the plugin API answers within one business day.
What a Plugin Can Do
A plugin’s manifest says what it contributes; the node refuses one that contributes anything else. Every decision about a visitor’s request stays with your rules.
Events after the fact, on the plugin’s own thread and bounded queue: a guard rule matched, a
rate limit exceeded, a circuit opened, an origin error, a fallback served, an invalidation, and a
sample of the request log. Ship them to Kafka, Loki or your SIEM. An event never carries a cookie
value, an Authorization header, the API key or a request body.
A plugin answers /fc-x/<id>/ and nothing else — never cached, never sent to
your origin, behind your guard rules like any path. It sees the request without credentials or
cookies it did not name. The open-source request debugger is one; Pro’s challenge page is
another.
ext:geo:country=DE,FR in guard-rules.conf or bots.conf. Every
call is timed: a plugin slower than its budget (200 microseconds at p99 by default) or failing too
often is switched off for five minutes, and a rule whose plugin has no answer does not match.
Scheduled work, management actions and metrics of its own — and address lists your rules read as they change, with no reload. The open-source crawler feeder keeps Googlebot, Bingbot and Applebot lists current this way.
From Template to Node
Java 25 and Gradle, from the template in the open-source repository. No fork of the engine, no rebuild of the server.
./gradlew build compiles against the plugin API, runs your tests
with the testkit’s contract checks, and makes one jar.FRONTCACHE_HOME/plugins/<id>/. A directory
on its own changes nothing.frontcache.properties, with the
jar’s SHA-256 if you want any other jar refused.# conf/frontcache.properties
front-cache.plugins = geo
# optional: refuse to load a jar that is not this one
front-cache.plugins.geo.sha256 = <./gradlew sha256>
A plugin directory not named here is reported and never read.
# build.gradle — compiled against, never bundled
compileOnly 'org.frontcache:frontcache-plugin-api:<version>'
testImplementation 'org.frontcache:frontcache-plugin-testkit:<version>'
Both from repo.eternita.co/maven2; the template’s
gradle.properties names the release.
Built to Fail Safely
A dropped-in plugin gets a class loader of its own. It sees the plugin API and a few logging and config libraries — never the engine, another plugin or the core’s internals. Two plugins can carry two versions of one library.
Whatever goes wrong, the node starts without it: a manifest that declares something
it may not, a class that will not load, a refused config, a throw in start. Each is logged
and shown on the Plugins screen and in the metrics.
Every decision stays with your rules. A plugin reacts, serves its own path, runs in the background or answers a condition you chose to write into a rule — it never decides on its own what a visitor gets.
The Same API as Pro
Eternita Edge Pro’s alerts, challenge pages and adaptive defence are plugins on this API — the events they react to, the pages they serve and the lists your rules read are the ones your plugin gets. They follow the same rule, too: they watch, serve and manage, and your rules decide.
The API, the testkit, the template and both examples are Apache-2.0, in the public repository.
Custom Edge Plugins
The plugin your edge needs, written by the people who wrote the plugin API — delivered as a jar in your repository, under your license, tested with the public testkit. Scoped per project.
A GeoIP or ASN condition from your own database, or a check against your own fraud signals — in memory, inside the time budget.
Request-log and guard events shipped to your Kafka, Loki or SIEM, with client addresses hashed.
An invalidation webhook from your CMS, or address lists kept from a source you trust.
What It Is Not
What a plugin cannot do in this release.
A plugin cannot change the pages your origin renders or answer for a path that is not its own. Your app and your cache rules decide what a visitor gets.
Plugins are JVM code against the Java API. A plugin’s config reloads in place; its code changes when the node restarts.
The plugins today are ours: the two open-source examples and Pro’s. Wrote one you want others to find? Tell us — a directory starts with the first.
Next Step
Copy the template and the testkit checks your plugin the way a node will. Or tell us what your edge should do, and we scope the plugin.