Extend the edge in Java — with an open plugin API.

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.

  • Four things a plugin can do. React to what happened, serve a page of its own, add a condition your rules can use, and run in the background.
  • Drop in a jar. Into the node’s plugins/ directory, enabled by name and pinned by its SHA-256.
  • Tested before it ships. A testkit runs your plugin in-process with the node’s own checks; a template and two open-source examples to start from.
  • A plugin that fails is a plugin that is absent. The node always starts, and a condition that turns slow is switched off for a while.
# 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.

Have us write it — or ask how

Tell us what your edge should do. An engineer who worked on the plugin API answers within one business day.

We reply within one business day — privacy policy.

Four Ways In, Each Declared and Checked

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.

React to what happened

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.

Serve a page of its own

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.

Add a condition your rules can use

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.

Run in the background

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.

Build, Drop In, Pin, Restart

Java 25 and Gradle, from the template in the open-source repository. No fork of the engine, no rebuild of the server.

  1. Build ./gradlew build compiles against the plugin API, runs your tests with the testkit’s contract checks, and makes one jar.
  2. Drop in Copy the jar to FRONTCACHE_HOME/plugins/<id>/. A directory on its own changes nothing.
  3. Enable and pin Name the plugin in frontcache.properties, with the jar’s SHA-256 if you want any other jar refused.
  4. Restart The console’s Plugins screen shows its state, kinds and counters. Its config reloads later without a restart.
# 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.

A Plugin Cannot Take the Node Down

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.

Pro Is Built on It

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.

Or We Write It

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.

Conditions from your own data

A GeoIP or ASN condition from your own database, or a check against your own fraud signals — in memory, inside the time budget.

Events where you already look

Request-log and guard events shipped to your Kafka, Loki or SIEM, with client addresses hashed.

Your systems driving the edge

An invalidation webhook from your CMS, or address lists kept from a source you trust.

Know the Edges of the API

What a plugin cannot do in this release.

Not a page rewriter

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.

Java, and a restart for new code

Plugins are JVM code against the Java API. A plugin’s config reloads in place; its code changes when the node restarts.

No marketplace yet

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.

Start From the Template, or From a Conversation

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.